// DYMICO_TRANSPILER_V=v2-cleanroom1 source=gs-in-dymico runtime=dymicoAsset cacheTier=mem
console.log("[DYMICO_TRANSPILER_V=v2-cleanroom1 source=gs-in-dymico runtime=dymicoAsset cacheTier=mem]");
if (typeof gs === "undefined" || typeof gs.mc !== "function") {
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
(function() {
    var gs = function(obj) {
        if (obj instanceof gs) return obj;
        if (!(this instanceof gs)) return new gs(obj);
    };
    var root = this;

    if (typeof exports !== 'undefined') {
        if (typeof module !== 'undefined' && module.exports) {
            exports = module.exports = gs;
        }
        exports.gs = gs;
    } else {
        root.gs = gs;
    }

    //Fails
    gs.fails = false;
    //Local console
    gs.consoleData = '';
    //If true and console is available, all output will go through console
    gs.consoleOutput = true;
    //If true and console is available, some methods will show info on console
    gs.consoleInfo = false;

    var globalMetaClass = {};

    //Categories
    var categories = [];

    // Mixins
    var mixins = [];
    var mixinsObjects = [];

    //Delegate
    var delegates = [];

    //Static this
    var aStT = null;

    //@Delegate
    var mapAddDelegate = {};

    gs.myCategories = {};

    /////////////////////////////////////////////////////////////////
    // assert and println
    /////////////////////////////////////////////////////////////////
    gs.assert = function(value) {
        if(value === false) {
            gs.fails = true;
            var message = 'Assert Fails! - ';
            if (arguments.length == 2 && arguments[1] !== null) {
                message = arguments[1] + ' - ';
            }
            gs.println(message + value);
        }
    };

    //Function that used for print and println in groovy
    gs.println = function(value) {
        if (gs.consoleOutput) {
            console.log(value);
        } else {
            if (gs.consoleData !== "") {
                gs.consoleData = gs.consoleData + "\n";
            }
            gs.consoleData = gs.consoleData + value;
        }
    };

    gs.printNashorn = function(value) {
        print(value);
    };

    //TODO We don't know if a function is constructor, atm if function name starts with uppercase, it is
    function isConstructor(name, func) {
        return name[0] == name[0].toUpperCase();
    }

    function isFunction(f) {
        return typeof(f) === "function";
    }

    function getterSetterRemove(name) {
        return name.charAt(3).toLowerCase() + name.slice(4);
    }

    /////////////////////////////////////////////////////////////////
    // Class functions
    /////////////////////////////////////////////////////////////////
    function BaseClass() { };
    gs.BaseClass = BaseClass;
    //gs.baseClass = {
        //The with function, with is a reserved word in JavaScript
    BaseClass.prototype.clazz = {};
    BaseClass.prototype.withz = function(closure) { return closure.apply(this, closure.arguments); },
    BaseClass.prototype.getProperties = function() {
            var result = gs.map(), ob;
            for (ob in this) {
                if (isFunction(this[ob]) && ob.startsWith('get') &&
                    this[ob].length == 0 && ob !== 'getProperties' && ob !== 'getMethods' &&
                    ob !== 'getMetaClass') {
                    result.add(getterSetterRemove(ob), this[ob]());
                } else if (!isFunction(this[ob]) && ob != 'clazz' && ob.indexOf('__') < 0) {
                    result.add(ob, this[ob]);
                }
            }
            return result;
        };
    BaseClass.prototype.getMethods = function() {
            var result = gs.list([]), ob;
            for (ob in this) {
                if (isFunction(this[ob])) {
                    if (!isObjectProperty(ob) && !(isConstructor(ob, this[ob]))) {
                        var item = {
                            name: ob
                        };
                        result.add(item);
                    }
                }
            }
            return result;
        };
    BaseClass.prototype.invokeMethod = function(name, values) {
            var i, newArgs = [];
            if (values) {
                for (i=0; i < values.length; i++) {
                    newArgs[i] = values[i];
                }
            }
            var f = this[name];
            return f.apply(this, newArgs);
        };
    BaseClass.prototype.constructor = function() {
            return this;
        };
    BaseClass.prototype.asType = function(type) {
            if (hasFunc(type, 'gSaT')) {
                type.gSaT(this);
            }
            return this;
        };
    BaseClass.prototype.withTraits = function() {
            var i;
            for (i = 0; i < arguments.length; i++) {
                arguments[i].gSaT(this);
            }
            return this;
        };
    BaseClass.prototype.getClass = function() {
            return this.clazz;
        };
    BaseClass.prototype.getMetaClass = function() {
            return gs.metaClass(this);
        };

    function applyBaseClassFunctions(item) {
        item.asType = BaseClass.prototype.asType;
    }

    function isObjectProperty(name) {
        return ['clazz','gSdefaultValue','leftShift',
            'minus','plus','equals','toString',
            'clone','withz','getProperties','getStatic', 'getClass', 'getMetaClass',
            'getMethods','invokeMethod','constructor', 'asType', 'withTraits'].indexOf(name) >= 0;
    }

    function isJsArray(array) {
        return array['clazz'] === undefined
    }

    gs.expando = function() {
        var object = gs.init('Expando');

        object.constructorWithMap = function(map) { gs.passMapToObject(map, this); return this;};
        if (arguments.length == 1) {object.constructorWithMap(arguments[0]); }

        return object;
    };

    gs.expandoMetaClass = function() {
        var object = gs.init('ExpandoMetaClass');
        object.initialize = function() {
            return this;
        };
        return object;
    };

    function expandWithMetaClass(item, objectName) {
        if (globalMetaClass && globalMetaClass[objectName]) {
            var obj, map = globalMetaClass[objectName];
            for (obj in map) {

                //Static methods
                var staticMap = map.getStatic();
                if (staticMap) {
                    var objStatic;
                    for (objStatic in staticMap) {
                        if (objStatic != 'gSparent') {
                            //console.log('Adding static->'+objStatic);
                            item[obj] = staticMap[objStatic];
                        }
                    }
                }
                //Non static methods and properties
                item[obj] = map[obj];
            }
        }
        return item;
    }

    gs.init = function(name) {
        return expandWithMetaClass(new BaseClass(), name);
    };

    function createClassNames(item, items) {
        var number = items.length, i, container;
        for (i = 0; i < number ; i++) {
            if (i === 0) {
                container = {};
                item.clazz = container;
            }
            container.name = items[i];
            container.simpleName = getSimpleName(items[i]);
            if (i < number) {
                container.superclass = {};
                container = container.superclass;
            }
        }
    }

    function getSimpleName(name) {
        var pos = name.indexOf(".");
        while (pos >= 0) {
            name = name.substring(pos + 1);
            pos = name.indexOf(".");
        }
        return name;
    }

    /////////////////////////////////////////////////////////////////
    // set - as Set and HashSet from groovy
    /////////////////////////////////////////////////////////////////
    gs.set = function(value) {
        var object;

        if (arguments.length === 0) {
            object = gs.list([]);
        } else {
            object = value;
        }

        createClassNames(object, ['java.util.HashSet']);

        object.isSet = true;

        object.withz = function(closure) {
            return interceptClosureCall(closure, this);
        };

        object.add = function(item) {
            if (!(this.contains(item))) {
                this.push(item);
                return this;
            } else {
                return false;
            }
        };

        object.addAll = function(elements) {
            if (elements instanceof Array) {
                var i, fails = false;

                //Check if items not in set
                for (i = 0; !fails && i < elements.length; i++) {
                    if (this.contains(elements[i])) {
                        fails = true;
                    }
                }
                if (fails) {
                    return false;
                } else {
                    //All ok, we add items to the set
                    for (i = 0; i < elements.length; i++) {
                        this.add(elements[i]);
                    }
                }
            }
            return this;
        };

        object.equals = function(other) {
            if (!(other instanceof Array) || other.length != this.length || !(other.isSet)) {
                return false;
            } else {
                var i, result = true;
                for (i = 0; i < this.length && result; i++) {
                    if (!(other.contains(this[i]))) {
                        result = false;
                    }
                }
                return result;
            }
        };

        object.toList = function() {
            var i, list = [];
            for (i = 0; i < this.length; i++) {
                list[i] = this[i];
            }
            return gs.list(list);
        };

        object.plus = function(other) {
            var result = gs.set();
            result.addAll(this);
            if (other instanceof Array) {
                var i;
                for (i = 0; i < other.length; i++) {
                    if (!(result.contains(other[i]))) {
                        result.add(other[i]);
                    }
                }
            }
            return result;
        };

        object.minus = function(other) {
            var result = gs.set();
            result.addAll(this);
            if (other instanceof Array) {
                var i;
                for (i = 0;i < other.length; i++) {
                    if (result.contains(other[i])) {
                        result.remove(other[i]);
                    }
                }
            }
            return result;
        };

        object.remove = function(value) {
            var index = this.indexOf(value);
            if (index >= 0) {
                this.splice(index, 1);
                return true;
            } else {
                return false;
            }
        };

        return object;
    };

    /////////////////////////////////////////////////////////////////
    // map - [:] from groovy
    /////////////////////////////////////////////////////////////////
    function isMapProperty(name) {
        return isObjectProperty(name) || ['any','collect',
            'collectEntries','collectMany','countBy','dropWhile',
            'each','eachWithIndex','every','find','findAll',
            'findResult','findResults','get','getAt','groupBy',
            'inject','intersect','max','min',
            'putAll','putAt','reverseEach', 'clear',
            'sort','spread','subMap','add','take','takeWhile',
            'withDefault','count','drop','keySet',
            'put','size','isEmpty','remove','containsKey',
            'containsValue','values'].indexOf(name) >= 0;
    }

    gs.map = function() {
        var gSobject = new GsGroovyMap();
        expandWithMetaClass(gSobject, 'LinkedHashMap');
        applyBaseClassFunctions(gSobject);
        if (arguments.length == 1 && arguments[0] instanceof Object) {
            gs.passMapToObject(arguments[0], gSobject);
        }

        return gSobject;
    };

    function GsGroovyMap() {}

    GsGroovyMap.prototype.clazz = { name: 'java.util.LinkedHashMap', simpleName: 'LinkedHashMap',
        superclass: { name: 'java.util.HashMap', simpleName: 'HashMap'}};
    GsGroovyMap.prototype.gSdefaultValue = null;
    GsGroovyMap.prototype.withz = BaseClass.prototype.withz;
    GsGroovyMap.prototype.add = function(key, value) {
        if (key == "spreadMap") {
            //We insert items of the map, from spread operator
            var ob;
            for (ob in value) {
                if (!isMapProperty(ob)) {
                    this[ob] = value[ob];
                }
            }
        } else {
            this[key] = value;
        }
        return this;
    };
    GsGroovyMap.prototype.put = function(key,value) {
        return this.add(key,value);
    };
    GsGroovyMap.prototype.leftShift = function(key,value) {
        if (arguments.length == 1) {
            return this.plus(arguments[0]);
        } else {
            return this.add(key,value);
        }
    };
    GsGroovyMap.prototype.putAt = function(key,value) {
        this.put(key,value);
    };
    GsGroovyMap.prototype.size = function() {
        var number = 0,ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                number++;
            }
        }
        return number;
    };
    GsGroovyMap.prototype.isEmpty = function() {
        return (this.size() === 0);
    };
    GsGroovyMap.prototype.remove = function(key) {
        if (this[key]) {
            delete this[key];
        }
    };
    GsGroovyMap.prototype.each = function(closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                //Nice, number of arguments in length property
                if (f.length == 1) {
                    closure({key: ob, value: this[ob]});
                }
                if (f.length == 2) {
                    closure(ob,this[ob]);
                }
            }
        }
    };

    GsGroovyMap.prototype.count = function(closure) {
        var number = 0, ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                if (closure.length == 1) {
                    if (closure({key: ob, value: this[ob]})) {
                        number++;
                    }
                }
                if (closure.length == 2) {
                    if (closure(ob, this[ob])) {
                        number++;
                    }
                }
            }
        }
        return number;
    };

    GsGroovyMap.prototype.any = function(closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length == 1) {
                    if (closure({key:ob, value: this[ob]})) {
                        return true;
                    }
                }
                if (f.length == 2) {
                    if (closure(ob, this[ob])) {
                        return true;
                    }
                }
            }
        }
        return false;
    };

    GsGroovyMap.prototype.every = function(closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length == 1) {
                    if (!closure({key: ob, value: this[ob]})) {
                        return false;
                    }
                }
                if (f.length == 2) {
                    if (!closure(ob, this[ob])) {
                        return false;
                    }
                }
            }
        }
        return true;
    };

    GsGroovyMap.prototype.find = function(closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length == 1) {
                    var entry = {key: ob, value: this[ob]};
                    if (closure(entry)) {
                        return entry;
                    }
                }
                if (f.length == 2) {
                    if (closure(ob, this[ob])) {
                        return {key: ob, value: this[ob]};
                    }
                }
            }
        }
        return null;
    };

    GsGroovyMap.prototype.dropWhile = function(closure) {
        var result = gs.map(), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var entry = {key: ob, value: this[ob]};

                var f = arguments[0];
                if (f.length == 1) {
                    if (!closure(entry)) {
                        result.add(entry.key, entry.value);
                    }
                }
                if (f.length == 2) {
                    if (!closure(entry.key, entry.value)) {
                        result.add(entry.key, entry.value);
                    }
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.drop = function(number) {
        var result = gs.map(), ob, count = 0;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                count ++;
                if (count > number) {
                    result.add(ob, this[ob]);
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.findAll = function(closure) {
        var result = gs.map(), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length == 1) {
                    var entry = {key: ob, value: this[ob]};
                    if (closure(entry)) {
                        result.add(entry.key, entry.value);
                    }
                }
                if (f.length == 2) {
                    if (closure(ob, this[ob])) {
                        result.add(ob, this[ob]);
                    }
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.collect = function(closure) {
        var result = gs.list([]), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length==1) {
                    result.add(closure({key:ob, value:this[ob]}));
                }
                if (f.length==2) {
                    result.add(closure(ob,this[ob]));
                }
            }
        }
        if (result.size()>0) {
            return result;
        } else {
            return null;
        }
    };

    GsGroovyMap.prototype.containsKey = function(key) {
        if (this[key] === undefined || this[key] === null) {
            return false;
        } else {
            return true;
        }
    };

    GsGroovyMap.prototype.containsValue = function(value) {
        var ob, gotIt = false;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                if (gs.equals(this[ob],value)) {
                    gotIt = true;
                    break;
                }
            }
        }
        return gotIt;
    };

    GsGroovyMap.prototype.get = function(key, defaultValue) {
        if (!this.containsKey(key)) {
            this[key] = defaultValue;
        }
        return this[key];
    };

    GsGroovyMap.prototype.toString = function() {
        var items = '';
        this.each (function(key,value) {
            items = items + key+': '+value+' ,';
        });
        return '[' + items + ']';
    };

    GsGroovyMap.prototype.equals = function(otherMap) {
        var result = true, ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                if (!gs.equals(this[ob],otherMap[ob])) {
                    result = false;
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.keySet = function() {
        var result = gs.list([]), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                result.add(ob);
            }
        }
        return result;
    };

    GsGroovyMap.prototype.values = function() {
        var result = gs.list([]), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                result.add(this[ob]);
            }
        }
        return result;
    };

    GsGroovyMap.prototype.withDefault = function(closure) {
        this.gSdefaultValue = closure;
        return this;
    };

    GsGroovyMap.prototype.inject = function(initial,closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                if (closure.length == 2) {
                    var entry = {key:ob, value:this[ob]};
                    initial = closure(initial, entry);
                }
                if (closure.length == 3) {
                    initial = closure(initial, ob, this[ob]);
                }
            }
        }
        return initial;
    };

    GsGroovyMap.prototype.putAll = function (items) {
        if (items instanceof Array) {
            var i;
            for (i=0;i<items.length;i++) {
                var item = items[i];
                this.add(item.key,item.value);
            }
        } else {
            var ob;
            for (ob in items) {
                if (!isMapProperty(ob)) {
                    this.add(ob,items[ob]);
                }
            }
        }
        return this;
    };

    GsGroovyMap.prototype.plus = function(other) {
        var result = this.clone();
        if (other instanceof Array) {
            result.putAll(other);
        } else {
            var ob;
            for (ob in other) {
                if (!isMapProperty(ob)) {
                    result.add(ob,other[ob]);
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.clone = function() {
        var result = gs.map(), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                result.add(ob, this[ob]);
            }
        }
        return result;
    };

    GsGroovyMap.prototype.minus = function(other) {
        var result = this.clone(), ob;
        for (ob in other) {
            if (!isMapProperty(ob)) {
                if (result[ob] !== null && result[ob] !==undefined && gs.equals(result[ob],other[ob])) {
                    delete result[ob];
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.clear = function() {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                delete this[ob];
            }
        }
    };

    /////////////////////////////////////////////////////////////////
    // Array prototype changes
    /////////////////////////////////////////////////////////////////
    Array.prototype.get = function(pos) {

        //Maybe comes a second parameter with default value
        if (arguments.length == 2) {
            if (this[pos] === null || this[pos] === undefined) {
                return arguments[1];
            } else {
                return this[pos];
            }
        } else {
            return this[pos];
        }
    };

    Array.prototype.getAt = function(pos) {
        return this[pos];
    };

    Array.prototype.withz = function(closure) {
        return interceptClosureCall(closure, this);
    };

    Array.prototype.size = function() {
        return this.length;
    };

    Array.prototype.isEmpty = function() {
        return this.length === 0;
    };

    Array.prototype.add = function(pos, element) {
        if (element === undefined) {
            this.push(pos);
        } else {
            this[pos] = element;
        }
        return this;
    };

    Array.prototype.addAll = function(elements) {
        var i;
        if (arguments.length == 1) {
            if (elements instanceof Array) {
                for (i = 0; i < elements.length; i++) {
                    this.add(elements[i]);
                }
            } else {
                this.push(elements);
            }
        } else {
            //Two parameters index and collection
            var index = arguments[0];
            var data = arguments[1];
            for (i=0; i < data.length; i++) {
                this.splice(index+i, 0, data[i]);
            }
        }
        return true;
    };

    Array.prototype.clone = function() {
        var result = gs.list([]);
        result.addAll(this);
        return result;
    };

    Array.prototype.plus = function(other) {
        var result = this.clone();
        result.addAll(other);
        return result;
    };

    Array.prototype.minus = function(other) {
        var result = this.clone();
        result.removeAll(other);
        return result;
    };

    Array.prototype.leftShift = function(element) {
        return this.add(element);
    };

    Array.prototype.contains = function(object) {
        var gotIt, i;
        for (i=0; !gotIt && i < this.length; i++) {
            if (gs.equals(this[i], object)) {
                gotIt = true;
            }
        }
        return gotIt;
    };

    Array.prototype.containsAll = function(list) {
        var i, numberEq = 0;
        for (i = 0; i < list.length; i++) {
            if (this.contains(list[i])) {
                numberEq++;
            }
        }
        if (numberEq == list.length) {
            return true;
        } else {
            return false;
        }
    };

    Array.prototype.each = function(closure) {
        var i;
        for (i = 0; i < this.length; i++) {
            //TODO Beware this change, have to apply to all closure calls
            interceptClosureCall(closure, this[i]);
        }
        return this;
    };

    Array.prototype.reverseEach = function(closure) {
        var i;
        for (i = this.length - 1; i >= 0; i--) {
            interceptClosureCall(closure, this[i]);
        }
        return this;
    };

    Array.prototype.eachWithIndex = function(closure,index) {
        for (index=0; index < this.length; index++) {
            closure(this[index], index);
        }
        return this;
    };

    Array.prototype.any = function(closure) {
        var i;
        for (i = 0;i < this.length; i++) {
            if (closure(this[i])) {
                return true;
            }
        }
        return false;
    };

    Array.prototype.oldValues = Array.prototype.values;

    Array.prototype.values = function() {
        if (isJsArray(this) && Array.prototype.oldValues) {
            return this.oldValues();
        } else {
            var i, result = [];
            for (i = 0; i < this.length; i++) {
                result[i] = this[i];
            }
            return result;
        }
    };
    //Remove only 1 item from the list
    Array.prototype.remove = function(indexOrValue) {
        var result = false,index = -1;
        if (typeof indexOrValue == 'number') {
            index = indexOrValue;
            result = this[index];
        } else {
            index = this.indexOf(indexOrValue);
            if (index >= 0) {
                result = true;
            }
        }
        if (index >= 0) {
            this.splice(index, 1);
        }
        return result;
    };

    //Maybe too much complex, not much inspired
    Array.prototype.removeAll = function(data) {
        if (data instanceof Array) {
            var result = [];
            this.forEach(function(v, i, a) {
                if (data.contains(v)) {
                    result.push(i);
                }
            });
            //Now in result we have index of items to delete
            if (result.length>0) {
                var decremental = 0;
                var thisList = this;
                result.forEach(function(v, i, a) {
                    //Had tho change this for thisList, other scope on this here
                    thisList.splice(v-decremental,1);
                    decremental=decremental+1;
                });
            }
        } else if (isFunction(data)) {
            var i;
            for (i = this.length - 1; i >= 0; i--) {
                if (data(this[i])) {
                    this.remove(i);
                }
            }
        }
        return this;
    };

    Array.prototype.collect = function(closure) {
        var i, result = gs.list([]);
        for (i = 0; i < this.length; i++) {
            result[i] = closure(this[i]);
        }
        return result;
    };

    Array.prototype.collectMany = function(closure) {
        var i, result = gs.list([]);
        for (i = 0;i < this.length; i++) {
            result.addAll(closure(this[i]));
        }
        return result;
    };

    Array.prototype.takeWhile = function(closure) {
        var i, result = gs.list([]);
        for (i = 0; i < this.length; i++) {
            if (closure(this[i])) {
                result[i] = this[i];
            } else {
                break;
            }
        }
        return result;
    };

    Array.prototype.dropWhile = function(closure) {
        var result = gs.list([]);
        var i, j=0, insert = false;
        for (i = 0; i < this.length; i++) {
            if (!closure(this[i])) {
                insert=true;
            }
            if (insert) {
                result[j++] = this[i];
            }
        }
        return result;
    };

    Array.prototype.drop = function(number) {
        var i, result = gs.list([]);
        for (i = number; i < this.length; i++) {
            result.push(this[i]);
        }
        return result;
    };

    Array.prototype.findAll = function(closure) {
        var values = this.filter(closure);
        return gs.list(values);
    };

    if (!Array.prototype.find) {
        Array.prototype.find = function (closure) {
            var result, i;
            for (i = 0; !result && i < this.length; i++) {
                if (closure(this[i])) {
                    result = this[i];
                }
            }
            return result;
        };
    }

    Array.prototype.first = function() {
        return this[0];
    };

    Array.prototype.head = function() {
        return this.first();
    };

    Array.prototype.last = function() {
        return this[this.length - 1];
    };

    Array.prototype.sum = function() {

        var i, result = 0;
        //can pass a closure to sum
        if (arguments.length == 1) {
            for (i = 0; i < this.length; i++) {
                result = result + arguments[0](this[i]);
            }
        } else {
            if (this.length > 0 && this[0].plus) {
                var item = this[0];
                for (i = 0; i + 1 < this.length; i++) {
                    item = item.plus(this[i + 1]);
                }
                return item;
            } else {
                for (i = 0; i < this.length; i++) {
                    result = result + this[i];
                }
            }
        }
        return result;
    };

    Array.prototype.inject = function() {

        var acc;
        //only 1 argument, just the closure
        if (arguments.length == 1) {
            acc = this[0];
            var i;
            for (i=1;i<this.length;i++) {
                acc = arguments[0](acc,this[i]);
            }

        } else {
            //We suppose arguments = 2
            acc = arguments[0];
            var j;
            for (j=0;j<this.length;j++) {
                acc = arguments[1](acc,this[j]);
            }
        }
        return acc;
    };

    Array.prototype.toList = function() {
        return this;
    };

    Array.prototype.intersect = function(otherList) {
        var i, result = gs.list([]);
        for (i = 0;i < this.length; i++) {
            if (otherList.contains(this[i])) {
                result.add(this[i]);
            }
        }
        return result;
    };

    Array.prototype.max = function() {
        var i, result = null;
        for (i = 0; i < this.length; i++) {
            if (result === null || this[i] > result) {
                result = this[i];
            }
        }
        return result;
    };

    Array.prototype.min = function() {
        var i, result = null;
        for (i = 0; i < this.length; i++) {
            if (result === null || this[i] < result) {
                result = this[i];
            }
        }
        return result;
    };

    Array.prototype.oldToString = Array.prototype.toString;

    Array.prototype.toString = function() {
        if (isJsArray(this)) {
            return this.oldToString();
        } else if (this.length > 0) {
            return '[' + this.join(', ') + ']';
        } else {
            return '[]';
        }
    };

    Array.prototype.grep = function(param) {
        var i, result = gs.list([]);
        if (param instanceof RegExp) {
            for (i = 0; i < this.length; i++) {
                if (gs.match(this[i],param)) {
                    result.add(this[i]);
                }
            }
            return result;
        } else if (param instanceof Array) {
            return this.intersect(param);
        } else if (isFunction(param)) {
            for (i = 0; i < this.length; i++) {
                if (param(this[i])) {
                    result.add(this[i]);
                }
            }
            return result;
        } else {
            for (i = 0; i < this.length ;i++) {
                if (this[i]==param) {
                    result.add(this[i]);
                }
            }
            return result;
        }
    };

    Array.prototype.equals = function(other) {
        if (!(other instanceof Array) || other.length!=this.length) {
            return false;
        } else {
            var i, result = true;
            for (i = 0;i < this.length && result; i++) {
                if (!gs.equals(this[i],other[i])) {
                    result = false;
                }
            }
            return result;
        }
    };

    Array.prototype.gSjoin = function() {
        var separator = '';
        if (arguments.length == 1) {
            separator = arguments[0];
        }
        var i, result = '';
        for (i = 0; i < this.length; i++) {
            result = result + this[i];
            if ((i + 1) < this.length) {
                result = result + separator;
            }
        }
        return result;
    };

    Array.prototype.oldSort = Array.prototype.sort;

    Array.prototype.sort = function() {
        var modify = true;
        if (arguments.length > 0 && arguments[0] === false) {
            modify = false;
        }
        var i,copy = [];
        //Maybe some closure as last parameter
        var tempFunction = null;
        if (arguments.length == 2 && isFunction(arguments[1])) {
            tempFunction = arguments[1];
        }
        if (arguments.length == 1 && isFunction(arguments[0])) {
            tempFunction = arguments[0];
        }
        //Copy all items
        for (i=0;i<this.length;i++) {
            copy[i] = this[i];
        }
        //If function has 2 parameter, inside compare both and return a number
        if (tempFunction !== null && tempFunction.length == 2) {
            copy.oldSort(tempFunction);
        }
        //If function has 1 parameter, we have to compare transformed items
        if (tempFunction !== null && tempFunction.length == 1) {
            copy.oldSort(function(a, b) {
                return gs.spaceShip(tempFunction(a),tempFunction(b));
            });
        }
        if (tempFunction === null) {
            copy.oldSort();
        }
        if (modify) {
            for (i=0;i<this.length;i++) {
                this[i] = copy[i];
            }
            return this;
        } else {
            return gs.list(copy);
        }
    };

    Array.prototype.unique = function() {
        var modify = true;
        if (arguments.length > 0 && arguments[0] === false) {
            modify = false;
        }
        var i, copy = [];
        //Copy all items
        for (i = 0; i < this.length; i++) {
            if (!copy.contains(this[i])) {
                copy.push(this[i]);
            }
        }

        if (modify) {
            this.length = 0;
            for (i = 0; i < copy.length; i++) {
                this[i] = copy[i];
            }
            return this;
        } else {
            return gs.list(copy);
        }
    };

    Array.prototype.oldReverse = Array.prototype.reverse;

    Array.prototype.reverse = function() {
        var i, count = 0;
        if (isJsArray(this)) {
            return this.oldReverse();
        } else if (arguments.length == 1 && arguments[0] === true) {
            for (i = this.length - 1; i > count; i--) {
                var temp = this[count];
                this[count++] = this[i];
                this[i] = temp;
            }
            return this;
        } else {
            var result = [];
            for (i = this.length - 1; i >= 0; i--) {
                result[count++] = this[i];
            }
            return gs.list(result);
        }
    };

    Array.prototype.take = function(number) {
        var i, result = [];
        for (i = 0; i < number; i++) {
            if (i < this.length) {
                result[i] = this[i];
            }
        }
        return gs.list(result);
    };

    Array.prototype.takeWhile = function(closure) {
        var result = [], i, exit=false;
        for (i = 0; !exit && i < this.length; i++) {
            if (closure(this[i])) {
                result[i] = this[i];
            } else {
                exit = true;
            }
        }
        return gs.list(result);
    };

    Array.prototype.multiply = function(number) {
        if (number === 0) {
            return gs.list([]);
        } else {
            var i, result = gs.list([]);
            for (i=0;i<number;i++) {
                var j;
                for (j=0;j<this.length;j++) {
                    result.add(this[j]);
                }
            }
            return result;
        }
    };

    Array.prototype.flatten = function() {
        var result = gs.list([]);
        gs.flatten(result, this);

        return result;
    };

    Array.prototype.collate = function(number) {
        var step = number,times = 0;
        if (arguments.length == 2) {
            step = arguments[1];
        }
        var result = gs.list([]);
        while (step * times < this.length) {
            var items = gs.list([]);
            var pos = step * times;
            while (pos < this.length && items.size() < number) {
                items.add(this[pos++]);
            }
            result.add(items);
            times++;
        }
        return result;
    };

    Array.prototype.groupBy = function(closure) {
        var i, result = gs.map();
        for (i=0;i<this.length;i++) {
            var r = closure(this[i]);
            var l = result[r];
            if (l) {
                l.add(this[i]);
            } else {
                result.add(r, gs.list().add(this[i]));
            }
        }
        return result;
    };

    Array.prototype.putAt = function(position, value) {
        this[position] = value;
    };

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

    Array.prototype.count = function(value) {
        var i, result = 0;
        if (isFunction(value)) {
            for (i = 0; i < this.length; i++) {
                if (gs.bool(value(this[i]))) {
                    result++;
                }
            }
        } else {
            for (i = 0; i < this.length; i++) {
                if (gs.equals(value, this[i])) {
                    result++;
                }
            }
        }
        return result;
    };

    Array.prototype.tail = function() {
        var i, result = [];
        for (i = 1; i < this.length; i++) {
            result.push(this[i]);
        }
        return gs.list(result);
    };

    Array.prototype.init = function() {
        var i, result = [];
        for (i = 0; i < this.length - 1; i++) {
            result.push(this[i]);
        }
        return gs.list(result);
    };

    /////////////////////////////////////////////////////////////////
    //list - [] from groovy
    /////////////////////////////////////////////////////////////////
    gs.list = function(value) {
        var data = [];
        if (value && value.length > 0) {
            var i;
            for (i = 0; i < value.length; i++) {
                if (value[i] instanceof gs.spread) {
                    var values = value[i].values;
                    if (values.length > 0) {
                        var j;
                        for (j = 0; j < values.length; j++) {
                            data.push(values[j]);
                        }
                    }
                } else {
                    data.push(value[i]);
                }
            }
        }
        var object = data;
        object.clazz = {name: 'java.util.ArrayList', simpleName: 'ArrayList'};
        applyBaseClassFunctions(object);
        return object;
    };

    gs.flatten = function(result, list) {
        list.each(function (it) {
            if (it instanceof Array) {
                if (it.length>0) {
                    gs.flatten(result, it);
                }
            } else {
                result.add(it);
            }
        });
    };

    /////////////////////////////////////////////////////////////////
    //range - [x..y] from groovy
    /////////////////////////////////////////////////////////////////
    gs.range = function(begin, end, inclusive) {
        var start = begin;
        var finish = end;
        var areChars = (typeof(begin) == 'string');
        if (areChars) {
            start = start.charCodeAt(0);
            finish = finish.charCodeAt(0);
        }
        var reverse = false;
        if (finish < start) {
            var oldStart = start;
            start = finish;
            finish = oldStart;
            reverse = true;
            if (!inclusive) {
                start = start + 1;
            }
        } else {
            if (!inclusive) {
                finish = finish - 1;
            }
        }

        var result,number,count;
        for (result=[], number = start, count = 0 ; number <= finish ; number++, count++) {
            if (areChars) {
                result[count] = String.fromCharCode(number);
            } else {
                result[count] = number;
            }
        }
        if (reverse) {
            result = result.reverse();
        }
        var object = gs.list(result);
        object.toList = function() {
            return gs.list(this.values());
        };
        return object;
    };

    /////////////////////////////////////////////////////////////////
    //date - Date() object from groovy / java
    /////////////////////////////////////////////////////////////////
    gs.date = function() {

        var gSobject;
        if (arguments.length == 1) {
            gSobject = new Date(arguments[0]);
        } else {
            gSobject = new Date();
        }

        createClassNames(gSobject, ['java.util.Date']);
        gSobject.withz = BaseClass.prototype.withz;

        gSobject.time = gSobject.getTime();
        gSobject.setTime = function(milis) {
            gSobject.time = milis;
        };

        gSobject.year = gSobject.getFullYear();
        gSobject.month = gSobject.getMonth();
        gSobject.date = gSobject.getDay();
        gSobject.plus = function(other) {
            if (typeof other == 'number') {
                return gs.date(gSobject.time + (other * 1440000));
            } else {
                return gSobject + other;
            }
        };
        gSobject.minus = function(other) {
            if (typeof other == 'number') {
                return gs.date(gSobject.time - (other * 1440000));
            } else {
                return gSobject - other;
            }
        };
        gSobject.format = function(rule) {
            //TODO complete
            var exit = '';
            if (rule) {
                exit = rule;
                exit = exit.replaceAll('yyyy', gSobject.getFullYear());
                exit = exit.replaceAll('MM', fillZerosLeft(gSobject.getMonth() + 1, 2));
                exit = exit.replaceAll('dd', fillZerosLeft(gSobject.getUTCDate(), 2));
                exit = exit.replaceAll('HH', fillZerosLeft(gSobject.getHours(), 2));
                exit = exit.replaceAll('mm', fillZerosLeft(gSobject.getMinutes(), 2));
                exit = exit.replaceAll('ss', fillZerosLeft(gSobject.getSeconds(), 2));
                exit = exit.replaceAll('yy', lastChars(gSobject.getFullYear(), 2));
            }
            return exit;
        };
        gSobject.parse = function(rule, text) {
            //TODO complete
            var pos = rule.indexOf('MM');
            if (pos >= 0) {
                var newMonth = text.substr(pos, 2) - 1;
                while (gSobject.getMonth() != newMonth) {
                    gSobject.setMonth(newMonth);
                }
            }
            pos = rule.indexOf('dd');
            if (pos >= 0) {
                var newDay = text.substr(pos, 2);
                while (gSobject.getUTCDate() != newDay) {
                    gSobject.setUTCDate(newDay);
                }
            }
            pos = rule.indexOf('yyyy');
            if (pos >= 0) {
                gSobject.setFullYear(text.substr(pos, 4));
            } else {
                pos = rule.indexOf('yy');
                if (pos >= 0) {
                    gSobject.setFullYear(text.substr(pos, 2));
                }
            }
            pos = rule.indexOf('HH');
            if (pos >= 0) {
                gSobject.setHours(text.substr(pos, 2));
            }
            pos = rule.indexOf('mm');
            if (pos >= 0) {
                gSobject.setMinutes(text.substr(pos, 2));
            }
            pos = rule.indexOf('ss');
            if (pos >= 0) {
                gSobject.setSeconds(text.substr(pos, 2));
            }

            return gSobject;
        };
        gSobject.clearTime = function() {
            gSobject.setHours(0, 0, 0, 0);
            return gSobject;
        };
        gSobject.equals = function(other) {
            return gSobject.time == other.time;
        };
        gSobject.before = function(other) {
            return gSobject.time < other.time;
        };
        gSobject.after = function(other) {
            return gSobject.time > other.time;
        };
        return gSobject;
    };

    gs.rangeFromList = function(list, begin, end) {
        return list.slice(begin, end + 1);
    };

    function fillZerosLeft(item, size) {
        var value = item + '';
        while (value.length < size) {
            value = '0' + value;
        }
        return value;
    }

    function lastChars(item, number) {
        var value = item + '';
        value = value.substring(value.length - number);
        return value;
    }

    /////////////////////////////////////////////////////////////////
    //exactMatch - For regular expressions
    /////////////////////////////////////////////////////////////////
    gs.exactMatch = function(text, regExp) {
        var mock = text;
        if (regExp instanceof RegExp) {
            mock = mock.replace(regExp, "#");
        } else {
            mock = mock.replace(new RegExp(regExp), "#");
        }
        return mock == "#";
    };

    gs.match = function(text, regExp) {
        var pos;
        if (regExp instanceof RegExp) {
            pos = text.search(regExp);
        }
        return (pos>=0);
    };

    /////////////////////////////////////////////////////////////////
    //regExp - For regular expressions
    /////////////////////////////////////////////////////////////////
    gs.regExp = function(text, ppattern) {

        var patt;
        if (ppattern instanceof RegExp) {
            patt = new RegExp(ppattern.source, 'g');
        } else {
            //g for search all occurences
            patt = new RegExp(ppattern, 'g');
        }

        var object;

        var data = patt.exec(text);
        if (data === null || data === undefined) {
            return null;
        } else {
            var list = gs.list([]);
            var i = 0;

            while (data) {
                if (data instanceof Array && data.length < 2) {
                    list[i] = data[0];
                } else {
                    list[i] = gs.list(data);
                }
                i = i + 1;
                data = patt.exec(text);
            }
            object = expandWithMetaClass(list, 'RegExp');
        }

        createClassNames(object, ['java.util.regex.Matcher']);

        object.pattern = patt;
        object.text = text;

        object.replaceFirst = function(data) {
            return this.text.replaceFirst(this[0], data);
        };

        object.replaceAll = function(data) {
            return this.text.replaceAll(this.pattern, data);
        };

        object.reset = function() {
            return this;
        };

        return object;
    };

    /////////////////////////////////////////////////////////////////
    //Pattern
    /////////////////////////////////////////////////////////////////
    gs.pattern = function(pattern) {
        var object = gs.init('Pattern');

        createClassNames(object, ['java.util.regex.Pattern']);

        object.value = pattern;
        return object;
    };

    /////////////////////////////////////////////////////////////////
    // Regular Expresions
    /////////////////////////////////////////////////////////////////
    gs.matcher = function(item, regExpression) {

        var object = gs.init('Matcher');
        createClassNames(object, ['java.util.regex.Matcher']);

        object.data = item;
        object.regExp = regExpression;
        object.matches = function() {
            return gs.exactMatch(this.data, this.regExp);
        };

        return object;
    };

    RegExp.prototype.matcher = function(item) {
        return gs.matcher(item, this);
    };

    /////////////////////////////////////////////////////////////////
    //Number functions
    /////////////////////////////////////////////////////////////////
    Number.prototype.times = function(closure) {
        var i;
        for (i = 0; i < this; i++) {
            closure(i);
        }
    };

    Number.prototype.upto = function(number, closure) {
        var i;
        for (i = this.value; i <= number; i++) {
            closure(i);
        }
    };

    Number.prototype.step = function(number, jump, closure) {
        var i;
        for (i = this.value; i < number;) {
            closure(i);
            i = i + jump;
        }
    };

    Number.prototype.multiply = function(number) {
        return this * number;
    };

    Number.prototype.power = function(number) {
        return Math.pow(this,number);
    };

    Number.prototype.byteValue = Number.prototype.doubleValue = Number.prototype.shortValue =
        Number.prototype.floatValue = Number.prototype.longValue = function() {
        return this;
    };

    Number.prototype.intValue = function() {
        return Math.floor(this);
    };

    /////////////////////////////////////////////////////////////////
    //String functions
    /////////////////////////////////////////////////////////////////
    String.prototype.contains = function(value) {
        return this.indexOf(value) >= 0;
    };

    String.prototype.startsWith = function(value) {
        return this.indexOf(value) === 0;
    };

    String.prototype.endsWith = function(value) {
        return this.indexOf(value) > -1 && this.indexOf(value) == (this.length - value.length);
    };

    String.prototype.count = function(value) {
        var reg = new RegExp(value, 'g');
        var result = this.match(reg);
        if (result) {
            return result.length;
        } else {
            return 0;
        }
    };

    String.prototype.size = function() {
        return this.length;
    };

    String.prototype.replaceAll = function(oldValue, newValue) {
        var reg;
        if (oldValue instanceof RegExp) {
            reg = new RegExp(oldValue.source, 'g');
        } else {
            reg = new RegExp(oldValue, 'g');
        }
        return this.replace(reg, newValue);
    };

    String.prototype.replaceFirst = function(oldValue, newValue) {
        return this.replace(oldValue, newValue);
    };


    String.prototype.reverse = function() {
        return this.split("").reverse().join("");
    };

    String.prototype.tokenize = function() {
        var str = " ";
        if (arguments.length == 1 && arguments[0]) {
            str = arguments[0];
        }
        var list = this.split(str);
        return gs.list(list);
    };

    String.prototype.multiply = function(value) {
        if (typeof(value) == 'number') {
            var result = '';
            var i;
            for (i=0; i < (value | 0); i++) {
                result = result + this;
            }
            return result;
        }
    };

    String.prototype.capitalize = function() {
        return this.charAt(0).toUpperCase() + this.slice(1);
    };

    String.prototype.each = function(closure) {
        var list = gs.list(this.split(''));
        list.each(closure);
    };

    String.prototype.inject = function(initial, closure) {
        var list = gs.list(this.split(''));
        return list.inject(initial, closure);
    };

    function getItemsMultiline(text) {
        var items = text.split('\n');
        if (items.length > 1 && items[items.length - 1] === '') {
            items.splice(items.length - 1, 1);
        }
        return items;
    }

    String.prototype.eachLine = function(closure) {
        var i, items = getItemsMultiline(this);
        for (i = 0; i < items.length; i++) {
            var item = items[i];
            //Closure with 2 arguments, line and count
            if (closure.length == 2) {
                closure(item, i);
            } else {
                closure(item);
            }
        }
    };

    String.prototype.readLines = function() {
        var items = getItemsMultiline(this);
        return gs.list(items);
    };

    String.prototype.padRight = function(number) {
        var sep = ' ';
        if (arguments.length==2) {
            sep = arguments[1];
        }
        var item = this;
        while (item.length < number) {
            item = item + sep;
        }
        return item;
    };

    String.prototype.padLeft = function(number) {
        var sep = ' ';
        if (arguments.length == 2) {
            sep = arguments[1];
        }
        var item = this;
        while (item.length < number) {
            item = sep + item;
        }
        return item;
    };

    String.prototype.isNumber = function() {
        if (this.trim() === '') {
            return false;
        } else {
            var res = Number(this);
            if (isNaN(res)) {
                return false;
            } else {
                return true;
            }
        }
    };

    String.prototype.plus = function(other) {
        var addText = 'null';
        if (other !== undefined && other !== null) {
            if (other['toString'] !== undefined) {
                addText = other.toString();
            } else {
                addText = other;
            }
        }
        return this + addText;
    };

    String.prototype.toInteger = function() {
        return parseInt(this);
    };

    /////////////////////////////////////////////////////////////////
    // Misc Functions
    /////////////////////////////////////////////////////////////////
    gs.classForName = function(name, obj) {
        var result = null;
        try {
            var pos = name.indexOf(".");
            while (pos >= 0) {
                name = name.substring(pos + 1);
                pos = name.indexOf(".");
            }
            result = (typeof globalThis!=="undefined"&&globalThis[name]!==undefined?globalThis[name]:undefined);
        } catch (err) {
            result = obj;
        }
        return result;
    };

    function StaticMethods(item) {
        this.gSparent = item;
    }

    gs.metaClass = function(item) {
        var type = typeof item;

        if (type == "string") {
            item = new String(item);
        } else if (type == "number") {
            item = new Number(item);
            //If type is a function, it's metaClass from a Class
        } else if (type === "function") {
            if (!globalMetaClass[item.name]) {
                globalMetaClass[item.name] = {
                    gSstatic: new StaticMethods(item),
                    getStatic : function() {
                        return this.gSstatic;
                    }
                };
            }
            item = globalMetaClass[item.name];
        }
        return item;
    };

    gs.passMapToObject = function(source, destination) {
        var prop;
        for (prop in source) {
            if (isFunction(source[prop])) continue;
            if (!isMapProperty(prop)) {
                gs.sp(destination, prop, source[prop]);
            }
        }
    };

    gs.equals = function(value1, value2) {
        if (!hasFunc(value1, 'equals')) {
            if (hasFunc(value2, 'equals')) {
                return value2.equals(value1);
            } else {
                return value1==value2;
            }
        } else {
            return value1.equals(value2);
        }
    };

    gs.is = function(value1, value2) {
        if (value1 !== null && hasFunc(value1, 'is')) {
            var count, params = gs.list([value2]);
            for (count = 2; count < arguments.length; count++) {
                params.add(arguments[count]);
            }
            return gs.mc(value1, 'is', params);
        } else {
            return value1 == value2;
        }
    };

    function interceptClosureCall(func, param) {
        if ((param instanceof Array) && func.length > 1) {
            return func.apply(func, param);
        } else {
            return func(param);
        }
    }

    gs.random = function() {
        var object = gs.init('Random');
        object.nextInt = function(number) {
            var ran = Math.ceil(Math.random()*number);
            return ran - 1;
        };
        object.nextBoolean = function() {
            var ran = Math.random();
            return ran < 0.5;
        };
        return object;
    };

    gs.bool = function(item) {
        if (item && item.isEmpty !== undefined) {
            return !item.isEmpty();
        } else {
            if (item) {
                if (item['asBoolean']) {
                    return item['asBoolean']();
                } else if (typeof(item) == 'number' && item === 0) {
                    return false;
                } else if (typeof(item) == 'string') {
                    return item !== '';
                }
            }
            return item;
        }
    };

    gs.less = function(itemLeft, itemRight) {
        return itemLeft < itemRight;
    };

    gs.greater = function(itemLeft, itemRight) {
        return itemLeft > itemRight;
    };

    // Operator <=>
    gs.spaceShip = function(itemLeft, itemRight) {
        if (gs.equals(itemLeft, itemRight)) {
            return 0;
        }
        if (gs.less(itemLeft, itemRight)) {
            return -1;
        }
        if (gs.greater(itemLeft, itemRight)) {
            return 1;
        }
    };

    //InstanceOf function
    gs.instanceOf = function(item, name) {
        var gotIt = false;

        if (name == "String")  {
            return typeof(item) == 'string';
        } else if (name == "Number") {
            return typeof(item) == 'number';
        } else if (item.clazz) {
            var classInfo;
            classInfo = item.clazz;
            while (classInfo && !gotIt) {
                if (classInfoContainsName(classInfo, name)) {
                    gotIt = true;
                } else {
                    classInfo = classInfo.superclass;
                }
            }
            if (!gotIt && item.clazz.interfaces) {
                var i;
                for (i = 0; i < item.clazz.interfaces.length && !gotIt; i++) {
                    if (classInfoContainsName(item.clazz.interfaces[i], name)) {
                        gotIt = true;
                    }
                }
            }
        } else if (isFunction(item) && name == 'Closure') {
            gotIt = true;
        }
        return gotIt;
    };

    function classInfoContainsName(classInfo, name) {
        return classInfo.name == name || classInfo.simpleName == name;
    }

    //Elvis operator
    gs.elvis = function(booleanExpression, trueExpression, falseExpression) {
        if (gs.bool(booleanExpression)) {
            return trueExpression;
        } else {
            return falseExpression;
        }
    };

    // * operator
    gs.multiply = function(a, b) {
        if (!hasFunc(a, 'multiply')) {
            return a * b;
        } else {
            return a.multiply(b);
        }
    };

    // / operator
    gs.div = function(a, b) {
        if (!hasFunc(a, 'div')) {
            return a / b;
        } else {
            return a.div(b);
        }
    };

    // ** operator
    gs.power = function(a, b) {
        if (!hasFunc(a, 'power')) {
            return Math.pow(a, b);
        } else {
            return a.power(b);
        }
    };

    // mod operator
    gs.mod = function(a, b) {
        if (!hasFunc(a, 'mod')) {
            return a % b;
        } else {
            return a.mod(b);
        }
    };

    // + operator
    gs.plus = function(a, b) {
        if (!hasFunc(a, 'plus')) {
            if ((typeof a == 'number') && (typeof b == 'number') && (a + b < 1)) {
                return ((a * 1000) + (b * 1000)) / 1000;
            } else {
                return a + b;
            }
        } else {
            return a.plus(b);
        }
    };

    // - operator
    gs.minus = function(a, b) {
        if (!hasFunc(a, 'minus')) {
            return a - b;
        } else {
            return a.minus(b);
        }
    };

    // in operator
    gs.gSin = function(item, group) {
        if (group && (isFunction(group.contains))) {
            return group.contains(item);
        } else {
            return false;
        }
    };

    //For some special cases where access a property with this."${name}"
    //This can be a closure
    gs.thisOrObject = function(thisItem, objectItem) {
        return objectItem || thisItem;
    };

    // spread operator (*)
    gs.spread = function(item) {
        if (item && item instanceof Array) {
            this.values = item;
        }
    };

    /////////////////////////////////////////////////////////////////
    // Beans functions - From groovy beans
    /////////////////////////////////////////////////////////////////
    //If an object has a function by name
    function hasFunc(item, name) {
        if (item === null || item === undefined || item[name] === undefined ||
            (!isFunction(item[name]))) {
            return false;
        } else {
            return true;
        }
    }

    //Set a property of a class
    gs.sp = function(item, nameProperty, value) {

        if (nameProperty == 'setProperty') {
            item[nameProperty] = value;
        } else if (nameProperty == 'getProperty') {
            item[nameProperty] = value;
        } else if (item !== null && item instanceof StaticMethods) {
            item[nameProperty] = value;
            item.gSparent[nameProperty] = value;
        } else {
            if (nameProperty === 'methodMissing' && value) {
                item[nameProperty] = value;
            } else if (!item['setProperty']) {
                var nameFunction = 'set' + nameProperty.charAt(0).toUpperCase() + nameProperty.slice(1);

                if (!item[nameFunction]) {
                    if (item[nameProperty] === undefined &&
                        item.setPropertyMissing !== undefined &&
                        isFunction(item.setPropertyMissing)) {
                        item.setPropertyMissing(nameProperty, value);
                    } else {
                        item[nameProperty] = value;
                    }
                } else {
                    item[nameFunction](value);
                }
            } else {
                item.setProperty(nameProperty,value);
            }
        }
    };

    //Get a property of a class
    gs.gp = function(item, nameProperty, inDelegates) {

        //It's a get with safe operator as item?.data
        if (arguments.length == 3) {
            if (item === null || item === undefined) {
                return null;
            }
        } else if (item == null || item === undefined) {
            throw 'gs.gp Get property: ' + nameProperty + ' on null or undefined object.'
        }

        if (!item['getProperty']) {
            return propFromObject(item, nameProperty, inDelegates);
        } else {
            var res = item.getProperty(nameProperty);
            return (res !== undefined ? res : propFromObject(item, nameProperty, inDelegates))
        }
    };

    function propFromObject(item, nameProperty, inDelegates) {
        var nameFunction = 'get' + nameProperty.charAt(0).toUpperCase() + nameProperty.slice(1);
        if (!item[nameFunction]) {
            if (nameProperty == 'size' && isFunction(item[nameProperty])) {
                return item[nameProperty]();
            } else {
                if (item[nameProperty] !== undefined) {
                    return item[nameProperty];
                } else {
                    //Lets check gp in @Delegate
                    if (item.clazz !== undefined) {
                        var addDelegate = mapAddDelegate[item.clazz.simpleName];
                        if (addDelegate !== null && addDelegate !== undefined) {
                            var i;
                            for (i = 0; i < addDelegate.length; i++) {
                                var prop = addDelegate[i];
                                var target = item[prop][nameProperty];
                                if (target !== undefined) {
                                    return item[prop][nameProperty];
                                }
                            }
                        }
                    }
                    //Default value of a map
                    if (item.gSdefaultValue !== undefined && (isFunction(item.gSdefaultValue))) {
                        item[nameProperty] = item.gSdefaultValue();
                    }
                    //Maybe in categories
                    if (categories.length > 0 && item[nameProperty] === undefined) {
                        var whereExecutes = categorySearching(nameFunction);
                        if (whereExecutes !== null) {
                            return whereExecutes[nameFunction].apply(item, [item]);
                        }
                    }

                    if (item.propertyMissing !== undefined && isFunction(item.propertyMissing)) {
                        return item.propertyMissing(nameProperty);
                    } else {
                        if (!inDelegates && delegates.length > 0) {
                            return findPropertyInDelegates(nameProperty, item);
                        } else {
                            return item[nameProperty];
                        }
                    }
                }
            }
        } else {
            return item[nameFunction]();
        }
    }

    function findPropertyInDelegates(nameProperty, item) {
        var i = delegates.length;
        var found = false;
        var result;
        while (i > 0 && !found && item ) {
            i = i - 1;
            result = gs.gp(delegates[i], nameProperty, true);
            if (result !== undefined) {
                found = true;
            }
        }
        return result;
    }

    //Control property changes with ++,--
    gs.plusPlus = function(item, nameProperty, plus, before) {
        var value = gs.gp(item, nameProperty);
        var newValue = value;
        if (plus) {
            gs.sp(item, nameProperty, value + 1);
            newValue++;
        } else {
            gs.sp(item, nameProperty, value - 1);
            newValue--;
        }
        if (before) {
            return newValue;
        } else {
            return value;
        }
    };

    function exFn(we, mn, it, val) {
        return we[mn].apply(it, joinParameters(it, val));
    }

    //Control all method calls
    gs.mc = function(item, methodName, values, objectVar, isSafe) {

        if (gs.consoleInfo && console) {
            console.log('[INFO] gs.mc (' + item + ').' + methodName + ' params:' + values);
        }

        if (item === null || item === undefined) {
            if (isSafe) {
                return null;
            } else {
                throw 'gs.mc Calling method: ' + methodName + ' on null or undefined object.';
            }
        }

        if (methodName == 'split' && typeof(item) == 'string') {
            return item.tokenize(values[0]);
        }
        if (methodName == 'length' && typeof(item) == 'string') {
            return item.length;
        }
        if (methodName == 'join' && (item instanceof Array)) {
            if (values.size() > 0) {
                return item.gSjoin(values[0]);
            } else {
                return item.gSjoin();
            }
        }

        if (objectVar) {
            try {
                //First, try to execute function in object
                return gs.mc(objectVar, methodName, values);
            } catch(e) {}
        }

        if (!item[methodName]) {

            if (methodName.startsWith('get') || methodName.startsWith('set')) {
                var varName = getterSetterRemove(methodName);
                if (item[varName] !== undefined && !hasFunc(item, varName)) {
                    if (methodName.startsWith('get')) {
                        return gs.gp(item, varName);
                    } else {
                        return gs.sp(item, varName, values[0]);
                    }
                }
            }

            if (methodName.startsWith('is')) {
                var varName = methodName.charAt(2).toLowerCase() + methodName.slice(3);
                if (item[varName] !== undefined && !hasFunc(item, varName)) {
                    return gs.gp(item, varName);
                }
            }

            //Check newInstance
            if (methodName=='newInstance') {
                return item();
            } else {
                var whereExecutes;
                //Lets check if in any category we have the static method
                if (categories.length > 0) {
                    whereExecutes = categorySearching(methodName);
                    if (whereExecutes !== null) {
                        return exFn(whereExecutes, methodName, item, values);
                    }
                }

                //In @Category
                var ob;
                for (ob in annotatedCategories) {
                    if (annotatedCategories[ob] == item.clazz.simpleName) {
                        var categoryItem = gs.myCategories[ob]();
                        if (categoryItem[methodName] && isFunction(categoryItem[methodName])) {
                            return exFn(categoryItem, methodName, item, values);
                        }
                    }
                }

                //Lets check in mixins classes
                if (mixins.length > 0) {
                    whereExecutes = mixinSearching(item, methodName);
                    if (whereExecutes !== null) {
                        return exFn(whereExecutes, methodName, item, values);
                    }
                }

                //Lets check in mixins objects
                if (mixinsObjects.length > 0) {
                    whereExecutes = mixinObjectsSearching(item, methodName);
                    if (whereExecutes !== null) {
                        return exFn(whereExecutes, methodName, item, values);
                    }
                }
                //Lets check mc in @Delegate
                if (item.clazz !== undefined) {
                    var addDelegate = mapAddDelegate[item.clazz.simpleName];
                    if (addDelegate) {
                        var i;
                        for (i = 0; i < addDelegate.length; i++) {
                            var prop = addDelegate[i];
                            var target = item[prop][methodName];
                            if (target !== undefined) {
                                return exFn(item[prop], methodName, item[prop], values);
                            }
                        }
                    }
                }

                //Lets check in delegate
                if (delegates.length > 0) {
                    var delegateFunc = delegatesFunc(methodName);
                    if (delegateFunc) {
                        return delegateFunc[methodName].apply(item, values);
                    }
                }

                if (item.methodMissing) {
                    return item.methodMissing(methodName, values);
                } else if (delegates.length > 0 && delegatesFunc('methodMissing')) {
                    return gs.mc(delegatesFunc('methodMissing'), methodName, values);
                } else {
                    if (item.invokeMethod && item.invokeMethod !== BaseClass.prototype.invokeMethod) {
                        return item.invokeMethod(methodName, values);
                    } else {
                        //Maybe there is a function in the script with the name of the method
                        //In Node.js 'this.xxFunction()' in the main context fails
                        if (isFunction((typeof globalThis!=="undefined"&&typeof globalThis[methodName]==="function"?globalThis[methodName]:undefined))) {
                            return (typeof globalThis!=="undefined"&&typeof globalThis[methodName]==="function"?globalThis[methodName]:undefined).apply(this, values);
                        }

                        //Not exist the method, throw exception
                        throw 'gs.mc Method ' + methodName + ' not exist in ' + item;
                    }
                }
            }

        } else {
            var f = item[methodName];
            if (f['apply']) {
                return f.apply(item, values);
            } else {
                return gs.execCall(f, item, values);
            }
        }
    };

    function delegatesFunc(nameMethod) {
        var result = null;
        if (delegates.length > 0) {
            var i;
            for (i = delegates.length - 1; i >= 0 && !result; i--) {
                if (delegates[i][nameMethod]) {
                    result = delegates[i];
                }
            }
        }
        return result;
    }

    function joinParameters(item, items) {
        var listParameters = [item],i;
        for (i=0; i < items.size(); i++) {
            listParameters.push(items[i]);
        }
        return listParameters;
    }

    ////////////////////////////////////////////////////////////
    // Categories
    ////////////////////////////////////////////////////////////
    gs.categoryUse = function(item, itemClass, closure) {
        var ob, categoryCreated;
        if (existAnnotatedCategory(item)) {
            categoryCreated = gs.myCategories[item]();
            for (ob in categoryCreated) {
                if (!isObjectProperty(ob) && !isConstructor(ob, categoryCreated[ob]) &&
                    isFunction(categoryCreated[ob])) {
                    addFunctionToClassIfPrototyped(ob, categoryCreated[ob], annotatedCategories[item]);
                }
            }
        } else {
            categories.push(itemClass);
        }
        closure();
        if (existAnnotatedCategory(item)) {
            categoryCreated = gs.myCategories[item]();
            for (ob in categoryCreated) {
                if (!isObjectProperty(ob) && !isConstructor(ob, categoryCreated[ob]) &&
                    isFunction(categoryCreated[ob])) {
                    removeFunctionToClass(ob, categoryCreated[ob], annotatedCategories[item]);
                }
            }
        } else {
            categories.splice(categories.length - 1, 1);
        }
    };

    function getPrototypeOfClass(className) {
        if (className == 'String') {
            return String.prototype;
        }
        if (className == 'Number') {
            return Number.prototype;
        }
        if (className == 'ArrayList') {
            return Array.prototype;
        }
        return null;
    }

    function addFunctionToClassIfPrototyped(name, func, className) {
        var proto = getPrototypeOfClass(className);
        if  (proto !== null) {
            if (proto[name] === undefined) {
                proto[name] = func;
            }
        }
    }

    function removeFunctionToClass(name, func, className) {
        var proto = getPrototypeOfClass(className);
        if  (proto !== null) {
            if (proto[name] == func) {
                proto[name] = null;
            }
        }
    }

    function categorySearching(methodName) {
        var i, result = null;
        for (i = categories.length - 1; i >= 0 && result === null; i--) {
            var itemClass = categories[i];
            if (itemClass[methodName]) {
                result = itemClass;
            }
        }
        return result;
    }

    function existAnnotatedCategory(name) {
        return (annotatedCategories[name] !== null && annotatedCategories[name] !== undefined);
    }

    var annotatedCategories = {};
    gs.addAnnotatedCategory = function(nameCategory, nameClass) {
        annotatedCategories[nameCategory] = nameClass;
    };

    ////////////////////////////////////////////////////////////
    // Mixins
    ////////////////////////////////////////////////////////////
    gs.mixinClass = function(item, classes) {

        //First check in that class has mixins
        var gotIt = false;
        if (mixins.length > 0) {
            var i;
            for (i = 0; i < mixins.length && !gotIt; i++) {
                if (mixins[i].name == item) {
                    var j;
                    for (j=0; j < classes.length; j++) {
                        mixins[i].items.push(classes[j]);
                    }
                    gotIt = true;
                }
            }
        }
        if (!gotIt) {
            mixins.push({ name: item, items: classes});
        }
    };

    gs.mixinObject = function(item, classes) {

        var gotIt = false;
        if (mixinsObjects.length > 0) {
            var i;
            for (i = 0; i < mixinsObjects.length && !gotIt; i++) {
                if (mixinsObjects[i].item == item) {
                    var j;
                    for (j = 0; j < classes.length; j++) {
                        mixinsObjects[i].items.push(classes[j]);
                    }
                    gotIt = true;
                }
            }
        }
        if (!gotIt) {
            mixinsObjects.push({ item: item, items: classes});
        }
        //TODO make any kinda cleanup if mixinsObjects growing
    };

    function mixinSearching(item, methodName) {
        var result = null, className = null;
        if (typeof(item) == 'string') {
            className = 'String';
        }
        if (item.clazz && item.clazz.simpleName && typeof(item) == 'object') {
            className = item.clazz.simpleName;
        }
        if (className !== null) {
            var i, ourMixin=null;
            for (i = mixins.length - 1; i >= 0 && ourMixin === null; i--) {
                var data = mixins[i];
                if (data.name == className) {
                    ourMixin = data.items;
                }
            }
            if (ourMixin !== null) {
                for (i = 0; i < ourMixin.length && result === null; i++) {
                    if (ourMixin[i][methodName]) {
                        result = ourMixin[i];
                    } else {
                        var classItem = ourMixin[i]();
                        if (classItem) {
                            var notStatic = classItem[methodName];
                            if (notStatic !== null && isFunction(notStatic)) {
                                result = classItem;
                            }
                        }
                    }
                }
            }
        }

        return result;
    }

    function mixinObjectsSearching(item, methodName) {

        var result = null, i, ourMixin = null;
        for (i = mixinsObjects.length - 1; i >= 0 && ourMixin === null; i--) {
            var data = mixinsObjects[i];
            if (data.item == item) {
                ourMixin = data.items;
            }
        }
        if (ourMixin !== null) {
            for (i=0 ; i < ourMixin.length && result === null; i++) {
                if (ourMixin[i][methodName]) {
                    result = ourMixin[i];
                }
            }
        }

        return result;
    }

    ////////////////////////////////////////////////////////////
    // StringBuffer - very basic support, for add with <<
    ////////////////////////////////////////////////////////////
    gs.stringBuffer = function() {

        var object = gs.init('StringBuffer');
        object.value = '';

        if (arguments.length == 1 && typeof arguments[0] === 'string') {
            object.value = arguments[0];
        }

        object.toString = function() {
            return this.value;
        };

        object.leftShift = function(value) {
            return this.append(value);
        };

        object.plus = function(value) {
            return this.append(value);
        };

        object.size = function() {
            return this.value.length;
        };

        object.append = function(value) {
            this.value = this.value + value;
            return this;
        };
        return object;
    };

    ////////////////////////////////////////////////////////////
    // @Delegate
    ////////////////////////////////////////////////////////////
    gs.astDelegate = function (baseClass, nameField) {
        var currentDelegate = mapAddDelegate[baseClass];
        if (currentDelegate === null || currentDelegate === undefined) {
            currentDelegate = [];
        }
        currentDelegate.push(nameField);
        mapAddDelegate[baseClass] = currentDelegate;
    };

    ////////////////////////////////////////////////////////////
    // Delegate
    ////////////////////////////////////////////////////////////
    function applyDelegate (func, delegate, params) {
        delegates.push(delegate);
        var result = func.apply(delegate, params);
        delegates.pop();
        return result;
    }

    gs.execCall = function (func, thisObject, params) {
        if (func.delegate !== undefined) {
            return applyDelegate(func, func.delegate, params);
        } else {
            if (func['call'] !== undefined && typeof func === 'object') {
                return func['call'].apply(func, params);
            } else {
                return func.apply(thisObject, params);
            }
        }
    };

    ////////////////////////////////////////////////////////////
    // Functional
    ////////////////////////////////////////////////////////////
    Function.prototype.curry = function () {
        var slice = Array.prototype.slice,
            args = slice.apply(arguments),
            that = this;
        return function () {
            return that.apply(null, args.concat(slice.apply(arguments)));
        };
    };

    Function.prototype.rcurry = function () {
        var slice = Array.prototype.slice,
            args = slice.apply(arguments),
            that = this;
        return function () {
            return that.apply(null, (slice.apply(arguments)).concat(args));
        };
    };

    Function.prototype.ncurry = function () {
        var slice = Array.prototype.slice,
            args = slice.apply(arguments, [1]),
            begin = arguments[0],
            that = this;
        return function () {
            return that.apply(null, slice.apply(arguments, [0, begin]).concat(args).concat(slice.apply(arguments, [begin])));
        };
    };

    Function.prototype.leftShift = function () {
        var func = arguments[0],
            that = this;
        return function () {
            return that(func.apply(null, arguments));
        };
    };

    Function.prototype.rightShift = function () {
        var func = arguments[0],
            that = this;
        return function () {
            return func(that.apply(null, arguments));
        };
    };

    Function.prototype.run = function() {
        return this();
    };

    Function.prototype.memoize = function() {
        var that = this;
        that._input = [];
        that._output = [];
        return function() {
            var i, result, foundPos = -1, inputs = Array.prototype.slice.call(arguments);
            for (i = 0; i < that._input.length && foundPos < 0; i++) {
                if (gs.equals(inputs, that._input[i])) {
                    foundPos = i;
                }
            }
            if (foundPos > -1) {
                result = that._output[foundPos];
            } else {
                that._input.push(inputs);
                result = that.apply(null, inputs);
                that._output.push(result);
            }
            return result;
        };
    };

    //MISC Find scope of a var
    gs.fs = function(name, thisScope, objScope) {
        if (objScope && objScope[name] !== undefined) {
            return objScope[name];
        } else if (thisScope && thisScope[name] !== undefined) {
            return thisScope[name];
        } else {
            var value = gs.gp(thisScope, name);
            if (value === undefined) {
                if (aStT && aStT[name] !== undefined) {
                    return aStT[name];
                } else {
                    var func = new Function("return " + name);
                    return func();
                }
            } else {
                return value;
            }
        }
    };

    //Convert a groovy object to javascript, but only properties
    gs.toJavascript = function(obj) {
        if (obj && gs.isGroovyObj(obj)) {
            var result;
            if (obj && !isFunction(obj)) {
                if (obj instanceof Array) {
                    result = [];
                    var i;
                    for (i = 0; i < obj.length; i++) {
                        result.push(gs.toJavascript(obj[i]));
                    }
                } else {
                    if (obj instanceof Object) {
                        result = {};
                        var ob;
                        for (ob in obj) {
                            if (!isMapProperty(ob) && !isFunction(obj[ob])) {
                                result[ob] = gs.toJavascript(obj[ob]);
                            }
                        }
                    } else {
                        result = obj;
                    }
                }
            }
            return result;
        } else {
            return obj;
        }
    };

    //Convert a javascript object to 'groovy', if you define groovy type, will use it, and not a map
    gs.toGroovy = function(obj, objClass) {
        var result;
        if (obj !== undefined && !isFunction(obj)) {
            if (obj instanceof Array) {
                result = gs.list([]);
                var i;
                for (i = 0; i < obj.length; i++) {
                    result.add(gs.toGroovy(obj[i], objClass));
                }
            } else {
                if (obj instanceof Object) {
                    var ob;
                    result = (objClass ? objClass() : gs.map());
                    for (ob in obj) {
                        result[ob] = gs.toGroovy(obj[ob]);
                    }
                } else {
                    result = obj;
                }
            }
        }
        return result;
    };

    gs.toNumber = function(number) {
        if (number) {
            if (typeof(number) == 'string') {
                return parseFloat(number);
            } else {
                return number;
            }
        }
    };

    gs.isGroovyObj = function(maybeGroovyObject) {
        return maybeGroovyObject !== null && maybeGroovyObject !== undefined && maybeGroovyObject.clazz !== undefined;
    };

    gs.execStatic = function(obj, methodName, thisObject, params) {
        var old = aStT;
        aStT = thisObject;
        var res = obj[methodName].apply(thisObject, params);
        aStT = old;
        return res;
    };

    gs.asChar = function(value) {
        return value.charCodeAt(0);
    };

    //Convert a groovy map to javascript object, including functions in the map
    gs.toJsObj = function(obj) {
        if (gs.isGroovyObj(obj)) {
            var ob, result = {};
            for (ob in obj) {
                if (!isMapProperty(ob)) {
                    if (isFunction(obj[ob])) {
                        result[ob] = obj[ob];
                    } else {
                        result[ob] = gs.toJsObj(obj[ob]);
                    }
                }
            }
            return result;
        } else {
            return obj;
        }
    };

}).call(this);function HtmlBuilder() {
  var gSobject = gs.init('HtmlBuilder');
  gSobject.clazz = { name: 'org.grooscript.builder.HtmlBuilder', simpleName: 'HtmlBuilder'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.tagSolver = function(name, args) {
    gSobject.htmCd += "<" + (name) + "";
    if ((((gs.bool(args)) && (gs.mc(args,"size",[]) > 0)) && (!gs.bool(gs.instanceOf((args[0]), "String")))) && (!gs.bool(gs.instanceOf((args[0]), "Closure")))) {
      gs.mc(args[0],"each",[function(key, value) {
        return gSobject.htmCd += " " + (key) + "='" + (value) + "'";
      }]);
    };
    gSobject.htmCd += (!gs.bool(args) ? "/>" : ">");
    if (gs.bool(args)) {
      if ((gs.equals(gs.mc(args,"size",[]), 1)) && (gs.instanceOf((args[0]), "String"))) {
        gs.mc(gSobject,"yield",[args[0]]);
      } else {
        var lastArg = gs.mc(args,"last",[]);
        if (gs.instanceOf(lastArg, "Closure")) {
          gs.sp(lastArg,"delegate",this);
          gs.execCall(lastArg, this, []);
        };
        if ((gs.instanceOf(lastArg, "String")) && (gs.mc(args,"size",[]) > 1)) {
          gs.mc(gSobject,"yield",[lastArg]);
        };
      };
      return gSobject.htmCd += "</" + (name) + ">";
    };
  };
  gSobject.htmCd = null;
  gSobject.build = function(x0) { return HtmlBuilder.build(x0); }
  gSobject['yield'] = function(text) {
    return gs.mc(text,"each",[function(ch) {
      var gSswitch0 = ch;
      if (gs.equals(gSswitch0, "&")) {
        gSobject.htmCd += "&amp;";
        ;
      } else if (gs.equals(gSswitch0, "<")) {
        gSobject.htmCd += "&lt;";
        ;
      } else if (gs.equals(gSswitch0, ">")) {
        gSobject.htmCd += "&gt;";
        ;
      } else if (gs.equals(gSswitch0, "\"")) {
        gSobject.htmCd += "&quot;";
        ;
      } else if (gs.equals(gSswitch0, "'")) {
        gSobject.htmCd += "&apos;";
        ;
      } else {
        gSobject.htmCd += ch;
        ;
      };
    }]);
  }
  gSobject['yieldUnescaped'] = function(text) {
    return gSobject.htmCd += text;
  }
  gSobject['comment'] = function(text) {
    return gSobject.htmCd += (gs.plus((gs.plus("<!--", text)), "-->"));
  }
  gSobject['newLine'] = function(it) {
    return gSobject.htmCd += "\n";
  }
  gSobject['methodMissing'] = function(name, args) {
    gs.sp(this,"" + (name) + "",function(ars) {
      if (arguments.length == 1 && arguments[0] instanceof Array) { ars=gs.list(arguments[0]); } else 
      if (arguments.length == 1) { ars=gs.list([arguments[1 - 1]]); } else 
      if (arguments.length < 1) { ars=gs.list([]); } else 
      if (arguments.length > 1) {
        ars=gs.list([ars]);
        for (gScount=1;gScount < arguments.length; gScount++) {
          ars.add(arguments[gScount]);
        }
      }
      return gs.mc(gSobject,"tagSolver",[name, ars]);
    });
    return gs.mc(this,"invokeMethod",[name, args], gSobject);
  }
  gSobject['HtmlBuilder0'] = function(it) {
    gSobject.htmCd = "";
    return this;
  }
  if (arguments.length==0) {gSobject.HtmlBuilder0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};
HtmlBuilder.build = function(closure) {
  var mc = gs.expandoMetaClass(HtmlBuilder, false, true);
  gs.mc(mc,"initialize",[]);
  var builder = HtmlBuilder();
  gs.sp(builder,"metaClass",mc);
  gs.sp(closure,"delegate",builder);
  gs.execCall(closure, this, []);
  return gs.gp(builder,"htmCd");
}

function Observable() {
  var gSobject = gs.init('Observable');
  gSobject.clazz = { name: 'org.grooscript.rx.Observable', simpleName: 'Observable'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.subscribers = gs.list([]);
  gSobject.sourceList = null;
  gSobject.chain = gs.list([]);
  gSobject.listen = function() { return Observable.listen(); }
  gSobject.from = function(x0) { return Observable.from(x0); }
  gSobject['produce'] = function(event) {
    return gs.mc(gSobject.subscribers,"each",[function(it) {
      return gs.mc(gSobject,"processFunction",[event, it]);
    }]);
  }
  gSobject['map'] = function(cl) {
    gs.mc(gSobject.chain,'leftShift', gs.list([cl]));
    return this;
  }
  gSobject['filter'] = function(cl) {
    gs.mc(gSobject.chain,'leftShift', gs.list([function(it) {
      if (gs.execCall(cl, this, [it])) {
        return it;
      } else {
        throw "Exception";
      };
    }]));
    return this;
  }
  gSobject['subscribe'] = function(cl) {
    while (gs.bool(gSobject.chain)) {
      cl = (gs.mc(cl,'leftShift', gs.list([gs.mc(gSobject.chain,"pop",[])])));
    };
    gs.mc(gSobject.subscribers,'leftShift', gs.list([cl]));
    if (gs.bool(gSobject.sourceList)) {
      return gs.mc(gSobject.sourceList,"each",[function(it) {
        return gs.mc(gSobject,"processFunction",[it, cl]);
      }]);
    };
  }
  gSobject['removeSubscribers'] = function(it) {
    return gSobject.subscribers = gs.list([]);
  }
  gSobject['processFunction'] = function(data, cl) {
    try {
      gs.execCall(cl, this, [data]);
    }
    catch (e) {
    }
    ;
  }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};
Observable.listen = function(it) {
  return Observable();
}
Observable.from = function(list) {
  return Observable(gs.map().add("sourceList",list));
}

function GQueryImpl() {
  var gSobject = gs.init('GQueryImpl');
  gSobject.clazz = { name: 'org.grooscript.jquery.GQueryImpl', simpleName: 'GQueryImpl'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.clazz.interfaces = [{ name: 'org.grooscript.jquery.GQuery', simpleName: 'GQuery'}];
  gSobject['bind'] = function(selector, target, nameProperty, closure) {
    if (closure === undefined) closure = null;
    return gs.mc(gs.execStatic(GQueryList,'of', this,[selector]),"bind",[target, nameProperty, closure]);
  }
  gSobject['bindProperty'] = function(selector, target, nameProperty, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"bind",[target, nameProperty]);
  }
  gSobject['existsSelector'] = function(selector, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"hasResults",[]);
  }
  gSobject['existsId'] = function(id, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",["#" + (id) + "", parent]),"hasResults",[]);
  }
  gSobject['existsName'] = function(name, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",["[name='" + (name) + "']", parent]),"hasResults",[]);
  }
  gSobject['existsGroup'] = function(name, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",["input:radio[name='" + (name) + "']", parent]),"hasResults",[]);
  }
  gSobject['onEvent'] = function(selector, nameEvent, func, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"onEvent",[nameEvent, func]);
  }
  gSobject.doRemoteCall = function(url, type, params, onSuccess, onFailure, objectResult) {
    if (objectResult === undefined) objectResult = null;
    $.ajax({
            type: type, //GET or POST
            data: gs.toJavascript(params),
            url: url,
            dataType: 'text'
        }).done(function(newData) {
            if (onSuccess) {
                onSuccess(gs.toGroovy(jQuery.parseJSON(newData), objectResult));
            }
        })
        .fail(function(error) {
            if (onFailure) {
                onFailure(error);
            }
        });
  }
  gSobject.onReady = function(func) {
    $(document).ready(func);
  }
  gSobject['attachMethodsToDomEvents'] = function(obj, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.gp((obj = gs.metaClass(obj)),"methods"),"each",[function(method) {
      if (gs.mc(gs.gp(method,"name"),"endsWith",["Click"])) {
        var shortName = gs.mc(gs.gp(method,"name"),"substring",[0, gs.minus(gs.mc(gs.gp(method,"name"),"length",[]), 5)]);
        if (gs.mc(gSobject,"existsId",[shortName, parent])) {
          gs.mc(gSobject,"onEvent",[gs.plus("#", shortName), "click", obj["" + (gs.gp(method,"name")) + ""], parent]);
        };
      };
      if (gs.mc(gs.gp(method,"name"),"endsWith",["Submit"])) {
        var shortName = gs.mc(gs.gp(method,"name"),"substring",[0, gs.minus(gs.mc(gs.gp(method,"name"),"length",[]), 6)]);
        if (gs.mc(gSobject,"existsId",[shortName, parent])) {
          gs.mc(gSobject,"onEvent",[gs.plus("#", shortName), "submit", gs.mc(obj["" + (gs.gp(method,"name")) + ""],'leftShift', gs.list([function(it) {
            return gs.mc(it,"preventDefault",[]);
          }])), parent]);
        };
      };
      if (gs.mc(gs.gp(method,"name"),"endsWith",["Change"])) {
        var shortName = gs.mc(gs.gp(method,"name"),"substring",[0, gs.minus(gs.mc(gs.gp(method,"name"),"length",[]), 6)]);
        if (gs.mc(gSobject,"existsId",[shortName, parent])) {
          return gs.mc(gSobject,"onChange",[gs.plus("#", shortName), obj["" + (gs.gp(method,"name")) + ""], parent]);
        };
      };
    }]);
  }
  gSobject['onChange'] = function(selector, closure, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"onChange",[closure]);
  }
  gSobject['focusEnd'] = function(selector, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"focusEnd",[]);
  }
  gSobject['bindAllProperties'] = function(target, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.gp(target,"properties"),"each",[function(name, value) {
      if (gs.mc(gSobject,"existsId",[name, parent])) {
        gs.mc(gSobject,"bindProperty",["#" + (name) + "", target, name, parent]);
      };
      if (gs.mc(gSobject,"existsName",[name, parent])) {
        gs.mc(gSobject,"bindProperty",["[name='" + (name) + "']", target, name, parent]);
      };
      if (gs.mc(gSobject,"existsGroup",[name, parent])) {
        return gs.mc(gSobject,"bindProperty",["input:radio[name='" + (name) + "']", target, name, parent]);
      };
    }]);
  }
  gSobject['bindAll'] = function(target, parent) {
    if (parent === undefined) parent = null;
    gs.mc(gSobject,"bindAllProperties",[target, parent]);
    return gs.mc(gSobject,"attachMethodsToDomEvents",[target, parent]);
  }
  gSobject['observeEvent'] = function(selector, nameEvent, data) {
    if (data === undefined) data = gs.map();
    var observable = gs.execStatic(Observable,'listen', this,[]);
    gs.mc(gs.execCall(this, this, [selector]),"on",[nameEvent, data, function(event) {
      return gs.mc(observable,"produce",[event]);
    }]);
    return observable;
  }
  gSobject['call'] = function(selector) {
    return gs.execStatic(GQueryList,'of', this,[selector]);
  }
  gSobject['resolveSelector'] = function(selector, parent) {
    return gs.execStatic(GQueryList,'of', this,[(parent != null ? gs.mc(parent,"find",[selector]) : selector)]);
  }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};

function GQueryList() {
  var gSobject = gs.init('GQueryList');
  gSobject.clazz = { name: 'org.grooscript.jquery.GQueryList', simpleName: 'GQueryList'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.list = null;
  gSobject.of = function(x0) { return GQueryList.of(x0); }
  gSobject.methodMissing = function(name, args) {
    return gSobject.list[name].apply(gSobject.list, args);
  }
  gSobject.withResultList = function(cl) {
    if (gSobject.list.length) {
            cl(gSobject.list.toArray());
        }
        return gSobject;
  }
  gSobject.hasResults = function() {
    return gSobject.list.length > 0;
  }
  gSobject.onEvent = function(nameEvent, cl) {
    gSobject.list.on(nameEvent, cl);
        return gSobject;
  }
  gSobject.onChange = function(cl) {
    var jq = gSobject.list;

        if (jq.is(":text")) {
            jq.bind('input', function() {
                cl($(this).val());
            });
        } else if (jq.is('textarea')) {
            jq.bind('input propertychange', function() {
                cl($(this).val());
            });
        } else if (jq.is(":checkbox")) {
            jq.change(function() {
                cl($(this).is(':checked'));
            });
        } else if (jq.is(":radio")) {
            jq.change(function() {
                cl($(this).val());
            });
        } else if (jq.is("select")) {
            jq.bind('change', function() {
                cl($(this).val());
            });
        } else {
            console.log('Not supporting onChange for jquery element');
            console.log(jq);
        }
        return gSobject;
  }
  gSobject.focusEnd = function() {
    var jq = gSobject.list;

        if (jq.length) {
            if (jq.is(":text") || jq.is('textarea')) {
                var originalValue = jq.val();
                jq.val('');
                jq.blur().focus().val(originalValue);
            } else {
                jq.focus();
            }
        }
        return gSobject;
  }
  gSobject.bind = function(target, nameProperty, closure) {
    if (closure === undefined) closure = null;
    var jq = gSobject.list;
        //Create set method
        var nameSetMethod = 'set'+nameProperty.capitalize();

        if (jq.is(":text")) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.val(newValue);
                if (closure) { closure(newValue); };
            };
            jq.bind('input', function() {
                var currentVal = $(this).val();
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else if (jq.is('textarea')) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.val(newValue);
                if (closure) { closure(newValue); };
            };
            jq.bind('input propertychange', function() {
                var currentVal = $(this).val();
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else if (jq.is(":checkbox")) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.prop('checked', newValue);
                if (closure) { closure(newValue); };
            };
            jq.change(function() {
                var currentVal = $(this).is(':checked');
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else if (jq.is(":radio")) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.each(function(idx, elem) {
                    if (elem.value == newValue) { $(elem).prop('checked', true) }
                });
                if (closure) { closure(newValue); };
            };
            jq.change(function() {
                var currentVal = $(this).val();
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else if (jq.is("select")) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.val(newValue);
                if (closure) { closure(newValue); };
            };
            jq.bind('change', function() {
                var currentVal = $(this).val();
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else {
            console.log('Not supporting bind for jquery element');
            console.log(jq);
        }
        return gSobject;
  }
  gSobject.jqueryList = function(selec) {
    return $(selec);
  }
  gSobject['GQueryList1'] = function(selecOrJq) {
    gSobject.list = (gs.instanceOf(selecOrJq, "String") ? gs.mc(gSobject,"jqueryList",[selecOrJq]) : selecOrJq);
    return this;
  }
  if (arguments.length==1) {gSobject.GQueryList1(arguments[0]); }
  
  return gSobject;
};
GQueryList.of = function(selecOrJq) {
  return GQueryList(selecOrJq);
}

function GrooscriptGrails() {
  var gSobject = gs.init('GrooscriptGrails');
  gSobject.clazz = { name: 'org.grooscript.grails.util.GrooscriptGrails', simpleName: 'GrooscriptGrails'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'remoteUrl', { get: function() { return GrooscriptGrails.remoteUrl; }, set: function(gSval) { GrooscriptGrails.remoteUrl = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'controllerRemoteDomain', { get: function() { return GrooscriptGrails.controllerRemoteDomain; }, set: function(gSval) { GrooscriptGrails.controllerRemoteDomain = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'actionRemoteDomain', { get: function() { return GrooscriptGrails.actionRemoteDomain; }, set: function(gSval) { GrooscriptGrails.actionRemoteDomain = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'count', { get: function() { return GrooscriptGrails.count; }, set: function(gSval) { GrooscriptGrails.count = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'components', { get: function() { return GrooscriptGrails.components; }, set: function(gSval) { GrooscriptGrails.components = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'GRAILS_PROPERTIES', { get: function() { return GrooscriptGrails.GRAILS_PROPERTIES; }, set: function(gSval) { GrooscriptGrails.GRAILS_PROPERTIES = gSval; }, enumerable: true });
  gSobject.register = function(x0) { return GrooscriptGrails.register(x0); }
  gSobject.recover = function(x0) { return GrooscriptGrails.recover(x0); }
  gSobject.getRemoteDomainClassProperties = function(x0) { return GrooscriptGrails.getRemoteDomainClassProperties(x0); }
  gSobject.sendClientMessage = function(x0,x1) { return GrooscriptGrails.sendClientMessage(x0,x1); }
  gSobject.sendWebsocketMessage = function(x0,x1) { return GrooscriptGrails.sendWebsocketMessage(x0,x1); }
  gSobject.doRemoteCall = function(x0,x1,x2,x3,x4) { return GrooscriptGrails.doRemoteCall(x0,x1,x2,x3,x4); }
  gSobject.remoteDomainAction = function(x0,x1,x2,x3) { return GrooscriptGrails.remoteDomainAction(x0,x1,x2,x3); }
  gSobject.createComponent = function(x0,x1) { return GrooscriptGrails.createComponent(x0,x1); }
  gSobject.findComponentById = function(x0) { return GrooscriptGrails.findComponentById(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};
GrooscriptGrails.register = function(component) {
  var number = GrooscriptGrails.count++;
  gs.sp(component,"cId",number);
  (GrooscriptGrails.components["id" + (number) + ""]) = component;
  return component;
}
GrooscriptGrails.recover = function(cId) {
  return GrooscriptGrails.components["id" + (cId) + ""];
}
GrooscriptGrails.getRemoteDomainClassProperties = function(remoteDomainClass) {
  var data;
        var result = gs.map();
        for (data in remoteDomainClass) {
            if ((typeof remoteDomainClass[data] !== "function") && !GrooscriptGrails.GRAILS_PROPERTIES.contains(data)) {
                result.add(data, remoteDomainClass[data]);
            }
        }
        return result;
}
GrooscriptGrails.sendClientMessage = function(channel, message) {
  var sendMessage = message;
        if (!gs.isGroovyObj(message)) {
            sendMessage = gs.toGroovy(message);
        }
        gsEvents.sendMessage(channel, sendMessage);
}
GrooscriptGrails.sendWebsocketMessage = function(channel, message) {
  var sendMessage = message;
        if (gs.isGroovyObj(message)) {
            sendMessage = gs.toJavascript(message);
        }
        websocketClient.send(channel, {}, JSON.stringify(sendMessage));
}
GrooscriptGrails.doRemoteCall = function(controller, action, params, onSuccess, onFailure) {
  var url = GrooscriptGrails.remoteUrl;
        url = url + '/' + controller;
        if (action !== null) {
            url = url + '/' + action;
        }
        $.ajax({
            type: "POST",
            data: (gs.isGroovyObj(params) ? gs.toJavascript(params) : params),
            url: url
        }).done(function(newData) {
            if (onSuccess !== null && onSuccess !== undefined) {
                var successData = gs.toGroovy(newData);
                onSuccess(successData);
            }
        })
        .fail(function(error) {
            if (onFailure !== null && onFailure !== undefined) {
                onFailure(error);
            }
        });
}
GrooscriptGrails.remoteDomainAction = function(params, onSuccess, onFailure, name) {
  var url = GrooscriptGrails.remoteUrl + params.url;
        var data = (gs.isGroovyObj(params.data) ? gs.toJavascript(params.data) : params.data);
        var type = 'GET';
        if (params.action == 'create') {
            type = 'POST';
        }
        if (params.action == 'update') {
            type = 'PUT';
        }
        if (params.action == 'delete') {
            type = 'DELETE';
        }
        if (params.action == 'read' || params.action == 'delete') {
            data = null;
            url = url + '/' + params.data.id;
        }
        $.ajax({
            type: type,
            data: data,
            url: url,
            accepts: 'application/json'
        }).done(function(newData) {
            var successData = gs.toGroovy(newData, (typeof globalThis!=="undefined"&&globalThis[name]!==undefined?globalThis[name]:undefined));
            if (onSuccess !== null && onSuccess !== undefined) {
                onSuccess(successData);
            }
        })
        .fail(function(error) {
            if (onFailure !== null && onFailure !== undefined) {
                onFailure(error);
            }
        });
}
GrooscriptGrails.createComponent = function(componentClass, name) {
  var component = Object.create(HTMLElement.prototype);
        component.createdCallback = function() {
            var shadow = this.createShadowRoot();
            var content = this.textContent;
            var attrs = this.attributes; //name and value
            var map = {shadowRoot: shadow, content: content};
            if (attrs && attrs.length > 0) {
                for (var i = 0; i < attrs.length; i++) {
                    var element = attrs[i];
                    map[element.name] = element.value;
                }
            }
            GrooscriptGrails.register(componentClass(map)).render();
        };
        document.registerElement(name, {prototype: component});
}
GrooscriptGrails.findComponentById = function(id) {
  return gs.gp(gs.mc(GrooscriptGrails.components,"find",[function(key, value) {
    return gs.equals(gs.gp(value,"id"), id);
  }]),"value",true);
}
GrooscriptGrails.remoteUrl = null;
GrooscriptGrails.controllerRemoteDomain = "remoteDomain";
GrooscriptGrails.actionRemoteDomain = "doAction";
GrooscriptGrails.count = 0;
GrooscriptGrails.components = gs.map();
GrooscriptGrails.GRAILS_PROPERTIES = gs.list(["url" , "class" , "clazz" , "gsName" , "transients" , "constraints" , "mapping" , "hasMany" , "belongsTo" , "validationSkipMap" , "gormPersistentEntity" , "properties" , "gormDynamicFinders" , "all" , "domainClass" , "attached" , "validationErrorsMap" , "dirtyPropertyNames" , "errors" , "dirty" , "count"]);
function RemoteDomain() {
  var gSobject = gs.init('RemoteDomain');
  gSobject.clazz = { name: 'org.grooscript.grails.promise.RemoteDomain', simpleName: 'RemoteDomain'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.clazz.interfaces = [{ name: 'org.grooscript.grails.promise.GsPromise', simpleName: 'GsPromise'}];
  gSobject.action = null;
  gSobject.url = null;
  gSobject.data = null;
  gSobject.onSuccess = null;
  gSobject.onFail = null;
  gSobject.name = null;
  gSobject.closure = function(it) {
    var remoteData = gs.map().add("action",gSobject.action).add("url",gSobject.url).add("data",gSobject.data);
    return gs.execStatic(GrooscriptGrails,'remoteDomainAction', this,[remoteData, gSobject.onSuccess, gSobject.onFail, gSobject.name]);
  };
  gSobject['then'] = function(success, fail) {
    gSobject.onSuccess = success;
    gSobject.onFail = fail;
    gs.sp(gSobject.closure,"delegate",this);
    return gs.mc(gSobject,"closure",[]);
  }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};
function ClientEventHandler() {
  var gSobject = gs.init('ClientEventHandler');
  gSobject.clazz = { name: 'org.grooscript.grails.event.ClientEventHandler', simpleName: 'ClientEventHandler'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.clazz.interfaces = [{ name: 'org.grooscript.grails.event.EventHandler', simpleName: 'EventHandler'}];
  gSobject.mapHandlers = gs.map();
  gSobject['sendMessage'] = function(channel, data) {
    if (gSobject.mapHandlers[channel]) {
      return gs.mc(gSobject.mapHandlers[channel],"each",[function(action) {
        return gs.execCall(action, this, [data]);
      }]);
    };
  }
  gSobject['onEvent'] = function(channel, action) {
    if (!gs.bool(gSobject.mapHandlers[channel])) {
      (gSobject.mapHandlers[channel]) = gs.list([]);
    };
    return gs.mc((gSobject.mapHandlers[channel]),'leftShift', gs.list([action]));
  }
  gSobject['close'] = function(it) {
    return gSobject.mapHandlers = gs.map();
  }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};

var gsEvents = ClientEventHandler();
}
// __DYMICO_V1_USER_CODE__
function BootstrapBase() {
  var gSobject = gs.init('BootstrapBase');
  gSobject.clazz = { name: 'BootstrapBase', simpleName: 'BootstrapBase'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.completed = false;
  gSobject.callbacks = gs.list([]);
  gSobject['callback'] = function(callback) {
    if (gs.bool(gSobject.completed)) {
      return gs.execCall(callback, this, []);
     };
    return gs.mc(gSobject.callbacks,"add",[callback]);
   }
  gSobject['runCallbacks'] = function(it) {
    gSobject.completed = true;
    return gs.mc(gSobject.callbacks,"each",[function(callback) {
      return gs.execCall(callback, this, []);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function Transmission() {
  var gSobject = gs.init('Transmission');
  gSobject.clazz = { name: 'Transmission', simpleName: 'Transmission'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'onReady', { get: function() { return Transmission.onReady; }, set: function(gSval) { Transmission.onReady = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'onAuthReady', { get: function() { return Transmission.onAuthReady; }, set: function(gSval) { Transmission.onAuthReady = gSval; }, enumerable: true });
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Transmission.onReady = BootstrapBase();
Transmission.onAuthReady = BootstrapBase();

function StartupParams() {
  var gSobject = gs.init('StartupParams');
  gSobject.clazz = { name: 'StartupParams', simpleName: 'StartupParams'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.session = gs.execStatic(Session,'instance', this,[]);
  Object.defineProperty(gSobject, 'deviceReadyListers', { get: function() { return StartupParams.deviceReadyListers; }, set: function(gSval) { StartupParams.deviceReadyListers = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'bootstrapComplete', { get: function() { return StartupParams.bootstrapComplete; }, set: function(gSval) { StartupParams.bootstrapComplete = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'deviceReady', { get: function() { return StartupParams.deviceReady; }, set: function(gSval) { StartupParams.deviceReady = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'doAuthToken', { get: function() { return StartupParams.doAuthToken; }, set: function(gSval) { StartupParams.doAuthToken = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'supportOfflineStart', { get: function() { return StartupParams.supportOfflineStart; }, set: function(gSval) { StartupParams.supportOfflineStart = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'websocketClientDebug', { get: function() { return StartupParams.websocketClientDebug; }, set: function(gSval) { StartupParams.websocketClientDebug = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'offlineStartFunction', { get: function() { return StartupParams.offlineStartFunction; }, set: function(gSval) { StartupParams.offlineStartFunction = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'onlineStartNoAuthFunction', { get: function() { return StartupParams.onlineStartNoAuthFunction; }, set: function(gSval) { StartupParams.onlineStartNoAuthFunction = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'onlineStartAuthSuccessFunction', { get: function() { return StartupParams.onlineStartAuthSuccessFunction; }, set: function(gSval) { StartupParams.onlineStartAuthSuccessFunction = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'onlineStartTokenAuthFailedFunction', { get: function() { return StartupParams.onlineStartTokenAuthFailedFunction; }, set: function(gSval) { StartupParams.onlineStartTokenAuthFailedFunction = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'beforeSocketInit', { get: function() { return StartupParams.beforeSocketInit; }, set: function(gSval) { StartupParams.beforeSocketInit = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'afterSocketInit', { get: function() { return StartupParams.afterSocketInit; }, set: function(gSval) { StartupParams.afterSocketInit = gSval; }, enumerable: true });
  gSobject.shouldCheckStartupAuth = function() {
    if (typeof checkStartupAuth !== 'undefined') {
            return checkStartupAuth
        }
        return true
   }
  gSobject['checkStartupAuth'] = function(it) {
    if (gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"AUTH_TOKEN")])) {
      gs.println(gs.plus("Writing session auth to local storage:", gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"AUTH_TOKEN")])));
      gs.mc(gs.fs('localStorage', this, gSobject),"setItem",["authToken", gs.plus((gs.plus("\"", gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"AUTH_TOKEN")]))), "\"")]);
     };
    if (gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"DEVICE_TOKEN")])) {
      gs.println(gs.plus("Writing device token to local storage:", gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"DEVICE_TOKEN")])));
      gs.mc(gs.fs('localStorage', this, gSobject),"setItem",["deviceToken", gs.plus((gs.plus("\"", gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"DEVICE_TOKEN")]))), "\"")]);
     };
    var rememberMe = gs.mc(gs.fs('localStorage', this, gSobject),"getItem",["remember_me"]);
    var rememberMeActive = rememberMe != "false";
    if (gs.equals(rememberMe, "once")) {
      gs.mc(gs.fs('localStorage', this, gSobject),"setItem",["remember_me", "false"]);
     };
    if ((gs.mc(gSobject,"shouldCheckStartupAuth",[])) && (gs.bool(StartupParams.doAuthToken))) {
      gs.println("Checking tokens...");
      if (((!gs.bool(rememberMeActive)) || (!gs.bool(gs.gp(gSobject.session,"authToken")))) || (!gs.bool(gs.gp(gSobject.session,"deviceToken")))) {
        return null;
       };
      return gs.println("Tokens good");
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
StartupParams.deviceReadyListers = gs.list([]);
StartupParams.bootstrapComplete = false;
StartupParams.deviceReady = true;
StartupParams.doAuthToken = true;
StartupParams.supportOfflineStart = false;
StartupParams.websocketClientDebug = false;
StartupParams.offlineStartFunction = null;
StartupParams.onlineStartNoAuthFunction = function(it) {
 };
StartupParams.onlineStartAuthSuccessFunction = function(it) {
  return gs.println("NB: onlineStartAuthSuccessFunction NOT SET!");
 };
StartupParams.onlineStartTokenAuthFailedFunction = function(it) {
  gs.println("onlineStartTokenAuthFailedFunction");
  return gs.execStatic(Utils,'logout', this,[]);
 };
StartupParams.beforeSocketInit = function(it) {
  gs.println(gs.plus("beforeSocketInit:", StartupParams.supportOfflineStart));
  if (gs.bool(StartupParams.supportOfflineStart)) {
    gs.println(gs.plus("beforeSocketInit:session.firstStartupCompleted:", gs.gp(this.session,"firstStartupCompleted")));
    gs.println("startupParams.onlineStartFunction:3");
    gs.mc(StartupParams,"offlineStartFunction",[]);
    StartupParams.bootstrapComplete = true;
    return gs.sp(this.session,"firstStartupCompleted",true);
   };
 };
StartupParams.afterSocketInit = function(it) {
  gs.println("afterSocketInit");
  if (!gs.bool(StartupParams.doAuthToken)) {
    gs.println("onlineStartNoAuthFunction:0");
    gs.mc(StartupParams,"onlineStartNoAuthFunction",[]);
    StartupParams.bootstrapComplete = true;
    return null;
   };
  return gs.execStatic(Utils,'tokenAuth', this,[function(it) {
    gs.println("onlineStartAuthSuccessFunction:1");
    gs.mc(StartupParams,"onlineStartAuthSuccessFunction",[]);
    StartupParams.bootstrapComplete = true;
    return gs.mc(gs.gp(gs.fs('transmission', this),"onAuthReady"),"runCallbacks",[]);
   }, function(it) {
    gs.println("onlineStartTokenAuthFailedFunction:2");
    gs.mc(StartupParams,"onlineStartTokenAuthFailedFunction",[]);
    StartupParams.bootstrapComplete = true;
    return gs.mc(gs.gp(gs.fs('transmission', this),"onAuthReady"),"runCallbacks",[]);
   }]);
 };

function Session() {
  var gSobject = gs.init('Session');
  gSobject.clazz = { name: 'Session', simpleName: 'Session'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'sessionMap', { get: function() { return Session.sessionMap; }, set: function(gSval) { Session.sessionMap = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'self', { get: function() { return Session.self; }, set: function(gSval) { Session.self = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'zoner', { get: function() { return Session.zoner; }, set: function(gSval) { Session.zoner = gSval; }, enumerable: true });
  gSobject.zonerRoleMap = gs.map();
  gSobject.instance = function() { return Session.instance(); }
  gSobject.toJs = function() { return Session.toJs(); }
  gSobject.setSessionStorage = function(x0,x1) { return Session.setSessionStorage(x0,x1); }
  gSobject.getSessionStorage = function(x0) { return Session.getSessionStorage(x0); }
  gSobject.clear = function() {
    var remember_me = localStorage.getItem('remember_me');
       
       localStorage.clear();
       
       localStorage.setItem('remember_me', remember_me);
   }
  gSobject['setProperty'] = function(name, value) {
    (Session.sessionMap[name]) = value;
    Session.setSessionStorage(name, value);
    if (gs.equals(name, "zoner")) {
      Session.zoner = null;
      return gSobject.zonerRoleMap = gs.map();
     };
   }
  gSobject['getProperty'] = function(name) {
    if (!gs.bool(Session.sessionMap[name])) {
      var value = Session.getSessionStorage(name);
      (Session.sessionMap[name]) = value;
     };
    return Session.sessionMap[name];
   }
  gSobject['hasRole'] = function(roles) {
    if (!gs.bool(roles)) {
      return true;
     };
    var result = gSobject.zonerRoleMap[roles];
    if (result != null) {
      return result;
     };
    if (!gs.bool(Session.zoner)) {
      Session.zoner = gs.mc(gSobject,"getProperty",["zoner"]);
     };
    if (!gs.bool(Session.zoner)) {
      return false;
     };
    if (gs.instanceOf(roles, "String")) {
      result = (gs.gSin(roles, gs.gp(Session.zoner,"roles")));
      (gSobject.zonerRoleMap[roles]) = result;
      return result;
     };
    for (_i26 = 0, role = roles[0]; _i26 < roles.length; role = roles[++_i26]) {
      if (gs.gSin(role, gs.gp(Session.zoner,"roles"))) {
        (gSobject.zonerRoleMap[roles]) = true;
        return true;
       };
     };
    (gSobject.zonerRoleMap[roles]) = false;
    return false;
   }
  gSobject['toString'] = function(it) {
    return gs.mc(Session.sessionMap,"toString",[]);
   }
  gSobject['Session0'] = function(it) {
    return this;
  }
  if (arguments.length==0) {gSobject.Session0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Session.instance = function(it) {
  if (!gs.bool(Session.self)) {
    Session.self = Session();
   };
  return Session.self;
 }
Session.toJs = function(it) {
  return Session.sessionMap;
 }
Session.setSessionStorage = function(name, value) {
  value = JSON.stringify(value)
       localStorage.setItem(name, value)
       return value
 }
Session.getSessionStorage = function(name) {
  var value = localStorage.getItem(name)
        try{
            return gs.toGroovy(jQuery.parseJSON(value))
        }catch(all){}
        return null
 }
Session.sessionMap = gs.map();
Session.self = null;
Session.zoner = null;

function Modals() {
  var gSobject = gs.init('Modals');
  gSobject.clazz = { name: 'Modals', simpleName: 'Modals'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.showModalCustom = function(x0,x1) { return Modals.showModalCustom(x0,x1); }
  gSobject.showModal = function(x0) { return Modals.showModal(x0); }
  gSobject.hideModal = function(x0) { return Modals.hideModal(x0); }
  gSobject.closeModal = function(x0) { return Modals.closeModal(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Modals.showModalCustom = function(id, type) {
  $(id).css("display", type);
        $(id).css("pointer-events", "initial");
 }
Modals.showModal = function(id) {
  $(id).css("display", "block");
        $(id).css("pointer-events", "initial");
 }
Modals.hideModal = function(id) {
  $(id).css("display", "none");
        $(id).css("pointer-events", "none");
 }
Modals.closeModal = function(id) {
  $(id).trigger( "click" );
 }

function Socket() {
  var gSobject = gs.init('Socket');
  gSobject.clazz = { name: 'Socket', simpleName: 'Socket'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'SOCKET_URL', { get: function() { return Socket.SOCKET_URL; }, set: function(gSval) { Socket.SOCKET_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_USER_URL', { get: function() { return Socket.SOCKET_USER_URL; }, set: function(gSval) { Socket.SOCKET_USER_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_OBJECT_URL', { get: function() { return Socket.SOCKET_OBJECT_URL; }, set: function(gSval) { Socket.SOCKET_OBJECT_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_TOPIC_URL', { get: function() { return Socket.SOCKET_TOPIC_URL; }, set: function(gSval) { Socket.SOCKET_TOPIC_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_OVER_HTTP_SYNCHRONOUS_URL', { get: function() { return Socket.SOCKET_OVER_HTTP_SYNCHRONOUS_URL; }, set: function(gSval) { Socket.SOCKET_OVER_HTTP_SYNCHRONOUS_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_OVER_HTTP_ASYNCHRONOUS_URL', { get: function() { return Socket.SOCKET_OVER_HTTP_ASYNCHRONOUS_URL; }, set: function(gSval) { Socket.SOCKET_OVER_HTTP_ASYNCHRONOUS_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SESSION_REFRESH_MINS', { get: function() { return Socket.SESSION_REFRESH_MINS; }, set: function(gSval) { Socket.SESSION_REFRESH_MINS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_CHECK_MSG_RECEIVED_SEC', { get: function() { return Socket.SOCKET_CHECK_MSG_RECEIVED_SEC; }, set: function(gSval) { Socket.SOCKET_CHECK_MSG_RECEIVED_SEC = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_RUNNER_RETRY_MS', { get: function() { return Socket.SOCKET_RUNNER_RETRY_MS; }, set: function(gSval) { Socket.SOCKET_RUNNER_RETRY_MS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_QUEUE_TIMEOUT_MIN', { get: function() { return Socket.SOCKET_QUEUE_TIMEOUT_MIN; }, set: function(gSval) { Socket.SOCKET_QUEUE_TIMEOUT_MIN = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'AUTH_TOKEN', { get: function() { return Socket.AUTH_TOKEN; }, set: function(gSval) { Socket.AUTH_TOKEN = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DEVICE_TOKEN', { get: function() { return Socket.DEVICE_TOKEN; }, set: function(gSval) { Socket.DEVICE_TOKEN = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'window', { get: function() { return Socket.window; }, set: function(gSval) { Socket.window = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'navigator', { get: function() { return Socket.navigator; }, set: function(gSval) { Socket.navigator = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'sendProtocol', { get: function() { return Socket.sendProtocol; }, set: function(gSval) { Socket.sendProtocol = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'queue', { get: function() { return Socket.queue; }, set: function(gSval) { Socket.queue = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'socketHeadersMap', { get: function() { return Socket.socketHeadersMap; }, set: function(gSval) { Socket.socketHeadersMap = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'userDataPipe', { get: function() { return Socket.userDataPipe; }, set: function(gSval) { Socket.userDataPipe = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'session', { get: function() { return Socket.session; }, set: function(gSval) { Socket.session = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'connected', { get: function() { return Socket.connected; }, set: function(gSval) { Socket.connected = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'socket', { get: function() { return Socket.socket; }, set: function(gSval) { Socket.socket = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'websocketClient', { get: function() { return Socket.websocketClient; }, set: function(gSval) { Socket.websocketClient = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'subscriptions', { get: function() { return Socket.subscriptions; }, set: function(gSval) { Socket.subscriptions = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'sessionRefresherThreads', { get: function() { return Socket.sessionRefresherThreads; }, set: function(gSval) { Socket.sessionRefresherThreads = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'socketReadyQueue', { get: function() { return Socket.socketReadyQueue; }, set: function(gSval) { Socket.socketReadyQueue = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'intervalRunner', { get: function() { return Socket.intervalRunner; }, set: function(gSval) { Socket.intervalRunner = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'reconnectMutex', { get: function() { return Socket.reconnectMutex; }, set: function(gSval) { Socket.reconnectMutex = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_PING_TIMEOUT_MS', { get: function() { return Socket.SOCKET_PING_TIMEOUT_MS; }, set: function(gSval) { Socket.SOCKET_PING_TIMEOUT_MS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'websocketPingCount', { get: function() { return Socket.websocketPingCount; }, set: function(gSval) { Socket.websocketPingCount = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'nextQueueClean', { get: function() { return Socket.nextQueueClean; }, set: function(gSval) { Socket.nextQueueClean = gSval; }, enumerable: true });
  gSobject.init = function() { return Socket.init(); }
  gSobject.socketHeaders = function() { return Socket.socketHeaders(); }
  gSobject.initSocket = function(x0,x1) { return Socket.initSocket(x0,x1); }
  gSobject.socketReady = function(x0) { return Socket.socketReady(x0); }
  gSobject.socketReadyQueueCallAll = function() { return Socket.socketReadyQueueCallAll(); }
  gSobject.addUserDataPipe = function() { return Socket.addUserDataPipe(); }
  gSobject.startSessionRefresher = function() { return Socket.startSessionRefresher(); }
  gSobject.sessionRefresher = function(x0,x1) { return Socket.sessionRefresher(x0,x1); }
  gSobject.reconnect = function(x0) { return Socket.reconnect(x0); }
  gSobject.socketConnectionInterval = function(x0) { return Socket.socketConnectionInterval(x0); }
  gSobject.socketConnect = function(x0,x1,x2) { return Socket.socketConnect(x0,x1,x2); }
  gSobject.pingHttp = function(callback) {
    if (!this.inUse) {
            this.status = 'unchecked';
            this.inUse = true;
            this.callback = callback;
            this.ip = ip;
            var _that = this;
            this.img = new Image();
            this.img.onload = function () {
                _that.inUse = false;
                _that.callback('responded');
    
            };
            this.img.onerror = function (e) {
                if (_that.inUse) {
                    _that.inUse = false;
                    _that.callback('responded', e);
                }
    
            };
            this.start = new Date().getTime();
            this.img.src = 'http://'+ window.location.hostname + '/index/ping';
            this.timer = setTimeout(function () {
                if (_that.inUse) {
                    _that.inUse = false;
                    _that.callback('timeout');
                }
            }, 1500);
        }
   }
  gSobject.pingWebSocket = function(x0) { return Socket.pingWebSocket(x0); }
  gSobject.remote = function(x0,x1,x2,x3) { return Socket.remote(x0,x1,x2,x3); }
  gSobject.callChain = function(x0,x1,x2) { return Socket.callChain(x0,x1,x2); }
  gSobject.callObject = function(x0,x1,x2,x3,x4) { return Socket.callObject(x0,x1,x2,x3,x4); }
  gSobject.isDymicoSystemUpdating = function() { return Socket.isDymicoSystemUpdating(); }
  gSobject.send = function(x0,x1,x2,x3) { return Socket.send(x0,x1,x2,x3); }
  gSobject.doSend = function(x0,x1) { return Socket.doSend(x0,x1); }
  gSobject.doSendNativeHttp = function(x0,x1) { return Socket.doSendNativeHttp(x0,x1); }
  gSobject.doSendNative = function(x0,x1) { return Socket.doSendNative(x0,x1); }
  gSobject.checkMessageReceived = function(x0) { return Socket.checkMessageReceived(x0); }
  gSobject.resendMessageQueue = function() { return Socket.resendMessageQueue(); }
  gSobject.cleanQueue = function() { return Socket.cleanQueue(); }
  gSobject.receive = function(x0) { return Socket.receive(x0); }
  gSobject.processException = function(x0) { return Socket.processException(x0); }
  gSobject.subscribe = function(x0,x1,x2) { return Socket.subscribe(x0,x1,x2); }
  gSobject.subscribeTopic = function(x0,x1) { return Socket.subscribeTopic(x0,x1); }
  gSobject.unsubscribeTopic = function(x0) { return Socket.unsubscribeTopic(x0); }
  gSobject.addSubscription = function(x0,x1,x2) { return Socket.addSubscription(x0,x1,x2); }
  gSobject.subscribeJs = function(x0,x1,x2) { return Socket.subscribeJs(x0,x1,x2); }
  gSobject.doReceiveNative = function(x0,x1) { return Socket.doReceiveNative(x0,x1); }
  gSobject.resubscribeAll = function() { return Socket.resubscribeAll(); }
  gSobject.unsubscribe = function(x0,x1) { return Socket.unsubscribe(x0,x1); }
  gSobject.post = function(x0,x1,x2,x3,x4) { return Socket.post(x0,x1,x2,x3,x4); }
  gSobject.postJson = function(x0,x1,x2,x3) { return Socket.postJson(x0,x1,x2,x3); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Socket.init = function(it) {
  gs.sp(Socket.session,"domain",gs.gp(gs.gp(Socket.window,"location"),"hostname"));
  gs.sp(Socket.session,"incomingUrl",(gs.plus((gs.plus(gs.gp(gs.gp(Socket.window,"location"),"protocol"), "//")), gs.gp(gs.gp(Socket.window,"location"),"hostname"))));
  return gs.sp(GrooscriptGrails,"remoteUrl",gs.gp(Socket.session,"incomingUrl"));
 }
Socket.socketHeaders = function(it) {
  gs.sp(Socket.socketHeadersMap,"domain",gs.gp(gs.gp(Socket.window,"location"),"hostname"));
  gs.sp(Socket.socketHeadersMap,"" + (Socket.AUTH_TOKEN) + "",gs.execStatic(Utils,'getAuthToken', this,[]));
  gs.sp(Socket.socketHeadersMap,"" + (Socket.DEVICE_TOKEN) + "",gs.execStatic(Utils,'getDeviceToken', this,[]));
  if (gs.bool(gs.gp(Socket.session,"jwt"))) {
    gs.sp(Socket.socketHeadersMap,"jwt",gs.gp(Socket.session,"jwt"));
   };
  return Socket.socketHeadersMap;
 }
Socket.initSocket = function(success, failure) {
  if (success === undefined) success = null;
  if (failure === undefined) failure = null;
  return gs.execStatic(Socket,'socketConnectionInterval', this,[success, failure]);
 }
Socket.socketReady = function(callback) {
  if (gs.bool(Socket.connected)) {
    gs.execCall(callback, this, []);
    return null;
   };
  return gs.mc(Socket.socketReadyQueue,"add",[callback]);
 }
Socket.socketReadyQueueCallAll = function(it) {
  var socketReadyQueueLocal = Socket.socketReadyQueue;
  Socket.socketReadyQueue = gs.list([]);
  return gs.mc(socketReadyQueueLocal,"each",[function(callback) {
    try {
      gs.execCall(callback, this, []);
     }
    catch (all) {
      gs.println(gs.fs('all', this));
     }
    ;
   }]);
 }
Socket.addUserDataPipe = function(it) {
  return Socket.addSubscription(gs.execStatic(Utils,'getDeviceToken', this,[]), Socket.SOCKET_USER_URL, Socket.userDataPipe);
 }
Socket.startSessionRefresher = function(it) {
  if (gs.bool(gs.gp(Socket.session,"authToken"))) {
    var sessionRefresherCallback = function(data) {
      if (data != "authed") {
        gs.println("NOT AUTHED");
        return gs.execStatic(Utils,'logout', this,[]);
       };
     };
    Socket.sessionRefresher(gs.gp(Socket.session,"authToken"), sessionRefresherCallback);
    for (_i27 = 0, sessionRefresherThread = Socket.sessionRefresherThreads[0]; _i27 < Socket.sessionRefresherThreads.length; sessionRefresherThread = Socket.sessionRefresherThreads[++_i27]) {
      gs.execStatic(Utils,'clearInterval', this,[sessionRefresherThread]);
      gs.mc(Socket.sessionRefresherThreads,"remove",[sessionRefresherThread]);
     };
    return gs.mc(Socket.sessionRefresherThreads,"add",[gs.execStatic(Utils,'setInterval', this,[function(it) {
      return gs.mc(Socket,"sessionRefresher",[gs.gp(Socket.session,"authToken"), sessionRefresherCallback]);
     }, gs.multiply((gs.multiply(1000, 60)), Socket.SESSION_REFRESH_MINS)])]);
   };
 }
Socket.sessionRefresher = function(token, sessionRefresherCallback) {
  console.log("refreshing:" + token +':'+new Date());
        $.ajax({
            url : '/login/tokenAuth?token='+token,
            type : 'GET',
            processData: false,
            contentType: false, 
            success : function(data) {
                console.log("grails session re-auth:"+data);
                sessionRefresherCallback(data)
            }
        });
 }
Socket.reconnect = function(retryInMs) {
  if (retryInMs === undefined) retryInMs = 0;
  if (gs.bool(retryInMs)) {
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(Socket,"reconnect",[]);
     }, retryInMs]);
   };
  if ((gs.bool(Socket.reconnectMutex)) || (!gs.bool(Socket.intervalRunner))) {
    return Socket.reconnect(500);
   };
  Socket.reconnectMutex = true;
  return gs.mc(Socket,"intervalRunner",[function(it) {
    return Socket.reconnectMutex = false;
   }]);
 }
Socket.socketConnectionInterval = function(success) {
  var reconnectCallback = function(it) {
    gs.println("Socket reconnected");
    Socket.connected = true;
    gs.mc(Socket,"addUserDataPipe",[]);
    gs.mc(Socket,"resubscribeAll",[]);
    gs.mc(Socket,"resendMessageQueue",[]);
    gs.mc(Socket,"startSessionRefresher",[]);
    gs.execCall(success, this, []);
    success = function(it) {
     };
    return gs.mc(Socket,"socketReadyQueueCallAll",[]);
   };
  var disconnectSockets = function(it) {
    gs.println("Socket disconnect");
    Socket.connected = false;
    try {
      gs.mc(gs.gp(Socket,"websocketClient"),"disconnect",[]);
     }
    catch (all) {
     }
    ;
   };
  Socket.intervalRunner = function(done) {
    gs.println(gs.plus((gs.plus((gs.plus((gs.plus((gs.plus("navigator.onLine:", gs.gp(Socket.navigator,"onLine"))), ":")), gs.gp(gs.gp(Socket,"websocketClient"),"connected"))), ":")), Socket.connected));
    if (!gs.bool(gs.gp(gs.gp(Socket,"websocketClient"),"connected"))) {
      gs.println("Socket.websocketClient.connected:false:reconnecting...");
      gs.mc(Socket,"socketConnect",[gs.map().add("domain",gs.gp(Socket.session,"domain")), function(it) {
        gs.println(gs.plus("Socket.websocketClient.connected:", gs.gp(gs.gp(Socket,"websocketClient"),"connected")));
        Socket.connected = true;
        gs.execCall(reconnectCallback, this, []);
        return gs.execCall(done, this, []);
       }, function(it) {
        gs.println("Socket.websocketClient.connected:connection down");
        gs.execCall(disconnectSockets, this, []);
        gs.execCall(done, this, []);
        if (gs.bool(Socket.queue)) {
          return gs.mc(Socket,"reconnect",[Socket.SOCKET_RUNNER_RETRY_MS]);
         };
       }]);
      return null;
     };
    gs.println("Sockets believed to be online.  Pinging socket connection...");
    gs.mc(Socket,"pingWebSocket",[function(pingResponse) {
      gs.println(gs.plus("pingWebSocket:", pingResponse));
      if (gs.equals(pingResponse, "timeout")) {
        gs.println("Connection timed out, reconnecting...");
        gs.execCall(disconnectSockets, this, []);
        gs.mc(Socket,"reconnect",[]);
        return gs.execCall(done, this, []);
       };
      gs.println("Connection good, false alarm.");
      return gs.execCall(done, this, []);
     }]);
    return gs.println(gs.plus("intervalRunner:Socket.websocketClient.connected:", gs.gp(gs.gp(Socket,"websocketClient"),"connected")));
   };
  return Socket.reconnect();
 }
Socket.socketConnect = function(headers, success, failed) {
  try{
            Socket.socket = new SockJS('/stomp');
            Socket.websocketClient = Stomp.over(Socket.socket);
            
            if (!StartupParams.websocketClientDebug){
                //switch off debuggging
                Socket.websocketClient.debug = function () {}  
            }
            
            Socket.websocketClient.connect(gs.toJavascript(headers), success, failed);
        }catch(error) {
            console.info(error);
        }
 }
Socket.pingWebSocket = function(callback) {
  var websocketPingCountNow = Socket.websocketPingCount;
  var wrapper = gs.mc(gs.map().add("uuid","ping").add("call","callChain").add("data",gs.list([gs.map().add("property","transmissionService") , gs.map().add("method","ping")])),'leftShift', gs.list([Socket.socketHeaders()]));
  Socket.doSendNative(Socket.SOCKET_URL, wrapper);
  return gs.execStatic(Utils,'setTimeout', this,[function(it) {
    if (gs.equals(websocketPingCountNow, Socket.websocketPingCount)) {
      gs.execCall(callback, this, ["timeout"]);
      return null;
     };
    return gs.execCall(callback, this, ["responded"]);
   }, Socket.SOCKET_PING_TIMEOUT_MS]);
 }
Socket.remote = function(closure, data, success, fail) {
  if (success === undefined) success = null;
  if (fail === undefined) fail = null;
  return gs.execStatic(Socket,'send', this,["remoteExec", closure, data, success, fail]);
 }
Socket.callChain = function(callChain, success, fail) {
  if (success === undefined) success = null;
  if (fail === undefined) fail = null;
  if (Socket.isDymicoSystemUpdating()) {
    return null;
   };
  gs.println(gs.plus("callChain:", callChain));
  return gs.execStatic(Socket,'send', this,["callChain", callChain, success, fail]);
 }
Socket.callObject = function(self, method, args, success, fail) {
  if (fail === undefined) fail = null;
  if (Socket.isDymicoSystemUpdating()) {
    return null;
   };
  gs.println(gs.plus("callObject:OObject:", self));
  gs.println(gs.plus("callObject:method:", method));
  return gs.execStatic(Socket,'send', this,["callObject", gs.map().add("self",self).add("method",method).add("args",args), success, fail]);
 }
Socket.isDymicoSystemUpdating = function() {
  try{
            if (typeof dymicoVersionUpdater !== 'undefined') { 
                return dymicoVersionUpdater.dymicoSystemUpdating;
            }
        }catch(all){ }
        return false;
 }
Socket.send = function(call, data, success, fail) {
  if (fail === undefined) fail = function(it) {
    return false;
   };
  var uuid = gs.execStatic(Utils,'uuid', this,[]);
  var wrapper = gs.map().add("uuid",uuid).add("call",call).add("data",data);
  var queueItem = gs.map().add("success",success).add("fail",fail).add("dataStr",gs.mc(data,"toString",[])).add("date",gs.gp(gs.date(),"time")).add("wrapper",wrapper);
  (Socket.queue[uuid]) = queueItem;
  Socket.doSend(Socket.SOCKET_URL, queueItem);
  return uuid;
 }
Socket.doSend = function(channel, queueItem) {
  if (gs.equals(Socket.sendProtocol, "websocket")) {
    Socket.doSendNative(channel, gs.mc(gs.gp(queueItem,"wrapper"),'leftShift', gs.list([Socket.socketHeaders()])));
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(Socket,"checkMessageReceived",[queueItem]);
     }, gs.multiply(Socket.SOCKET_CHECK_MSG_RECEIVED_SEC, 1000)]);
    if (!gs.bool(Socket.connected)) {
      return Socket.reconnect();
     };
   } else {
    if (gs.equals(Socket.sendProtocol, "http")) {
      return Socket.doSendNativeHttp(gs.mc(gs.gp(queueItem,"wrapper"),'leftShift', gs.list([Socket.socketHeaders()])), function(it) {
        gs.println("HTTP TIMEOUT");
        return gs.mc(Socket,"reconnect",[]);
       });
     } else {
      throw "Exception";
     };
   };
 }
Socket.doSendNativeHttp = function(map, timeoutCallback) {
  var sendMessage = map;

        sendMessage = Utils.mapToJsonString(sendMessage);
        // sendMessage = LZString.compressToBase64(sendMessage); //no compression needed, cause the browser will gzip it anyway
        sendMessage = "message="+encodeURIComponent(sendMessage)
            
        var xhr = new XMLHttpRequest();
        xhr.ontimeout = timeoutCallback
        xhr.open('POST', Socket.SOCKET_OVER_HTTP_SYNCHRONOUS_URL, true);
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");

        xhr.onreadystatechange = function(e) {
            if (this.status == 404) {
                console.log('AJAX FAILED');
            }
            if (this.readyState == 4 && this.status == 200) {
                Socket.receive(Socket.doReceiveNative(this.responseText, false))
            }
        };
        xhr.send(sendMessage);
 }
Socket.doSendNative = function(channel, map) {
  try{
            var sendMessage = map;
            sendMessage = Utils.mapToJsonString(sendMessage)
            sendMessage = LZString.compressToBase64(sendMessage)
            return Socket.websocketClient.send(channel, {}, sendMessage);
        }catch(all){ }
 }
Socket.checkMessageReceived = function(queueItem) {
  if (Socket.queue[gs.gp(gs.gp(queueItem,"wrapper"),"uuid")]) {
    Socket.reconnect();
    return Socket.cleanQueue();
   };
 }
Socket.resendMessageQueue = function(it) {
  return gs.mc(gs.mc(gs.mc(Socket.queue,"values",[]),"sort",[function(it) {
    return gs.gp(it,"date",true);
   }]),"each",[function(queueItem) {
    return gs.mc(Socket,"doSend",[Socket.SOCKET_URL, queueItem]);
   }]);
 }
Socket.cleanQueue = function(it) {
  if (Socket.nextQueueClean < gs.gp(gs.date(),"time")) {
    var timeoutMs = gs.multiply((gs.multiply(Socket.SOCKET_QUEUE_TIMEOUT_MIN, 60)), 1000);
    Socket.nextQueueClean = (gs.plus(gs.gp(gs.date(),"time"), timeoutMs));
    gs.println(gs.plus("nextQueueClean:", Socket.nextQueueClean));
    gs.println("cleanQueue.start");
    var timeout = gs.minus(gs.gp(gs.date(),"time"), timeoutMs);
    gs.println(gs.plus("cleanQueue.queue.size:", gs.mc(Socket.queue,"size",[])));
    gs.mc(Socket.queue,"each",[function(key, queueItem) {
      if (gs.gp(queueItem,"date") < timeout) {
        gs.println("REMOVED");
        gs.mc(Socket.queue,"remove",[key]);
        return gs.mc(queueItem,"fail",[]);
       };
     }]);
    return gs.println("cleanQueue.end");
   };
 }
Socket.receive = function(wrapper) {
  Socket.websocketPingCount++;
  if (gs.equals(gs.gp(wrapper,"uuid"), "ping")) {
    return null;
   };
  var queueItem = Socket.queue[gs.gp(wrapper,"uuid")];
  gs.mc(Socket.queue,"remove",[gs.gp(wrapper,"uuid")]);
  if (gs.bool(queueItem)) {
    if (gs.bool(gs.gp(wrapper,"error"))) {
      gs.mc(queueItem,"fail",[gs.gp(wrapper,"data")]);
      Socket.processException(gs.gp(wrapper,"data"));
      return null;
     };
    var object = gs.execStatic(ObjectRegistry,'register', this,[gs.gp(wrapper,"data")]);
    return gs.mc(queueItem,"success",[object]);
   };
 }
Socket.processException = function(ex) {
  gs.execStatic(Utils,'logExceptionStack', this,[gs.plus((gs.plus(ex.clazz, ":")), gs.gp(ex,"message"))]);
  return gs.execStatic(Utils,'logExceptionStack', this,[gs.gp(ex,"stackTrace")]);
 }
Socket.subscribe = function(objectId, success, topic) {
  if (topic === undefined) topic = Socket.SOCKET_OBJECT_URL;
  return Socket.socketReady(function(it) {
    gs.mc(Socket,"unsubscribe",[objectId, topic]);
    gs.println(gs.plus("subscribe:", objectId));
    var successWrapper = function(messageObject) {
      return gs.execCall(success, this, [messageObject]);
     };
    gs.mc(Socket,"addSubscription",[objectId, topic, success]);
    try {
      gs.mc(Socket,"subscribeJs",[objectId, gs.plus(topic, objectId), successWrapper]);
     }
    catch (all) {
      gs.println("subscribeJs failed");
      gs.println(gs.fs('all', this));
     }
    ;
   });
 }
Socket.subscribeTopic = function(topicId, success) {
  return Socket.subscribe(topicId, success, Socket.SOCKET_TOPIC_URL);
 }
Socket.unsubscribeTopic = function(topicId) {
  return Socket.unsubscribe(topicId, Socket.SOCKET_TOPIC_URL);
 }
Socket.addSubscription = function(objectId, topic, success) {
  return (Socket.subscriptions[objectId]) = gs.map().add("objectId",objectId).add("success",success).add("topic",topic);
 }
Socket.subscribeJs = function(objectId, subId, success) {
  console.log('subscribeJs:'+subId)
        
        return Socket.websocketClient.subscribe(subId, function(message){
            success(Socket.doReceiveNative(message.body))
        }, {id:objectId})
 }
Socket.doReceiveNative = function(message, compressed) {
  if (compressed === undefined) compressed = true;
  if (compressed) message = LZString.decompressFromBase64(message)
        
        // console.log('message', message)
        
        return Utils.stringToJson(message)
 }
Socket.resubscribeAll = function(it) {
  var oldSubscriptions = Socket.subscriptions;
  Socket.subscriptions = gs.map();
  return gs.mc(oldSubscriptions,"each",[function(key, subscription) {
    return gs.mc(Socket,"subscribe",[gs.gp(subscription,"objectId"), gs.gp(subscription,"success"), gs.gp(subscription,"topic")]);
   }]);
 }
Socket.unsubscribe = function(objectId, topic) {
  if (topic === undefined) topic = Socket.SOCKET_OBJECT_URL;
  gs.println(gs.plus("unsubscribe:", objectId));
  try {
    gs.mc(gs.gp(Socket,"websocketClient"),"unsubscribe",[objectId]);
    gs.mc(Socket.subscriptions,"remove",[objectId]);
   }
  catch (all) {
    gs.println(all);
   }
  ;
 }
Socket.post = function(file, parameter, objectName, id, callback) {
  var postUrl = "/post/upload";
        var formData = new FormData();
        
        formData.append('file', file);
        formData.append('id', id);
        formData.append('parameter', parameter);
        formData.append('objectName', objectName);

        $.ajax({
            url : postUrl,
            type : 'POST',
            data : formData,
            processData: false,  // tell jQuery not to process the data
            contentType: false,  // tell jQuery not to set contentType
            success : function(data) {
                console.log(data);
                callback(data);
            }
        });
 }
Socket.postJson = function(url, map, success, failed) {
  if (success === undefined) success = function(it) {
   };
  if (failed === undefined) failed = function(it) {
   };
  
 }
Socket.SOCKET_URL = "/app/api4WebSocketForPublic";
Socket.SOCKET_USER_URL = "/topic/api4WebSocketForUser/";
Socket.SOCKET_OBJECT_URL = "/topic/api4WebSocketForObject/";
Socket.SOCKET_TOPIC_URL = "/topic/api4WebSocketForTopic/";
Socket.SOCKET_OVER_HTTP_SYNCHRONOUS_URL = "/api4WebSocket/synchronous";
Socket.SOCKET_OVER_HTTP_ASYNCHRONOUS_URL = "/api4WebSocket/asynchronous";
Socket.SESSION_REFRESH_MINS = 10;
Socket.SOCKET_CHECK_MSG_RECEIVED_SEC = 7;
Socket.SOCKET_RUNNER_RETRY_MS = 5000;
Socket.SOCKET_QUEUE_TIMEOUT_MIN = 2;
Socket.AUTH_TOKEN = "secToken2";
Socket.DEVICE_TOKEN = "deviceToken1";
Socket.window = null;
Socket.navigator = null;
Socket.sendProtocol = "http";
Socket.queue = gs.map();
Socket.socketHeadersMap = gs.map();
Socket.userDataPipe = function(data) {
  return gs.mc(Socket,"receive",[data]);
 };
Socket.session = gs.execStatic(Session,'instance', this,[]);
Socket.connected = false;
Socket.socket = null;
Socket.websocketClient = gs.map().add("connected",false).add("disconnect",function(it) {
 }).add("subscriptions",function(it) {
 });
Socket.subscriptions = gs.map();
Socket.sessionRefresherThreads = gs.list([]);
Socket.socketReadyQueue = gs.list([]);
Socket.intervalRunner = null;
Socket.reconnectMutex = false;
Socket.SOCKET_PING_TIMEOUT_MS = 3000;
Socket.websocketPingCount = 0;
Socket.nextQueueClean = 0;

function Utils() {
  var gSobject = gs.init('Utils');
  gSobject.clazz = { name: 'Utils', simpleName: 'Utils'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'session', { get: function() { return Utils.session; }, set: function(gSval) { Utils.session = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'window', { get: function() { return Utils.window; }, set: function(gSval) { Utils.window = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'document', { get: function() { return Utils.document; }, set: function(gSval) { Utils.document = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DeviceTypes', { get: function() { return Utils.DeviceTypes; }, set: function(gSval) { Utils.DeviceTypes = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'AUTH_FAILED', { get: function() { return Utils.AUTH_FAILED; }, set: function(gSval) { Utils.AUTH_FAILED = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'NO_AUTH', { get: function() { return Utils.NO_AUTH; }, set: function(gSval) { Utils.NO_AUTH = gSval; }, enumerable: true });
  gSobject.getAuthToken = function() { return Utils.getAuthToken(); }
  gSobject.getDeviceToken = function() { return Utils.getDeviceToken(); }
  gSobject.setTimeout = function(x0,x1) { return Utils.setTimeout(x0,x1); }
  gSobject.setInterval = function(x0,x1) { return Utils.setInterval(x0,x1); }
  gSobject.clearInterval = function(x0) { return Utils.clearInterval(x0); }
  gSobject.localDateString = function(x0) { return Utils.localDateString(x0); }
  gSobject.utcDateString = function(x0) { return Utils.utcDateString(x0); }
  gSobject.newDate = function(x0,x1,x2) { return Utils.newDate(x0,x1,x2); }
  gSobject.documentReady = function(x0) { return Utils.documentReady(x0); }
  gSobject.uniqueList = function(x0,x1) { return Utils.uniqueList(x0,x1); }
  gSobject.listsEqual = function(x0,x1) { return Utils.listsEqual(x0,x1); }
  gSobject.uuid = function() { return Utils.uuid(); }
  gSobject.guid = function() { return Utils.guid(); }
  gSobject.callChain = function(x0,x1,x2) { return Utils.callChain(x0,x1,x2); }
  gSobject.callObject = function(x0,x1,x2,x3,x4) { return Utils.callObject(x0,x1,x2,x3,x4); }
  gSobject.send = function(x0,x1,x2,x3) { return Utils.send(x0,x1,x2,x3); }
  gSobject.subscribe = function(x0,x1,x2) { return Utils.subscribe(x0,x1,x2); }
  gSobject.unsubscribe = function(x0) { return Utils.unsubscribe(x0); }
  gSobject.subscribeTopic = function(x0,x1) { return Utils.subscribeTopic(x0,x1); }
  gSobject.unsubscribeTopic = function(x0) { return Utils.unsubscribeTopic(x0); }
  gSobject.tokenAuth = function(x0,x1) { return Utils.tokenAuth(x0,x1); }
  gSobject.userAgent = function() { return Utils.userAgent(); }
  gSobject.login = function(x0,x1,x2,x3) { return Utils.login(x0,x1,x2,x3); }
  gSobject.updateAuthTokenToSession = function(x0) { return Utils.updateAuthTokenToSession(x0); }
  gSobject.triggerLoginRerenderCheck = function(x0) { return Utils.triggerLoginRerenderCheck(x0); }
  gSobject.logout = function(x0,x1) { return Utils.logout(x0,x1); }
  gSobject.urlSafeBase64Encode = function(x0) { return Utils.urlSafeBase64Encode(x0); }
  gSobject.open = function(x0,x1,x2) { return Utils.open(x0,x1,x2); }
  gSobject.inAppBrowser = function(x0,x1,x2) { return Utils.inAppBrowser(x0,x1,x2); }
  gSobject.loadPage = function(x0) { return Utils.loadPage(x0); }
  gSobject.reloadPage = function() { return Utils.reloadPage(); }
  gSobject.setCookie = function(x0,x1) { return Utils.setCookie(x0,x1); }
  gSobject.getCookie = function(x0) { return Utils.getCookie(x0); }
  gSobject.deviceType = function() { return Utils.deviceType(); }
  gSobject.isBrowser = function() { return Utils.isBrowser(); }
  gSobject.isAndroid = function() { return Utils.isAndroid(); }
  gSobject.isIos = function() { return Utils.isIos(); }
  gSobject.isCordova = function() { return Utils.isCordova(); }
  gSobject.cordovaDevice = function() { return Utils.cordovaDevice(); }
  gSobject.isOnline = function() { return Utils.isOnline(); }
  gSobject.userAgent = function() { return Utils.userAgent(); }
  gSobject.toast = function(x0,x1) { return Utils.toast(x0,x1); }
  gSobject.post = function(x0,x1,x2,x3,x4) { return Utils.post(x0,x1,x2,x3,x4); }
  gSobject.validateEmail = function(x0) { return Utils.validateEmail(x0); }
  gSobject.validateCellphone = function(x0) { return Utils.validateCellphone(x0); }
  gSobject.getType = function(x0) { return Utils.getType(x0); }
  gSobject.dateString = function(x0) { return Utils.dateString(x0); }
  gSobject.clearTime = function(x0) { return Utils.clearTime(x0); }
  gSobject.utc = function(x0) { return Utils.utc(x0); }
  gSobject.appendAppVersion = function(x0) { return Utils.appendAppVersion(x0); }
  gSobject.logExceptionStack = function(x0) { return Utils.logExceptionStack(x0); }
  gSobject.getIp = function(x0) { return Utils.getIp(x0); }
  gSobject.preloadImage = function(x0) { return Utils.preloadImage(x0); }
  gSobject.loadScript = function(x0,x1,x2) { return Utils.loadScript(x0,x1,x2); }
  gSobject.mapToJsonString = function(x0) { return Utils.mapToJsonString(x0); }
  gSobject.stringToJson = function(x0,x1) { return Utils.stringToJson(x0,x1); }
  gSobject.stringToDate = function(x0) { return Utils.stringToDate(x0); }
  gSobject.isDate = function(x0) { return Utils.isDate(x0); }
  gSobject.deepCopyMap = function(x0) { return Utils.deepCopyMap(x0); }
  gSobject.findDeep = function(x0,x1) { return Utils.findDeep(x0,x1); }
  gSobject.removeMapKey = function(x0,x1,x2) { return Utils.removeMapKey(x0,x1,x2); }
  gSobject.formatNumber = function(x0,x1,x2,x3) { return Utils.formatNumber(x0,x1,x2,x3); }
  gSobject.iFrameById = function(x0) { return Utils.iFrameById(x0); }
  gSobject.decodeJWT = function(x0) { return Utils.decodeJWT(x0); }
  gSobject.embedTextInBlob = function(x0,x1,x2) { return Utils.embedTextInBlob(x0,x1,x2); }
  gSobject.embedTextInBlobNative = function(x0,x1,x2) { return Utils.embedTextInBlobNative(x0,x1,x2); }
  gSobject.blobToDataUrl = function(x0,x1) { return Utils.blobToDataUrl(x0,x1); }
  gSobject.dataUrlToBlob = function(x0,x1) { return Utils.dataUrlToBlob(x0,x1); }
  gSobject.take = function(x0,x1) { return Utils.take(x0,x1); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Utils.getAuthToken = function(it) {
  return gs.gp(Utils.session,"authToken");
 }
Utils.getDeviceToken = function(it) {
  return gs.gp(Utils.session,"deviceToken");
 }
Utils.setTimeout = function(callback, timeout) {
  return setTimeout(callback, timeout);
 }
Utils.setInterval = function(callback, timeout) {
  return setInterval(callback, timeout);
 }
Utils.clearInterval = function(interval) {
  return clearInterval(interval);
 }
Utils.localDateString = function(date) {
  return gs.mc(gs.mc(gs.mc(Utils,"moment",[date]),"utcOffset",[0, true]),"toISOString",[]);
 }
Utils.utcDateString = function(date) {
  return gs.mc(gs.mc(gs.mc(Utils,"moment",[date]),"utc",[]),"toISOString",[]);
 }
Utils.newDate = function(year, month, day) {
  return new Date(year, month, day)
 }
Utils.documentReady = function(callback) {
  if ((gs.gp(Utils.document,"readyState") === "complete") || ((gs.gp(Utils.document,"readyState") !== "loading") && (!gs.bool(gs.gp(gs.gp(Utils.document,"documentElement"),"doScroll"))))) {
    return gs.execCall(callback, this, []);
   } else {
    return gs.mc(Utils.document,"addEventListener",["DOMContentLoaded", callback]);
   };
 }
Utils.uniqueList = function(list, closure) {
  var newList = gs.list([]);
  gs.mc(gs.mc(list,"reverse",[]),"each",[function(listItem) {
    if (!gs.bool(gs.mc(newList,"find",[function(it) {
      return gs.equals(gs.execCall(closure, this, [listItem]), gs.execCall(closure, this, [it]));
     }]))) {
      return gs.mc(newList,"add",[listItem]);
     };
   }]);
  return gs.mc(newList,"reverse",[]);
 }
Utils.listsEqual = function(a, b) {
  if (gs.mc(a,"size",[]) != gs.mc(b,"size",[])) {
    return false;
   };
  for (var i = 0 ; i < gs.mc(a,"size",[]) ; i++) {
    if ((a[i]) != (b[i])) {
      return false;
     };
   };
  return true;
 }
Utils.uuid = function(it) {
  return gs.mc(Utils.guid(),"replaceAll",["-", ""]);
 }
Utils.guid = function() {
  const UNIX_TS_MS_BITS = 48;
        const VER_DIGIT = "7";
        const SEQ_BITS = 12;
        const VAR = 0b10;
        const VAR_BITS = 2;
        const RAND_BITS = 62;
        
        let prevTimestamp = -1;
        let seq = 0;
    
        const timestamp = Math.max(Date.now(), prevTimestamp);
        seq = timestamp === prevTimestamp ? seq + 1 : 0;
        prevTimestamp = timestamp;
        
        const var_rand = new Uint32Array(2);
        crypto.getRandomValues(var_rand);
        var_rand[0] = (VAR << (32 - VAR_BITS)) | (var_rand[0] >>> VAR_BITS);
        
        const digits = timestamp.toString(16).padStart(UNIX_TS_MS_BITS / 4, "0") + VER_DIGIT +
            seq.toString(16).padStart(SEQ_BITS / 4, "0") +
            var_rand[0].toString(16).padStart((VAR_BITS + RAND_BITS) / 2 / 4, "0") +
            var_rand[1].toString(16).padStart((VAR_BITS + RAND_BITS) / 2 / 4, "0");
        
        return (digits.slice(0, 8) + "-" + digits.slice(8, 12) + "-" + digits.slice(12, 16) + "-" + 
            digits.slice(16, 20) + "-" + digits.slice(20));
 }
Utils.callChain = function(callChain, success, fail) {
  if (success === undefined) success = null;
  if (fail === undefined) fail = null;
  return gs.execStatic(Socket,'callChain', this,[callChain, success, fail]);
 }
Utils.callObject = function(self, method, args, success, fail) {
  if (fail === undefined) fail = null;
  return gs.execStatic(Socket,'callObject', this,[self, method, args, success, fail]);
 }
Utils.send = function(call, data, success, fail) {
  if (fail === undefined) fail = null;
  return gs.execStatic(Socket,'send', this,[call, data, success, fail]);
 }
Utils.subscribe = function(objectId, success, topic) {
  if (topic === undefined) topic = gs.gp(Socket,"SOCKET_OBJECT_URL");
  return gs.execStatic(Socket,'subscribe', this,[objectId, success, topic]);
 }
Utils.unsubscribe = function(objectId) {
  return gs.execStatic(Socket,'unsubscribe', this,[objectId]);
 }
Utils.subscribeTopic = function(topicId, success) {
  return gs.execStatic(Socket,'subscribeTopic', this,[topicId, success]);
 }
Utils.unsubscribeTopic = function(topicId) {
  return gs.execStatic(Socket,'unsubscribeTopic', this,[topicId]);
 }
Utils.tokenAuth = function(success, fail) {
  if (fail === undefined) fail = function(it) {
   };
  gs.println(gs.plus("Utils:tokenAuth:", gs.gp(StartupParams,"doAuthToken")));
  if (gs.bool(gs.gp(Utils.session,"zoner"))) {
    gs.println("Utils:tokenAuth:zoner cached");
    gs.execCall(success, this, []);
    success = null;
    return null;
   };
  gs.println("Utils:tokenAuth:loading zoner");
  var callback = function(authMap) {
    gs.println(gs.plus("tokenAuth:callback:authMap:", authMap));
    if (gs.bool(gs.gp(authMap,"authenticated",true))) {
      gs.mc(Utils,"updateAuthTokenToSession",[authMap]);
      if (gs.bool(success)) {
        gs.execCall(success, this, []);
       };
      return null;
     };
    return gs.execCall(fail, this, []);
   };
  gs.println(gs.plus("getDeviceToken():", Utils.getDeviceToken()));
  return gs.execStatic(Utils,'send', this,["authenticationToken", gs.map().add("deviceId",Utils.getDeviceToken()), callback]);
 }
Utils.userAgent = function() {
  return navigator.userAgent.toLowerCase()
 }
Utils.login = function(username, password, success, fail) {
  if (fail === undefined) fail = function(it) {
   };
  var callback = function(authMap) {
    if (gs.bool(gs.gp(authMap,"authenticated",true))) {
      gs.mc(Utils,"updateAuthTokenToSession",[authMap]);
      gs.execCall(success, this, []);
      return null;
     };
    gs.sp(Utils.session,"zoner",null);
    gs.println("Login failed");
    return gs.execCall(fail, this, []);
   };
  return gs.execStatic(Utils,'send', this,["authentication", gs.map().add("username",username).add("password",password).add("deviceId",Utils.getDeviceToken()).add("userAgent",Utils.userAgent()), callback, fail]);
 }
Utils.updateAuthTokenToSession = function(authMap) {
  Utils.setCookie(gs.gp(Socket,"AUTH_TOKEN"), gs.gp(gs.gp(authMap,"zoner"),"token"));
  gs.sp(Utils.session,"zoner",gs.gp(authMap,"zoner"));
  gs.sp(Utils.session,"zonerId",gs.gp(gs.gp(authMap,"zoner"),"id"));
  if (gs.bool(gs.gp(authMap,"jwt"))) {
    gs.sp(Utils.session,"jwt",gs.gp(authMap,"jwt"));
   };
  return Utils.triggerLoginRerenderCheck(gs.gp(gs.gp(authMap,"zoner"),"id"));
 }
Utils.triggerLoginRerenderCheck = function(zonerId) {
  try {
            if (window.dymicoVersionUpdater && window.dymicoVersionUpdater.checkAfterLogin){
                window.dymicoVersionUpdater.checkAfterLogin(zonerId);
            }
        } catch(e){ console.log('triggerLoginRerenderCheck failed', e); }
 }
Utils.logout = function(pathAfterLogout, dropDatabase) {
  if (pathAfterLogout === undefined) pathAfterLogout = "/login/logout";
  if (dropDatabase === undefined) dropDatabase = true;
  gs.println("Utils.logout");
  gs.sp(Utils.session,"zoner",null);
  gs.sp(Utils.session,"redirectAfterLogin",null);
  gs.sp(Utils.session,"authToken",null);
  gs.sp(Utils.session,"deviceToken",null);
  gs.mc(Utils.session,"clear",[]);
  if (gs.bool(dropDatabase)) {
    gs.execStatic(LocalDB,'getInstance', this,[function(it) {
      return gs.mc(gs.execStatic(LocalDB,'getInstance', this,[]),"dropDatabase",[]);
     }]);
   };
  gs.println(gs.plus("Utils.logout:redirect to ", pathAfterLogout));
  return Utils.loadPage(pathAfterLogout);
 }
Utils.urlSafeBase64Encode = function(str) {
  // 1. Encode to standard Base64
      let base64 = btoa(str);
      
      // 2. Modify to be URL-safe (RFC 4648 Section 5)
      return base64
        .replace(/\+/g, '-')   // Replace + with -
        .replace(/\//g, '_')   // Replace / with _
        .replace(/=+$/, '');    // Remove trailing = padding
 }
Utils.open = function(url, target, options) {
  if (target === undefined) target = "_system";
  if (options === undefined) options = "";
  if (Utils.isCordova()) {
    return Utils.inAppBrowser(gs.mc(Utils,"encodeURI",[url]), target, options);
   };
  return gs.mc(Utils.window,"open",[url, target, options]);
 }
Utils.inAppBrowser = function(url, target, options) {
  return cordova.InAppBrowser.open(encodeURI(url), target, options)
 }
Utils.loadPage = function(url) {
  window.location = url
 }
Utils.reloadPage = function() {
  var url = window.location.href;   
            var seperator = '?'
            if (url.indexOf('?') > -1){ seperator = '&' }
            window.location.href = url+seperator+'v='+ new Date().getTime(); 
            window.location.reload(true);
 }
Utils.setCookie = function(name, value) {
  Cookies.set(name, JSON.stringify(value));
 }
Utils.getCookie = function(name) {
  try{
            return JSON.parse(Cookies.get(name));
            // return gs.toGroovy(jQuery.parseJSON(unescape(Cookies.get(name)))); 
        }catch(all){
            return null
        }
 }
Utils.deviceType = function(it) {
  if (gs.mc(gs.mc(Utils.userAgent(),"toLowerCase",[]),"contains",["electron"])) {
    return gs.gp(gs.gp(Utils,"DeviceTypes"),"ELECTRON");
   };
  if ((gs.mc(gs.mc(Utils.userAgent(),"toLowerCase",[]),"contains",["iphone"])) || (gs.mc(gs.mc(Utils.userAgent(),"toLowerCase",[]),"contains",["ipad"]))) {
    return gs.gp(gs.gp(Utils,"DeviceTypes"),"IOS");
   };
  if (gs.mc(gs.mc(Utils.userAgent(),"toLowerCase",[]),"contains",["android"])) {
    return gs.gp(gs.gp(Utils,"DeviceTypes"),"ANDROID");
   };
  return gs.gp(gs.gp(Utils,"DeviceTypes"),"BROWSER");
 }
Utils.isBrowser = function(it) {
  return gs.equals(Utils.deviceType(), gs.gp(Utils.DeviceTypes,"BROWSER"));
 }
Utils.isAndroid = function(it) {
  return gs.equals(Utils.deviceType(), gs.gp(gs.gp(Utils,"DeviceTypes"),"ANDROID"));
 }
Utils.isIos = function(it) {
  return gs.equals(Utils.deviceType(), gs.gp(gs.gp(Utils,"DeviceTypes"),"IOS"));
 }
Utils.isCordova = function(it) {
  return gs.mc(Utils.userAgent(),"contains",["cordova"]);
 }
Utils.cordovaDevice = function(it) {
  return Utils.isCordova();
 }
Utils.isOnline = function() {
  return window.navigator.onLine
 }
Utils.userAgent = function() {
  return navigator.userAgent.toLowerCase()
 }
Utils.toast = function(message, showDuration) {
  if (showDuration === undefined) showDuration = 300;
  toastr.options = {
            "closeButton": false,
            "debug": false,
            "newestOnTop": false,
            "progressBar": false,
            "positionClass": "toast-bottom-center",
            "preventDuplicates": false,
            "onclick": null,
            "showDuration": showDuration,
            "hideDuration": "1000",
            "timeOut": "5000",
            "extendedTimeOut": "1000",
            "showEasing": "swing",
            "hideEasing": "linear",
            "showMethod": "fadeIn",
            "hideMethod": "fadeOut"
        }
        toastr.info(message);
 }
Utils.post = function(file, parameter, objectName, id, callback) {
  return gs.execStatic(Socket,'post', this,[file, parameter, objectName, id, callback]);
 }
Utils.validateEmail = function(text) {
  return gs.exactMatch(text,/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[A-Za-z.]{2,}$/);
 }
Utils.validateCellphone = function(text) {
  var cleaned = gs.mc(gs.mc(gs.mc(text,"toString",[], null, true),"trim",[], null, true),"replaceAll",["[\s\-\(\)]", ""], null, true);
  if (!gs.bool(cleaned)) {
    return false;
   };
  if (gs.mc(cleaned,"startsWith",["+"])) {
    return gs.exactMatch(cleaned,/^\+[0-9]{7,15}$/);
   };
  return gs.exactMatch(cleaned,/^0[0-9]{9}$/);
 }
Utils.getType = function(value) {
  return typeof value
 }
Utils.dateString = function(date) {
  return gs.plus((gs.plus((gs.plus((gs.plus(gs.mc(date,"getDate",[]), "/")), (gs.plus(gs.mc(date,"getMonth",[]), 1)))), "/")), gs.mc(date,"getFullYear",[]));
 }
Utils.clearTime = function(date) {
  if (date === undefined) date = gs.date();
  return gs.mc(gs.mc(Utils,"moment",[date]),"startOf",["day"]);
 }
Utils.utc = function(date) {
  if (date === undefined) date = gs.date();
  return gs.mc(gs.mc(Utils,"moment",[date]),"utc",[]);
 }
Utils.appendAppVersion = function(url) {
  if (gs.bool(gs.gp(Utils.session,"branchRevision"))) {
    var appender = "?";
    if (gs.mc(url,"contains",["?"])) {
      appender = "&";
     };
    url += (gs.plus((gs.plus(appender, "branchRevision=")), gs.gp(Utils.session,"branchRevision")));
   };
  return url;
 }
Utils.logExceptionStack = function(msg) {
  console.log('%c ' + msg + ' ', 'color: #cc0000');
 }
Utils.getIp = function(callback) {
  Utils.documentReady(function () {
            $.getJSON("http://jsonip.com/?callback=?", function (data) {
                callback(data.ip)
            });
        });
 }
Utils.preloadImage = function(path) {
  new Image().src = path
 }
Utils.loadScript = function(scriptUrl, type, callback) {
  if (type === undefined) type = "text/javascript";
  if (callback === undefined) callback = function(it) {
   };
  
 }
Utils.mapToJsonString = function(map) {
  return JSON.stringify(map)
 }
Utils.stringToJson = function(message, parseDate) {
  if (parseDate === undefined) parseDate = true;
  var jsonMessage = JSON.parse(message, function(key, value) {
              return Utils.stringToDate(value);
            }
        )
        return gs.toGroovy(jsonMessage)
 }
Utils.stringToDate = function(value) {
  if (typeof value === 'string') {
            //var a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
            var a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})?\.(\d*)?Z$/.exec(value);
            if (a) {
                // console.log('stringToDate:value', value)
                const date = new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4], +a[5], +a[6], +a[7]));
                // console.log('stringToDate:date', date)
                return date
            }
        }
        return value;
 }
Utils.isDate = function(date) {
  return date instanceof Date
 }
Utils.deepCopyMap = function(map) {
  return Utils.removeMapKey(gs.toGroovy(Utils.stringToJson(Utils.mapToJsonString(map))),'clazz')
 }
Utils.findDeep = function(m, key) {
  if (m[key]) {
    return m[key];
   };
  var foundValue = null;
  gs.mc(m,"each",[function(k, v) {
    if (gs.bool(foundValue)) {
      return null;
     };
    if (gs.instanceOf(v, "HashMap")) {
      return foundValue = gs.mc(Utils,"findDeep",[v, key]);
     } else {
      if (gs.instanceOf(v, "ArrayList")) {
        return gs.mc(v,"each",[function(item) {
          if (gs.bool(foundValue)) {
            return null;
           };
          if (gs.instanceOf(item, "HashMap")) {
            return foundValue = gs.mc(Utils,"findDeep",[item, key]);
           };
         }]);
       };
     };
   }]);
  return foundValue;
 }
Utils.removeMapKey = function(value, removeKey, list) {
  if (removeKey === undefined) removeKey = "clazz";
  if (list === undefined) list = gs.list([]);
  if (!gs.bool(value)) {
    return value;
   };
  if (((gs.instanceOf(value, "Map")) || (gs.instanceOf(value, "LinkedHashMap"))) || (gs.instanceOf(value, "HashMap"))) {
    gs.mc(value,"remove",[removeKey]);
    if (gs.mc(list,"includes",[value])) {
      return value;
     };
    gs.mc(list,"add",[value]);
    gs.mc(value,"each",[function(key, mapValue) {
      return gs.mc(Utils,"removeMapKey",[mapValue, removeKey, list]);
     }]);
   };
  if ((gs.instanceOf(value, "List")) || (gs.instanceOf(value, "ArrayList"))) {
    for (_i0 = 0, listValue = value[0]; _i0 < value.length; listValue = value[++_i0]) {
      Utils.removeMapKey(listValue, removeKey, list);
     };
   };
  return value;
 }
Utils.formatNumber = function(number, decimals, dec, sep) {
  if (decimals === undefined) decimals = 0;
  if (dec === undefined) dec = ".";
  if (sep === undefined) sep = " ";
  var n = !isFinite(+number) ? 0 : +number, 
            prec = Math.abs(decimals),
            toFixedFix = function (n, prec) {
                // Fix for IE parseFloat(0.55).toFixed(0) = 0;
                var k = Math.pow(10, prec);
                return Math.round(n * k) / k;
            },
            s = (prec ? toFixedFix(n, prec) : Math.round(n)).toString().split('.');
        if (s[0].length > 3) {
            s[0] = s[0].replace(/\B(?=(?:\d{3})+(?!\d))/g, sep);
        }
        if ((s[1] || '').length < prec) {
            s[1] = s[1] || '';
            s[1] += new Array(prec - s[1].length + 1).join('0');
        }
        return s.join(dec);
 }
Utils.iFrameById = function(id) {
  var x = gs.mc(Utils.document,"getElementById",[id]);
  return gs.elvis(gs.bool(gs.gp(x,"contentWindow")) , gs.gp(x,"contentWindow") , gs.gp(x,"contentDocument"));
 }
Utils.decodeJWT = function(token) {
  var base64Url = token.split('.')[1];
        var base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
        var jsonPayload = decodeURIComponent(atob(base64).split('').map(function(c) {
            return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
        }).join(''));
    
        return JSON.parse(jsonPayload);
 }
Utils.embedTextInBlob = function(fileOrBlob, textToEmbed, callback) {
  gs.println("textToEmbed");
  gs.println(textToEmbed);
  if (!gs.bool(textToEmbed)) {
    return gs.execCall(callback, this, [fileOrBlob]);
   };
  return Utils.embedTextInBlobNative(fileOrBlob, textToEmbed, callback);
 }
Utils.embedTextInBlobNative = function(fileOrBlob, text, callback) {
  const reader = new FileReader();
    
      reader.onload = function (e) {
        const img = new Image();
        img.onload = function () {
          const canvas = document.createElement("canvas");
          const ctx = canvas.getContext("2d");
    
          canvas.width = img.width;
          canvas.height = img.height;
          
          var fontSize = canvas.width * 0.025
          
          console.log('fontSize1', fontSize)
          
          if (fontSize < 5 ) fontSize = 5
          
          console.log('fontSize2', fontSize)
    
          // Draw the image
          ctx.drawImage(img, 0, 0);
    
          // Draw text bottom-right
          ctx.font = fontSize+"px Sans-serif";
          ctx.fillStyle = "White";
          ctx.textAlign = "right";
          ctx.textBaseline = "bottom";
    
          const padding = 2;
          ctx.fillText(text, canvas.width - padding, canvas.height - padding);
    
          // Return result as a Blob
          canvas.toBlob(function (blob) {
            callback(blob);
          }, "image/png");
        };
    
        img.onerror = function (err) {
          callback("Image failed to load: " + err);
        };
    
        img.src = e.target.result;
      };
    
      reader.onerror = function (err) {
        callback("FileReader error: " + err);
      };
    
      // Read the file/blob as Data URL
      reader.readAsDataURL(fileOrBlob);
 }
Utils.blobToDataUrl = function(blob, callback) {
  const fileReader = new FileReader();
  
        fileReader.onload = function() {
            callback(fileReader.result)
        }
    
        fileReader.readAsDataURL(blob);
 }
Utils.dataUrlToBlob = function(dataUrl, callback) {
  return gs.mc(gs.mc(gs.mc(Utils.window,"fetch",[dataUrl]),"then",[function(res) {
    return gs.mc(res,"blob",[]);
   }]),"then",[function(blob) {
    return gs.execCall(callback, this, [blob]);
   }]);
 }
Utils.take = function(string, len) {
  if (len === undefined) len = 40;
  if ((!gs.bool(string)) || (gs.mc(string,"size",[]) < len)) {
    return string;
   };
  return gs.rangeFromList(string, 0, len);
 }
Utils.session = gs.execStatic(Session,'instance', this,[]);
Utils.window = null;
Utils.document = null;
Utils.DeviceTypes = gs.map().add("ANDROID","android").add("IOS","ios").add("ELECTRON","electron").add("BROWSER","browser");
Utils.AUTH_FAILED = "AUTH_FAILED";
Utils.NO_AUTH = "NO_AUTH";

function ObjectRegistry() {
  var gSobject = gs.init('ObjectRegistry');
  gSobject.clazz = { name: 'ObjectRegistry', simpleName: 'ObjectRegistry'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'objectRegistry', { get: function() { return ObjectRegistry.objectRegistry; }, set: function(gSval) { ObjectRegistry.objectRegistry = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'enabled', { get: function() { return ObjectRegistry.enabled; }, set: function(gSval) { ObjectRegistry.enabled = gSval; }, enumerable: true });
  gSobject.object = function(x0) { return ObjectRegistry.object(x0); }
  gSobject.register = function(x0) { return ObjectRegistry.register(x0); }
  gSobject.registerSingle = function(x0,x1) { return ObjectRegistry.registerSingle(x0,x1); }
  gSobject.isDatabaseObject = function(x0) { return ObjectRegistry.isDatabaseObject(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
ObjectRegistry.object = function(id) {
  return ObjectRegistry.objectRegistry[id];
 }
ObjectRegistry.register = function(objects) {
  if (!gs.bool(ObjectRegistry.enabled)) {
    return objects;
   };
  if (gs.instanceOf(objects, "ArrayList")) {
    var oObjectList = gs.list([]);
    gs.mc(objects,"eachWithIndex",[function(object, index) {
      return gs.mc(oObjectList,"add",[gs.mc(ObjectRegistry,"registerSingle",[object])]);
     }]);
    return oObjectList;
   } else {
    return ObjectRegistry.registerSingle(objects);
   };
 }
ObjectRegistry.registerSingle = function(object, flatCopy) {
  if (flatCopy === undefined) flatCopy = true;
  if (!gs.bool(ObjectRegistry.isDatabaseObject(object))) {
    return object;
   };
  var oObject = ObjectRegistry.objectRegistry[gs.gp(object,"_id")];
  if (!gs.bool(oObject)) {
    oObject = OObject(object);
    (ObjectRegistry.objectRegistry[gs.gp(object,"_id")]) = oObject;
   } else {
    gs.mc(oObject,"merge",[object, flatCopy]);
   };
  gs.mc(object,"each",[function(key, value) {
    if (gs.mc(ObjectRegistry,"isDatabaseObject",[value])) {
      var newValue = gs.mc(ObjectRegistry,"registerSingle",[value, false]);
      return (gs.gp(oObject,"internalMap")[key]) = gs.mc(newValue,"toJs",[]);
     } else {
      if ((value != null) && (gs.instanceOf(value, "ArrayList"))) {
        var oObjectList = gs.list([]);
        gs.mc(value,"eachWithIndex",[function(objectVal, index) {
          if (gs.mc(ObjectRegistry,"isDatabaseObject",[objectVal])) {
            return gs.mc(oObjectList,"add",[gs.mc(gs.mc(ObjectRegistry,"registerSingle",[objectVal]),"toJs",[])]);
           } else {
            return gs.mc(oObjectList,"add",[objectVal]);
           };
         }]);
        return (gs.gp(oObject,"internalMap")[key]) = oObjectList;
       };
     };
   }]);
  gs.execStatic(Utils,'setTimeout', this,[function(it) {
    return gs.mc(gs.execStatic(LocalDB,'getInstance', this,[]),"updateIfExists",[oObject]);
   }, 100]);
  return oObject;
 }
ObjectRegistry.isDatabaseObject = function(object) {
  return ((object != null) && (gs.instanceOf(object, "HashMap"))) && (gs.bool(gs.gp(object,"_id")));
 }
ObjectRegistry.objectRegistry = gs.map();
ObjectRegistry.enabled = false;

function OObject() {
  var gSobject = gs.init('OObject');
  gSobject.clazz = { name: 'OObject', simpleName: 'OObject'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.internalMap = gs.map();
  gSobject.methodMissingName = null;
  gSobject.methodMissingArgs = null;
  gs.astDelegate('OObject', 'internalMap');
  gSobject.refresher = null;
  gSobject.updateCallback = function(it) {
   };
  gSobject['subscribe'] = function(it) {
    return gs.execStatic(Utils,'subscribe', this,[gs.gp(gSobject.internalMap,"_id"), gSobject.updateCallback]);
   }
  gSobject['unsubscribe'] = function(it) {
    return gs.execStatic(Utils,'unsubscribe', this,[gs.gp(gSobject.internalMap,"_id")]);
   }
  gSobject['setRefresher'] = function(closure, update) {
    if (update === undefined) update = true;
    gs.mc(gSobject,"subscribe",[]);
    if ((!gs.bool(gSobject.refresher)) || ((gs.bool(gSobject.refresher)) && (gs.bool(update)))) {
      return gSobject.refresher = closure;
     };
   }
  gSobject['merge'] = function(object, flatCopy) {
    if (flatCopy === undefined) flatCopy = true;
    if ((gs.bool(object)) && (gs.instanceOf(object, "OObject"))) {
      object = gs.gp(object,"internalMap");
     };
    gs.mc(object,"each",[function(key, value) {
      if (gs.bool(flatCopy)) {
        (gSobject.internalMap[key]) = value;
        return null;
       };
      if (!gs.bool(((value != null) && (gs.instanceOf(value, "String"))) && (gs.execStatic(ObjectRegistry,'isDatabaseObject', this,[gSobject.internalMap[key]])))) {
        return (gSobject.internalMap[key]) = value;
       } else {
        gs.println("WARNING: skip overwrite of DatabaseObject with String");
        gs.println(gs.plus("Key:", key));
        gs.println(gs.plus("String:", value));
        gs.println("internalMap[key]:");
        gs.println(gSobject.internalMap[key]);
        gs.println("Object:");
        return gs.println(gSobject.internalMap);
       };
     }]);
    if (gs.bool(gSobject.refresher)) {
      return gs.mc(gSobject,"refresher",[this]);
     };
   }
  gSobject['toJs'] = function(it) {
    return gSobject.internalMap;
   }
  gSobject['toString'] = function(it) {
    return gs.mc(gSobject.internalMap,"toString",[]);
   }
  gSobject['setProperty'] = function(name, value) {
    return (gSobject.internalMap[name]) = value;
   }
  gSobject['getProperty'] = function(name) {
    return gSobject.internalMap[name];
   }
  gSobject['methodMissing'] = function(name, args) {
    gSobject.methodMissingName = name;
    gSobject.methodMissingArgs = args;
    if (gs.bool(args)) {
      var successClosure = gs.mc(args,"last",[]);
      if (gs.instanceOf(successClosure, "Closure")) {
        if (gs.equals(gs.mc(args,"size",[]), 1)) {
          args = null;
         } else {
          args = (gs.rangeFromList(args, 0, -2));
         };
        gSobject.methodMissingArgs = args;
        return gs.mc(gSobject,"then",[successClosure]);
       };
     };
   }
  gSobject['then'] = function(successClosure, fail) {
    if (successClosure === undefined) successClosure = function(it) {
     };
    if (fail === undefined) fail = function(it) {
     };
    return gs.execStatic(Utils,'callObject', this,[gSobject.internalMap, gSobject.methodMissingName, gSobject.methodMissingArgs, successClosure, fail]);
   }
  gSobject['do'] = function(success) {
    if (success === undefined) success = function(it) {
     };
    return gs.mc(gSobject,"then",[success, null]);
   }
  gSobject.await = function() {
    
   }
  gSobject.promise = function() {
    var self = this;
        return new Promise(function(resolve, reject) {
            self.then(resolve, function(err) { reject(err); });
        });
   }
  gSobject['OObject1'] = function(self) {
    gs.mc(gSobject,"merge",[self]);
    return this;
  }
  if (arguments.length==1) {gSobject.OObject1(arguments[0]); }
  
  return gSobject;
 };

function ObjectFinder() {
  var gSobject = gs.init('ObjectFinder');
  gSobject.clazz = { name: 'ObjectFinder', simpleName: 'ObjectFinder'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'singleO', { get: function() { return ObjectFinder.singleO; }, set: function(gSval) { ObjectFinder.singleO = gSval; }, enumerable: true });
  gSobject.log = RemoteLog("Transmission");
  gSobject.getInstance = function() { return ObjectFinder.getInstance(); }
  gSobject['propertyMissing'] = function(name) {
    var argList = gs.list([gs.map().add("property",name)]);
    return NestedO(argList, CacheCallTracker(0, false, false));
   }
  gSobject['local'] = function(ttl, remoteOnce) {
    if (remoteOnce === undefined) remoteOnce = false;
    var argList = gs.list([]);
    return NestedO(argList, CacheCallTracker(ttl, remoteOnce));
   }
  gSobject['localAndRemote'] = function(ttl) {
    if (ttl === undefined) ttl = -1;
    gs.println("localAndRemote");
    return gs.mc(gSobject,"local",[ttl]);
   }
  gSobject['localAndRemoteOnce'] = function(ttl) {
    if (ttl === undefined) ttl = -1;
    return gs.mc(gSobject,"local",[ttl, true]);
   }
  gSobject['post'] = function(file, parameter, objectName, id, callback) {
    if (objectName === undefined) objectName = null;
    if (id === undefined) id = null;
    if (callback === undefined) callback = function(it) {
     };
    if (!gs.bool(file)) {
      gs.println("No file selected");
      return null;
     };
    gs.println(gs.plus("file: ", file));
    gs.println(gs.plus("parameter: ", parameter));
    gs.println(gs.plus("objectName: ", objectName));
    gs.println(gs.plus("id: ", id));
    return gs.execStatic(Utils,'post', this,[file, parameter, objectName, id, callback]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
ObjectFinder.getInstance = function(it) {
  if (gs.bool(ObjectFinder.singleO)) {
    return ObjectFinder.singleO;
   };
  ObjectFinder.singleO = ObjectFinder();
  return ObjectFinder.singleO;
 }
ObjectFinder.singleO = null;

function RemoteLog() {
  var gSobject = gs.init('RemoteLog');
  gSobject.clazz = { name: 'RemoteLog', simpleName: 'RemoteLog'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.className = null;
  gSobject['info'] = function(message) {
    return gs.mc(gSobject,"generic",["info", message]);
   }
  gSobject['debug'] = function(message) {
    return gs.mc(gSobject,"generic",["debug", message]);
   }
  gSobject['warn'] = function(message) {
    return gs.mc(gSobject,"generic",["warn", message]);
   }
  gSobject['error'] = function(message) {
    return gs.mc(gSobject,"generic",["error", message]);
   }
  gSobject['off'] = function(message) {
    return gs.mc(gSobject,"generic",["off", message]);
   }
  gSobject['trace'] = function(message) {
    return gs.mc(gSobject,"generic",["trace", message]);
   }
  gSobject['generic'] = function(callName, message) {
    try {
      gs.println(gs.plus((gs.plus(gSobject.className, ":")), message));
     }
    catch (all) {
     }
    ;
    return gs.mc(gs.mc(gs.mc(gs.execStatic(ObjectFinder,'getInstance', this,[]),"propertyMissing",["log"]),"" + (callName) + "",[message, gSobject.className]),"do",[]);
   }
  gSobject['RemoteLog1'] = function(className) {
    gs.sp(this,"className",className);
    return this;
  }
  if (arguments.length==1) {gSobject.RemoteLog1(arguments[0]); }
  
  return gSobject;
 };

function NestedO() {
  var gSobject = gs.init('NestedO');
  gSobject.clazz = { name: 'NestedO', simpleName: 'NestedO'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.cacheCallTracker = null;
  gSobject.successClosure = null;
  gSobject.failClosure = function(it) {
   };
  gSobject.argList = gs.list([]);
  gSobject['methodMissing'] = function(name, args) {
    if (gs.mc(gSobject.argList,"size",[]) > 16) {
      throw {message: "Maximum call stack size 16 exceeded"};
     };
    if (gs.bool(args)) {
      var successClosure = gs.mc(args,"last",[]);
      var failClosure = function(it) {
       };
      if ((gs.bool(successClosure)) && (gs.instanceOf(successClosure, "Closure"))) {
        if (gs.equals(gs.mc(args,"size",[]), 1)) {
          args = null;
         } else {
          args = (gs.rangeFromList(args, 0, -2));
          if ((gs.mc(args,"last",[])) && (gs.instanceOf(gs.mc(args,"last",[]), "Closure"))) {
            failClosure = successClosure;
            successClosure = gs.mc(args,"last",[]);
            if (gs.equals(gs.mc(args,"size",[]), 1)) {
              args = null;
             } else {
              args = (gs.rangeFromList(args, 0, -2));
             };
           };
         };
        gs.mc(gSobject.argList,"add",[gs.map().add("method",name).add("args",args)]);
        gs.sp(this,"successClosure",successClosure);
        gs.sp(this,"failClosure",failClosure);
        gs.mc(gSobject,"then",[successClosure, failClosure]);
        return null;
       };
     };
    gs.mc(gSobject.argList,"add",[gs.map().add("method",name).add("args",args)]);
    return NestedO(gSobject.argList, gSobject.cacheCallTracker);
   }
  gSobject.isUndefined = function(val) {
    return val === undefined
   }
  gSobject['propertyMissing'] = function(name) {
    if (gs.mc(gSobject.argList,"size",[]) > 16) {
      throw {message: "Maximum call stack size 16 exceeded"};
     };
    gs.mc(gSobject.argList,"add",[gs.map().add("property",name)]);
    return NestedO(gSobject.argList, gSobject.cacheCallTracker);
   }
  gSobject['then'] = function(success, fail) {
    if (fail === undefined) fail = function(it) {
     };
    return gs.mc(gSobject.cacheCallTracker,"callAndCache",[gSobject.argList, success, fail]);
   }
  gSobject['do'] = function(it) {
    return gs.mc(gSobject,"then",[function(it) {
     }]);
   }
  gSobject.await = function() {
    
   }
  gSobject.promise = function() {
    var self = this;
        return new Promise(function(resolve, reject) {
            self.then(resolve, function(err) { reject(err); });
        });
   }
  gSobject['NestedO2'] = function(argList, cacheCallTracker) {
    gs.sp(this,"cacheCallTracker",cacheCallTracker);
    gs.sp(this,"argList",argList);
    return this;
  }
  if (arguments.length==2) {gSobject.NestedO2(arguments[0], arguments[1]); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function LocalDB() {
  var gSobject = gs.init('LocalDB');
  gSobject.clazz = { name: 'LocalDB', simpleName: 'LocalDB'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'DB_VERSION_NO', { get: function() { return LocalDB.DB_VERSION_NO; }, set: function(gSval) { LocalDB.DB_VERSION_NO = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DB_NAME', { get: function() { return LocalDB.DB_NAME; }, set: function(gSval) { LocalDB.DB_NAME = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MAX_ROWS_PER_BATCH', { get: function() { return LocalDB.MAX_ROWS_PER_BATCH; }, set: function(gSval) { LocalDB.MAX_ROWS_PER_BATCH = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'ASYNC_DB', { get: function() { return LocalDB.ASYNC_DB; }, set: function(gSval) { LocalDB.ASYNC_DB = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DB_COMPRESS', { get: function() { return LocalDB.DB_COMPRESS; }, set: function(gSval) { LocalDB.DB_COMPRESS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DB_ENCRYPT', { get: function() { return LocalDB.DB_ENCRYPT; }, set: function(gSval) { LocalDB.DB_ENCRYPT = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'startupCompleted', { get: function() { return LocalDB.startupCompleted; }, set: function(gSval) { LocalDB.startupCompleted = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'instance', { get: function() { return LocalDB.instance; }, set: function(gSval) { LocalDB.instance = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'jsDbInstance', { get: function() { return LocalDB.jsDbInstance; }, set: function(gSval) { LocalDB.jsDbInstance = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'db', { get: function() { return LocalDB.db; }, set: function(gSval) { LocalDB.db = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'objectMaps', { get: function() { return LocalDB.objectMaps; }, set: function(gSval) { LocalDB.objectMaps = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'callbacks', { get: function() { return LocalDB.callbacks; }, set: function(gSval) { LocalDB.callbacks = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'checkVersion', { get: function() { return LocalDB.checkVersion; }, set: function(gSval) { LocalDB.checkVersion = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'cleanupStaleData', { get: function() { return LocalDB.cleanupStaleData; }, set: function(gSval) { LocalDB.cleanupStaleData = gSval; }, enumerable: true });
  gSobject.localO = LocalDB$LocalO(this);
  gSobject.getInstance = function(x0) { return LocalDB.getInstance(x0); }
  gSobject.initDb = function(x0,x1) { return LocalDB.initDb(x0,x1); }
  gSobject.dropDatabase = function(x0) { return LocalDB.dropDatabase(x0); }
  gSobject['cacheObjects'] = function(key, objectsIn, ttl, callback) {
    var ttlInMs = (gs.equals(ttl, -1) ? null : gs.plus(gs.gp(gs.date(),"time"), (gs.multiply(ttl, 1000))));
    key = (gs.plus("c:", key));
    return gs.mc(LocalDB.db,"upsert",[gs.map().add("_id",key).add("_ttl",ttlInMs).add("stringValue",gs.execStatic(Utils,'mapToJsonString', this,[objectsIn])), function(it) {
      var callbackTmp = callback;
      callback = null;
      if (gs.bool(callbackTmp)) {
        return gs.execCall(callbackTmp, this, []);
       };
     }]);
   }
  gSobject['readCache'] = function(key) {
    key = (gs.plus("c:", key));
    var keyObject = gs.mc(LocalDB.db,"find",[gs.map().add("_id",key)]);
    gs.println(keyObject);
    if (gs.equals(gs.gp(keyObject,"length"), 0)) {
      return null;
     };
    keyObject = (keyObject[0]);
    if ((gs.bool(gs.gp(keyObject,"_ttl"))) && (gs.gp(keyObject,"_ttl") <= gs.gp(gs.date(),"time"))) {
      gs.mc(LocalDB.db,"remove",[gs.map().add("_id",key)]);
      gs.mc(LocalDB.db,"save",[]);
      return null;
     };
    return gs.execStatic(Utils,'stringToJson', this,[gs.gp(keyObject,"stringValue")]);
   }
  gSobject['registerPath'] = function(objectName, objectMap) {
    return (LocalDB.objectMaps[objectName]) = objectMap;
   }
  gSobject['insert'] = function(object, callback) {
    if (callback === undefined) callback = null;
    object = (gs.mc(gs.map(),'leftShift', gs.list([object])));
    gs.mc(gSobject,"fixDatesToDb",[object]);
    if (gs.bool(callback)) {
      return gs.mc(LocalDB.db,"upsert",[object, function(it) {
        var callbackTmp = callback;
        callback = null;
        if (gs.bool(callbackTmp)) {
          return gs.execCall(callbackTmp, this, [object]);
         };
       }]);
     };
    gs.mc(LocalDB.db,"upsert",[object]);
    gs.mc(LocalDB.db,"save",[]);
    return object;
   }
  gSobject['save'] = function(object, callback) {
    if (callback === undefined) callback = null;
    gs.sp(object,"_dateCreated",gs.elvis(gs.bool(gs.gp(object,"_dateCreated")) , gs.gp(object,"_dateCreated") , gs.date()));
    gs.sp(object,"_lastUpdated",gs.date());
    gs.sp(object,"_remoteChange",true);
    return gs.mc(gSobject,"insert",[object, callback]);
   }
  gSobject['insertAll'] = function(objects, callback) {
    if (callback === undefined) callback = function(it) {
     };
    for (_i29 = 0, object = objects[0]; _i29 < objects.length; object = objects[++_i29]) {
      gs.mc(this,"fixDatesToDb",[object], gSobject);
     };
    return gs.mc(LocalDB.db,"upsert",[objects, callback]);
   }
  gSobject['saveAll'] = function(objects, callback) {
    if (callback === undefined) callback = function(it) {
     };
    for (_i30 = 0, object = objects[0]; _i30 < objects.length; object = objects[++_i30]) {
      gs.sp(object,"_dateCreated",gs.elvis(gs.bool(gs.gp(object,"_dateCreated")) , gs.gp(object,"_dateCreated") , gs.date()));
      gs.sp(object,"_lastUpdated",gs.date());
      gs.sp(object,"_remoteChange",true);
     };
    return gs.mc(gSobject,"insertAll",[objects, callback]);
   }
  gSobject['commit'] = function(errorCallback) {
    if (errorCallback === undefined) errorCallback = function(it) {
     };
    return gs.mc(LocalDB.db,"save",[errorCallback]);
   }
  gSobject['updateIfExists'] = function(object) {
    var keyObject = gs.mc(LocalDB.db,"find",[gs.toJavascript(gs.map().add("_id",gs.gp(object,"_id")))]);
    if (gs.bool(keyObject)) {
      return gs.mc(gSobject,"insert",[object]);
     };
   }
  gSobject['getO'] = function(it) {
    return gSobject.localO;
   }
  gSobject['objectCallWrapper'] = function(objectName) {
    var staticFilter = LocalDB.objectMaps[objectName];
    return gs.map().add("getOne",function(id, callback) {
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"getOne",[id, callback]);
     }).add("findOne",function(filter, callback) {
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"findOne",[gs.mc(filter,'leftShift', gs.list([staticFilter])), callback]);
     }).add("findOrCreate",function(filter, mapToSave, callback) {
      if (mapToSave === undefined) mapToSave = gs.map();
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"findOrCreate",[gs.mc(filter,'leftShift', gs.list([staticFilter])), mapToSave, callback]);
     }).add("find",function(filter, params) {
      if (params === undefined) params = gs.map();
      return gs.mc(LocalDB.instance,"find",[gs.mc(filter,'leftShift', gs.list([staticFilter])), params]);
     }).add("findAll",function(params) {
      if (params === undefined) params = gs.map();
      return gs.mc(LocalDB.instance,"find",[staticFilter, params]);
     }).add("new",function(initParams) {
      if (initParams === undefined) initParams = gs.map();
      var item = gs.mc(initParams,'leftShift', gs.list([staticFilter]));
      gs.sp(item,"_id",gs.execStatic(Utils,'uuid', this,[]));
      return gs.mc(gSobject,"decorate",[item]);
     });
   }
  gSobject['findOrCreate'] = function(filter, mapToSave, callback) {
    if (mapToSave === undefined) mapToSave = gs.map();
    if (callback === undefined) callback = null;
    var item = gs.mc(gSobject,"findOne",[filter]);
    if (gs.bool(item)) {
      if (gs.bool(callback)) {
        return gs.execCall(callback, this, [item]);
       };
      return item;
     };
    mapToSave = (gs.mc(gs.mc(mapToSave,"clone",[]),'leftShift', gs.list([filter])));
    gs.sp(mapToSave,"_id",gs.execStatic(Utils,'uuid', this,[]));
    if (gs.bool(callback)) {
      return gs.mc(LocalDB.instance,"save",[mapToSave, function(savedItem) {
        return gs.mc(gSobject,"getOne",[gs.gp(savedItem,"_id"), callback]);
       }]);
     };
    item = gs.mc(LocalDB.instance,"save",[mapToSave]);
    return gs.mc(gSobject,"getOne",[gs.gp(item,"_id")]);
   }
  gSobject['getOne'] = function(id, expandableFields, level) {
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    return gs.mc(gSobject,"getOne",[id, null, expandableFields, level]);
   }
  gSobject['getOne'] = function(id, callback, expandableFields, level) {
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    if (gs.bool(expandableFields)) {
      return gs.mc(gSobject,"findOne",[gs.map().add("_id",id), callback, expandableFields, level]);
     } else {
      return gs.mc(gSobject,"findOne",[gs.map().add("_id",id), callback]);
     };
   }
  gSobject['findOne'] = function(filter, callback, expandableFields, level) {
    if (callback === undefined) callback = null;
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    return gs.mc(gSobject,"findOne",[filter, null, expandableFields, level]);
   }
  gSobject['findOne'] = function(filter, callback, expandableFields, level) {
    if (callback === undefined) callback = null;
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    var item = null;
    if (gs.bool(expandableFields)) {
      item = gs.mc(gSobject,"find",[filter, gs.map().add("limit",1), expandableFields, level]);
     } else {
      item = gs.mc(gSobject,"find",[filter, gs.map().add("limit",1)]);
     };
    if (!gs.bool(item)) {
      if (gs.bool(callback)) {
        gs.execCall(callback, this, [gs.map()]);
       };
      return gs.map();
     };
    item = (item[0]);
    gs.mc(gSobject,"decorate",[item]);
    if (gs.bool(callback)) {
      gs.execCall(callback, this, [item]);
     };
    return item;
   }
  gSobject['delete'] = function(id, callback) {
    if (callback === undefined) callback = function(it) {
     };
    gs.mc(LocalDB.db,"remove",[gs.map().add("_id",id)]);
    return gs.mc(LocalDB.db,"save",[callback]);
   }
  gSobject['find'] = function(filter, params, expandableFields, level) {
    if (params === undefined) params = gs.map();
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    var dbList = gs.mc(LocalDB.db,"find",[gs.toJavascript(filter), gs.toJavascript(gs.mc((gs.mc(gs.mc(gSobject,"getLimit",[params]),'leftShift', gs.list([gs.mc(gSobject,"getSkip",[params])]))),'leftShift', gs.list([gs.mc(gSobject,"getSort",[params])])))]);
    var objectList = gs.list([]);
    gs.mc(dbList,"each",[function(dbItem) {
      var item = gs.mc(gs.map(),'leftShift', gs.list([dbItem]));
      gs.mc(gSobject,"fixDatesFromDb",[item]);
      gs.mc(gSobject,"decorate",[item]);
      if (gs.bool(expandableFields)) {
        item = gs.mc(gSobject,"expandItem",[item, expandableFields, level]);
       };
      return gs.mc(objectList,"add",[item]);
     }]);
    return objectList;
   }
  gSobject['remove'] = function(filter, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(LocalDB.db,"remove",[gs.toJavascript(filter)]);
   }
  gSobject['count'] = function(filter) {
    return gs.mc(LocalDB.db,"count",[gs.toJavascript(filter)]);
   }
  gSobject['expandItem'] = function(item, expandableFields, level) {
    if (level === undefined) level = 1;
    var fields = gs.mc(expandableFields,"collect",[function(it) {
      return gs.gp(it,"field");
     }]);
    gs.mc(item,"each",[function(k, v) {
      if (gs.mc(fields,"contains",[k])) {
        if (((gs.equals(v, null)) || (gs.equals(v, gs.fs('undefined', this, gSobject)))) || (gs.equals(v, ""))) {
          return null;
         };
        var currentField = gs.mc(expandableFields,"find",[function(it) {
          return gs.equals(gs.gp(it,"field"), k);
         }]);
        if (gs.instanceOf(v, "List")) {
          var expandResult = gs.mc(LocalDB.db,"find",[gs.toJavascript(gs.map().add("_id",gs.map().add("$in",v)).add("_path",gs.gp(currentField,"_path")))]);
          var expandResultObjects = gs.list([]);
          gs.mc(expandResult,"each",[function(expandResultItem) {
            var expandedItem = gs.mc(gs.map(),'leftShift', gs.list([expandResultItem]));
            gs.mc(gSobject,"fixDatesFromDb",[expandedItem]);
            if (level > 1) {
              expandedItem = gs.mc(gSobject,"expandItem",[expandedItem, expandableFields, gs.minus(level, 1)]);
             };
            return gs.mc(expandResultObjects,"add",[expandedItem]);
           }]);
          return (item[k]) = gs.elvis(gs.bool(expandResultObjects) , expandResultObjects , gs.list([]));
         } else {
          var expandResult = gs.mc(LocalDB.db,"find",[gs.toJavascript(gs.map().add("_id",v).add("_path",gs.gp(currentField,"_path"))), gs.toJavascript(gs.mc(gSobject,"getLimit",[gs.map().add("limit",1)]))])[0];
          var expandedItem = gs.mc(gs.map(),'leftShift', gs.list([expandResult]));
          gs.mc(gSobject,"fixDatesFromDb",[expandedItem]);
          if (level > 1) {
            expandedItem = gs.mc(gSobject,"expandItem",[expandedItem, expandableFields, gs.minus(level, 1)]);
           };
          return (item[k]) = gs.elvis(gs.bool(expandedItem) , expandedItem , null);
         };
       };
     }]);
    return item;
   }
  gSobject['getLimit'] = function(params) {
    return gs.map().add("$limit",gs.elvis(gs.bool(params["limit"]) , params["limit"] , gs.elvis(gs.bool(gs.gp(params,"max")) , gs.gp(params,"max") , LocalDB.MAX_ROWS_PER_BATCH)));
   }
  gSobject['getSkip'] = function(params) {
    return gs.map().add("$skip",gs.elvis(gs.bool(gs.gp(params,"offset")) , gs.gp(params,"offset") , gs.elvis(gs.bool(params["skip"]) , params["skip"] , 0)));
   }
  gSobject['getSort'] = function(params) {
    var order = 1;
    if (gs.equals(gs.gp(params,"order"), "desc")) {
      order = -1;
     };
    if (gs.bool(params["sort"])) {
      return gs.map().add("$orderBy",gs.map().add(params["sort"],order));
     };
    return gs.map();
   }
  gSobject['fixDatesToDb'] = function(object) {
    gs.mc(object,"each",[function(key, value) {
      if ((gs.bool(value)) && (gs.instanceOf(value, "HashMap"))) {
        gs.mc(gSobject,"fixDatesToDb",[value]);
       };
      if (gs.execStatic(Utils,'isDate', this,[value])) {
        return (object[key]) = gs.mc(LocalDB.db,"make",[value]);
       };
     }]);
    return object;
   }
  gSobject['fixDatesFromDb'] = function(object) {
    gs.mc(object,"each",[function(key, value) {
      if ((gs.bool(value)) && (gs.instanceOf(value, "HashMap"))) {
        gs.mc(gSobject,"fixDatesFromDb",[value]);
       };
      if (gs.execStatic(Utils,'isDate', this,[value])) {
        return (object[key]) = gs.date(value);
       };
     }]);
    return object;
   }
  gSobject['decorate'] = function(item) {
    gs.sp(item,"merge",function(map) {
      gs.mc(item,"putAll",[map]);
      return item;
     });
    gs.sp(item,"save",function(callback) {
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"save",[item, callback]);
     });
    gs.sp(item,"delete",function(callback) {
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"delete",[gs.gp(item,"_id"), callback]);
     });
    return item;
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
LocalDB.getInstance = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  if (!gs.bool(LocalDB.instance)) {
    LocalDB.instance = LocalDB();
    if (!gs.bool(LocalDB.db)) {
      LocalDB.initDb(LocalDB.DB_NAME, function(it) {
        return gs.mc(LocalDB,"checkVersion",[function(it) {
          return gs.mc(LocalDB,"cleanupStaleData",[function(it) {
            LocalDB.startupCompleted = true;
            gs.execCall(callback, this, [LocalDB.instance]);
            gs.mc(LocalDB.callbacks,"each",[function(it) {
              return gs.execCall(it, this, [LocalDB.instance]);
             }]);
            return LocalDB.callbacks = gs.list([]);
           }]);
         }]);
       });
     };
   } else {
    if (!gs.bool(LocalDB.startupCompleted)) {
      gs.mc(LocalDB.callbacks,"add",[callback]);
      return LocalDB.instance;
     };
    gs.execCall(callback, this, [LocalDB.instance]);
   };
  return LocalDB.instance;
 }
LocalDB.initDb = function(dbName, callback) {
  var fdb = new ForerunnerDB();
        var forerunnerdb = fdb.db(dbName);
        
        // if (LocalDB.DB_COMPRESS) forerunnerdb.persist.addStep(new forerunnerdb.shared.plugins.FdbCompress());
        // if (LocalDB.DB_ENCRYPT) forerunnerdb.persist.addStep(new forerunnerdb.shared.plugins.FdbCrypto({
        //       pass: "dbStoreCode"
        // }));


        forerunnerdb.persist.addStep(new forerunnerdb.shared.plugins.FdbCompress());
        forerunnerdb.persist.addStep(new forerunnerdb.shared.plugins.FdbCrypto({
              pass: "dbStoreCode"
        }));
        
        var collection = forerunnerdb.collection("appCollection")
        // collection.deferredCalls(LocalDB.ASYNC_DB)
        collection.deferredCalls(false)
        collection.load(function (err, tableStats, metaStats) {
        	if (err) {
        		console.error('forerunnerdb error')
        	}else{
        	    console.log('forerunnerdb started')
        	}
        	
        	LocalDB.jsDbInstance = forerunnerdb
        	LocalDB.db = collection
        	
        	callback()
        });
 }
LocalDB.dropDatabase = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  return gs.mc(LocalDB.jsDbInstance,"drop",[true, function(it) {
    return gs.mc(LocalDB,"initDb",[LocalDB.DB_NAME, function(it) {
      return gs.mc(LocalDB.db,"upsert",[gs.map().add("_id","dbVersionNumber").add("version",LocalDB.DB_VERSION_NO), callback]);
     }]);
   }]);
 }
LocalDB.DB_VERSION_NO = "1.2";
LocalDB.DB_NAME = "1";
LocalDB.MAX_ROWS_PER_BATCH = 1000;
LocalDB.ASYNC_DB = false;
LocalDB.DB_COMPRESS = true;
LocalDB.DB_ENCRYPT = true;
LocalDB.startupCompleted = false;
LocalDB.instance = null;
LocalDB.jsDbInstance = null;
LocalDB.db = null;
LocalDB.objectMaps = gs.map();
LocalDB.callbacks = gs.list([]);
LocalDB.checkVersion = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  gs.println("LocalDB.checkVersion");
  var version = gs.mc(LocalDB.db,"find",[gs.map().add("_id","dbVersionNumber")]);
  if ((gs.equals(gs.gp(version,"length"), 0)) || (gs.gp(version[0],"version") != LocalDB.DB_VERSION_NO)) {
    gs.println("FOUND OLD DB:DROP DB");
    gs.mc(LocalDB,"dropDatabase",[callback]);
    return null;
   };
  return gs.execCall(callback, this, []);
 };
LocalDB.cleanupStaleData = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  gs.println("LocalDB.cleanupStaleData");
  var nowMs = gs.gp(gs.date(),"time");
  return gs.execCall(callback, this, []);
 };

function LocalDB$LocalO() {
  var gSobject = gs.init('LocalDB$LocalO');
  gSobject.clazz = { name: 'LocalDB$LocalO', simpleName: 'LocalDB$LocalO'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.this$0 = null;
  gSobject['propertyMissing'] = function(objectName) {
    return gs.mc(gs.gp(LocalDB,"instance"),"objectCallWrapper",[objectName]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CacheCallTracker() {
  var gSobject = gs.init('CacheCallTracker');
  gSobject.clazz = { name: 'CacheCallTracker', simpleName: 'CacheCallTracker'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'remoteOnceMap', { get: function() { return CacheCallTracker.remoteOnceMap; }, set: function(gSval) { CacheCallTracker.remoteOnceMap = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'resultCache', { get: function() { return CacheCallTracker.resultCache; }, set: function(gSval) { CacheCallTracker.resultCache = gSval; }, enumerable: true });
  gSobject.ttl = 0;
  gSobject.remoteOnce = false;
  gSobject['callAndCache'] = function(argList, successClosure, fail) {
    if (successClosure === undefined) successClosure = function(it) {
     };
    if (fail === undefined) fail = null;
    var argListString = gs.mc(argList,"toString",[]);
    if (!gs.bool(gSobject.ttl)) {
      return gs.execStatic(Socket,'callChain', this,[argList, function(result) {
        return gs.execCall(successClosure, this, [result]);
       }, fail]);
     };
    var objects = CacheCallTracker.resultCache[argListString];
    return gs.execStatic(LocalDB,'getInstance', this,[function(localDB) {
      if (!gs.bool(objects)) {
        objects = gs.mc(gs.execStatic(LocalDB,'getInstance', this,[]),"readCache",[argListString]);
       };
      if (gs.bool(objects)) {
        gs.execStatic(ObjectRegistry,'register', this,[objects]);
        gs.execCall(successClosure, this, [objects]);
       };
      return gs.execStatic(Utils,'setTimeout', this,[function(it) {
        if (gs.bool(objects)) {
          (CacheCallTracker.remoteOnceMap[argListString]) = (CacheCallTracker.remoteOnceMap[argListString] ? gs.plus((CacheCallTracker.remoteOnceMap[argListString]), 1) : 1);
          if ((gs.bool(gSobject.remoteOnce)) && ((CacheCallTracker.remoteOnceMap[argListString]) > 1)) {
            return null;
           };
         };
        return gs.execStatic(Socket,'callChain', this,[argList, function(result) {
          (CacheCallTracker.resultCache[argListString]) = result;
          gs.execCall(successClosure, this, [result]);
          return gs.execStatic(Utils,'setTimeout', this,[function(it) {
            return gs.mc(gSobject,"syncCache",[argListString, result, function(it) {
              return gs.println("syncCache:done");
             }]);
           }, 0]);
         }, fail]);
       }, 0]);
     }]);
   }
  gSobject['syncCache'] = function(argListString, objects, callback) {
    if (gs.bool(gSobject.ttl)) {
      return gs.execStatic(LocalDB,'getInstance', this,[function(it) {
        return gs.mc(gs.execStatic(LocalDB,'getInstance', this,[]),"cacheObjects",[argListString, objects, gSobject.ttl, callback]);
       }]);
     };
   }
  gSobject['CacheCallTracker2'] = function(ttl, remoteOnce) {
    gs.sp(this,"ttl",ttl);
    gs.sp(this,"remoteOnce",remoteOnce);
    return this;
  }
  if (arguments.length==2) {gSobject.CacheCallTracker2(arguments[0], arguments[1]); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CacheCallTracker.remoteOnceMap = gs.map();
CacheCallTracker.resultCache = gs.map();

function GpsLocationTracker() {
  var gSobject = gs.init('GpsLocationTracker');
  gSobject.clazz = { name: 'GpsLocationTracker', simpleName: 'GpsLocationTracker'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'HIGH_ACCURACY', { get: function() { return GpsLocationTracker.HIGH_ACCURACY; }, set: function(gSval) { GpsLocationTracker.HIGH_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MEDIUM_ACCURACY', { get: function() { return GpsLocationTracker.MEDIUM_ACCURACY; }, set: function(gSval) { GpsLocationTracker.MEDIUM_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'LOW_ACCURACY', { get: function() { return GpsLocationTracker.LOW_ACCURACY; }, set: function(gSval) { GpsLocationTracker.LOW_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'PASSIVE_ACCURACY', { get: function() { return GpsLocationTracker.PASSIVE_ACCURACY; }, set: function(gSval) { GpsLocationTracker.PASSIVE_ACCURACY = gSval; }, enumerable: true });
  gSobject.gpsService = null;
  gSobject.lastLocation = null;
  Object.defineProperty(gSobject, 'singletonInstance', { get: function() { return GpsLocationTracker.singletonInstance; }, set: function(gSval) { GpsLocationTracker.singletonInstance = gSval; }, enumerable: true });
  gSobject.desiredAccuracy = GpsLocationTracker.HIGH_ACCURACY;
  gSobject.instance = function() { return GpsLocationTracker.instance(); }
  gSobject['config'] = function(config) {
    gs.mc(gSobject.gpsService,"setConfig",[config]);
    return this;
   }
  gSobject['getCurrentLocation'] = function(successCallback, failedCallback, config) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    if (config === undefined) config = gs.map();
    var callbackWrapper = function(location) {
      gSobject.lastLocation = location;
      gs.execCall(successCallback, this, [location]);
      return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userLocation",[location]),"do",[]);
     };
    gs.mc(gSobject.gpsService,"getCurrentLocation",[callbackWrapper, failedCallback]);
    return this;
   }
  gSobject['onLocation'] = function(successCallback, failedCallback) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    var callbackWrapper = function(location) {
      gSobject.lastLocation = location;
      gs.execCall(successCallback, this, [location]);
      return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userLocation",[location]),"do",[]);
     };
    gs.mc(gSobject.gpsService,"onLocation",[callbackWrapper, failedCallback]);
    return this;
   }
  gSobject['onStationary'] = function(stationaryCallback, failedCallback) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    gs.mc(gSobject.gpsService,"onStationary",[stationaryCallback, failedCallback]);
    return this;
   }
  gSobject['start'] = function(it) {
    gs.mc(gSobject.gpsService,"start",[]);
    return this;
   }
  gSobject['stop'] = function(it) {
    gs.mc(gSobject.gpsService,"stop",[]);
    return this;
   }
  gSobject['sync'] = function(it) {
    gs.mc(gSobject.gpsService,"sync",[]);
    return this;
   }
  gSobject['getName'] = function(it) {
    gs.mc(gSobject.gpsService,"getName",[]);
    return this;
   }
  gSobject.backgroundGeoLocationDefined = function() {
    return typeof BackgroundGeolocation !== 'undefined';
   }
  gSobject['GpsLocationTracker0'] = function(it) {
    if (gs.mc(gSobject,"backgroundGeoLocationDefined",[])) {
      gSobject.gpsService = GpsLocationTracker$CordovaBackgroundGeolocation(this);
     } else {
      if (gs.bool(gs.gp(navigator,"geolocation"))) {
        gSobject.gpsService = GpsLocationTracker$Html5Gps(this);
       } else {
        throw {message: "GPS not supported"};
       };
     };
    return this;
  }
  if (arguments.length==0) {gSobject.GpsLocationTracker0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
GpsLocationTracker.instance = function(it) {
  if (!gs.bool(GpsLocationTracker.singletonInstance)) {
    GpsLocationTracker.singletonInstance = GpsLocationTracker();
   };
  return GpsLocationTracker.singletonInstance;
 }
GpsLocationTracker.HIGH_ACCURACY = 0;
GpsLocationTracker.MEDIUM_ACCURACY = 10;
GpsLocationTracker.LOW_ACCURACY = 1000;
GpsLocationTracker.PASSIVE_ACCURACY = 10000;
GpsLocationTracker.singletonInstance = null;

function GpsLocationTracker$Html5Gps() {
  var gSobject = gs.init('GpsLocationTracker$Html5Gps');
  gSobject.clazz = { name: 'GpsLocationTracker$Html5Gps', simpleName: 'GpsLocationTracker$Html5Gps'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.watchPositionId = null;
  gSobject.onLocationSuccessCallback = function(it) {
   };
  gSobject.onLocationFailedCallback = function(it) {
   };
  gSobject.config = gs.map().add("desiredAccuracy",gs.gp(GpsLocationTracker,"HIGH_ACCURACY")).add("backgroundDesiredAccuracy",gs.gp(GpsLocationTracker,"LOW_ACCURACY")).add("enableHighAccuracy",true).add("maximumAge",30000).add("timeout",30000);
  gSobject.this$0 = null;
  gSobject['getName'] = function(it) {
    return "Html5Gps";
   }
  gSobject['setConfig'] = function(config) {
    return gs.mc(gs.gp(gs.thisOrObject(this,gSobject),"config"),'leftShift', gs.list([config]));
   }
  gSobject['getCurrentLocation'] = function(successCallback, failedCallback, config) {
    if (config === undefined) config = gs.map();
    return gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"geolocation"),"getCurrentPosition",[function(location) {
      return gs.execCall(successCallback, this, [gs.gp(location,"coords")]);
     }, failedCallback, gs.map().add("enableHighAccuracy",gs.gp(config,"desiredAccuracy") <= gs.gp(GpsLocationTracker,"MEDIUM_ACCURACY")).add("maximumAge",gs.gp(config,"maximumAge")).add("timeout",gs.gp(config,"timeout"))]);
   }
  gSobject['onLocation'] = function(successCallback, failedCallback) {
    gSobject.onLocationSuccessCallback = successCallback;
    return gSobject.onLocationFailedCallback = failedCallback;
   }
  gSobject['setDesiredAccuracy'] = function(desiredAccuracy) {
    return gs.sp(gSobject.config,"desiredAccuracy",desiredAccuracy);
   }
  gSobject['onStationary'] = function(stationaryCallback) {
   }
  gSobject['sync'] = function(it) {
   }
  gSobject['start'] = function(it) {
    return gSobject.watchPositionId = gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"geolocation"),"watchPosition",[function(location) {
      var gpsMap = gs.mc(gs.map().add("fixId",gs.execStatic(Utils,'uuid', this,[])).add("provider",gs.mc(gSobject,"getName",[])).add("unixTimeMs",gs.gp(location,"timestamp")).add("accuracy",null).add("speed",null).add("altitude",null).add("latitude",null).add("longitude",null).add("bearing",gs.gp(gs.gp(location,"coords"),"heading")).add("service","Html5Gps").add("user",gs.gp(gs.fs('session', this, gSobject),"userId")).add("uuid",gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"uuid")),'leftShift', gs.list([gs.gp(location,"coords")]));
      return gs.mc(gSobject,"onLocationSuccessCallback",[gs.mc(gs.fs('gs', this, gSobject),"toJavascript",[gpsMap])]);
     }, gSobject.onLocationFailedCallback, gs.map().add("enableHighAccuracy",gs.gp(gSobject.config,"backgroundDesiredAccuracy") <= gs.gp(GpsLocationTracker,"MEDIUM_ACCURACY")).add("maximumAge",gs.gp(gSobject.config,"maximumAge")).add("timeout",gs.gp(gSobject.config,"timeout"))]);
   }
  gSobject['stop'] = function(it) {
    if (gs.bool(gSobject.watchPositionId)) {
      return gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"geolocation"),"clearWatch",[gSobject.watchPositionId]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function GpsLocationTracker$CordovaBackgroundGeolocation() {
  var gSobject = gs.init('GpsLocationTracker$CordovaBackgroundGeolocation');
  gSobject.clazz = { name: 'GpsLocationTracker$CordovaBackgroundGeolocation', simpleName: 'GpsLocationTracker$CordovaBackgroundGeolocation'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.config = gs.map().add("debug",false).add("locationProvider",gs.gp(BackgroundGeolocation,"DISTANCE_FILTER_PROVIDER")).add("backgroundLocationProvider",gs.gp(BackgroundGeolocation,"DISTANCE_FILTER_PROVIDER")).add("desiredAccuracy",gs.gp(GpsLocationTracker,"HIGH_ACCURACY")).add("backgroundDesiredAccuracy",gs.gp(GpsLocationTracker,"HIGH_ACCURACY")).add("activityType","OtherNavigation").add("stationaryRadius",10).add("distanceFilter",10).add("notificationTitle","GPS tracking").add("notificationText","enabled").add("enableHighAccuracy",true).add("startForeground",true).add("stopOnTerminate",false).add("interval",5000).add("fastestInterval",5000).add("activitiesInterval",5000).add("autoSync",true).add("syncThreshold",100).add("maxLocations",gs.multiply(10, 1000)).add("url","" + (gs.gp(session,"incomingUrl")) + "/cordovaWrapper/gps").add("syncUrl","" + (gs.gp(session,"incomingUrl")) + "/cordovaWrapper/gps").add("httpHeaders",gs.map()).add("postTemplate",gs.map().add("fixId","@id").add("provider","@provider").add("unixTimeMs","@time").add("accuracy","@accuracy").add("speed","@speed").add("altitude","@altitude").add("latitude","@latitude").add("longitude","@longitude").add("bearing","@bearing").add("service","BackgroundGeolocation").add("user",gs.gp(session,"userId")).add("uuid",gs.gp(gs.gp(cordovaDevice,"device"),"uuid")));
  gSobject.this$0 = null;
  gSobject['getName'] = function(it) {
    return "CordovaBackgroundGeolocation";
   }
  gSobject['setConfig'] = function(config) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("BackgroundGeolocation:setConfig:", config)]);
    gs.mc(gs.gp(gs.thisOrObject(this,gSobject),"config"),'leftShift', gs.list([config]));
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[gs.gp(gs.thisOrObject(this,gSobject),"config")]);
    return this;
   }
  gSobject['getCurrentLocation'] = function(successCallback, failedCallback, config) {
    if (config === undefined) config = gs.map();
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getCurrentLocation",[successCallback, failedCallback, gs.mc(gs.map().add("enableHighAccuracy",true).add("maximumAge",gs.multiply((gs.multiply(4, 60)), 1000)).add("timeout",gs.multiply(60, 1000)),'leftShift', gs.list([config]))]);
   }
  gSobject['onLocation'] = function(successCallback, failedCallback) {
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["location", function(location) {
      return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"startTask",[function(taskKey) {
        gs.execCall(successCallback, this, [location]);
        return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"endTask",[taskKey]);
       }]);
     }]);
   }
  gSobject['onStationary'] = function(stationaryCallback) {
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["stationary", stationaryCallback]);
   }
  gSobject['sync'] = function(it) {
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"forceSync",[]);
   }
  gSobject['start'] = function(it) {
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"start",[]);
    gs.mc(gSobject,"sync",[]);
    return this;
   }
  gSobject['stop'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("BackgroundGeolocation:stop:", gs.gp(gs.fs('session', this, gSobject),"userId"))]);
   }
  gSobject['GpsLocationTracker$CordovaBackgroundGeolocation0'] = function(it) {
    gs.mc(BackgroundGeolocation,"on",["background", function(it) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["BackgroundGeolocation:background"]);
      appStatus = "background";
      return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[function(it) {
        return gs.gp(gSobject.config,"backgroundDesiredAccuracy");
       }]);
     }]);
    gs.mc(BackgroundGeolocation,"on",["foreground", function(it) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["BackgroundGeolocation:foreground"]);
      appStatus = "foreground";
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[function(it) {
        return gs.gp(gSobject.config,"desiredAccuracy");
       }]);
      return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"forceSync",[]);
     }]);
    gs.mc(BackgroundGeolocation,"on",["authorization", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("BackgroundGeolocation:authorization:status: ", status)]);
      if (status !== gs.gp(gs.fs('BackgroundGeolocation', this, gSobject),"AUTHORIZED")) {
        return gs.execStatic(Utils,'setTimeout', this,[function(it) {
          var showSettings = gs.mc(this,"confirm",["App requires location tracking permission. Would you like to open app settings?"], gSobject);
          if (gs.bool(showSettings)) {
            return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"showAppSettings",[]);
           };
         }, 500]);
       };
     }]);
    return this;
  }
  if (arguments.length==0) {gSobject.GpsLocationTracker$CordovaBackgroundGeolocation0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaAppleSignIn() {
  var gSobject = gs.init('CordovaAppleSignIn');
  gSobject.clazz = { name: 'CordovaAppleSignIn', simpleName: 'CordovaAppleSignIn'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.AppleSignIn = function(onSuccess, onError) {
    window.cordova.plugins.SignInWithApple.signin({ 
                requestedScopes: [FullName, Email] },
                function(succ){
                    console.log(succ)
                    alert(JSON.stringify(succ))
                },  
                function(err){
                    console.error(err)  
                    console.log(JSON.stringify(err))
                    onError(err)
                }
            )
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function QRScanner() {
  var gSobject = gs.init('QRScanner');
  gSobject.clazz = { name: 'QRScanner', simpleName: 'QRScanner'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['scan'] = function(success, failure) {
    var options = gs.map().add("preferFrontCamera",false).add("showFlipCameraButton",true).add("prompt","Place a barcode inside the scan area");
    return gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"barcodeScanner"),"scan",[success, failure, options]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaCamera() {
  var gSobject = gs.init('CordovaCamera');
  gSobject.clazz = { name: 'CordovaCamera', simpleName: 'CordovaCamera'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['takePhotoAndUpload'] = function(objectName, property, objectId, onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["takePhotoAndUpload"]);
    var success = function(tempImageUrl) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["takePhotoAndUpload:success1"]);
      gs.println(tempImageUrl);
      return gs.mc(gs.fs('cordovaFile', this, gSobject),"addFile",[tempImageUrl, objectName, property, objectId, onSuccess, onError]);
     };
    return gs.mc(gSobject,"takePhoto",[success, onError]);
   }
  gSobject['takePhotoBlob'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    var success = function(imageUri) {
      return gs.mc(gs.fs('cordovaFile', this, gSobject),"blobFromFileUrl",[imageUri, function(blob) {
        gs.execCall(onSuccess, this, [blob]);
        return gs.mc(gSobject,"clearCache",[]);
       }, onError]);
     };
    return gs.mc(gSobject,"takePhoto",[success, onError]);
   }
  gSobject['takePhoto'] = function(onSuccess, onFail, config) {
    if (config === undefined) config = gs.map();
    CordovaCamera.hasCameraPermission("android.permission.CAMERA", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.CAMERA:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.ACTION_CREATE_DOCUMENT", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.ACTION_CREATE_DOCUMENT:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.ACTION_OPEN_DOCUMENT", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.ACTION_OPEN_DOCUMENT:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.READ_EXTERNAL_STORAGE", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.READ_EXTERNAL_STORAGE:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.READ_MEDIA_IMAGES", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.READ_MEDIA_IMAGES:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.READ_MEDIA_VIDEO", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.READ_MEDIA_IMAGES:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    gs.mc(gs.fs('camera', this, gSobject),"getPicture",[onSuccess, onFail, gs.mc(gs.map().add("destinationType",gs.gp(gs.gp(gs.fs('camera', this, gSobject),"DestinationType"),"FILE_URI")).add("sourceType",gs.gp(gs.gp(gs.fs('camera', this, gSobject),"PictureSourceType"),"CAMERA")).add("encodingType",gs.gp(gs.gp(gs.fs('cameraConst', this, gSobject),"EncodingType"),"JPEG")).add("correctOrientation",true).add("saveToPhotoAlbum",false).add("targetHeight",1024).add("targetWidth",1024),'leftShift', gs.list([config]))]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["takePhoto2"]);
   }
  gSobject.hasCameraPermission = function(x0,x1) { return CordovaCamera.hasCameraPermission(x0,x1); }
  gSobject.verifyCameraPlugin = function() { return CordovaCamera.verifyCameraPlugin(); }
  gSobject['clearCache'] = function(it) {
    return gs.mc(gs.fs('camera', this, gSobject),"cleanup",[]);
   }
  gSobject.getCamera = function() { return CordovaCamera.getCamera(); }
  gSobject.getCameraConst = function() { return CordovaCamera.getCameraConst(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaCamera.hasCameraPermission = function(permission, callback) {
  if (!Utils.isCordova()) return false;
        var permissions = cordova.plugins.permissions;
        if (!permissions) return false
        
        console.log('permission', permission)
        
        permissions.checkPermission(permission, function( status ){
            if ( status.hasPermission ) {
                return callback(status);
            } else {
                permissions.requestPermission(permissions.CAMERA, function( result ){
                    return callback(result)
                });
            }
        });
 }
CordovaCamera.verifyCameraPlugin = function() {
  return ( typeof navigator !== 'undefined' && typeof navigator.camera !== 'undefined' )
 }
CordovaCamera.getCamera = function() {
  return navigator.camera
 }
CordovaCamera.getCameraConst = function() {
  return Camera
 }

function VueApp() {
  var gSobject = gs.init('VueApp');
  gSobject.clazz = { name: 'VueApp', simpleName: 'VueApp'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.componentList = gs.list([]);
  gSobject.authComponentPath = null;
  gSobject.vue = null;
  gSobject.router = null;
  gSobject.scope = gs.map().add("topHeading","").add("backStack",gs.list([]));
  gSobject.data = function(it) {
    return gSobject.scope = gs.mc(gs.fs('Vue', this, gSobject),"reactive",[gSobject.scope]);
   };
  gSobject.methods = gs.map();
  gSobject.watch = gs.map();
  gSobject.compute = gs.map();
  gSobject.events = gs.map();
  gSobject.filters = gs.map();
  gSobject.mixins = gs.list([]);
  gSobject.toggleDarkMode = function(it) {
    gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Dark"),"toggle",[]);
    return gs.sp(gs.fs('session', this, gSobject),"darkMode",gs.gp(gs.gp(gs.fs('Quasar', this, gSobject),"Dark"),"isActive"));
   };
  gSobject.initialised = false;
  gSobject['init'] = function(mountElement) {
    if (mountElement === undefined) mountElement = "#vue-app";
    gs.println("VueApp.init");
    if (gs.bool(gSobject.initialised)) {
      return null;
     };
    gSobject.initialised = true;
    gs.mc(gSobject.componentList,"each",[function(component) {
      return gs.mc(gSobject,"registerVueComponent",[gs.gp(component,"vueComponentName"), component]);
     }]);
    var routes = gs.list([]);
    var childComponents = gs.set();
    gs.mc(gSobject.componentList,"each",[function(component) {
      return gs.mc(gs.gp(component,"children"),"each",[function(child) {
        return gs.mc(childComponents,"add",[gs.gp(child,"vueComponentName")]);
       }], null, true);
     }]);
    var buildRoute = null;
    buildRoute = function(component) {
      var route = gs.map().add("path",gs.gp(component,"path")).add("component",gs.mc(gSobject.componentList,"find",[function(it) {
        return gs.equals(gs.gp(it,"vueComponentName"), gs.gp(component,"vueComponentName"));
       }]));
      if (gs.bool(gs.gp(component,"children"))) {
        gs.sp(route,"children",gs.mc(gs.gp(component,"children"),"collect",[function(child) {
          return gs.execCall(buildRoute, this, [child]);
         }]));
       };
      return route;
     };
    gs.mc(gSobject.componentList,"each",[function(component) {
      if (!gs.bool(gs.mc(childComponents,"contains",[gs.gp(component,"vueComponentName")]))) {
        if (gs.instanceOf(gs.gp(component,"path"), "ArrayList")) {
          return gs.mc(gs.gp(component,"path"),"each",[function(it) {
            if (gs.bool(it)) {
              var cloned = gs.execStatic(Utils,'deepCopyMap', this,[component]);
              gs.sp(cloned,"path",it);
              return gs.mc(routes,"add",[gs.execCall(buildRoute, this, [cloned])]);
             };
           }]);
         } else {
          if (gs.bool(gs.gp(component,"path"))) {
            return gs.mc(routes,"add",[gs.execCall(buildRoute, this, [component])]);
           };
         };
       };
     }]);
    gs.println("routes");
    gs.println(routes);
    gs.mc(gSobject.filters,"each",[function(key, filterFunction) {
      return gs.mc(gSobject,"addVueFilter",[key, filterFunction]);
     }]);
    gSobject.router = gs.mc(gSobject,"newVueRouter",[routes]);
    gs.mc(gSobject.vue,"use",[gs.fs('Quasar', this, gSobject)]);
    gs.mc(gSobject.vue,"use",[gSobject.router]);
    gs.mc(gSobject,"setQuasarTheme",[]);
    gs.mc(gSobject.vue,"mount",[mountElement]);
    return this;
   }
  gSobject['registerComponent'] = function(component) {
    return gs.mc(gSobject.componentList,"add",[component]);
   }
  gSobject['registerAuthComponent'] = function(component) {
    var path = gs.gp(component,"path");
    if (gs.instanceOf(gs.gp(component,"path"), "ArrayList")) {
      path = (path[0]);
     };
    return gSobject.authComponentPath = path;
   }
  gSobject['setQuasarTheme'] = function(it) {
    gs.sp(gs.fs('session', this, gSobject),"darkMode",gs.elvis(gs.bool(gs.gp(gs.fs('session', this, gSobject),"darkMode")) , gs.gp(gs.fs('session', this, gSobject),"darkMode") , gs.gp(gs.gp(gs.fs('Quasar', this, gSobject),"Dark"),"isActive")));
    return gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Dark"),"set",[gs.gp(gs.fs('session', this, gSobject),"darkMode")]);
   }
  gSobject['registerVueComponent'] = function(name, component) {
    return gs.mc(gSobject,"registerVueComponentNative",[gSobject.vue, name, component]);
   }
  gSobject.addVueFilter = function(name, filter) {
    Vue.filter(name, filter)
   }
  gSobject.registerVueComponentNative = function(vue, name, component) {
    return vue.component(name, component)
   }
  gSobject.newVue = function(router, data, methods, watch, compute, events, mixins) {
    return Vue.createApp({
            router   : router, 
            data     : data,
            methods  : methods,
            watch    : watch,
            computed : compute,
            events   : events,
            mixins   : mixins
        });
   }
  gSobject.newVueRouter = function(routes) {
    return VueRouter.createRouter({routes:routes, history: VueRouter.createWebHashHistory()})
   }
  gSobject['VueApp0'] = function(it) {
    gSobject.vue = gs.mc(gSobject,"newVue",[gSobject.router, gs.toJsObj(gSobject.data), gs.toJsObj(gSobject.methods), gs.toJsObj(gSobject.watch), gs.toJsObj(gSobject.compute), gs.toJsObj(gSobject.events), gSobject.mixins]);
    return this;
  }
  if (arguments.length==0) {gSobject.VueApp0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function VueComponent() {
  var gSobject = gs.init('VueComponent');
  gSobject.clazz = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.vueComponentName = null;
  gSobject.path = "";
  gSobject.template = "";
  gSobject.props = gs.list([]);
  gSobject.vueMeta = gs.map();
  gSobject.route = null;
  gSobject.q = null;
  gSobject.refs = null;
  gSobject.options = gs.map();
  gSobject.emit = null;
  gSobject.scope = gs.map();
  gSobject.methods = null;
  gSobject.watch = null;
  gSobject.compute = null;
  gSobject.events = null;
  gSobject.roles = gs.list([]);
  gSobject.self = null;
  gSobject.beforeCreate = function(it) {
    gSobject.self = this;
    gSobject.route = gs.gp(gSobject.self,"$route");
    gSobject.q = gs.gp(gSobject.self,"$q");
    gSobject.options = gs.gp(gSobject.self,"$options");
    gSobject.nextTick = gs.gp(gSobject.self,"$nextTick");
    gSobject.emit = gs.gp(gSobject.self,"$emit");
    return gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"scrollTo",[0, 0]);
   };
  gSobject.nextTick = function(callback) {
    return gs.execCall(callback, this, []);
   };
  Object.defineProperty(gSobject, 'notifyParams', { get: function() { return VueComponent.notifyParams; }, set: function(gSval) { VueComponent.notifyParams = gSval; }, enumerable: true });
  gSobject.notify = function(message, type, map) {
    if (type === undefined) type = "positive";
    if (map === undefined) map = gs.map();
    gs.sp(map,"message",message);
    gs.sp(map,"type",type);
    return gs.mc(gSobject.q,"notify",[gs.mc(gs.mc(VueComponent.notifyParams,"clone",[]),'leftShift', gs.list([map]))]);
   };
  Object.defineProperty(gSobject, 'dialogParams', { get: function() { return VueComponent.dialogParams; }, set: function(gSval) { VueComponent.dialogParams = gSval; }, enumerable: true });
  gSobject.dialog = function(title, message, map) {
    if (map === undefined) map = gs.map();
    gs.sp(map,"title",title);
    gs.sp(map,"message",message);
    return gs.mc(gSobject.q,"dialog",[gs.mc(gs.mc(VueComponent.dialogParams,"clone",[]),'leftShift', gs.list([map]))]);
   };
  gSobject.data = function(it) {
    gSobject.scope = gs.map();
    return gSobject.scope = gs.mc(gs.fs('Vue', this, gSobject),"reactive",[gSobject.scope]);
   };
  gSobject.meta = function(it) {
    return gSobject.vueMeta;
   };
  Object.defineProperty(gSobject, 'METHOD_EXCLUDE_LIST', { get: function() { return VueComponent.METHOD_EXCLUDE_LIST; }, set: function(gSval) { VueComponent.METHOD_EXCLUDE_LIST = gSval; }, enumerable: true });
  gSobject['register'] = function(templateName, componentName) {
    if (templateName === undefined) templateName = "";
    if (componentName === undefined) componentName = "";
    gSobject.vueComponentName = gs.elvis(gs.bool(componentName) , componentName , gs.mc(gs.mc(this,"getClass",[], gSobject),"getSimpleName",[]));
    if (!gs.bool(gSobject.template)) {
      gSobject.template = (gs.bool(templateName) ? gs.plus("#", templateName) : gs.plus((gs.plus("#", gs.mc(gs.mc(this,"getClass",[], gSobject),"getSimpleName",[]))), "View"));
     };
    gs.println("VueComponent.register:" + (gSobject.vueComponentName) + ":" + (gSobject.template) + ":" + (gSobject.path) + "");
    var methodsMap = gs.map();
    gs.mc(gs.mc(gs.gp(this,"methods"),"findAll",[function(method) {
      var name = gs.gp(method,"name");
      return (((!gs.bool(gs.mc(name,"startsWith",["set"]))) && (!gs.bool(gs.mc(name,"startsWith",["get"])))) && (!gs.bool(gs.mc(name,"contains",["$"])))) && (!gs.bool(gs.gSin(name, VueComponent.METHOD_EXCLUDE_LIST)));
     }]),"each",[function(it) {
      return (methodsMap[gs.gp(it,"name")]) = gs.gp(gs.thisOrObject(this,gSobject),"" + (gs.gp(it,"name")) + "");
     }]);
    gSobject.methods = gs.toJsObj(methodsMap);
    var watchMap = gs.map();
    gs.mc(gs.mc(gs.gp(this,"methods"),"findAll",[function(method) {
      return gs.mc(gs.gp(method,"name"),"startsWith",["watch"]);
     }]),"each",[function(method) {
      var watchVar = gs.mc(gs.gp(method,"name"),"substring",[5]);
      watchVar = (gs.plus(gs.mc(watchVar[0],"toLowerCase",[]), gs.mc(watchVar,"substring",[1])));
      return (watchMap[watchVar]) = gs.gp(gs.thisOrObject(this,gSobject),"" + (gs.gp(method,"name")) + "");
     }]);
    gSobject.watch = gs.toJsObj(watchMap);
    var computeMap = gs.map();
    gs.mc(gs.mc(gs.gp(this,"methods"),"findAll",[function(method) {
      return gs.mc(gs.gp(method,"name"),"startsWith",["computed"]);
     }]),"each",[function(it) {
      return (computeMap[gs.gp(it,"name")]) = gs.gp(gs.thisOrObject(this,gSobject),"" + (gs.gp(it,"name")) + "");
     }]);
    gSobject.compute = gs.toJsObj(computeMap);
    var eventsMap = gs.map();
    gs.mc(gs.mc(gs.gp(this,"methods"),"findAll",[function(method) {
      return gs.mc(gs.gp(method,"name"),"startsWith",["event"]);
     }]),"each",[function(it) {
      return (eventsMap[gs.gp(it,"name")]) = gs.gp(gs.thisOrObject(this,gSobject),"" + (gs.gp(it,"name")) + "");
     }]);
    gSobject.events = gs.toJsObj(eventsMap);
    gs.mc(gs.fs('vue', this, gSobject),"registerComponent",[this]);
    return this;
   }
  gSobject['registerAsAuthComponent'] = function(it) {
    gs.mc(gs.fs('vue', this, gSobject),"registerAuthComponent",[this]);
    return this;
   }
  gSobject['getRefs'] = function(it) {
    gs.sp(this,"refs",gs.gp(gSobject.self,"$refs"));
    return gs.gp(gSobject.self,"$refs");
   }
  gSobject['beforeMount'] = function(it) {
    return gs.mc(gSobject,"enforceComponentRoles",[]);
   }
  gSobject['created'] = function(it) {
   }
  gSobject['mounted'] = function(it) {
    return gs.mc(gSobject,"nextTick",[function(it) {
      gs.mc(gSobject,"getRefs",[]);
      return gs.mc(gSobject,"afterMounted",[]);
     }]);
   }
  gSobject['afterMounted'] = function(it) {
   }
  gSobject['unmounted'] = function(it) {
    return gs.mc(gSobject,"destroyed",[]);
   }
  gSobject['destroyed'] = function(it) {
    return gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"topHeading","");
   }
  gSobject['toggleDarkMode'] = function(it) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"scope"),"toggleDarkMode",[]);
   }
  gSobject['showLoading'] = function(text, spinnerColor) {
    if (text === undefined) text = "Loading...";
    if (spinnerColor === undefined) spinnerColor = "primary";
    return gs.mc(gs.gp(gSobject.q,"loading"),"show",[gs.map().add("group",text).add("message",text).add("delay",250).add("spinnerColor",spinnerColor).add("backgroundColor","transparent")]);
   }
  gSobject['hideLoading'] = function(text) {
    if (text === undefined) text = "";
    if (!gs.bool(text)) {
      return gs.mc(gs.gp(gSobject.q,"loading"),"hide",[]);
     };
    return gs.mc(gs.gp(gSobject.q,"loading"),"hide",[gs.map().add("group",text)]);
   }
  gSobject.moment = function(date) {
    return moment(date)
   }
  gSobject['placeholder'] = function(value, placeholder) {
    return gs.elvis(gs.bool(value) , value , placeholder);
   }
  gSobject['onPaste'] = function(evt, reference) {
    var text = "";
    var elem = (gs.mc(gSobject,"getRefs",[])[reference])[0];
    if (!gs.bool(elem)) {
      elem = (gs.mc(gSobject,"getRefs",[])[reference]);
     };
    if ((gs.bool(gs.gp(elem,"originalEvent"))) && (gs.bool(gs.gp(gs.gp(gs.gp(evt,"originalEvent"),"clipboardData"),"getData")))) {
      text = gs.mc(gs.gp(gs.gp(evt,"originalEvent"),"clipboardData"),"getData",["text/plain"]);
     };
    if ((gs.bool(gs.gp(evt,"clipboardData"))) && (gs.bool(gs.gp(gs.gp(evt,"clipboardData"),"getData")))) {
      text = gs.mc(gs.gp(evt,"clipboardData"),"getData",["text/plain"]);
     };
    return gs.mc(elem,"runCmd",["insertText", text]);
   }
  gSobject['filterOptions'] = function(val, update, options, filteredOptions, object, excludeSelected) {
    if (object === undefined) object = gs.map();
    if (excludeSelected === undefined) excludeSelected = false;
    return gs.execCall(update, this, [function(it) {
      return (gSobject.scope[filteredOptions]) = gs.mc(gs.mc(gSobject.scope[options],"findAll",[function(option) {
        if ((gs.bool(excludeSelected)) && (gs.equals(gs.gp(option,"_id"), gs.gp(object,"_id")))) {
          return false;
         };
        if (!gs.bool(val)) {
          return true;
         };
        return gs.mc(gs.mc(gs.gp(option,"name"),"toLowerCase",[], null, true),"contains",[gs.mc(val,"toLowerCase",[], null, true)], null, true);
       }]),"sort",[]);
     }]);
   }
  gSobject['enforceComponentRoles'] = function(it) {
    if (gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"embedded"))) {
      gs.println("enforceComponentRoles skipped for embedded mode");
      return true;
     };
    if ((!gs.bool(gSobject.roles)) || (gs.mc(gs.fs('session', this, gSobject),"hasRole",[gSobject.roles]))) {
      return true;
     };
    if (gs.bool(gs.gp(gs.fs('vue', this, gSobject),"authComponentPath"))) {
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",[gs.gp(gs.fs('vue', this, gSobject),"authComponentPath")]);
     };
    throw {message: "" + (gSobject.vueComponentName) + " roles required: " + (gSobject.roles) + ""};
   }
  gSobject['formatCurrency'] = function(value) {
    try {
      gs.mc(value,"split",["."]);
      gs.mc(this,"parseFloat",[value], gSobject);
     }
    catch (all) {
      value = "0.00";
     }
    ;
    if (!gs.bool(gs.mc(value,"contains",["."]))) {
      value = (gs.plus("0.0", value));
     };
    var newValue = null;
    var decPartSize = gs.mc(gs.mc(value,"split",["."])[1],"size",[]);
    if (decPartSize > 2) {
      newValue = gs.mc(gs.multiply(gs.mc(this,"parseFloat",[value], gSobject), 10),"toFixed",[2]);
     } else {
      if (gs.equals(decPartSize, 1)) {
        newValue = gs.mc(gs.div(gs.mc(this,"parseFloat",[value], gSobject), 10),"toFixed",[2]);
       } else {
        newValue = gs.mc(gs.mc(this,"parseFloat",[value], gSobject),"toFixed",[2]);
       };
     };
    return newValue;
   }
  gSobject['formatNumberInput'] = function(scopeName, size, decimals, parent) {
    if (size === undefined) size = 0;
    if (decimals === undefined) decimals = 0;
    if (parent === undefined) parent = gSobject.scope;
    var oldVal = gs.mc(gs.gp(parent,"" + (scopeName) + ""),"toString",[]);
    var newVal = "";
    if ((gs.equals((oldVal[0]), ".")) || (gs.equals((oldVal[0]), ","))) {
      newVal = "0";
     };
    var index = 0;
    var dotCount = 0;
    var afterDotCount = 0;
    gs.mc(oldVal,"each",[function(character) {
      index++;
      if (gs.equals(decimals, 0)) {
        if ((gs.mc(character,"isNumber",[])) && ((gs.equals(size, 0)) || (index <= size))) {
          newVal += character;
         };
        return null;
       };
      if (gs.equals(character, ",")) {
        character = ".";
       };
      if (gs.equals(character, ".")) {
        dotCount++;
       };
      if (dotCount > 1) {
        return null;
       };
      if (gs.equals(dotCount, 1)) {
        afterDotCount++;
        if (afterDotCount > (gs.plus(decimals, 1))) {
          return null;
         };
       };
      if (((gs.mc(character,"isNumber",[])) || (gs.equals(character, "."))) && ((gs.equals(size, 0)) || (index <= size))) {
        return newVal += character;
       };
     }]);
    return gs.mc(gSobject,"nextTick",[function(it) {
      return gs.sp(parent,"" + (scopeName) + "",newVal);
     }]);
   }
  gSobject['formatNumberInputOnBlur'] = function(scopeName, size, decimals, parent) {
    if (size === undefined) size = 0;
    if (decimals === undefined) decimals = 0;
    if (parent === undefined) parent = gSobject.scope;
    gs.mc(gSobject,"formatNumberInput",[scopeName, size, decimals, parent]);
    return gs.mc(gSobject,"nextTick",[function(it) {
      return gs.sp(parent,"" + (scopeName) + "",gs.mc(this,"Number",[gs.mc(gs.gp(parent,"" + (scopeName) + ""),"toString",[])], gSobject));
     }]);
   }
  gSobject['formatCurrencyInput'] = function(scopeName, parent) {
    if (parent === undefined) parent = gSobject.scope;
    return gs.mc(gSobject,"formatNumberInput",[scopeName, 15, 2, parent]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
VueComponent.notifyParams = gs.map().add("type","positive").add("position","bottom").add("avatar","").add("timeout",3000).add("actions",null).add("spinner",false).add("multiLine",false).add("progress",false);
VueComponent.dialogParams = gs.map().add("ok",gs.map().add("push",true).add("color","primary")).add("cancel",gs.map().add("push",true).add("color","negative")).add("persistent",true);
VueComponent.METHOD_EXCLUDE_LIST = gs.list(["equals" , "hashCode" , "notify" , "notifyAll" , "toString" , "wait" , "register" , "invokeMethod" , "data" , "beforeCreate" , "created" , "mounted" , "destroyed"]);

function LegionLoginComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'LegionLoginComponent', simpleName: 'LegionLoginComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/login";
  gSobject.appleAuth = gs.map();
  gSobject['created'] = function(it) {
    gs.println("LegionLoginComponent.created()");
    gs.sp(gSobject.scope,"showFooter",false);
    gs.sp(gSobject.scope,"showApple",gs.execStatic(Utils,'isIos', this,[]));
    gs.sp(gSobject.scope,"showAndroid",gs.execStatic(Utils,'isAndroid', this,[]));
    gs.sp(gSobject.scope,"email","");
    return gs.sp(gSobject.scope,"phoneNumber","");
   }
  gSobject['login'] = function(it) {
    gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username",gs.elvis(gs.bool(gs.gp(gSobject.scope,"email")) , gs.gp(gSobject.scope,"email") , gs.gp(gSobject.scope,"phoneNumber")));
    if (!gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"))) {
      gs.mc(gSobject,"notify",["Please enter details", "negative"]);
      return null;
     };
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"generatePinForExistingUser",[gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"), (gs.bool(gs.gp(gSobject.scope,"phoneNumber")) ? true : false)]),"then",[function(it) {
      gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/legionPin"]);
      return gs.mc(gSobject,"notify",["Pin Sent"]);
     }, function(error) {
      return gs.mc(gSobject,"notify",[gs.gp(error,"message"), "negative"]);
     }]);
   }
  gSobject['googleSignIn'] = function(it) {
    if (!gs.bool(gs.execStatic(Utils,'isCordova', this,[]))) {
      return gs.mc(gSobject,"notify",["Could not complete sign in", "negative"]);
     };
    return gs.mc(gs.fs('cordovaGoogleSignIn', this, gSobject),"googleSignIn",[function(success) {
      gs.println("cordovaGoogleSignIn");
      gs.println(success);
      var object = gs.mc(gSobject,"toObject",[success]);
      gs.println(object);
      return gs.mc(gSobject,"signInWith",[gs.gp(gs.gp(object,"message"),"email"), gs.gp(gs.gp(object,"message"),"id"), function(it) {
        return gs.mc(gs.fs('legionUserService', this, gSobject),"loadLegionUser",[function(user) {
          return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/"]);
         }]);
       }, function(error) {
        gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/login"]);
        return gs.mc(gSobject,"errorNotification",[error]);
       }]);
     }, function(error) {
      gs.println(error);
      return gs.mc(gSobject,"notify",["Error Signing in with Google", "negative"]);
     }]);
   }
  gSobject['signInWithApple'] = function(it) {
    if (!gs.bool(gs.execStatic(Utils,'isCordova', this,[]))) {
      return gs.mc(gSobject,"notify",["Could not complete sign in", "negative"]);
     };
    return LegionLoginComponent.signInWithAppleAuth(function(result) {
      gs.println("signInWithAppleAuth result:");
      gs.println(result);
      var jwt = gs.execStatic(Utils,'decodeJWT', this,[gs.gp(result,"identityToken")]);
      var email = gs.gp(jwt,"email");
      var password = gs.gp(jwt,"sub");
      gSobject.appleAuth = result;
      return gs.mc(gSobject,"signInWith",[email, password, function(it) {
        return gs.mc(gs.fs('legionUserService', this, gSobject),"loadLegionUser",[function(user) {
          gs.mc(gSobject,"saveAppleCustomer",[gs.gp(user,"_id")]);
          return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/"]);
         }]);
       }, function(error) {
        gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/login"]);
        return gs.mc(gSobject,"errorNotification",[error]);
       }]);
     });
   }
  gSobject.signInWithAppleAuth = function(x0) { return LegionLoginComponent.signInWithAppleAuth(x0); }
  gSobject['saveAppleCustomer'] = function(userId) {
    var user = gs.map();
    if (gs.bool(gs.gp(gs.gp(gSobject.appleAuth,"fullName"),"familyName"))) {
      gs.sp(user,"surname",gs.gp(gs.gp(gSobject.appleAuth,"fullName"),"familyName"));
     };
    if (gs.bool(gs.gp(gs.gp(gSobject.appleAuth,"fullName"),"givenName"))) {
      gs.sp(user,"name",gs.gp(gs.gp(gSobject.appleAuth,"fullName"),"givenName"));
     };
    return gs.mc(gs.fs('legionUserService', this, gSobject),"updateUserDetails",[userId, gs.gp(user,"name"), gs.gp(user,"surname")]);
   }
  gSobject['signInWith'] = function(email, password, successCallback, failCallback) {
    return gs.mc(gs.fs('legionUserService', this, gSobject),"auth",[email, password, function(authenticated) {
      if (gs.bool(authenticated)) {
        return gs.execCall(successCallback, this, [authenticated]);
       };
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"repairUser",[email, password, function(result) {
        if (!gs.bool(gs.gp(result,"success"))) {
          gs.execCall(failCallback, this, ["Registration Failed"]);
         };
        return gs.mc(gs.fs('legionUserService', this, gSobject),"auth",[email, password, function(isAuthenticated) {
          if (gs.bool(isAuthenticated)) {
            return gs.execCall(successCallback, this, [isAuthenticated]);
           };
          return gs.execCall(failCallback, this, ["Login Failed"]);
         }]);
       }]);
     }]);
   }
  gSobject['errorNotification'] = function(notification) {
    return gs.mc(this,"alert",[notification], gSobject);
   }
  gSobject['differentLogin'] = function(it) {
    return gs.mc(gSobject,"notify",["WIP"]);
   }
  gSobject.toObject = function(data) {
    return JSON.parse(data)
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
LegionLoginComponent.signInWithAppleAuth = function(callback) {
  var value
        window.cordova.plugins.SignInWithApple.signin(
            { requestedScopes: [0,1] },
            function(succ){
                value = succ
                console.log("signInWithAppleAuth----------------------------------")
                console.log(JSON.stringify(value))
                callback(value)
            },
            function(err){
                if(err.code == "1001" || err.code == "1003"){
                    alert('Authentication failed: User cancelled sign in.');
                }else if(err.code == "1002"){
                    alert('Error: Sign in response received an invalid response');
                }else{
                    alert('Error: Authentication failed');
                }
            }
        )
 }

function LegionUserService() {
  var gSobject = gs.init('LegionUserService');
  gSobject.clazz = { name: 'LegionUserService', simpleName: 'LegionUserService'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.legionUser = null;
  gSobject.country = null;
  gSobject['lookupCountry'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionLocaleService"),"fetchCountry",[function(countryIn) {
      return gSobject.country = countryIn;
     }]);
   }
  gSobject['auth'] = function(username, password, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"authenticate",[username, password, function(authData) {
      gs.println("LegionUserService.auth1");
      gs.println(authData);
      if (!gs.bool(authData)) {
        return gs.execCall(callback, this, [false]);
       };
      if (gs.bool(gs.gp(authData,"authenticated"))) {
        gs.execStatic(Utils,'updateAuthTokenToSession', this,[authData]);
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("User authdata:", authData)]);
        gs.mc(gSobject,"updateSession",[authData]);
        gs.mc(gSobject,"loadLegionUser",[function(it) {
          return gs.execCall(callback, this, [gs.gp(authData,"authenticated")]);
         }]);
        return null;
       };
      return gs.execCall(callback, this, [gs.gp(authData,"authenticated")]);
     }]);
   }
  gSobject['updateSession'] = function(authData) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("User authdata:", authData)]);
    gs.sp(gs.fs('session', this, gSobject),"legionUser",gs.gp(authData,"legionUser"));
    gs.sp(gs.fs('session', this, gSobject),"user",gs.gp(authData,"legionUser"));
    gs.sp(gs.fs('session', this, gSobject),"legionUserId",gs.gp(gs.gp(authData,"legionUser"),"_id",true));
    gs.sp(gs.fs('session', this, gSobject),"userId",gs.gp(gs.gp(authData,"legionUser"),"_id",true));
    if (gs.bool(gs.gp(authData,"zoner"))) {
      gs.sp(gs.fs('session', this, gSobject),"zoner",gs.gp(authData,"zoner"));
      gs.sp(gs.fs('session', this, gSobject),"zonerId",gs.gp(gs.gp(authData,"zoner"),"id"));
      return gs.sp(gs.fs('session', this, gSobject),"authToken",gs.gp(gs.gp(authData,"zoner"),"token"));
     };
   }
  gSobject['authWithPin'] = function(username, pin, callback, failCallback) {
    if (callback === undefined) callback = function(it) {
     };
    if (failCallback === undefined) failCallback = function(it) {
     };
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"authenticateWithPin",[username, pin]),"then",[function(authData) {
      if (!gs.bool(authData)) {
        return gs.execCall(callback, this, [false]);
       };
      if (gs.bool(gs.gp(authData,"authenticated"))) {
        gs.execStatic(Utils,'updateAuthTokenToSession', this,[authData]);
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("User authdata:", authData)]);
        gs.mc(gSobject,"updateSession",[authData]);
        gs.mc(gSobject,"loadLegionUser",[function(it) {
          return gs.execCall(callback, this, [gs.gp(authData,"authenticated")]);
         }]);
        return null;
       };
      return gs.mc(this,"success",[gs.gp(authData,"authenticated")], gSobject);
     }, function(error) {
      return gs.execCall(failCallback, this, [error]);
     }]);
   }
  gSobject['loadLegionUserFromServer'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gs.gp(gs.fs('transmission', this, gSobject),"onAuthReady"),"callback",[function(it) {
      if (gs.bool(gs.gp(gs.fs('session', this, gSobject),"legionUserId"))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"loadLegionUser",[gs.gp(gs.fs('session', this, gSobject),"legionUserId"), function(legionUser) {
          gs.mc(gSobject,"updateSession",[gs.map().add("legionUser",legionUser)]);
          return gs.execCall(callback, this, [gs.gp(gs.fs('session', this, gSobject),"legionUser")]);
         }]);
        return null;
       };
      if (gs.bool(gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id",true))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"loadLegionUserFromZonerId",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), function(legionUser) {
          gs.println("legionUser2");
          gs.println(legionUser);
          gs.mc(gSobject,"updateSession",[gs.map().add("legionUser",legionUser)]);
          return gs.execCall(callback, this, [gs.gp(gs.fs('session', this, gSobject),"legionUser")]);
         }]);
       };
      return gs.execCall(callback, this, []);
     }]);
   }
  gSobject['loadLegionUser'] = function(callback, failCallback, resetCache) {
    if (callback === undefined) callback = function(it) {
     };
    if (failCallback === undefined) failCallback = function(it) {
     };
    if (resetCache === undefined) resetCache = false;
    if ((gs.bool(gSobject.legionUser)) && (!gs.bool(resetCache))) {
      return gs.execCall(callback, this, [gSobject.legionUser]);
     };
    if (gs.bool(gs.gp(gs.fs('session', this, gSobject),"authToken"))) {
      gs.mc(gs.gp(gs.fs('transmission', this, gSobject),"onAuthReady"),"callback",[function(it) {
        if (!gs.bool(gs.gp(gs.fs('session', this, gSobject),"legionUser"))) {
          throw {message: "Auth is authenticated, but legionUser not found"};
         };
        gSobject.legionUser = gs.gp(gs.fs('session', this, gSobject),"legionUser");
        gs.execStatic(Utils,'subscribe', this,[gs.gp(gSobject.legionUser,"_id"), function(updatedlegionUser) {
          return gSobject.legionUser = updatedlegionUser;
         }]);
        return gs.execCall(callback, this, [gSobject.legionUser]);
       }]);
      return null;
     };
    return gs.execCall(failCallback, this, []);
   }
  gSobject['registerPushDevice'] = function(data) {
    return gs.mc(gSobject,"loadLegionUser",[function(user) {
      gs.println(">>>>>>>>>>> Register Push Device");
      gs.println(gs.plus((gs.plus((gs.plus((gs.plus((gs.plus("Data: ", gs.gp(user,"_id"))), " ")), gs.gp(data,"registrationId"))), " ")), gs.execStatic(Utils,'deviceType', this,[])));
      gs.println(data);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionPushService"),"registerDevice",[gs.gp(user,"_id"), gs.gp(data,"registrationId"), gs.execStatic(Utils,'deviceType', this,[]), function(it) {
        return gs.println(">>>>>>>>>>> Register Push Device - SUCCESS");
       }]);
     }]);
   }
  gSobject['getSetting'] = function(key, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"loadLegionUser",[function(user) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionService"),"getUserSetting",[gs.gp(user,"_id"), key, function(result) {
        return gs.execCall(callback, this, [result]);
       }]);
     }]);
   }
  gSobject['setSetting'] = function(key, value, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"loadLegionUser",[function(user) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionService"),"getUserSetting",[gs.gp(user,"_id"), key, value, function(result) {
        return gs.execCall(callback, this, [result]);
       }]);
     }]);
   }
  gSobject['updateUserDetails'] = function(userId, name, surname) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"loadLegionUser",[userId, function(user) {
      gs.sp(user,"name",name);
      gs.sp(user,"surname",surname);
      return gs.mc(user,"save",[]);
     }]);
   }
  gSobject['LegionUserService0'] = function(it) {
    gs.mc(gSobject,"loadLegionUserFromServer",[]);
    gs.mc(gSobject,"lookupCountry",[]);
    return this;
  }
  if (arguments.length==0) {gSobject.LegionUserService0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaDevice() {
  var gSobject = gs.init('CordovaDevice');
  gSobject.clazz = { name: 'CordovaDevice', simpleName: 'CordovaDevice'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.network = gs.map().add("type","NONE").add("status","online");
  gSobject.battery = gs.map().add("level",50).add("isPlugged",false).add("state","normal").add("date",gs.date());
  gSobject.device = gs.map().add("network",gSobject.network).add("battery",gSobject.battery).add("orientation","portrait").add("keyboard","hide");
  gSobject.onKeyboardListeners = gs.list([]);
  gSobject.appEventListeners = gs.list([]);
  gSobject.onBackKeyDown = function(it) {
   };
  gSobject.userId = null;
  gSobject['splashScreenHide'] = function(it) {
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      try {
        gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"splashscreen"),"hide",[], null, true);
        if (CordovaDevice.cordovaPluginStatusBarInstalled()) {
          gs.mc(gs.fs('StatusBar', this, gSobject),"overlaysWebView",[false]);
          gs.mc(gs.fs('StatusBar', this, gSobject),"backgroundColorByName",["black"]);
         };
        try {
          var p = gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["portrait"]);
          if ((gs.bool(p)) && (gs.bool(gs.gp(p,"catch")))) {
            gs.mc(p,"catch",[gs.mc(this,"function",[function(it) {
             }], gSobject)]);
           };
         }
        catch (e) {
         }
        ;
       }
      catch (all) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["splashScreenHide:" + (gs.fs('all', this, gSobject)) + ""]);
       }
      ;
     };
   }
  gSobject['disableBackButton'] = function(it) {
    return gs.mc(gs.fs('document', this, gSobject),"addEventListener",["backbutton", gSobject.onBackKeyDown, false]);
   }
  gSobject['setupCordovaAppEvents'] = function(it) {
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["pause", function(it) {
      return gs.mc(gSobject,"emitEvent",["app.pause"]);
     }, false]);
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["resume", function(it) {
      return gs.mc(gSobject,"emitEvent",["app.resume"]);
     }, false]);
    return gs.mc(gs.fs('document', this, gSobject),"addEventListener",["menubutton", function(it) {
      return gs.mc(gSobject,"emitEvent",["app.menubutton"]);
     }, false]);
   }
  gSobject['preventScreenshots'] = function(it) {
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gs.fs('OurCodeWorldpreventscreenshots', this, gSobject),"enable",[]);
     }, 1]);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"preventscreenshot"),"enable",[function(it) {
       }, function(it) {
       }]);
     }, 1]);
   }
  gSobject['allowScreenshots'] = function(it) {
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gs.fs('OurCodeWorldpreventscreenshots', this, gSobject),"disable",[]);
     }, 1]);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"preventscreenshot"),"disable",[function(it) {
       }, function(it) {
       }]);
     }, 1]);
   }
  gSobject['setupCordovaPluginKeyboard'] = function(it) {
    var initialViewportHeight = gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"height");
    var initialViewportWidth = gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"width");
    return gs.mc(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"addEventListener",["resize", function(it) {
      if (initialViewportWidth != gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"width")) {
        gs.execStatic(Utils,'setTimeout', this,[function(it) {
          initialViewportHeight = gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"height");
          initialViewportWidth = gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"width");
          gs.mc(gSobject,"emitEvent",["orientation." + (gs.mc(gSobject,"getOrientation",[])) + ""]);
          gs.sp(gSobject.device,"orientation",gs.mc(gSobject,"getOrientation",[]));
          return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["setupCordovaPluginKeyboard:orientation." + (gs.mc(gSobject,"getOrientation",[])) + ""]);
         }, 100]);
        return null;
       };
      if (gs.equals(gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"height"), initialViewportHeight)) {
        gs.sp(gSobject.device,"keyboard","hide");
        gs.mc(gSobject,"emitEvent",["keyboard.hide"]);
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["setupCordovaPluginKeyboard:keyboard.hide"]);
       } else {
        gs.sp(gSobject.device,"keyboard","show");
        gs.mc(gSobject,"emitEvent",["keyboard.show"]);
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["setupCordovaPluginKeyboard:keyboard.show"]);
       };
     }]);
   }
  gSobject['getOrientation'] = function(it) {
    return gs.gp(gs.fs('screen', this, gSobject)["orientation"],"type");
   }
  gSobject['setupCordovaPluginDevice'] = function(it) {
    gs.mc(gSobject.device,"putAll",[gs.gp(gs.fs('window', this, gSobject),"device")]);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userDevice",[gSobject.userId, gSobject.device]),"do",[]);
   }
  gSobject['setupCordovaPluginBatteryStatus'] = function(it) {
    var batteryUpdate = function(status, state) {
      if (gs.bool(gs.gp(state,"level"))) {
        gSobject.battery = gs.map().add("level",gs.gp(state,"level")).add("isPlugged",gs.gp(state,"isPlugged")).add("isTrusted",gs.gp(state,"isTrusted")).add("status",status).add("date",gs.date());
        gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userDeviceBattery",[gSobject.userId, gs.gp(gSobject.device,"uuid"), gSobject.battery]),"do",[]);
       };
      gs.sp(gSobject.network,"bettery",status);
      return gs.mc(gSobject,"emitEvent",["bettery." + (status) + ""]);
     };
    gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterystatus", function(state) {
      return gs.execCall(batteryUpdate, this, ["normal", state]);
     }, false]);
    gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterylow", function(state) {
      return gs.execCall(batteryUpdate, this, ["low", state]);
     }, false]);
    return gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterycritical", function(state) {
      return gs.execCall(batteryUpdate, this, ["critical", state]);
     }, false]);
   }
  gSobject['setupCordovaPluginNetworkInformation'] = function(it) {
    var networkUpdate = function(status) {
      gs.sp(gSobject.network,"status",status);
      gs.sp(gSobject.network,"type",gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"connection"),"type"));
      gs.sp(gSobject.network,"date",gs.date());
      gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userNetwork",[gSobject.userId, gs.gp(gSobject.device,"uuid"), gSobject.network]),"do",[]);
      return gs.mc(gSobject,"emitEvent",["network." + (status) + ""]);
     };
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["offline", function(it) {
      return gs.execCall(networkUpdate, this, ["offline"]);
     }, false]);
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["online", function(it) {
      return gs.execCall(networkUpdate, this, ["online"]);
     }, false]);
    return gs.execCall(networkUpdate, this, ["online"]);
   }
  gSobject['addAppEventListeners'] = function(callback) {
    return gs.mc(gSobject.appEventListeners,"add",[callback]);
   }
  gSobject['emitEvent'] = function(event) {
    return gs.mc(gSobject.appEventListeners,"each",[function(listner) {
      return gs.execStatic(Utils,'setTimeout', this,[function(it) {
        return gs.execCall(listner, this, [event]);
       }, 0]);
     }]);
   }
  gSobject['vibrate'] = function(timeMs) {
    return gs.mc(gs.fs('navigator', this, gSobject),"vibrate",[timeMs]);
   }
  gSobject.spinnerInstalled = function() { return CordovaDevice.spinnerInstalled(); }
  gSobject['statusBarShow'] = function(it) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"show",[]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarShow error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarHide'] = function(it) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"hide",[]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarHide error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarColor'] = function(hex) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"backgroundColorByHexString",[hex]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarColor error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarStyleLight'] = function(it) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"styleLightContent",[]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarStyleLight error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarStyleDark'] = function(it) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"styleDefault",[]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarStyleDark error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarOverlay'] = function(overlay) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"overlaysWebView",[overlay]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarOverlay error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['lockPortrait'] = function(it) {
    return gs.mc(gSobject,"doLockOrientation",["portrait"]);
   }
  gSobject['lockLandscape'] = function(it) {
    return gs.mc(gSobject,"doLockOrientation",["landscape"]);
   }
  gSobject['unlockOrientation'] = function(it) {
    try {
      gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"unlock",[], null, true);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["unlockOrientation: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject.doLockOrientation = function(orientation) {
    try {
            var result = screen.orientation.lock(orientation);
            // iOS 16+ returns a Promise — handle rejection silently
            if (result && result.then) {
                result.catch(function(e) { console.log('orientation lock rejected:', e); });
            }
            return 'ok';
        } catch (e) {
            console.log('orientation lock error:', e);
            return 'Not supported: ' + (e.message || e);
        }
   }
  gSobject['hasPermission'] = function(name, callback) {
    if (!gs.bool(CordovaDevice.permissionsInstalled())) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",true)]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"checkPermission",[name, callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",e)]);
       }]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",gs.fs('e', this, gSobject))]);
     }
    ;
   }
  gSobject['requestPermission'] = function(name, callback) {
    if (!gs.bool(CordovaDevice.permissionsInstalled())) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",true)]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"requestPermission",[name, callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",e)]);
       }]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",gs.fs('e', this, gSobject))]);
     }
    ;
   }
  gSobject['hasPermissions'] = function(names, callback) {
    if (!gs.bool(CordovaDevice.permissionsInstalled())) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",true)]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"checkPermission",[names, callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",e)]);
       }]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",gs.fs('e', this, gSobject))]);
     }
    ;
   }
  gSobject.permissionsInstalled = function() { return CordovaDevice.permissionsInstalled(); }
  gSobject.cordovaPluginStatusBarInstalled = function() { return CordovaDevice.cordovaPluginStatusBarInstalled(); }
  gSobject.cordovaPluginDeviceInstalled = function() { return CordovaDevice.cordovaPluginDeviceInstalled(); }
  gSobject.crdovaPluginNetworkInformationInstalled = function() { return CordovaDevice.crdovaPluginNetworkInformationInstalled(); }
  gSobject['showSpinner'] = function(message, cancelable) {
    if (message === undefined) message = "";
    if (cancelable === undefined) cancelable = false;
    return gs.mc(gSobject,"nativeSpinnerShow",[gs.map().add("message",message).add("cancelable",cancelable), function(it) {
     }, function(it) {
     }]);
   }
  gSobject['hideSpinner'] = function(it) {
    return gs.mc(gSobject,"nativeSpinnerHide",[function(it) {
     }, function(it) {
     }]);
   }
  gSobject.nativeSpinnerShow = function(options, success, error) {
    if (typeof window.i3Spinner !== 'undefined') {
            window.i3Spinner.show(options, success, error);
        } else if (typeof SpinnerDialog !== 'undefined') {
            SpinnerDialog.show(null, options.message || '', options.cancelable || false);
            if (success) success();
        } else { if (error) error('Spinner not available'); }
   }
  gSobject.nativeSpinnerHide = function(success, error) {
    if (typeof window.i3Spinner !== 'undefined') {
            window.i3Spinner.hide(success, error);
        } else if (typeof SpinnerDialog !== 'undefined') {
            SpinnerDialog.hide();
            if (success) success();
        } else { if (error) error('Spinner not available'); }
   }
  gSobject['preventCapture'] = function(enabled, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativePreventCapture",[enabled, success, error]);
   }
  gSobject['onScreenshot'] = function(callback) {
    return gs.mc(gSobject,"nativeOnScreenshot",[callback]);
   }
  gSobject['onScreenRecording'] = function(callback) {
    return gs.mc(gSobject,"nativeOnScreenRecording",[callback]);
   }
  gSobject.nativePreventCapture = function(enabled, success, error) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.i3Screenshot) {
            cordova.plugins.i3Screenshot.preventCapture(enabled, success, error);
        } else { if (error) error('i3Screenshot not available'); }
   }
  gSobject.nativeOnScreenshot = function(callback) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.i3Screenshot) {
            cordova.plugins.i3Screenshot.onScreenshot(callback);
        }
   }
  gSobject.nativeOnScreenRecording = function(callback) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.i3Screenshot) {
            cordova.plugins.i3Screenshot.onScreenRecording(callback);
        }
   }
  gSobject['getAppInfo'] = function(callback, error) {
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeGetAppInfo",[callback, error]);
   }
  gSobject['setBadge'] = function(count, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeSetBadge",[count, success, error]);
   }
  gSobject['clearBadge'] = function(success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeSetBadge",[0, success, error]);
   }
  gSobject.nativeGetAppInfo = function(success, error) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.i3App) {
            cordova.plugins.i3App.getInfo(success, error);
        } else { if (error) error('i3App not available'); }
   }
  gSobject.nativeSetBadge = function(count, success, error) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.i3App) {
            cordova.plugins.i3App.setBadge(count, success, error);
        } else { if (error) error('i3App not available'); }
   }
  gSobject['print'] = function(content, options, callback) {
    if (options === undefined) options = gs.map();
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"nativePrint",[content, options, callback]);
   }
  gSobject.nativePrint = function(content, options, callback) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.printer) {
            cordova.plugins.printer.print(content, options, callback);
        } else { if (callback) callback(false); }
   }
  gSobject['installErrorCapture'] = function(it) {
    gs.mc(gSobject,"nativeInstallErrorCapture",[]);
    gs.mc(gSobject,"nativeInstallConsoleTail",[]);
    return gs.mc(gSobject,"nativeInstallRouteHistory",[]);
   }
  gSobject['enableErrorFlush'] = function(it) {
    gs.mc(gSobject,"nativePrimeErrorContext",[gs.map().add("userId",gs.elvis(gs.bool(gSobject.userId) , gSobject.userId , "")).add("uuid",gs.elvis(gs.bool(gs.gp(gSobject.device,"uuid")) , gs.gp(gSobject.device,"uuid") , "")).add("platform",gs.elvis(gs.bool(gs.gp(gSobject.device,"platform")) , gs.gp(gSobject.device,"platform") , "browser")).add("appVersion",gs.elvis(gs.bool(gs.gp(gSobject.device,"version")) , gs.gp(gSobject.device,"version") , "")).add("appBuild",gs.elvis(gs.bool(gs.gp(gSobject.device,"cordova")) , gs.gp(gSobject.device,"cordova") , ""))]);
    return gs.mc(gSobject,"nativeFlushErrors",[]);
   }
  gSobject.nativeInstallErrorCapture = function() {
    if (window._cwErr) return; // idempotent

        var BUF_KEY = 'cw.errBuf';
        var BUF_CAP = 50;
        var DEDUP_MS = 60000;

        var dedup = {};
        var ctx = { userId: '', uuid: '', platform: 'browser', appVersion: '', appBuild: '' };
        var flushing = false;
        var buf;

        function readBuf() {
            try { var s = window.localStorage.getItem(BUF_KEY); return s ? JSON.parse(s) : []; }
            catch(e) { return []; }
        }
        function writeBuf(arr) {
            try {
                if (arr.length > BUF_CAP) arr = arr.slice(arr.length - BUF_CAP);
                window.localStorage.setItem(BUF_KEY, JSON.stringify(arr));
            } catch(e) {}
        }
        buf = readBuf();

        function fingerprint(type, msg, stack) {
            var first = (stack || '').split('\n')[0] || '';
            var s = (type || '') + ':' + (msg || '').substring(0, 80) + ':' + first.substring(0, 120);
            var h = 0;
            for (var i = 0; i < s.length; i++) { h = ((h << 5) - h) + s.charCodeAt(i); h |= 0; }
            return ('00000000' + (h >>> 0).toString(16)).slice(-8);
        }

        function capture(rec) {
            try {
                if (!rec.fingerprint) rec.fingerprint = fingerprint(rec.type, rec.message, rec.stack);
                if (!rec.clientReportedAt) rec.clientReportedAt = Date.now();
                if (!rec.userAgent && typeof navigator !== 'undefined') rec.userAgent = navigator.userAgent || '';
                rec.count = rec.count || 1;

                var now = Date.now();
                var d = dedup[rec.fingerprint];
                if (d && (now - d.lastTs) < DEDUP_MS && buf[d.idx] && buf[d.idx].fingerprint === rec.fingerprint) {
                    buf[d.idx].count = (buf[d.idx].count || 1) + 1;
                    d.lastTs = now;
                    writeBuf(buf);
                    return;
                }

                buf.push(rec);
                if (buf.length > BUF_CAP) {
                    buf = buf.slice(buf.length - BUF_CAP);
                    dedup = {};
                }
                dedup[rec.fingerprint] = { idx: buf.length - 1, lastTs: now };
                writeBuf(buf);

                if (typeof navigator !== 'undefined' && navigator.onLine !== false) flush();
            } catch(e) { try { console.log('[cwErr] capture failed:', e); } catch(_) {} }
        }

        function buildUrl() {
            try {
                var p = window.location.pathname.split('/').filter(function(s){ return s; });
                if (p.length >= 2) return '/' + p[0] + '/' + p[1] + '/cordova/errors';
            } catch(e) {}
            return '/cordova/errors';
        }

        function flush() {
            if (flushing || buf.length === 0) return;
            if (typeof navigator !== 'undefined' && navigator.onLine === false) return;

            flushing = true;
            var sent = buf.length;
            var batch = buf.slice();

            for (var i = 0; i < batch.length; i++) {
                if (!batch[i].user && ctx.userId) batch[i].user = ctx.userId;
                if (!batch[i].uuid && ctx.uuid) batch[i].uuid = ctx.uuid;
                if (!batch[i].platform && ctx.platform) batch[i].platform = ctx.platform;
                if (!batch[i].appVersion && ctx.appVersion) batch[i].appVersion = ctx.appVersion;
                if (!batch[i].appBuild && ctx.appBuild) batch[i].appBuild = ctx.appBuild;
            }

            var done = function(ok) {
                flushing = false;
                if (ok) {
                    buf = buf.slice(sent);
                    dedup = {};
                    writeBuf(buf);
                }
            };

            try {
                var xhr = new XMLHttpRequest();
                xhr.open('POST', buildUrl(), true);
                xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
                xhr.timeout = 5000;
                xhr.onload = function() { done(xhr.status >= 200 && xhr.status < 300); };
                xhr.onerror = function() { done(false); };
                xhr.ontimeout = function() { done(false); };
                xhr.send('json=' + encodeURIComponent(JSON.stringify(batch)));
            } catch(e) { done(false); }
        }

        window.onerror = function(message, source, line, col, error) {
            capture({
                type: 'js_error',
                message: message ? String(message) : '',
                stack: error && error.stack ? String(error.stack) : '',
                source: source || '',
                line: line || 0,
                col: col || 0
            });
        };

        window.addEventListener('unhandledrejection', function(event) {
            var reason = event.reason || {};
            var msg;
            if (reason && reason.message) { msg = String(reason.message); }
            else { try { msg = String(reason); } catch(e) { msg = ''; } }
            capture({
                type: 'unhandled_rejection',
                message: msg,
                stack: reason && reason.stack ? String(reason.stack) : '',
                source: '',
                line: 0,
                col: 0
            });
        });

        function installExecInterceptor() {
            if (!(window.cordova && window.cordova.exec) || window.cordova.exec.__cwWrapped) return false;
            var orig = window.cordova.exec;
            var wrapped = function(success, fail, service, action, args) {
                var wrappedFail = function(err) {
                    try {
                        var emsg;
                        if (typeof err === 'string') emsg = err;
                        else if (err && err.message) emsg = String(err.message);
                        else { try { emsg = JSON.stringify(err); } catch(e) { emsg = String(err); } }
                        capture({
                            type: 'plugin_error',
                            message: emsg,
                            stack: '',
                            source: service + '.' + action,
                            line: 0,
                            col: 0
                        });
                    } catch(_) {}
                    if (fail) fail(err);
                };
                return orig(success, wrappedFail, service, action, args);
            };
            wrapped.__cwWrapped = true;
            window.cordova.exec = wrapped;
            return true;
        }
        if (!installExecInterceptor()) {
            var tries = 0;
            var iv = setInterval(function() {
                tries++;
                if (installExecInterceptor() || tries > 50) clearInterval(iv);
            }, 100);
        }

        window.addEventListener('online', flush);
        document.addEventListener('resume', flush, false);
        document.addEventListener('deviceready', flush, false);

        window._cwErr = {
            capture: capture,
            flush: flush,
            setContext: function(c) { for (var k in c) ctx[k] = c[k]; },
            _ctx: ctx,
            _buf: function() { return buf.slice(); }
        };

        try { console.log('[CordovaDevice] error capture installed (offline-aware)'); } catch(_) {}
   }
  gSobject.nativePrimeErrorContext = function(ctx) {
    if (window._cwErr) window._cwErr.setContext(ctx);
   }
  gSobject.nativeFlushErrors = function() {
    if (window._cwErr) window._cwErr.flush();
   }
  gSobject['reportProblem'] = function(userMessage, opts, success, error) {
    if (opts === undefined) opts = gs.map();
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    if (!gs.bool(gs.mc(userMessage,"trim",[], null, true))) {
      return gs.execCall(error, this, ["userMessage is required"]);
     };
    return gs.mc(gs.fs('cordovaScreenCapture', this, gSobject),"reportProblem",[userMessage, opts, success, error]);
   }
  gSobject.nativeInstallConsoleTail = function() {
    if (window._cwConsoleTailInstalled) return;
        window._cwConsoleTailInstalled = true;
        window._cwConsoleTail = window._cwConsoleTail || [];
        var CAP = 50;
        var levels = ['log', 'info', 'warn', 'error'];
        for (var i = 0; i < levels.length; i++) {
            (function(level) {
                var orig = console[level];
                console[level] = function() {
                    try {
                        var parts = [];
                        for (var j = 0; j < arguments.length; j++) {
                            var a = arguments[j];
                            if (a == null) { parts.push(String(a)); continue; }
                            if (typeof a === 'string') { parts.push(a); continue; }
                            try { parts.push(JSON.stringify(a)); }
                            catch(e) { parts.push(String(a)); }
                        }
                        var line = '[' + new Date().toISOString().substr(11,12) + '] ' + level.toUpperCase() + ' ' + parts.join(' ');
                        if (line.length > 500) line = line.substring(0, 500) + '...';
                        window._cwConsoleTail.push(line);
                        if (window._cwConsoleTail.length > CAP) {
                            window._cwConsoleTail = window._cwConsoleTail.slice(-CAP);
                        }
                    } catch(_) {}
                    if (orig && orig.apply) orig.apply(console, arguments);
                };
            })(levels[i]);
        }
   }
  gSobject.nativeInstallRouteHistory = function() {
    if (window._cwRouteHistoryInstalled) return;
        var CAP = 10;
        window._cwRouteHistory = window._cwRouteHistory || [];
        var tries = 0;
        var iv = setInterval(function() {
            tries++;
            try {
                if (window.vue && window.vue.router && window.vue.router.afterEach) {
                    window.vue.router.afterEach(function(to) {
                        try {
                            var path = to && (to.fullPath || to.path) ? (to.fullPath || to.path) : '';
                            if (path) {
                                window._cwRouteHistory.push(path);
                                if (window._cwRouteHistory.length > CAP) {
                                    window._cwRouteHistory = window._cwRouteHistory.slice(-CAP);
                                }
                            }
                        } catch(_) {}
                    });
                    window._cwRouteHistoryInstalled = true;
                    clearInterval(iv);
                }
            } catch(_) {}
            if (tries > 100) clearInterval(iv);
        }, 200);
   }
  gSobject['CordovaDevice0'] = function(it) {
    gs.mc(gSobject,"installErrorCapture",[]);
    gs.mc(document,"addEventListener",["deviceready", function(it) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaDevice:deviceready"]);
      gs.mc(gSobject,"splashScreenHide",[]);
      gs.mc(gSobject,"setupCordovaPluginKeyboard",[]);
      if (!gs.bool(gs.mc(this,"cordovaPluginDeviceInstalled",[], gSobject))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaDevice:NOT INSTALLED"]);
        gs.mc(gSobject,"enableErrorFlush",[]);
        return null;
       };
      if (!gs.bool(gs.gp(gs.fs('session', this, gSobject),"userId"))) {
        gs.mc(gSobject,"enableErrorFlush",[]);
        return null;
       };
      gSobject.userId = gs.gp(gs.fs('session', this, gSobject),"userId");
      try {
        gs.mc(gSobject,"setupCordovaPluginDevice",[]);
        gs.mc(gSobject,"setupCordovaPluginBatteryStatus",[]);
        gs.mc(gSobject,"setupCordovaPluginNetworkInformation",[]);
        gs.mc(gSobject,"disableBackButton",[]);
       }
      catch (all) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",[gs.plus("CordovaDevice:init:ERROR:", gs.fs('all', this, gSobject))]);
       }
      ;
      return gs.mc(gSobject,"enableErrorFlush",[]);
     }]);
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"splashScreenHide",[]);
     }, 1000]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaDevice0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaDevice.spinnerInstalled = function() {
  return typeof window.i3Spinner !== 'undefined';
 }
CordovaDevice.permissionsInstalled = function() {
  return typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.permissions !== 'undefined';
 }
CordovaDevice.cordovaPluginStatusBarInstalled = function() {
  return ( typeof StatusBar !== 'undefined' )
 }
CordovaDevice.cordovaPluginDeviceInstalled = function() {
  return ( typeof device !== 'undefined' || typeof window.device !== 'undefined')
 }
CordovaDevice.crdovaPluginNetworkInformationInstalled = function() {
  return ( typeof navigator.connection !== 'undefined')
 }

function CordovaDeepLink() {
  var gSobject = gs.init('CordovaDeepLink');
  gSobject.clazz = { name: 'CordovaDeepLink', simpleName: 'CordovaDeepLink'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.callbackList = gs.list([]);
  gSobject['registerCallback'] = function(callback) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["================CordovaDeepLink registerCallback"]);
    return gs.mc(gSobject.callbackList,"add",[callback]);
   }
  gSobject['openDeepLink'] = function(eventData) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["=====================CordovaDeepLink openDeepLink"]);
    return gs.mc(gSobject.callbackList,"each",[function(callback) {
      return gs.execCall(callback, this, [eventData]);
     }]);
   }
  gSobject['CordovaDeepLink0'] = function(it) {
    gs.mc(document,"addEventListener",["deviceready", function(it) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["======================CordovaDeepLink eventlistener"]);
      return gs.mc(gs.fs('universalLinks', this, gSobject),"subscribe",["openDeepLink", gs.gp(gs.thisOrObject(this,gSobject),"openDeepLink")]);
     }, false]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaDeepLink0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaFile() {
  var gSobject = gs.init('CordovaFile');
  gSobject.clazz = { name: 'CordovaFile', simpleName: 'CordovaFile'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'DB_NAME', { get: function() { return CordovaFile.DB_NAME; }, set: function(gSval) { CordovaFile.DB_NAME = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'STORE_NAME', { get: function() { return CordovaFile.STORE_NAME; }, set: function(gSval) { CordovaFile.STORE_NAME = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'FILE_CACHE_MIL', { get: function() { return CordovaFile.FILE_CACHE_MIL; }, set: function(gSval) { CordovaFile.FILE_CACHE_MIL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MAX_FILE_SIZE_TO_CACHE', { get: function() { return CordovaFile.MAX_FILE_SIZE_TO_CACHE; }, set: function(gSval) { CordovaFile.MAX_FILE_SIZE_TO_CACHE = gSval; }, enumerable: true });
  gSobject.db = null;
  Object.defineProperty(gSobject, 'MIME_TYPES', { get: function() { return CordovaFile.MIME_TYPES; }, set: function(gSval) { CordovaFile.MIME_TYPES = gSval; }, enumerable: true });
  gSobject['initDB'] = function(it) {
    var request = gs.mc(gs.fs('indexedDB', this, gSobject),"open",[gs.gp(CordovaFile,"DB_NAME"), 1]);
    gs.sp(request,"onupgradeneeded",function(e) {
      var db = gs.gp(gs.gp(e,"target"),"result");
      if (!gs.bool(gs.mc(gs.gp(db,"objectStoreNames"),"contains",[gs.gp(CordovaFile,"STORE_NAME")]))) {
        var store = gs.mc(db,"createObjectStore",[gs.gp(CordovaFile,"STORE_NAME"), gs.map().add("keyPath","id").add("autoIncrement",true)]);
        gs.mc(store,"createIndex",["objectKey", gs.list(["objectName" , "property" , "objectId"]), gs.map().add("unique",true)]);
        return gs.mc(store,"createIndex",["synced", "synced"]);
       };
     });
    gs.sp(request,"onsuccess",function(e) {
      gSobject.db = gs.gp(gs.gp(e,"target"),"result");
      return gs.println("✅ Browser file cache (IndexedDB) ready – 2-day cleanup active");
     });
    return gs.sp(request,"onerror",function(e) {
      return gs.mc(gs.fs('console', this, gSobject),"error",["IndexedDB failed", gs.gp(gs.gp(e,"target"),"error")]);
     });
   }
  gSobject['transaction'] = function(mode, callback) {
    if (!gs.bool(gSobject.db)) {
      return gs.execStatic(Utils,'setTimeout', this,[function(it) {
        return gs.mc(gSobject,"transaction",[mode, callback]);
       }, 50]);
     };
    var tx = gs.mc(gSobject.db,"transaction",[gs.gp(CordovaFile,"STORE_NAME"), mode]);
    var store = gs.mc(tx,"objectStore",[gs.gp(CordovaFile,"STORE_NAME")]);
    return gs.execCall(callback, this, [store, tx]);
   }
  gSobject['find'] = function(objectName, property, objectId, cb) {
    gs.println("find");
    gs.println(objectName);
    gs.println(property);
    gs.println(objectId);
    return gs.mc(gSobject,"transaction",["readonly", function(store, tx) {
      var idx = gs.mc(store,"index",["objectKey"]);
      var req = gs.mc(idx,"get",[gs.list([objectName , property , objectId])]);
      gs.sp(req,"onsuccess",function(it) {
        return gs.execCall(cb, this, [gs.gp(req,"result")]);
       });
      return gs.sp(req,"onerror",function(it) {
        return gs.execCall(cb, this, [null]);
       });
     }]);
   }
  gSobject['put'] = function(entry, cb) {
    if (cb === undefined) cb = function(it) {
     };
    gs.sp(entry,"_lastUpdated",gs.mc(gs.date(),"getTime",[]));
    if (!gs.bool(gs.gp(entry,"_created"))) {
      gs.sp(entry,"_created",gs.gp(entry,"_lastUpdated"));
     };
    return gs.mc(gSobject,"transaction",["readwrite", function(store, tx) {
      var req = gs.mc(store,"put",[gs.mc(gs.fs('gs', this, gSobject),"toJavascript",[entry])]);
      return gs.sp(req,"onsuccess",function(it) {
        gs.sp(entry,"id",gs.gp(req,"result"));
        return gs.execCall(cb, this, [entry]);
       });
     }]);
   }
  gSobject['delete'] = function(objectName, property, objectId, cb) {
    if (cb === undefined) cb = function(it) {
     };
    return gs.mc(gSobject,"find",[objectName, property, objectId, function(existing) {
      if (!gs.bool(existing)) {
        return gs.execCall(cb, this, [null]);
       };
      return gs.mc(gSobject,"transaction",["readwrite", function(store) {
        gs.mc(store,"delete",[gs.gp(existing,"id")]);
        return gs.execCall(cb, this, [existing]);
       }]);
     }]);
   }
  gSobject['findUnsynced'] = function(cb) {
    gs.println("findUnsynced:start");
    return gs.mc(gSobject,"transaction",["readonly", function(store) {
      var idx = gs.mc(store,"index",["synced"]);
      var cursor = gs.mc(idx,"openCursor",[gs.mc(gs.fs('IDBKeyRange', this, gSobject),"only",[0])]);
      var list = gs.list([]);
      return gs.sp(cursor,"onsuccess",function(e) {
        var c = gs.gp(gs.gp(e,"target"),"result");
        gs.println("findUnsynced:list");
        gs.println(c);
        if (gs.bool(c)) {
          gs.mc(list,"push",[gs.gp(c,"value")]);
          return gs.mc(c,"continue",[]);
         } else {
          return gs.execCall(cb, this, [list]);
         };
       });
     }]);
   }
  gSobject['addFile'] = function(fileOrBlob, objectName, property, objectId, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (gs.instanceOf(fileOrBlob, "String")) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["addFile:fileOrBlob:string"]);
      return CordovaFile.blobFromFileUrl(fileOrBlob, function(blob) {
        return gs.mc(gSobject,"addFile",[blob, objectName, property, objectId, onSuccess, onError]);
       }, onError);
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["addFile:fileOrBlob:blob"]);
    var size = gs.elvis(gs.bool(gs.gp(fileOrBlob,"size")) , gs.gp(fileOrBlob,"size") , 0);
    var entry = gs.map().add("objectName",objectName).add("property",property).add("objectId",objectId).add("name",gs.elvis(gs.bool(gs.gp(fileOrBlob,"name")) , gs.gp(fileOrBlob,"name") , "blob")).add("type",gs.gp(fileOrBlob,"type")).add("size",size).add("lastModified",gs.elvis(gs.bool(gs.gp(fileOrBlob,"lastModified")) , gs.gp(fileOrBlob,"lastModified") , gs.mc(gs.date(),"getTime",[]))).add("blob",fileOrBlob).add("synced",0);
    return gs.mc(gSobject,"delete",[objectName, property, objectId, function(stored) {
      return gs.mc(gSobject,"put",[entry, function(saved) {
        if (gs.equals(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"network"),"status"), "offline")) {
          return gs.execCall(onError, this, [entry, fileOrBlob]);
         };
        return gs.mc(gSobject,"syncSingle",[saved, function(it) {
          return gs.execCall(onSuccess, this, [entry, fileOrBlob]);
         }, onError]);
       }]);
     }]);
   }
  gSobject['deleteFile'] = function(objectName, property, objectId, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"delete",[objectName, property, objectId, function(it) {
      return gs.execCall(onSuccess, this, [it]);
     }]);
   }
  gSobject['getBlobFromCachedFile'] = function(objectName, property, objectId, callback) {
    return gs.mc(gSobject,"find",[objectName, property, objectId, function(entry) {
      return gs.execCall(callback, this, [entry]);
     }]);
   }
  gSobject['syncSingle'] = function(entry, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (!gs.bool(gs.gp(entry,"blob",true))) {
      return null;
     };
    return gs.execStatic(Utils,'post', this,[gs.gp(entry,"blob"), gs.gp(entry,"property"), gs.gp(entry,"objectName"), gs.gp(entry,"objectId"), function(data) {
      gs.sp(entry,"synced",1);
      gs.sp(entry,"_lastUpdated",gs.mc(gs.date(),"getTime",[]));
      gs.mc(gSobject,"put",[entry]);
      gs.mc(gSobject,"delete",[gs.gp(entry,"property"), gs.gp(entry,"objectName"), gs.gp(entry,"objectId")]);
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaFile:syncSingle:success"]);
      return gs.execCall(onSuccess, this, [entry]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaFile:syncSingle:failed:" + (err) + ""]);
      return gs.execCall(onError, this, [entry]);
     }]);
   }
  gSobject['sync'] = function(it) {
    return gs.mc(gSobject,"findUnsynced",[function(list) {
      return gs.mc(list,"each",[function(it) {
        return gs.mc(gSobject,"syncSingle",[it]);
       }]);
     }]);
   }
  gSobject['cleanup'] = function(it) {
    var now = gs.mc(gs.date(),"getTime",[]);
    return gs.mc(gSobject,"transaction",["readonly", function(store) {
      var req = gs.mc(store,"getAll",[]);
      return gs.sp(req,"onsuccess",function(it) {
        return gs.mc(gs.gp(req,"result"),"each",[function(entry) {
          var age = gs.minus(now, gs.elvis(gs.bool(gs.gp(entry,"_lastUpdated")) , gs.gp(entry,"_lastUpdated") , gs.elvis(gs.bool(gs.gp(entry,"_created")) , gs.gp(entry,"_created") , 0)));
          if (age > gs.gp(CordovaFile,"FILE_CACHE_MIL")) {
            gs.println("cleanup: deleting file older than 2 days – " + (gs.gp(entry,"name")) + "");
            return gs.mc(gSobject,"delete",[gs.gp(entry,"objectName"), gs.gp(entry,"property"), gs.gp(entry,"objectId")]);
           };
         }]);
       });
     }]);
   }
  gSobject['showAll'] = function(it) {
    return gs.mc(gSobject,"transaction",["readonly", function(store) {
      return gs.sp(gs.mc(store,"getAll",[]),"onsuccess",function(it) {
        return gs.println("Cached files:", gs.gp(gs.gp(it,"target"),"result"));
       });
     }]);
   }
  gSobject['clearAll'] = function(it) {
    return gs.mc(gSobject,"transaction",["readwrite", function(store) {
      return gs.mc(store,"clear",[]);
     }]);
   }
  gSobject['getContentTypeFromUrl'] = function(url) {
    if (!gs.bool(url)) {
      return null;
     };
    var fileName = gs.mc(gs.mc(url,"tokenize",["/"]),"last",[]);
    if (!gs.bool(gs.mc(fileName,"contains",["."]))) {
      return null;
     };
    var ext = gs.mc(gs.mc(gs.mc(fileName,"tokenize",["."]),"last",[]),"toLowerCase",[]);
    return gs.mc(CordovaFile.MIME_TYPES,"get",[ext, "application/octet-stream"]);
   }
  gSobject['resolveFileUrl'] = function(url) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:1:", url)]);
    if (gs.mc(url,"startsWith",["app://localhost/_app_file_"])) {
      url = (url = gs.mc(url,"substring",[26]));
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:2:", url)]);
    if (gs.mc(url,"startsWith",["file:///"])) {
      url = (url = gs.mc(url,"substring",[8]));
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:3:", url)]);
    if (gs.mc(url,"startsWith",["private/"])) {
      url = gs.mc(url,"substring",[8]);
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:4:", url)]);
    if (!gs.bool(gs.mc(url,"startsWith",["http"]))) {
      url = (gs.plus("file:///", url));
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:5:", url)]);
    return url;
   }
  gSobject.blobFromFileUrl = function(x0,x1,x2) { return CordovaFile.blobFromFileUrl(x0,x1,x2); }
  gSobject['CordovaFile0'] = function(it) {
    gs.mc(gSobject,"initDB",[]);
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"sync",[]);
     }, gs.multiply(60, 1000)]);
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"cleanup",[]);
     }, gs.multiply((gs.multiply(3, 60)), 1000)]);
    gs.mc(cordovaDevice,"addAppEventListeners",[function(event) {
      if ("network.online") {
        return gs.mc(gSobject,"sync",[]);
       };
     }]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaFile0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaFile.blobFromFileUrl = function(url, onSuccess, onError) {
  url = cordovaFile.resolveFileUrl(url)
    
        var contentType = cordovaFile.getContentTypeFromUrl(url)
        
        console.log('blobFromFileUrl', contentType, url)
        
        window.resolveLocalFileSystemURL(url, function success(fileEntry) {
            fileEntry.file(function (file) {
                var reader = new FileReader();
                reader.onloadend = function() {
                    var blob = new Blob([new Uint8Array(this.result)], { type: contentType });
                    onSuccess(blob)
                };
                reader.readAsArrayBuffer(file);
            }, function (err) { 
                console.error('error getting fileentry file!' + err); 
                onError(err)
            });
        }, function (err) { 
            console.error('error getting file! ' + err); 
            onError(err)
        });
 }
CordovaFile.DB_NAME = "localFileCacheDB";
CordovaFile.STORE_NAME = "localFiles";
CordovaFile.FILE_CACHE_MIL = gs.multiply((gs.multiply((gs.multiply((gs.multiply(2, 24)), 60)), 60)), 1000);
CordovaFile.MAX_FILE_SIZE_TO_CACHE = gs.multiply((gs.multiply(1024, 1024)), 8);
CordovaFile.MIME_TYPES = gs.map().add("txt","text/plain").add("html","text/html").add("htm","text/html").add("css","text/css").add("js","application/javascript").add("json","application/json").add("xml","application/xml").add("csv","text/csv").add("rtf","application/rtf").add("pdf","application/pdf").add("doc","application/msword").add("docx","application/vnd.openxmlformats-officedocument.wordprocessingml.document").add("xls","application/vnd.ms-excel").add("xlsx","application/vnd.openxmlformats-officedocument.spreadsheetml.sheet").add("ppt","application/vnd.ms-powerpoint").add("pptx","application/vnd.openxmlformats-officedocument.presentationml.presentation").add("zip","application/zip").add("rar","application/vnd.rar").add("7z","application/x-7z-compressed").add("tar","application/x-tar").add("gz","application/gzip").add("bz2","application/x-bzip2").add("xz","application/x-xz").add("jpg","image/jpeg").add("jpeg","image/jpeg").add("png","image/png").add("gif","image/gif").add("bmp","image/bmp").add("webp","image/webp").add("heic","image/heic").add("heif","image/heif").add("tiff","image/tiff").add("tif","image/tiff").add("svg","image/svg+xml").add("raw","image/x-raw").add("dng","image/x-adobe-dng").add("ico","image/x-icon").add("mp3","audio/mpeg").add("wav","audio/wav").add("m4a","audio/mp4").add("aac","audio/aac").add("ogg","audio/ogg").add("oga","audio/ogg").add("opus","audio/opus").add("flac","audio/flac").add("amr","audio/amr").add("awb","audio/amr-wb").add("3ga","audio/3gpp").add("3g2a","audio/3gpp2").add("mid","audio/midi").add("midi","audio/midi").add("mp4","video/mp4").add("m4v","video/mp4").add("mov","video/quicktime").add("qt","video/quicktime").add("3gp","video/3gpp").add("3g2","video/3gpp2").add("avi","video/x-msvideo").add("mkv","video/x-matroska").add("webm","video/webm").add("ts","video/mp2t").add("mpeg","video/mpeg").add("mpg","video/mpeg").add("mpe","video/mpeg").add("vcf","text/vcard").add("vcs","text/x-vcalendar").add("ics","text/calendar");

function TestAppMediaComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppMediaComponent', simpleName: 'TestAppMediaComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/media";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppMediaComponent: created"]);
    gs.sp(gSobject.scope,"recording",false);
    gs.sp(gSobject.scope,"playing",false);
    gs.sp(gSobject.scope,"recordingFile","");
    gs.sp(gSobject.scope,"duration",0);
    gs.sp(gSobject.scope,"position",0);
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"capturedFiles",gs.list([]));
    gs.sp(gSobject.scope,"mediaAvailable",false);
    return gs.sp(gSobject.scope,"captureAvailable",false);
   }
  gSobject['afterMounted'] = function(it) {
    gs.sp(gSobject.scope,"mediaAvailable",TestAppMediaComponent.mediaAvailable());
    return gs.sp(gSobject.scope,"captureAvailable",TestAppMediaComponent.captureAvailable());
   }
  gSobject.mediaAvailable = function() { return TestAppMediaComponent.mediaAvailable(); }
  gSobject.captureAvailable = function() { return TestAppMediaComponent.captureAvailable(); }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 29)));
     };
   }
  gSobject['recordAudio'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppMediaComponent: recordAudio"]);
    gs.sp(gSobject.scope,"recording",true);
    gs.sp(gSobject.scope,"recordingFile",(gs.plus((gs.plus("test_recording_", gs.mc(gs.date(),"getTime",[]))), ".m4a")));
    gs.mc(gSobject,"addLog",["Recording to: " + (gs.gp(gSobject.scope,"recordingFile")) + ""]);
    return gs.mc(gSobject,"startRecord",[gs.gp(gSobject.scope,"recordingFile")]);
   }
  gSobject.startRecord = function(filename) {
    var self = this;
        window._testMedia = new Media(filename,
            function() { self.addLog('Recording saved'); },
            function(e) { self.addLog('Media error: ' + JSON.stringify(e)); self.scope.recording = false; }
        );
        window._testMedia.startRecord();
   }
  gSobject['stopRecording'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppMediaComponent: stopRecording"]);
    gs.mc(gSobject,"doStopRecord",[]);
    gs.sp(gSobject.scope,"recording",false);
    return gs.mc(gSobject,"addLog",["Recording stopped"]);
   }
  gSobject['playRecording'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppMediaComponent: playRecording"]);
    if (!gs.bool(gs.gp(gSobject.scope,"recordingFile"))) {
      gs.mc(gSobject,"addLog",["No recording to play"]);
      return null;
     };
    gs.sp(gSobject.scope,"playing",true);
    gs.mc(gSobject,"doPlay",[]);
    return gs.mc(gSobject,"addLog",["Playing: " + (gs.gp(gSobject.scope,"recordingFile")) + ""]);
   }
  gSobject['stopPlaying'] = function(it) {
    gs.mc(gSobject,"doStopPlay",[]);
    gs.sp(gSobject.scope,"playing",false);
    return gs.mc(gSobject,"addLog",["Playback stopped"]);
   }
  gSobject.doStopRecord = function() {
    if (window._testMedia) { window._testMedia.stopRecord(); }
   }
  gSobject.doPlay = function() {
    if (window._testMedia) { window._testMedia.play(); }
   }
  gSobject.doStopPlay = function() {
    if (window._testMedia) { window._testMedia.stop(); }
   }
  gSobject['captureAudio'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppMediaComponent: captureAudio"]);
    return gs.mc(gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"device"),"capture"),"captureAudio",[function(files) {
      var result = gs.list([]);
      for (var i = 0 ; i < gs.gp(files,"length") ; i++) {
        gs.mc(result,"add",[gs.map().add("name",gs.gp(files[i],"name")).add("size",gs.gp(files[i],"size")).add("type",gs.gp(files[i],"type"))]);
       };
      gs.sp(gSobject.scope,"capturedFiles",result);
      return gs.mc(gSobject,"addLog",["Captured " + (gs.gp(files,"length")) + " audio file(s)"]);
     }, function(e) {
      return gs.mc(gSobject,"addLog",["Capture error: " + (gs.gp(e,"code")) + ""]);
     }, gs.map().add("limit",1)]);
   }
  gSobject['captureVideo'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppMediaComponent: captureVideo"]);
    return gs.mc(gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"device"),"capture"),"captureVideo",[function(files) {
      var result = gs.list([]);
      for (var i = 0 ; i < gs.gp(files,"length") ; i++) {
        gs.mc(result,"add",[gs.map().add("name",gs.gp(files[i],"name")).add("size",gs.gp(files[i],"size")).add("type",gs.gp(files[i],"type"))]);
       };
      gs.sp(gSobject.scope,"capturedFiles",result);
      return gs.mc(gSobject,"addLog",["Captured " + (gs.gp(files,"length")) + " video file(s)"]);
     }, function(e) {
      return gs.mc(gSobject,"addLog",["Video capture error: " + (gs.gp(e,"code")) + ""]);
     }, gs.map().add("limit",1).add("duration",10)]);
   }
  gSobject['destroyed'] = function(it) {
    return gs.mc(gSobject,"releaseMedia",[]);
   }
  gSobject.releaseMedia = function() {
    if (window._testMedia) { window._testMedia.release(); window._testMedia = null; }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppMediaComponent.mediaAvailable = function() {
  return typeof Media !== 'undefined';
 }
TestAppMediaComponent.captureAvailable = function() {
  return typeof navigator.device !== 'undefined' && typeof navigator.device.capture !== 'undefined';
 }

function CordovaBiometrics() {
  var gSobject = gs.init('CordovaBiometrics');
  gSobject.clazz = { name: 'CordovaBiometrics', simpleName: 'CordovaBiometrics'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.disableBackup = false;
  gSobject.requireStrongBiometrics = false;
  gSobject.storeKeyName = "com.i3";
  gSobject['deviceHasBiometrics'] = function(onSuccess, onError, opts) {
    if (onError === undefined) onError = function(it) {
     };
    if (opts === undefined) opts = gs.map().add("requireStrongBiometrics",gSobject.requireStrongBiometrics);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"isAvailable",[onSuccess, onError, opts]);
   }
  gSobject['showBiometricDialog'] = function(onSuccess, onError, params) {
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("title","Biometric Sign On").add("description","Authenticate").add("subtitle","").add("disableBackup",gSobject.disableBackup).add("requireStrongBiometrics",gSobject.requireStrongBiometrics).add("keyName",gSobject.storeKeyName);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"show",[params, onSuccess, onError]);
   }
  gSobject['registerSecret'] = function(secret, onSuccess, onError, params) {
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("description","Register new biometric").add("invalidateOnEnrollment",true).add("disableBackup",gSobject.disableBackup).add("keyName",gSobject.storeKeyName);
    gs.sp(params,"secret",secret);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"registerBiometricSecret",[params, onSuccess, onError]);
   }
  gSobject['loadSecret'] = function(onSuccess, onError, params) {
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("description","Load biometrics").add("disableBackup",gSobject.disableBackup).add("keyName",gSobject.storeKeyName);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"loadBiometricSecret",[params, onSuccess, onError]);
   }
  gSobject['deleteSecret'] = function(onSuccess, onError, params) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("keyName",gSobject.storeKeyName);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"deleteBiometricSecret",[params, onSuccess, onError]);
   }
  gSobject.verifyBiometricsPlugin = function() { return CordovaBiometrics.verifyBiometricsPlugin(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaBiometrics.verifyBiometricsPlugin = function() {
  return ( window?.Fingerprint !== undefined)
 }

function CordovaBrowser() {
  var gSobject = gs.init('CordovaBrowser');
  gSobject.clazz = { name: 'CordovaBrowser', simpleName: 'CordovaBrowser'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['openInApp'] = function(url, options) {
    if (options === undefined) options = gs.map();
    if (!gs.bool(CordovaBrowser.browserInstalled())) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBrowser: InAppBrowser not installed"]);
      return null;
     };
    try {
      return gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[url, "_blank", gs.mc(gSobject,"optionsString",[options])]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["openInApp: " + (gs.fs('e', this, gSobject)) + ""]);
      return null;
     }
    ;
   }
  gSobject['openSystem'] = function(url) {
    if (!gs.bool(CordovaBrowser.browserInstalled())) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBrowser: InAppBrowser not installed"]);
      return null;
     };
    try {
      return gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[url, "_system"]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["openSystem: " + (gs.fs('e', this, gSobject)) + ""]);
      return null;
     }
    ;
   }
  gSobject['openHidden'] = function(url, onLoad) {
    if (onLoad === undefined) onLoad = function(it) {
     };
    if (!gs.bool(CordovaBrowser.browserInstalled())) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBrowser: InAppBrowser not installed"]);
      return null;
     };
    try {
      var ref = gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[url, "_blank", "hidden=yes"]);
      gs.mc(ref,"addEventListener",["loadstop", function(event) {
        gs.execCall(onLoad, this, [event]);
        try {
          gs.mc(ref,"close",[]);
         }
        catch (e2) {
         }
        ;
       }]);
      gs.mc(ref,"addEventListener",["loaderror", function(event) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["openHidden loaderror: " + (event) + ""]);
        try {
          gs.mc(ref,"close",[]);
         }
        catch (e2) {
         }
        ;
       }]);
      return ref;
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["openHidden: " + (gs.fs('e', this, gSobject)) + ""]);
      return null;
     }
    ;
   }
  gSobject['open'] = function(url, target, options) {
    if (target === undefined) target = "_blank";
    if (options === undefined) options = gs.map();
    if (!gs.bool(CordovaBrowser.browserInstalled())) {
      return null;
     };
    try {
      return gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[url, target, gs.mc(gSobject,"optionsString",[options])]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["open: " + (gs.fs('e', this, gSobject)) + ""]);
      return null;
     }
    ;
   }
  gSobject['optionsString'] = function(opts) {
    if ((gs.equals(opts, null)) || ((gs.instanceOf(opts, "Map")) && (gs.mc(opts,"isEmpty",[])))) {
      return "";
     };
    if (gs.instanceOf(opts, "String")) {
      return opts;
     };
    var parts = gs.list([]);
    gs.mc(opts,"each",[function(k, v) {
      return gs.mc(parts,"add",["" + (k) + "=" + (v) + ""]);
     }]);
    return gs.mc(parts,"join",[","]);
   }
  gSobject.browserInstalled = function() { return CordovaBrowser.browserInstalled(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaBrowser.browserInstalled = function() {
  return typeof cordova !== 'undefined' && typeof cordova.InAppBrowser !== 'undefined';
 }

function CordovaScreenCapture() {
  var gSobject = gs.init('CordovaScreenCapture');
  gSobject.clazz = { name: 'CordovaScreenCapture', simpleName: 'CordovaScreenCapture'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['capture'] = function(success, error, opts) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    if (opts === undefined) opts = gs.map();
    return gs.mc(gSobject,"nativeCaptureSvgToPng",[gs.elvis(gs.bool(gs.gp(opts,"maxWidth")) , gs.gp(opts,"maxWidth") , 1280), success, error]);
   }
  gSobject['openProblemReport'] = function(it) {
    return gs.mc(gSobject,"capture",[function(blob, meta) {
      gs.mc(gSobject,"nativeStashBlob",[blob]);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/reportProblem"]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["openProblemReport: capture failed: " + (err) + ""]);
      gs.mc(gSobject,"nativeStashBlob",[null]);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/reportProblem"]);
     }]);
   }
  gSobject['reportProblem'] = function(userMessage, opts, success, error) {
    if (opts === undefined) opts = gs.map();
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    var stashed = gs.mc(gSobject,"nativeReadStashedBlob",[]);
    if (gs.bool(stashed)) {
      gs.mc(gSobject,"uploadAndCreateReport",[userMessage, opts, stashed, gs.map().add("type","image/png").add("width",0).add("height",0).add("fallback",false), success, error]);
      return null;
     };
    return gs.mc(gSobject,"capture",[function(blob, meta) {
      return gs.mc(gSobject,"uploadAndCreateReport",[userMessage, opts, blob, meta, success, error]);
     }, function(captureErr) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaScreenCapture:reportProblem:capture failed: " + (captureErr) + ""]);
      return gs.mc(gSobject,"uploadAndCreateReport",[userMessage, opts, null, gs.map(), success, error]);
     }]);
   }
  gSobject['uploadAndCreateReport'] = function(userMessage, opts, blob, meta, success, error) {
    var report = gs.mc(gSobject,"buildReportContext",[userMessage, opts, meta]);
    gs.sp(report,"hasScreenshot",(blob != null));
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userProblem",[gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"uuid"), report, function(result) {
      if (!gs.bool(gs.gp(result,"id",true))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaScreenCapture:reportProblem:userProblem returned no id"]);
        return gs.execCall(error, this, ["Failed to create problem report"]);
       };
      if (!gs.bool(blob)) {
        return gs.execCall(success, this, [gs.gp(result,"id")]);
       };
      return gs.execStatic(Utils,'post', this,[blob, "screenshot", "userError", gs.gp(result,"id"), function(uploadResult) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaScreenCapture:reportProblem:uploaded screenshot for " + (gs.gp(result,"id")) + ""]);
        return gs.execCall(success, this, [gs.gp(result,"id")]);
       }, function(uploadErr) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaScreenCapture:reportProblem:screenshot upload failed: " + (uploadErr) + ""]);
        return gs.execCall(success, this, [gs.gp(result,"id")]);
       }]);
     }]);
   }
  gSobject['buildReportContext'] = function(userMessage, opts, meta) {
    var ctx = gs.mc(gSobject,"nativeGatherContext",[]);
    return gs.map().add("userMessage",gs.elvis(gs.bool(userMessage) , userMessage , "")).add("severity",gs.elvis(gs.bool(gs.gp(opts,"severity")) , gs.gp(opts,"severity") , "normal")).add("message",gs.elvis(gs.bool(userMessage) , userMessage , "(no description)")).add("route",gs.gp(ctx,"route")).add("pageTitle",gs.gp(ctx,"pageTitle")).add("appPath",gs.gp(ctx,"appPath")).add("viewport",gs.gp(ctx,"viewport")).add("orientation",gs.gp(ctx,"orientation")).add("locale",gs.gp(ctx,"locale")).add("tz",gs.gp(ctx,"tz")).add("consoleTail",gs.gp(ctx,"consoleTail")).add("routeHistory",gs.gp(ctx,"routeHistory")).add("userAgent",gs.gp(ctx,"userAgent")).add("platform",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"platform")) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"platform") , "browser")).add("appVersion",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"version")) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"version") , "")).add("appBuild",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"cordova")) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"cordova") , "")).add("clientReportedAt",gs.mc(gs.date(),"getTime",[]));
   }
  gSobject.nativeGatherContext = function() {
    var route = '';
        var routeHistory = '';
        try {
            if (window.vue && window.vue.router && window.vue.router.currentRoute) {
                route = window.vue.router.currentRoute.value
                    ? window.vue.router.currentRoute.value.fullPath
                    : window.vue.router.currentRoute.fullPath || '';
            }
        } catch(e) {}
        try {
            if (window._cwRouteHistory) routeHistory = window._cwRouteHistory.slice(-5).join(' -> ');
        } catch(e) {}

        var tail = '';
        try { if (window._cwConsoleTail) tail = window._cwConsoleTail.join('\n'); } catch(e) {}

        return {
            route       : route,
            pageTitle   : (typeof document !== 'undefined') ? (document.title || '') : '',
            appPath     : (typeof window !== 'undefined' && window.location) ? window.location.pathname : '',
            viewport    : (window.innerWidth + 'x' + window.innerHeight + ' @ ' + (window.devicePixelRatio || 1) + 'x'),
            orientation : (screen && screen.orientation) ? (screen.orientation.type || '') : '',
            locale      : (navigator && navigator.language) ? navigator.language : '',
            tz          : (Intl && Intl.DateTimeFormat) ? Intl.DateTimeFormat().resolvedOptions().timeZone : '',
            consoleTail : tail,
            routeHistory: routeHistory,
            userAgent   : (navigator && navigator.userAgent) ? navigator.userAgent : ''
        };
   }
  gSobject.nativeStashBlob = function(blob) {
    if (blob) window._cwPendingReport = { blob: blob, ts: Date.now() };
        else window._cwPendingReport = null;
   }
  gSobject.nativeReadStashedBlob = function() {
    return window._cwPendingReport ? window._cwPendingReport.blob : null;
   }
  gSobject.nativeCaptureSvgToPng = function(maxWidth, success, error) {
    try {
            var node = document.documentElement;
            var w = Math.max(node.scrollWidth, document.body ? document.body.scrollWidth : 0, window.innerWidth);
            var h = Math.max(node.scrollHeight, document.body ? document.body.scrollHeight : 0, window.innerHeight);

            // Clone so we can inline computed styles without mutating the live DOM.
            var clone = node.cloneNode(true);

            // Strip <script> and elements that don't render.
            var scripts = clone.querySelectorAll('script, link[rel="preload"], link[as="script"]');
            for (var i = 0; i < scripts.length; i++) scripts[i].parentNode.removeChild(scripts[i]);

            var serializer = new XMLSerializer();
            var html;
            try {
                html = serializer.serializeToString(clone);
            } catch(e) {
                return error('serialize failed: ' + e);
            }

            // Wrap in xhtml namespace so foreignObject can host it
            var svg =
                '<svg xmlns="http://www.w3.org/2000/svg" width="' + w + '" height="' + h + '">' +
                  '<foreignObject width="100%" height="100%">' +
                    '<div xmlns="http://www.w3.org/1999/xhtml">' + html + '</div>' +
                  '</foreignObject>' +
                '</svg>';

            var svgBlob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
            var url = URL.createObjectURL(svgBlob);
            var img = new Image();

            // Optional downscale for very wide pages
            var scale = (maxWidth && w > maxWidth) ? (maxWidth / w) : 1;
            var outW = Math.round(w * scale);
            var outH = Math.round(h * scale);

            img.onload = function() {
                try {
                    var canvas = document.createElement('canvas');
                    canvas.width = outW;
                    canvas.height = outH;
                    var ctx = canvas.getContext('2d');
                    ctx.fillStyle = '#ffffff';
                    ctx.fillRect(0, 0, outW, outH);
                    ctx.drawImage(img, 0, 0, outW, outH);
                    URL.revokeObjectURL(url);

                    canvas.toBlob(function(blob) {
                        if (blob) {
                            success(blob, { type:'image/png', width:outW, height:outH, fallback:false });
                        } else {
                            // Canvas likely tainted by cross-origin images — fall back to raw SVG
                            success(svgBlob, { type:'image/svg+xml', width:w, height:h, fallback:true });
                        }
                    }, 'image/png', 0.9);
                } catch(e) {
                    URL.revokeObjectURL(url);
                    // Tainted canvas → fall back to raw SVG so the report still has *something*
                    success(svgBlob, { type:'image/svg+xml', width:w, height:h, fallback:true });
                }
            };
            img.onerror = function(e) {
                URL.revokeObjectURL(url);
                // Image load failed — return the raw SVG so caller still has visual context
                success(svgBlob, { type:'image/svg+xml', width:w, height:h, fallback:true });
            };
            img.src = url;
        } catch(e) {
            error('capture failed: ' + (e.message || e));
        }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaHealth() {
  var gSobject = gs.init('CordovaHealth');
  gSobject.clazz = { name: 'CordovaHealth', simpleName: 'CordovaHealth'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['testIsAvailable'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeIsAvailable",[function(available) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health. isAvailable -> success: " + (available) + ""]);
      return gs.execCall(onSuccess, this, [available]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.isAvailable -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['requestPermissions'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    datatypes = gs.map().add("read",gs.list(["steps" , "blood_pressure" , "heart_rate"]));
    return gs.mc(gSobject,"nativeRequestAuthorization",[datatypes, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health. requestAuthorization -> success: " + (result) + ""]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova. plugins.health.requestAuthorization -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['querySteps'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    var queryParams = gs.map().add("startDate",startDate).add("endDate",endDate).add("dataType","steps").add("limit",50000);
    return gs.mc(gSobject,"nativeQuery",[queryParams, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query steps -> success: " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query steps -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryBloodPressure'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    var queryParams = gs.map().add("startDate",startDate).add("endDate",endDate).add("dataType","blood_pressure").add("limit",2000);
    return gs.mc(gSobject,"nativeQuery",[queryParams, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query blood_pressure -> success: " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query blood_pressure -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryHeartRate'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    var queryParams = gs.map().add("startDate",startDate).add("endDate",endDate).add("dataType","heart_rate").add("limit",50000);
    return gs.mc(gSobject,"nativeQuery",[queryParams, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query heart_rate -> success: " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query heart_rate -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryAggregatedSteps'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    var queryParams = gs.map().add("startDate",startDate).add("endDate",endDate).add("dataType","steps").add("bucket","day");
    return gs.mc(gSobject,"nativeQueryAggregated",[queryParams, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins. health.queryAggregated steps -> success"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova. plugins.health.queryAggregated steps -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['isAuthorizedForHealth'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    datatypes = gs.map().add("read",gs.list(["steps"]));
    return gs.mc(gSobject,"nativeIsAuthorized",[datatypes, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.isAuthorized health -> success: " + (result) + ""]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.isAuthorized health -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject.nativeIsAvailable = function(successCallback, errorCallback) {
    try {
            if (! Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.isAvailable(
                function(available) {
                    successCallback(available);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins.health.isAvailable:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeRequestAuthorization = function(datatypes, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.requestAuthorization(
                datatypes,
                function(result) {
                    successCallback(result);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins.health.requestAuthorization:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeQuery = function(queryParams, successCallback, errorCallback) {
    try {
            if (! Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.query(
                queryParams,
                function(result) {
                    successCallback(result);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins. health.query:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeQueryAggregated = function(queryParams, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.queryAggregated(
                queryParams,
                function(result) {
                    successCallback(result);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins.health.queryAggregated:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeIsAuthorized = function(datatypes, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.isAuthorized(
                datatypes,
                function(result) {
                    successCallback(result);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins.health.isAuthorized:', e);
            errorCallback(e.toString());
        }
   }
  gSobject['CordovaHealth0'] = function(it) {
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaHealth0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppCameraComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppCameraComponent', simpleName: 'TestAppCameraComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/camera";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppCameraComponent: created"]);
    gs.sp(gSobject.scope,"photoUri","");
    gs.sp(gSobject.scope,"photos",gs.list([]));
    gs.sp(gSobject.scope,"error","");
    return gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
   }
  gSobject['takePhoto'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppCameraComponent: takePhoto"]);
    gs.sp(gSobject.scope,"error","");
    return gs.mc(gs.fs('cordovaPhoto', this, gSobject),"takePhoto",[function(imageUri) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppCameraComponent: photo taken: " + (imageUri) + ""]);
      return gs.mc(gSobject,"convertToDataUrl",[imageUri]);
     }, function(error) {
      return gs.sp(gSobject.scope,"error","Camera error: " + (error) + "");
     }]);
   }
  gSobject['takePhotoFromGallery'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppCameraComponent: takePhotoFromGallery"]);
    gs.sp(gSobject.scope,"error","");
    return gs.mc(gs.fs('cordovaPhoto', this, gSobject),"pickFromLibrary",[function(imageUri) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppCameraComponent: gallery photo: " + (imageUri) + ""]);
      return gs.mc(gSobject,"convertToDataUrl",[imageUri]);
     }, function(error) {
      return gs.sp(gSobject.scope,"error","Gallery error: " + (error) + "");
     }]);
   }
  gSobject['convertToDataUrl'] = function(imageUri) {
    return gs.mc(gs.fs('cordovaFile', this, gSobject),"blobFromFileUrl",[imageUri, function(blob) {
      return gs.execStatic(Utils,'blobToDataUrl', this,[blob, function(dataUrl) {
        gs.sp(gSobject.scope,"photoUri",dataUrl);
        gs.sp(gSobject.scope,"photos",(gs.plus(gs.list([gs.map().add("uri",dataUrl).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"photos"))));
        if (gs.mc(gs.gp(gSobject.scope,"photos"),"size",[]) > 10) {
          return gs.sp(gSobject.scope,"photos",(gs.rangeFromList(gs.gp(gSobject.scope,"photos"), 0, 9)));
         };
       }]);
     }, function(err) {
      return gs.sp(gSobject.scope,"error","File read error: " + (err) + "");
     }]);
   }
  gSobject['clearPhotos'] = function(it) {
    gs.sp(gSobject.scope,"photos",gs.list([]));
    gs.sp(gSobject.scope,"photoUri","");
    return gs.mc(gs.fs('cordovaPhoto', this, gSobject),"clearCache",[]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaCalendar() {
  var gSobject = gs.init('CordovaCalendar');
  gSobject.clazz = { name: 'CordovaCalendar', simpleName: 'CordovaCalendar'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['createEvent'] = function(title, location, notes, startDate, endDate, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeCreateEvent",[title, location, notes, startDate, endDate, success, error]);
   }
  gSobject['createEventInteractively'] = function(title, location, notes, startDate, endDate, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeCreateEventInteractively",[title, location, notes, startDate, endDate, success, error]);
   }
  gSobject['findEvent'] = function(title, location, notes, startDate, endDate, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeFindEvent",[title, location, notes, startDate, endDate, success, error]);
   }
  gSobject['deleteEvent'] = function(title, location, notes, startDate, endDate, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeDeleteEvent",[title, location, notes, startDate, endDate, success, error]);
   }
  gSobject['listCalendars'] = function(success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeListCalendars",[success, error]);
   }
  gSobject['openCalendar'] = function(date) {
    if (date === undefined) date = null;
    return gs.mc(gSobject,"nativeOpenCalendar",[date]);
   }
  gSobject.nativeCreateEvent = function(title, location, notes, startDate, endDate, success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.createEvent(title, location, notes, startDate, endDate, success, error); }
        else { if (error) error('Calendar not available'); }
   }
  gSobject.nativeCreateEventInteractively = function(title, location, notes, startDate, endDate, success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.createEventInteractively(title, location, notes, startDate, endDate, success, error); }
        else { if (error) error('Calendar not available'); }
   }
  gSobject.nativeFindEvent = function(title, location, notes, startDate, endDate, success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.findEvent(title, location, notes, startDate, endDate, success, error); }
        else { if (success) success([]); }
   }
  gSobject.nativeDeleteEvent = function(title, location, notes, startDate, endDate, success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.deleteEvent(title, location, notes, startDate, endDate, success, error); }
        else { if (error) error('Calendar not available'); }
   }
  gSobject.nativeListCalendars = function(success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.listCalendars(success, error); }
        else { if (success) success([]); }
   }
  gSobject.nativeOpenCalendar = function(date) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.openCalendar(date); }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function VueDateComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueDateComponent', simpleName: 'VueDateComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.toJavascript(gs.list(["modelValue" , "label" , "onSelect" , "outlined" , "filled" , "standout" , "borderless" , "square" , "dark" , "clearable" , "required" , "autoClose" , "format" , "time"]));
  gSobject.data = function(it) {
    return gs.map().add("dateString","").add("selectedDate","").add("selectedTime","").add("hasTime",false).add("showDate",false).add("showTime",false).add("rules",gs.list(["val => false"])).add("autoCloseData",true).add("formatData","DD MMM YYYY");
   };
  gSobject['mounted'] = function(it) {
    var self = this;
    gs.sp(self,"hasTime",(gs.equals(gs.gp(self,"time"), "")));
    if (gs.bool(gs.gp(self,"hasTime"))) {
      gs.sp(self,"formatData","DD MMM YYYY HH:mm");
     };
    if (gs.bool(gs.gp(self,"required"))) {
      gs.sp(self,"rules",gs.list(["date"]));
     };
    if (gs.equals(gs.gp(self,"autoClose"), "false")) {
      gs.sp(self,"autoCloseData",false);
     };
    if (gs.bool(gs.gp(self,"format"))) {
      gs.sp(self,"formatData",gs.gp(self,"format"));
     };
    return gs.mc(gSobject,"updateDate",[self, gs.gp(self,"modelValue")]);
   }
  gSobject['updateDate'] = function(self, date) {
    gs.sp(this,"modelValue",date);
    gs.sp(self,"dateString",(gs.bool(date) ? gs.mc(gs.mc(gSobject,"moment",[date]),"format",[gs.gp(self,"formatData")]) : null));
    return gs.mc(self,"$emit",["update:modelValue", date]);
   }
  gSobject['clearDate'] = function(it) {
    gs.sp(this,"modelValue",null);
    gs.sp(this,"dateString",null);
    return gs.mc(gSobject.self,"$emit",["update:modelValue", gs.fs('date', this, gSobject)]);
   }
  gSobject['openDate'] = function(it) {
    return gs.sp(this,"showDate",true);
   }
  gSobject['closeAll'] = function(it) {
    gs.sp(this,"showDate",false);
    return gs.sp(this,"showTime",false);
   }
  gSobject['selectedDateString'] = function(dateStringValue) {
    if (!gs.bool(dateStringValue)) {
      return null;
     };
    gs.mc(gSobject,"updateDate",[this, gs.date(dateStringValue)]);
    var self = this;
    gs.sp(this,"showDate",false);
    if (gs.bool(gs.gp(self,"hasTime"))) {
      return gs.sp(this,"showTime",true);
     };
   }
  gSobject['selectedTimeString'] = function(timeStringValue) {
    if (!gs.bool(timeStringValue)) {
      return null;
     };
    gs.sp(this,"showTime",false);
    var timeParts = gs.mc(timeStringValue,"split",[":"]);
    gs.mc(gs.gp(gs.thisOrObject(this,gSobject),"modelValue"),"setHours",[timeParts[0]]);
    gs.mc(gs.gp(gs.thisOrObject(this,gSobject),"modelValue"),"setMinutes",[timeParts[1]]);
    return gs.mc(gSobject,"updateDate",[this, gs.gp(gs.thisOrObject(this,gSobject),"modelValue")]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppSpinnerComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppSpinnerComponent', simpleName: 'TestAppSpinnerComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/spinner";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppSpinnerComponent: created"]);
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"available",false);
    return gs.sp(gSobject.scope,"platform","");
   }
  gSobject['afterMounted'] = function(it) {
    gs.sp(gSobject.scope,"available",gs.execStatic(CordovaDevice,'spinnerInstalled', this,[]));
    gs.sp(gSobject.scope,"platform",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device",true),"platform",true)) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device",true),"platform",true) , "unknown"));
    return gs.mc(gSobject,"addLog",["i3 native spinner: " + (gs.gp(gSobject.scope,"available")) + ", platform: " + (gs.gp(gSobject.scope,"platform")) + ""]);
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 20) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 19)));
     };
   }
  gSobject['showSpinner'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"showSpinner",["Loading...", true]);
    gs.mc(gSobject,"addLog",["Spinner shown (3s)"]);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"hideSpinner",[]);
     }, 3000]);
   }
  gSobject['showSpinnerNoMessage'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"showSpinner",["", false]);
    gs.mc(gSobject,"addLog",["Spinner shown — no message (3s)"]);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"hideSpinner",[]);
     }, 3000]);
   }
  gSobject['showSpinnerFixed'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"showSpinner",["Processing data...", false]);
    gs.mc(gSobject,"addLog",["Spinner shown — non-cancelable (5s)"]);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"hideSpinner",[]);
     }, 5000]);
   }
  gSobject['hideSpinner'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"hideSpinner",[]);
    return gs.mc(gSobject,"addLog",["Spinner hidden"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaBgGps() {
  var gSobject = gs.init('CordovaBgGps');
  gSobject.clazz = { name: 'CordovaBgGps', simpleName: 'CordovaBgGps'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'HIGH_ACCURACY', { get: function() { return CordovaBgGps.HIGH_ACCURACY; }, set: function(gSval) { CordovaBgGps.HIGH_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'BALANCED_ACCURACY', { get: function() { return CordovaBgGps.BALANCED_ACCURACY; }, set: function(gSval) { CordovaBgGps.BALANCED_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'LOW_ACCURACY', { get: function() { return CordovaBgGps.LOW_ACCURACY; }, set: function(gSval) { CordovaBgGps.LOW_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'PASSIVE_ACCURACY', { get: function() { return CordovaBgGps.PASSIVE_ACCURACY; }, set: function(gSval) { CordovaBgGps.PASSIVE_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MEDIUM_ACCURACY', { get: function() { return CordovaBgGps.MEDIUM_ACCURACY; }, set: function(gSval) { CordovaBgGps.MEDIUM_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'GEOFENCE_ENTER', { get: function() { return CordovaBgGps.GEOFENCE_ENTER; }, set: function(gSval) { CordovaBgGps.GEOFENCE_ENTER = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'GEOFENCE_EXIT', { get: function() { return CordovaBgGps.GEOFENCE_EXIT; }, set: function(gSval) { CordovaBgGps.GEOFENCE_EXIT = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'GEOFENCE_DWELL', { get: function() { return CordovaBgGps.GEOFENCE_DWELL; }, set: function(gSval) { CordovaBgGps.GEOFENCE_DWELL = gSval; }, enumerable: true });
  gSobject.lastLocation = null;
  gSobject.started = false;
  gSobject.compassHeading = 0;
  gSobject.acceleration = gs.map().add("x",0).add("y",0).add("z",0);
  gSobject.linearAccel = gs.map().add("x",0).add("y",0).add("z",0);
  gSobject.motionMagnitude = 0;
  gSobject.isMoving = false;
  gSobject.motionState = "unknown";
  Object.defineProperty(gSobject, 'STILL_SPEED', { get: function() { return CordovaBgGps.STILL_SPEED; }, set: function(gSval) { CordovaBgGps.STILL_SPEED = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'FAST_SPEED', { get: function() { return CordovaBgGps.FAST_SPEED; }, set: function(gSval) { CordovaBgGps.FAST_SPEED = gSval; }, enumerable: true });
  gSobject.lastSpeedMps = null;
  Object.defineProperty(gSobject, 'STILL_THRESHOLD', { get: function() { return CordovaBgGps.STILL_THRESHOLD; }, set: function(gSval) { CordovaBgGps.STILL_THRESHOLD = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MOVING_THRESHOLD', { get: function() { return CordovaBgGps.MOVING_THRESHOLD; }, set: function(gSval) { CordovaBgGps.MOVING_THRESHOLD = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'FAST_THRESHOLD', { get: function() { return CordovaBgGps.FAST_THRESHOLD; }, set: function(gSval) { CordovaBgGps.FAST_THRESHOLD = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'singletonInstance', { get: function() { return CordovaBgGps.singletonInstance; }, set: function(gSval) { CordovaBgGps.singletonInstance = gSval; }, enumerable: true });
  gSobject.compassListening = false;
  gSobject.accelListening = false;
  gSobject.onMotionStateCallback = function(it) {
   };
  gSobject.onLocationCallback = function(it) {
   };
  gSobject.onStationaryCallback = function(it) {
   };
  gSobject.onActivityCallback = function(it) {
   };
  gSobject.onGeofenceCallback = function(it) {
   };
  gSobject.onErrorCallback = function(it) {
   };
  gSobject.defaultConfig = gs.map().add("debug",false).add("desiredAccuracy",CordovaBgGps.BALANCED_ACCURACY).add("notificationTitle","GPS tracking").add("notificationText","Location tracking active").add("startOnBoot",false).add("stopOnTerminate",false);
  gSobject.currentConfig = gs.map();
  gSobject.instance = function() { return CordovaBgGps.instance(); }
  gSobject['config'] = function(cfg) {
    gs.mc(gSobject.currentConfig,'leftShift', gs.list([cfg]));
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[gSobject.currentConfig]);
     };
    gs.mc(gSobject,"configureTelemetry",[]);
    return this;
   }
  gSobject['getConfig'] = function(it) {
    return gSobject.currentConfig;
   }
  gSobject['start'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: BackgroundGeolocation not available"]);
      return this;
     };
    if (gs.bool(gSobject.started)) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[gSobject.currentConfig]);
    gs.mc(gSobject,"configureTelemetry",[]);
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"start",[]);
    gSobject.started = true;
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: started"]);
    return this;
   }
  gSobject['stop'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"stop",[]);
    gSobject.started = false;
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: stopped"]);
    return this;
   }
  gSobject['switchToHighAccuracy'] = function(it) {
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"switchMode",[1]);
     };
    return this;
   }
  gSobject['switchToBalanced'] = function(it) {
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"switchMode",[0]);
     };
    return this;
   }
  gSobject['getCurrentLocation'] = function(successCallback, failedCallback, config) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    if (config === undefined) config = gs.map();
    var callbackWrapper = function(location) {
      var normalized = gs.mc(gSobject,"normalizeLocation",[location]);
      gSobject.lastLocation = normalized;
      gs.execCall(successCallback, this, [normalized]);
      return gs.mc(gSobject,"persistLocation",[normalized]);
     };
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getCurrentLocation",[callbackWrapper, failedCallback, gs.mc(gs.map().add("enableHighAccuracy",true).add("maximumAge",gs.multiply((gs.multiply(4, 60)), 1000)).add("timeout",gs.multiply(60, 1000)),'leftShift', gs.list([config]))]);
     } else {
      if (gs.mc(gSobject,"navigatorGeoDefined",[])) {
        gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"geolocation"),"getCurrentPosition",[function(position) {
          return gs.execCall(callbackWrapper, this, [gs.gp(position,"coords")]);
         }, failedCallback, gs.map().add("enableHighAccuracy",true).add("maximumAge",30000).add("timeout",30000)]);
       } else {
        gs.execCall(failedCallback, this, [gs.map().add("code",2).add("message","GPS not available")]);
       };
     };
    return this;
   }
  gSobject['onLocation'] = function(successCallback, failedCallback) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    gSobject.onLocationCallback = successCallback;
    gSobject.onErrorCallback = failedCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["location", function(location) {
        var normalized = gs.mc(gSobject,"normalizeLocation",[location]);
        gSobject.lastLocation = normalized;
        gs.mc(gSobject,"onLocationCallback",[normalized]);
        return gs.mc(gSobject,"persistLocation",[normalized]);
       }]);
     };
    return this;
   }
  gSobject['onStationary'] = function(stationaryCallback, failedCallback) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    gSobject.onStationaryCallback = stationaryCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["stationary", function(location) {
        var normalized = gs.mc(gSobject,"normalizeLocation",[location]);
        gSobject.lastLocation = normalized;
        return gs.mc(gSobject,"onStationaryCallback",[normalized]);
       }]);
     };
    return this;
   }
  gSobject['onActivity'] = function(activityCallback) {
    gSobject.onActivityCallback = activityCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["activity", function(activity) {
        return gs.mc(gSobject,"onActivityCallback",[activity]);
       }]);
     };
    return this;
   }
  gSobject['onMotionState'] = function(callback) {
    gSobject.onMotionStateCallback = callback;
    return this;
   }
  gSobject['isDeviceMoving'] = function(it) {
    return gSobject.isMoving;
   }
  gSobject['onError'] = function(errorCallback) {
    gSobject.onErrorCallback = errorCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["error", function(error) {
        return gs.mc(gSobject,"onErrorCallback",[error]);
       }]);
     };
    return this;
   }
  gSobject['addGeofence'] = function(fence) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"addGeofence",[fence, function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: geofence added: " + (gs.gp(fence,"id")) + ""]);
     }, function(error) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: geofence error: " + (error) + ""]);
     }]);
    return this;
   }
  gSobject['addGeofences'] = function(fences) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"addGeofences",[fences, function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: " + (gs.mc(fences,"size",[])) + " geofences added"]);
     }, function(error) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: geofences error: " + (error) + ""]);
     }]);
    return this;
   }
  gSobject['removeGeofence'] = function(id) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"removeGeofence",[id]);
    return this;
   }
  gSobject['removeAllGeofences'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"removeAllGeofences",[]);
    return this;
   }
  gSobject['getGeofences'] = function(callback) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.execCall(callback, this, [gs.list([])]);
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getGeofences",[callback]);
    return this;
   }
  gSobject['onGeofence'] = function(geofenceCallback) {
    gSobject.onGeofenceCallback = geofenceCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["geofence", function(event) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: geofence event: " + (gs.gp(event,"fenceId")) + " " + (gs.gp(event,"transition")) + ""]);
        return gs.mc(gSobject,"onGeofenceCallback",[event]);
       }]);
     };
    return this;
   }
  gSobject['getGeofenceEvents'] = function(callback) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.execCall(callback, this, [gs.list([])]);
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getGeofenceEvents",[callback]);
    return this;
   }
  gSobject['checkStatus'] = function(callback) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.execCall(callback, this, [gs.map().add("isRunning",false)]);
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"checkStatus",[callback]);
    return this;
   }
  gSobject['getName'] = function(it) {
    return "CordovaBgGps";
   }
  gSobject['sync'] = function(it) {
    return this;
   }
  gSobject['normalizeLocation'] = function(location) {
    if (gs.gp(location,"speed") != null) {
      gSobject.lastSpeedMps = gs.gp(location,"speed");
     };
    var speed = gs.gp(location,"speed");
    if ((speed != null) && (speed < CordovaBgGps.STILL_SPEED)) {
      speed = 0;
     };
    gSobject.motionState = gs.mc(gSobject,"classifyMotion",[]);
    gSobject.isMoving = (gSobject.motionState != "still");
    return gs.map().add("fixId",gs.execStatic(Utils,'uuid', this,[])).add("provider",gs.elvis(gs.bool(gs.gp(location,"provider")) , gs.gp(location,"provider") , "gps")).add("unixTimeMs",gs.elvis(gs.bool(gs.gp(location,"time")) , gs.gp(location,"time") , gs.mc(gs.date(),"getTime",[]))).add("accuracy",gs.gp(location,"accuracy")).add("speed",speed).add("altitude",gs.gp(location,"altitude")).add("latitude",gs.gp(location,"latitude")).add("longitude",gs.gp(location,"longitude")).add("bearing",gs.elvis(gs.bool(gs.gp(location,"bearing")) , gs.gp(location,"bearing") , 0)).add("heading",gSobject.compassHeading).add("motionState",gSobject.motionState).add("motionMagnitude",gSobject.motionMagnitude).add("service","CordovaBgGps").add("user",gs.gp(gs.fs('session', this, gSobject),"userId")).add("uuid",gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device",true),"uuid",true));
   }
  gSobject['persistLocation'] = function(location) {
    if (gs.mc(gSobject,"telemetryDefined",[])) {
      return null;
     };
    try {
      gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userLocation",[location]),"do",[]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: persistLocation error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['configureTelemetry'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"telemetryDefined",[]))) {
      return null;
     };
    try {
      gs.mc(gs.fs('DymicoTelemetry', this, gSobject),"configure",[gs.map().add("syncUrl",gs.plus(gs.mc(gSobject,"originUrl",[]), "/cordovaTelemetryApi/telemetry")).add("user",gs.gp(gs.fs('session', this, gSobject),"userId")).add("uuid",gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device",true),"uuid",true)).add("syncIntervalMs",30000)]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: configureTelemetry error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['getBufferStats'] = function(callback) {
    if ((gs.mc(gSobject,"telemetryDefined",[])) && (gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getBufferStats",[callback]);
     } else {
      gs.execCall(callback, this, [gs.map().add("bound",false).add("unsynced",0)]);
     };
    return this;
   }
  gSobject['flushSync'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    if (gs.mc(gSobject,"telemetryDefined",[])) {
      gs.mc(gs.fs('DymicoTelemetry', this, gSobject),"flushNow",[callback]);
     };
    return this;
   }
  gSobject['recentTelemetry'] = function(opts, callback) {
    if (gs.mc(gSobject,"telemetryDefined",[])) {
      gs.mc(gs.fs('DymicoTelemetry', this, gSobject),"query",[opts, callback]);
     } else {
      gs.execCall(callback, this, [gs.list([])]);
     };
    return this;
   }
  gSobject['setupAuthorizationHandler'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return null;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["authorization", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: authorization status: " + (status) + ""]);
      if (status !== gs.gp(gs.fs('BackgroundGeolocation', this, gSobject),"AUTHORIZED")) {
        return gs.execStatic(Utils,'setTimeout', this,[function(it) {
          var showSettings = gs.mc(this,"confirm",["App requires location tracking permission. Would you like to open app settings?"], gSobject);
          if (gs.bool(showSettings)) {
            return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"showAppSettings",[]);
           };
         }, 500]);
       };
     }]);
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["foreground", function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: app foreground"]);
     }]);
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["background", function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: app background"]);
     }]);
   }
  gSobject.bgGeoDefined = function() {
    return typeof BackgroundGeolocation !== 'undefined';
   }
  gSobject.navigatorGeoDefined = function() {
    return typeof navigator !== 'undefined' && navigator.geolocation;
   }
  gSobject.telemetryDefined = function() {
    return typeof DymicoTelemetry !== 'undefined';
   }
  gSobject.originUrl = function() {
    return (typeof window !== 'undefined' && window.location && window.location.origin) ? window.location.origin : '';
   }
  gSobject['setupCompass'] = function(it) {
    if (gs.bool(gSobject.compassListening)) {
      return null;
     };
    if (CordovaBgGps.deviceOrientationAvailable()) {
      var handler = function(event) {
        if (gs.gp(event,"webkitCompassHeading") != null) {
          return gSobject.compassHeading = Math.round(gs.gp(event,"webkitCompassHeading"));
         } else {
          if (gs.gp(event,"alpha") != null) {
            return gSobject.compassHeading = Math.round(gs.gp(event,"alpha"));
           };
         };
       };
      gs.mc(gSobject,"addOrientationListener",[handler]);
      gSobject.compassListening = true;
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: compass listener started"]);
     } else {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: DeviceOrientation API not available"]);
     };
   }
  gSobject.addOrientationListener = function(handler) {
    // iOS 13+ requires explicit permission via user gesture
        if (typeof DeviceOrientationEvent.requestPermission === 'function') {
            // Defer: register a one-time touch handler to request permission
            var requestOnce = function() {
                document.removeEventListener('touchend', requestOnce);
                document.removeEventListener('click', requestOnce);
                DeviceOrientationEvent.requestPermission().then(function(state) {
                    if (state === 'granted') {
                        window.addEventListener('deviceorientation', handler, true);
                    }
                }).catch(function() {});
            };
            document.addEventListener('touchend', requestOnce, { once: true });
            document.addEventListener('click', requestOnce, { once: true });
        } else {
            // Android and older iOS: just add the listener
            window.addEventListener('deviceorientationabsolute', handler, true);
            window.addEventListener('deviceorientation', handler, true);
        }
   }
  gSobject.deviceOrientationAvailable = function() { return CordovaBgGps.deviceOrientationAvailable(); }
  gSobject['classifyMotion'] = function(it) {
    if (gSobject.lastSpeedMps != null) {
      if (gSobject.lastSpeedMps < CordovaBgGps.STILL_SPEED) {
        return "still";
       };
      if (gSobject.lastSpeedMps < CordovaBgGps.FAST_SPEED) {
        return "moving";
       };
      return "fast";
     };
    if (gSobject.motionMagnitude < CordovaBgGps.STILL_THRESHOLD) {
      return "still";
     };
    if (gSobject.motionMagnitude < CordovaBgGps.MOVING_THRESHOLD) {
      return "moving";
     };
    return "fast";
   }
  gSobject['setupAccelerometer'] = function(it) {
    if (gs.bool(gSobject.accelListening)) {
      return null;
     };
    if (CordovaBgGps.deviceMotionAvailable()) {
      gs.mc(gSobject,"addMotionListener",[function(event) {
        if (gs.bool(gs.gp(event,"accelerationIncludingGravity"))) {
          gSobject.acceleration = gs.map().add("x",gs.elvis(gs.bool(gs.gp(gs.gp(event,"accelerationIncludingGravity"),"x")) , gs.gp(gs.gp(event,"accelerationIncludingGravity"),"x") , 0)).add("y",gs.elvis(gs.bool(gs.gp(gs.gp(event,"accelerationIncludingGravity"),"y")) , gs.gp(gs.gp(event,"accelerationIncludingGravity"),"y") , 0)).add("z",gs.elvis(gs.bool(gs.gp(gs.gp(event,"accelerationIncludingGravity"),"z")) , gs.gp(gs.gp(event,"accelerationIncludingGravity"),"z") , 0));
         };
        if (gs.bool(gs.gp(event,"acceleration"))) {
          gSobject.linearAccel = gs.map().add("x",gs.elvis(gs.bool(gs.gp(gs.gp(event,"acceleration"),"x")) , gs.gp(gs.gp(event,"acceleration"),"x") , 0)).add("y",gs.elvis(gs.bool(gs.gp(gs.gp(event,"acceleration"),"y")) , gs.gp(gs.gp(event,"acceleration"),"y") , 0)).add("z",gs.elvis(gs.bool(gs.gp(gs.gp(event,"acceleration"),"z")) , gs.gp(gs.gp(event,"acceleration"),"z") , 0));
         };
        var ax = gs.elvis(gs.bool(gs.gp(gSobject.linearAccel,"x")) , gs.gp(gSobject.linearAccel,"x") , 0);
        var ay = gs.elvis(gs.bool(gs.gp(gSobject.linearAccel,"y")) , gs.gp(gSobject.linearAccel,"y") , 0);
        var az = gs.elvis(gs.bool(gs.gp(gSobject.linearAccel,"z")) , gs.gp(gSobject.linearAccel,"z") , 0);
        gSobject.motionMagnitude = Math.sqrt(gs.plus((gs.plus((gs.multiply(ax, ax)), (gs.multiply(ay, ay)))), (gs.multiply(az, az))));
        var prevState = gSobject.motionState;
        gSobject.motionState = gs.mc(gSobject,"classifyMotion",[]);
        gSobject.isMoving = (gSobject.motionState != "still");
        if ((prevState != gSobject.motionState) && (gs.bool(gSobject.onMotionStateCallback))) {
          return gs.mc(gSobject,"onMotionStateCallback",[gs.map().add("state",gSobject.motionState).add("magnitude",gSobject.motionMagnitude)]);
         };
       }]);
      gSobject.accelListening = true;
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: accelerometer listener started"]);
     } else {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: DeviceMotion API not available"]);
     };
   }
  gSobject.addMotionListener = function(handler) {
    window.addEventListener('devicemotion', handler, true);
   }
  gSobject.deviceMotionAvailable = function() { return CordovaBgGps.deviceMotionAvailable(); }
  gSobject['CordovaBgGps0'] = function(it) {
    gs.mc(gSobject.currentConfig,'leftShift', gs.list([gSobject.defaultConfig]));
    gs.mc(gSobject,"setupAuthorizationHandler",[]);
    gs.mc(gSobject,"setupCompass",[]);
    gs.mc(gSobject,"setupAccelerometer",[]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaBgGps0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaBgGps.instance = function(it) {
  if (!gs.bool(CordovaBgGps.singletonInstance)) {
    CordovaBgGps.singletonInstance = CordovaBgGps();
   };
  return CordovaBgGps.singletonInstance;
 }
CordovaBgGps.deviceOrientationAvailable = function() {
  return typeof DeviceOrientationEvent !== 'undefined';
 }
CordovaBgGps.deviceMotionAvailable = function() {
  return typeof DeviceMotionEvent !== 'undefined';
 }
CordovaBgGps.HIGH_ACCURACY = 0;
CordovaBgGps.BALANCED_ACCURACY = 100;
CordovaBgGps.LOW_ACCURACY = 1000;
CordovaBgGps.PASSIVE_ACCURACY = 10000;
CordovaBgGps.MEDIUM_ACCURACY = 100;
CordovaBgGps.GEOFENCE_ENTER = 1;
CordovaBgGps.GEOFENCE_EXIT = 2;
CordovaBgGps.GEOFENCE_DWELL = 4;
CordovaBgGps.STILL_SPEED = 0.7;
CordovaBgGps.FAST_SPEED = 6.0;
CordovaBgGps.STILL_THRESHOLD = 0.3;
CordovaBgGps.MOVING_THRESHOLD = 1.5;
CordovaBgGps.FAST_THRESHOLD = 5.0;
CordovaBgGps.singletonInstance = null;

function TestAppGpsComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppGpsComponent', simpleName: 'TestAppGpsComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/gps";
  gSobject.roles = gs.list([]);
  gSobject.gps = null;
  gSobject.sensorInterval = null;
  gSobject.onlineHandler = null;
  gSobject.offlineHandler = null;
  gSobject.leafletMap = null;
  gSobject.mapMarker = null;
  gSobject.accuracyCircle = null;
  Object.defineProperty(gSobject, 'connectionTypes', { get: function() { return TestAppGpsComponent.connectionTypes; }, set: function(gSval) { TestAppGpsComponent.connectionTypes = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'locationTypes', { get: function() { return TestAppGpsComponent.locationTypes; }, set: function(gSval) { TestAppGpsComponent.locationTypes = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'motionTypes', { get: function() { return TestAppGpsComponent.motionTypes; }, set: function(gSval) { TestAppGpsComponent.motionTypes = gSval; }, enumerable: true });
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppGpsComponent: created"]);
    gs.sp(gSobject.scope,"location",gs.map());
    gs.sp(gSobject.scope,"tracking",false);
    gs.sp(gSobject.scope,"activity","");
    gs.sp(gSobject.scope,"status",gs.map());
    gs.sp(gSobject.scope,"history",gs.list([]));
    gs.sp(gSobject.scope,"filteredHistory",gs.list([]));
    gs.sp(gSobject.scope,"error","");
    gs.sp(gSobject.scope,"compassDeg",0);
    gs.sp(gSobject.scope,"historyFilter","All");
    gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
    gs.sp(gSobject.scope,"followMap",true);
    gs.sp(gSobject.scope,"accel",gs.map().add("x",0).add("y",0).add("z",0));
    gs.sp(gSobject.scope,"linearAccel",gs.map().add("x",0).add("y",0).add("z",0));
    gs.sp(gSobject.scope,"motionMagnitude",0);
    gs.sp(gSobject.scope,"motionState","unknown");
    return gSobject.gps = gs.execStatic(CordovaBgGps,'instance', this,[]);
   }
  gSobject['afterMounted'] = function(it) {
    gs.mc(gSobject,"fetchLocation",[]);
    gs.mc(gSobject,"startSensorWatch",[]);
    gs.mc(gSobject,"startNetworkWatch",[]);
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"initMap",[]);
     }, 0]);
    return gs.mc(gSobject.gps,"onMotionState",[function(event) {
      gs.sp(gSobject.scope,"motionState",gs.gp(event,"state"));
      return gs.mc(gSobject,"addHistory",["Motion", "" + (gs.gp(event,"state")) + " (magnitude: " + (gs.div(Math.round(gs.multiply(gs.gp(event,"magnitude"), 100)), 100)) + " m/s²)"]);
     }]);
   }
  gSobject['startSensorWatch'] = function(it) {
    gSobject.sensorInterval = gs.execStatic(Utils,'setInterval', this,[function(it) {
      gs.sp(gSobject.scope,"compassDeg",gs.elvis(gs.bool(gs.gp(gSobject.gps,"compassHeading")) , gs.gp(gSobject.gps,"compassHeading") , 0));
      gs.sp(gSobject.scope,"accel",gs.elvis(gs.bool(gs.gp(gSobject.gps,"acceleration")) , gs.gp(gSobject.gps,"acceleration") , gs.map().add("x",0).add("y",0).add("z",0)));
      gs.sp(gSobject.scope,"linearAccel",gs.elvis(gs.bool(gs.gp(gSobject.gps,"linearAccel")) , gs.gp(gSobject.gps,"linearAccel") , gs.map().add("x",0).add("y",0).add("z",0)));
      gs.sp(gSobject.scope,"motionMagnitude",gs.elvis(gs.bool(gs.gp(gSobject.gps,"motionMagnitude")) , gs.gp(gSobject.gps,"motionMagnitude") , 0));
      return gs.sp(gSobject.scope,"motionState",gs.elvis(gs.bool(gs.gp(gSobject.gps,"motionState")) , gs.gp(gSobject.gps,"motionState") , "unknown"));
     }, 300]);
    return gs.mc(gSobject,"addHistory",["Sensors", "Compass + accelerometer watch started"]);
   }
  gSobject['startNetworkWatch'] = function(it) {
    gSobject.offlineHandler = function(it) {
      return gs.mc(gSobject,"addHistory",["Offline", "Internet connection lost"]);
     };
    gSobject.onlineHandler = function(it) {
      return gs.mc(gSobject,"addHistory",["Online", "Internet connection restored"]);
     };
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["offline", gSobject.offlineHandler, false]);
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["online", gSobject.onlineHandler, false]);
    var online = gs.gp(gs.fs('navigator', this, gSobject),"onLine");
    return gs.mc(gSobject,"addHistory",["Network", (gs.bool(online) ? "Connected" : "No connection")]);
   }
  gSobject['fetchLocation'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppGpsComponent: fetchLocation"]);
    gs.sp(gSobject.scope,"error","");
    return gs.mc(gSobject.gps,"getCurrentLocation",[function(loc) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppGpsComponent: got location: " + (gs.gp(loc,"latitude")) + ", " + (gs.gp(loc,"longitude")) + ""]);
      gs.sp(gSobject.scope,"location",loc);
      gs.sp(gSobject.scope,"compassDeg",gs.elvis(gs.bool(gs.gp(gSobject.gps,"compassHeading")) , gs.gp(gSobject.gps,"compassHeading") , gs.elvis(gs.bool(gs.gp(loc,"bearing")) , gs.gp(loc,"bearing") , 0)));
      gs.mc(gSobject,"updateMap",[loc]);
      return gs.mc(gSobject,"addHistory",["Fix", "Lat: " + (gs.gp(loc,"latitude")) + ", Lng: " + (gs.gp(loc,"longitude")) + ", Bear: " + (gs.elvis(gs.bool(gs.gp(loc,"bearing")) , gs.gp(loc,"bearing") , "N/A")) + ", Head: " + (gs.elvis(gs.bool(gs.gp(loc,"heading")) , gs.gp(loc,"heading") , "N/A")) + ", Spd: " + (gs.elvis(gs.bool(gs.gp(loc,"speed")) , gs.gp(loc,"speed") , 0)) + ""]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppGpsComponent: error: " + (err) + ""]);
      return gs.sp(gSobject.scope,"error","Location error: " + (gs.elvis(gs.bool(gs.gp(err,"message")) , gs.gp(err,"message") , err)) + "");
     }]);
   }
  gSobject['startTracking'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppGpsComponent: startTracking"]);
    gs.sp(gSobject.scope,"error","");
    gs.mc(gs.mc(gs.mc(gs.mc(gs.mc(gs.mc(gSobject.gps,"config",[gs.map().add("desiredAccuracy",gs.gp(CordovaBgGps,"HIGH_ACCURACY")).add("debug",false)]),"onLocation",[function(loc) {
      gs.sp(gSobject.scope,"location",loc);
      gs.sp(gSobject.scope,"compassDeg",gs.elvis(gs.bool(gs.gp(gSobject.gps,"compassHeading")) , gs.gp(gSobject.gps,"compassHeading") , gs.elvis(gs.bool(gs.gp(loc,"bearing")) , gs.gp(loc,"bearing") , 0)));
      gs.mc(gSobject,"updateMap",[loc]);
      return gs.mc(gSobject,"addHistory",["Move", "Lat: " + (gs.gp(loc,"latitude")) + ", Lng: " + (gs.gp(loc,"longitude")) + ", Spd: " + (gs.elvis(gs.bool(gs.gp(loc,"speed")) , gs.gp(loc,"speed") , 0)) + ", Bear: " + (gs.elvis(gs.bool(gs.gp(loc,"bearing")) , gs.gp(loc,"bearing") , "N/A")) + ", Head: " + (gs.elvis(gs.bool(gs.gp(loc,"heading")) , gs.gp(loc,"heading") , "N/A")) + ""]);
     }]),"onStationary",[function(loc) {
      gs.sp(gSobject.scope,"location",loc);
      gs.mc(gSobject,"updateMap",[loc]);
      return gs.mc(gSobject,"addHistory",["Still", "Stationary at " + (gs.gp(loc,"latitude")) + ", " + (gs.gp(loc,"longitude")) + ""]);
     }]),"onActivity",[function(act) {
      gs.sp(gSobject.scope,"activity",gs.elvis(gs.bool(gs.gp(act,"type")) , gs.gp(act,"type") , "unknown"));
      return gs.mc(gSobject,"addHistory",["Activity", "" + (gs.gp(act,"type")) + " (confidence: " + (gs.gp(act,"confidence")) + "%)"]);
     }]),"onError",[function(err) {
      return gs.sp(gSobject.scope,"error","Tracking error: " + (err) + "");
     }]),"start",[]);
    gs.sp(gSobject.scope,"tracking",true);
    return gs.mc(gSobject,"addHistory",["Start", "Live tracking started — locations auto-saved via CordovaBgGps"]);
   }
  gSobject['stopTracking'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppGpsComponent: stopTracking"]);
    gs.mc(gSobject.gps,"stop",[]);
    gs.sp(gSobject.scope,"tracking",false);
    return gs.mc(gSobject,"addHistory",["Stop", "Tracking stopped"]);
   }
  gSobject['switchAccuracy'] = function(mode) {
    if (gs.equals(mode, "high")) {
      gs.mc(gSobject.gps,"switchToHighAccuracy",[]);
      return gs.mc(gSobject,"addHistory",["Mode", "Switched to HIGH accuracy"]);
     } else {
      gs.mc(gSobject.gps,"switchToBalanced",[]);
      return gs.mc(gSobject,"addHistory",["Mode", "Switched to BALANCED accuracy"]);
     };
   }
  gSobject['checkStatus'] = function(it) {
    return gs.mc(gSobject.gps,"checkStatus",[function(s) {
      gs.sp(gSobject.scope,"status",s);
      return gs.mc(gSobject,"addHistory",["Status", "Running: " + (gs.gp(s,"isRunning")) + ", Auth: " + (gs.gp(s,"authorization")) + ""]);
     }]);
   }
  gSobject['initMap'] = function(it) {
    if (!gs.bool(gs.gp(gs.fs('window', this, gSobject),"L"))) {
      gs.mc(gSobject,"addHistory",["Sensors", "Leaflet failed to load"]);
      return null;
     };
    gSobject.leafletMap = gs.mc(gs.mc(gs.fs('L', this, gSobject),"map",["gpsMapContainer"]),"setView",[gs.list([0 , 0]), 2]);
    gs.mc(gs.mc(gs.fs('L', this, gSobject),"tileLayer",["https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", gs.map().add("attribution","&copy; OpenStreetMap").add("maxZoom",19)]),"addTo",[gSobject.leafletMap]);
    if ((gs.bool(gs.gp(gs.gp(gSobject.scope,"location"),"latitude",true))) && (gs.bool(gs.gp(gs.gp(gSobject.scope,"location"),"longitude",true)))) {
      return gs.mc(gSobject,"updateMap",[gs.gp(gSobject.scope,"location")]);
     };
   }
  gSobject['updateMap'] = function(loc) {
    if (((!gs.bool(gSobject.leafletMap)) || (!gs.bool(gs.gp(loc,"latitude",true)))) || (!gs.bool(gs.gp(loc,"longitude",true)))) {
      return null;
     };
    var latlng = gs.list([gs.gp(loc,"latitude") , gs.gp(loc,"longitude")]);
    if (!gs.bool(gSobject.mapMarker)) {
      gSobject.mapMarker = gs.mc(gs.mc(gs.fs('L', this, gSobject),"marker",[latlng]),"addTo",[gSobject.leafletMap]);
      gs.mc(gSobject.leafletMap,"setView",[latlng, 17]);
     } else {
      gs.mc(gSobject.mapMarker,"setLatLng",[latlng]);
     };
    if (gs.bool(gs.gp(loc,"accuracy"))) {
      if (!gs.bool(gSobject.accuracyCircle)) {
        gSobject.accuracyCircle = gs.mc(gs.mc(gs.fs('L', this, gSobject),"circle",[latlng, gs.map().add("radius",gs.gp(loc,"accuracy")).add("color","#2196F3").add("weight",1).add("fillOpacity",0.15)]),"addTo",[gSobject.leafletMap]);
       } else {
        gs.mc(gSobject.accuracyCircle,"setLatLng",[latlng]);
        gs.mc(gSobject.accuracyCircle,"setRadius",[gs.gp(loc,"accuracy")]);
       };
     };
    if (gs.bool(gs.gp(gSobject.scope,"followMap"))) {
      return gs.mc(gSobject.leafletMap,"panTo",[latlng]);
     };
   }
  gSobject['recenterMap'] = function(it) {
    if (((gs.bool(gSobject.leafletMap)) && (gs.bool(gs.gp(gs.gp(gSobject.scope,"location"),"latitude",true)))) && (gs.bool(gs.gp(gs.gp(gSobject.scope,"location"),"longitude",true)))) {
      return gs.mc(gSobject.leafletMap,"setView",[gs.list([gs.gp(gs.gp(gSobject.scope,"location"),"latitude") , gs.gp(gs.gp(gSobject.scope,"location"),"longitude")]), 17]);
     };
   }
  gSobject['toggleFollow'] = function(it) {
    gs.sp(gSobject.scope,"followMap",!gs.gp(gSobject.scope,"followMap"));
    if (((gs.bool(gs.gp(gSobject.scope,"followMap"))) && (gs.bool(gs.gp(gs.gp(gSobject.scope,"location"),"latitude",true)))) && (gs.bool(gSobject.leafletMap))) {
      return gs.mc(gSobject.leafletMap,"panTo",[gs.list([gs.gp(gs.gp(gSobject.scope,"location"),"latitude") , gs.gp(gs.gp(gSobject.scope,"location"),"longitude")])]);
     };
   }
  gSobject['addHistory'] = function(type, message) {
    gs.sp(gSobject.scope,"history",(gs.plus(gs.list([gs.map().add("type",type).add("message",message).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"history"))));
    if (gs.mc(gs.gp(gSobject.scope,"history"),"size",[]) > 200) {
      gs.sp(gSobject.scope,"history",(gs.rangeFromList(gs.gp(gSobject.scope,"history"), 0, 199)));
     };
    return gs.mc(gSobject,"recomputeFilter",[]);
   }
  gSobject['changeHistoryFilter'] = function(filter) {
    gs.sp(gSobject.scope,"historyFilter",filter);
    return gs.mc(gSobject,"recomputeFilter",[]);
   }
  gSobject['recomputeFilter'] = function(it) {
    var f = gs.gp(gSobject.scope,"historyFilter");
    if (gs.equals(f, "Connection")) {
      return gs.sp(gSobject.scope,"filteredHistory",gs.mc(gs.gp(gSobject.scope,"history"),"findAll",[function(it) {
        return gs.mc(TestAppGpsComponent.connectionTypes,"contains",[gs.gp(it,"type")]);
       }]));
     } else {
      if (gs.equals(f, "Location")) {
        return gs.sp(gSobject.scope,"filteredHistory",gs.mc(gs.gp(gSobject.scope,"history"),"findAll",[function(it) {
          return gs.mc(TestAppGpsComponent.locationTypes,"contains",[gs.gp(it,"type")]);
         }]));
       } else {
        if (gs.equals(f, "Motion")) {
          return gs.sp(gSobject.scope,"filteredHistory",gs.mc(gs.gp(gSobject.scope,"history"),"findAll",[function(it) {
            return gs.mc(TestAppGpsComponent.motionTypes,"contains",[gs.gp(it,"type")]);
           }]));
         } else {
          return gs.sp(gSobject.scope,"filteredHistory",gs.gp(gSobject.scope,"history"));
         };
       };
     };
   }
  gSobject['destroyed'] = function(it) {
    if (gs.bool(gSobject.sensorInterval)) {
      gs.execStatic(Utils,'clearInterval', this,[gSobject.sensorInterval]);
     };
    if (gs.bool(gSobject.offlineHandler)) {
      gs.mc(gs.fs('document', this, gSobject),"removeEventListener",["offline", gSobject.offlineHandler]);
     };
    if (gs.bool(gSobject.onlineHandler)) {
      gs.mc(gs.fs('document', this, gSobject),"removeEventListener",["online", gSobject.onlineHandler]);
     };
    if (gs.bool(gs.gp(gSobject.scope,"tracking"))) {
      gs.mc(gSobject.gps,"stop",[]);
     };
    if (gs.bool(gSobject.leafletMap)) {
      gs.mc(gSobject.leafletMap,"remove",[]);
      return gSobject.leafletMap = null;
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppGpsComponent.connectionTypes = gs.list(["Offline" , "Online" , "Network"]);
TestAppGpsComponent.locationTypes = gs.list(["Fix" , "Move" , "Still" , "Start" , "Stop" , "Mode" , "Status"]);
TestAppGpsComponent.motionTypes = gs.list(["Motion" , "Activity" , "Sensors"]);

function TestAppScreenshotComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppScreenshotComponent', simpleName: 'TestAppScreenshotComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/screenshot";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppScreenshotComponent: created"]);
    gs.sp(gSobject.scope,"preventing",false);
    gs.sp(gSobject.scope,"log",gs.list([]));
    return gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
   }
  gSobject['afterMounted'] = function(it) {
    gs.mc(gSobject,"screenshotWatch",[function(it) {
      return gs.mc(gSobject,"addLog",["SCREENSHOT DETECTED!"]);
     }]);
    gs.mc(gSobject,"screenshotWatchRecording",[function(result) {
      return gs.mc(gSobject,"addLog",[(gs.bool(gs.gp(result,"isRecording")) ? "SCREEN RECORDING STARTED" : "Screen recording stopped")]);
     }]);
    return gs.mc(gSobject,"addLog",["Detection active - take a screenshot or start recording to test"]);
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 20) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 19)));
     };
   }
  gSobject['togglePreventCapture'] = function(it) {
    return gs.mc(gSobject,"screenshotPreventCapture",[gs.gp(gSobject.scope,"preventing"), function(it) {
      return gs.mc(gSobject,"addLog",[(gs.bool(gs.gp(gSobject.scope,"preventing")) ? "Capture prevention ON - screen is now protected" : "Capture prevention OFF")]);
     }, function(err) {
      gs.sp(gSobject.scope,"preventing",!gs.gp(gSobject.scope,"preventing"));
      return gs.mc(gSobject,"addLog",["Error: " + (err) + ""]);
     }]);
   }
  gSobject['checkStatus'] = function(it) {
    return gs.mc(gSobject,"screenshotIsPreventingCapture",[function(result) {
      gs.sp(gSobject.scope,"preventing",gs.gp(result,"enabled"));
      return gs.mc(gSobject,"addLog",["Prevention active: " + (gs.gp(result,"enabled")) + ""]);
     }]);
   }
  gSobject.screenshotPreventCapture = function(enabled, success, error) {
    if (cordova.plugins.dymicoScreenshot) {
            cordova.plugins.dymicoScreenshot.preventCapture(enabled, success, error);
        } else { if (error) error('dymicoScreenshot not available'); }
   }
  gSobject.screenshotWatch = function(callback) {
    if (cordova.plugins.dymicoScreenshot) {
            cordova.plugins.dymicoScreenshot.onScreenshot(callback);
        }
   }
  gSobject.screenshotWatchRecording = function(callback) {
    if (cordova.plugins.dymicoScreenshot) {
            cordova.plugins.dymicoScreenshot.onScreenRecording(callback);
        }
   }
  gSobject.screenshotIsPreventingCapture = function(callback) {
    if (cordova.plugins.dymicoScreenshot) {
            cordova.plugins.dymicoScreenshot.isPreventingCapture(callback);
        } else { if (callback) callback({enabled: false}); }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppBiometricsComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppBiometricsComponent', simpleName: 'TestAppBiometricsComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/biometrics";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBiometricsComponent: created"]);
    gs.sp(gSobject.scope,"available","unknown");
    gs.sp(gSobject.scope,"biometricType","");
    gs.sp(gSobject.scope,"authResult","");
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"error","");
    gs.sp(gSobject.scope,"requireStrong",false);
    gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
    return gs.mc(gSobject,"checkAvailability",[]);
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 20) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 19)));
     };
   }
  gSobject['applyOptions'] = function(it) {
    return gs.sp(gs.fs('cordovaBiometrics', this, gSobject),"requireStrongBiometrics",gs.gp(gSobject.scope,"requireStrong"));
   }
  gSobject['checkAvailability'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBiometricsComponent: checkAvailability"]);
    gs.mc(gSobject,"applyOptions",[]);
    return gs.mc(gs.fs('cordovaBiometrics', this, gSobject),"deviceHasBiometrics",[function(result) {
      gs.sp(gSobject.scope,"available","yes");
      gs.sp(gSobject.scope,"biometricType",gs.elvis(gs.bool(gs.gp(result,"biometryType")) , gs.gp(result,"biometryType") , result));
      return gs.mc(gSobject,"addLog",["Biometrics available: " + (result) + ""]);
     }, function(error) {
      gs.sp(gSobject.scope,"available","no");
      return gs.mc(gSobject,"addLog",["Biometrics not available: " + (error) + ""]);
     }]);
   }
  gSobject['authenticate'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBiometricsComponent: authenticate"]);
    gs.sp(gSobject.scope,"error","");
    gs.sp(gSobject.scope,"authResult","");
    gs.mc(gSobject,"applyOptions",[]);
    return gs.mc(gs.fs('cordovaBiometrics', this, gSobject),"showBiometricDialog",[function(result) {
      gs.sp(gSobject.scope,"authResult","success");
      return gs.mc(gSobject,"addLog",["Auth success: " + (result) + ""]);
     }, function(error) {
      gs.sp(gSobject.scope,"authResult","failed");
      gs.sp(gSobject.scope,"error","Auth failed: " + (error) + "");
      return gs.mc(gSobject,"addLog",["Auth failed: " + (error) + ""]);
     }]);
   }
  gSobject['registerSecret'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBiometricsComponent: registerSecret"]);
    gs.sp(gSobject.scope,"error","");
    gs.mc(gSobject,"applyOptions",[]);
    return gs.mc(gs.fs('cordovaBiometrics', this, gSobject),"registerSecret",["test-app-secret-123", function(result) {
      return gs.mc(gSobject,"addLog",["Secret registered: " + (result) + ""]);
     }, function(error) {
      gs.sp(gSobject.scope,"error","Register error: " + (error) + "");
      return gs.mc(gSobject,"addLog",["Register failed: " + (error) + ""]);
     }]);
   }
  gSobject['loadSecret'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBiometricsComponent: loadSecret"]);
    gs.sp(gSobject.scope,"error","");
    gs.mc(gSobject,"applyOptions",[]);
    return gs.mc(gs.fs('cordovaBiometrics', this, gSobject),"loadSecret",[function(result) {
      return gs.mc(gSobject,"addLog",["Secret loaded: " + (result) + ""]);
     }, function(error) {
      gs.sp(gSobject.scope,"error","Load error: " + (error) + "");
      return gs.mc(gSobject,"addLog",["Load failed: " + (error) + ""]);
     }]);
   }
  gSobject['deleteSecret'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBiometricsComponent: deleteSecret"]);
    gs.sp(gSobject.scope,"error","");
    return gs.mc(gs.fs('cordovaBiometrics', this, gSobject),"deleteSecret",[function(result) {
      return gs.mc(gSobject,"addLog",["Secret deleted: " + (result) + ""]);
     }, function(error) {
      gs.sp(gSobject.scope,"error","Delete error: " + (error) + "");
      return gs.mc(gSobject,"addLog",["Delete failed: " + (error) + ""]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppErrorComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppErrorComponent', simpleName: 'TestAppErrorComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/errortest";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    return gs.sp(gSobject.scope,"log",gs.list([]));
   }
  gSobject['addLog'] = function(msg) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppError: " + (msg) + ""]);
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 29)));
     };
   }
  gSobject['triggerJsError'] = function(it) {
    gs.mc(gSobject,"addLog",["Triggering JS error..."]);
    return gs.mc(gSobject,"nativeTriggerJsError",[]);
   }
  gSobject['triggerPromiseRejection'] = function(it) {
    gs.mc(gSobject,"addLog",["Triggering unhandled promise rejection..."]);
    return gs.mc(gSobject,"nativeTriggerPromiseRejection",[]);
   }
  gSobject['triggerPluginError'] = function(it) {
    gs.mc(gSobject,"addLog",["Triggering plugin error..."]);
    return gs.mc(gSobject,"nativeTriggerPluginError",[]);
   }
  gSobject['reportProblem'] = function(it) {
    gs.mc(gSobject,"addLog",["Capturing screen and opening report page..."]);
    return gs.mc(gs.fs('cordovaScreenCapture', this, gSobject),"openProblemReport",[]);
   }
  gSobject['viewErrors'] = function(it) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/cordovaErrors"]);
   }
  gSobject.nativeTriggerJsError = function() {
    setTimeout(function() {
            var obj = null;
            obj.doesNotExist();
        }, 100);
   }
  gSobject.nativeTriggerPromiseRejection = function() {
    new Promise(function(resolve, reject) {
            reject(new Error('Test unhandled promise rejection'));
        });
   }
  gSobject.nativeTriggerPluginError = function() {
    if (window.cordova && window.cordova.exec) {
            cordova.exec(
                function() {},
                function(err) { console.log('Expected plugin error:', err); },
                'NonExistentPlugin', 'fakeAction', []
            );
        }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function PinchToZoomHandler() {
  var gSobject = gs.init('PinchToZoomHandler');
  gSobject.clazz = { name: 'PinchToZoomHandler', simpleName: 'PinchToZoomHandler'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.addPinchToZoomById = function(x0) { return PinchToZoomHandler.addPinchToZoomById(x0); }
  gSobject.addPinchToZoomByElement = function(x0) { return PinchToZoomHandler.addPinchToZoomByElement(x0); }
  gSobject.addPinchToZoomToPdf = function(x0) { return PinchToZoomHandler.addPinchToZoomToPdf(x0); }
  gSobject['PinchToZoomHandler2'] = function(id, type) {
    if (gs.equals(type, "pdf")) {
      return PinchToZoomHandler.addPinchToZoomToPdf(id);
     };
    PinchToZoomHandler.addPinchToZoomById(id);
    return this;
  }
  if (arguments.length==2) {gSobject.PinchToZoomHandler2(arguments[0], arguments[1]); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
PinchToZoomHandler.addPinchToZoomById = function(id) {
  new PinchZoom(document.getElementById(id));
 }
PinchToZoomHandler.addPinchToZoomByElement = function(element) {
  new PinchZoom(element);
 }
PinchToZoomHandler.addPinchToZoomToPdf = function(id) {
  let canvasList = document.getElementById(id).children
        for (let canvas of canvasList) {
            PinchToZoomHandler.addPinchToZoomByElement(canvas);
        }
 }

function TestAppPushComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppPushComponent', simpleName: 'TestAppPushComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/push";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppPushComponent: created"]);
    gs.sp(gSobject.scope,"token","");
    gs.sp(gSobject.scope,"notifications",gs.list([]));
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"registered",false);
    return gs.sp(gSobject.scope,"available",false);
   }
  gSobject['afterMounted'] = function(it) {
    gs.sp(gSobject.scope,"available",TestAppPushComponent.pushAvailable());
    return gs.mc(gSobject,"addLog",["PushNotification available: " + (gs.gp(gSobject.scope,"available")) + ""]);
   }
  gSobject.pushAvailable = function() { return TestAppPushComponent.pushAvailable(); }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 29)));
     };
   }
  gSobject['registerPush'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppPushComponent: registerPush"]);
    var pushInstance = gs.mc(gs.fs('PushNotification', this, gSobject),"init",[gs.map().add("android",gs.map().add("senderID","000000000000").add("icon","ic_notification").add("iconColor","#2196F3")).add("ios",gs.map().add("alert",true).add("badge",true).add("sound",true))]);
    gs.mc(pushInstance,"on",["registration", function(data) {
      gs.sp(gSobject.scope,"token",gs.gp(data,"registrationId"));
      gs.sp(gSobject.scope,"registered",true);
      return gs.mc(gSobject,"addLog",["Registered! Token: " + (gs.mc(gs.gp(data,"registrationId"),"substring",[0, 30])) + "..."]);
     }]);
    gs.mc(pushInstance,"on",["notification", function(data) {
      gs.sp(gSobject.scope,"notifications",(gs.plus(gs.list([gs.map().add("title",gs.gp(data,"title")).add("message",gs.gp(data,"message")).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"notifications"))));
      return gs.mc(gSobject,"addLog",["Notification: " + (gs.gp(data,"title")) + " - " + (gs.gp(data,"message")) + ""]);
     }]);
    gs.mc(pushInstance,"on",["error", function(e) {
      return gs.mc(gSobject,"addLog",["Push error: " + (gs.gp(e,"message")) + ""]);
     }]);
    return gs.mc(gSobject,"addLog",["Push registration started"]);
   }
  gSobject['copyToken'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"token"))) {
      gs.mc(gSobject,"doCopyToken",[gs.gp(gSobject.scope,"token")]);
      return gs.mc(gSobject,"addLog",["Token copied to clipboard"]);
     };
   }
  gSobject.doCopyToken = function(token) {
    navigator.clipboard.writeText(token);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppPushComponent.pushAvailable = function() {
  return typeof PushNotification !== 'undefined';
 }

function CordovaPhoto() {
  var gSobject = gs.init('CordovaPhoto');
  gSobject.clazz = { name: 'CordovaPhoto', simpleName: 'CordovaPhoto'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['takePhoto'] = function(onSuccess, onFail, config) {
    if (config === undefined) config = gs.map();
    return gs.mc(gSobject,"capture",["camera", onSuccess, onFail, config]);
   }
  gSobject['pickFromLibrary'] = function(onSuccess, onFail, config) {
    if (config === undefined) config = gs.map();
    return gs.mc(gSobject,"capture",["library", onSuccess, onFail, config]);
   }
  gSobject['takePhotoBlob'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    var success = function(imageUri) {
      return gs.mc(gs.fs('cordovaFile', this, gSobject),"blobFromFileUrl",[imageUri, function(blob) {
        gs.execCall(onSuccess, this, [blob]);
        return gs.mc(gSobject,"clearCache",[]);
       }, onError]);
     };
    return gs.mc(gSobject,"takePhoto",[success, onError]);
   }
  gSobject['takePhotoAndUpload'] = function(objectName, property, objectId, onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    var success = function(tempImageUrl) {
      return gs.mc(gs.fs('cordovaFile', this, gSobject),"addFile",[tempImageUrl, objectName, property, objectId, onSuccess, onError]);
     };
    return gs.mc(gSobject,"takePhoto",[success, onError]);
   }
  gSobject['clearCache'] = function(it) {
   }
  gSobject['capture'] = function(source, onSuccess, onFail, config) {
    var opts = gs.mc(gs.map().add("source",source).add("output","fileUri").add("maxWidth",1024).add("maxHeight",1024),'leftShift', gs.list([config]));
    return CordovaPhoto.pick(opts, function(result) {
      return gs.execCall(onSuccess, this, [gs.gp(result,"data")]);
     }, onFail);
   }
  gSobject.pick = function(x0,x1,x2) { return CordovaPhoto.pick(x0,x1,x2); }
  gSobject.isAvailable = function() { return CordovaPhoto.isAvailable(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaPhoto.pick = function(options, onSuccess, onFail) {
  if (typeof cordova === 'undefined' || !cordova.plugins || !cordova.plugins.dymicoPhoto) {
            return onFail('dymico-photo plugin not available');
        }
        cordova.plugins.dymicoPhoto.pick(options, onSuccess, onFail);
 }
CordovaPhoto.isAvailable = function() {
  return ( typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.dymicoPhoto !== 'undefined' );
 }

function CordovaGoogleSignIn() {
  var gSobject = gs.init('CordovaGoogleSignIn');
  gSobject.clazz = { name: 'CordovaGoogleSignIn', simpleName: 'CordovaGoogleSignIn'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.googleSignIn = function(success, error) {
    // Try new i3 plugin first, fall back to old plugin
        if (cordova.plugins.i3GoogleSignIn) {
            cordova.plugins.i3GoogleSignIn.login(function(authData) {
                success(authData);
            }, function(err) {
                if (error) error(err);
            });
        } else if (cordova.plugins.GoogleSignInPlugin) {
            cordova.plugins.GoogleSignInPlugin.signIn(function(authData) {
                success(authData);
            }, function(err) {
                if (error) error(err);
            });
        } else {
            if (error) error('No Google Sign-In plugin available');
        }
   }
  gSobject.isSignedIn = function(success, error) {
    if (cordova.plugins.GoogleSignInPlugin && cordova.plugins.GoogleSignInPlugin.isSignedIn) {
            cordova.plugins.GoogleSignInPlugin.isSignedIn(function(result) {
                success(result);
            }, function(err) { 
                if (error) error(err);
            });
        } else {
            success({isSignedIn: false});
        }
   }
  gSobject.signOut = function(success, error) {
    if (cordova.plugins.i3GoogleSignIn) {
            cordova.plugins.i3GoogleSignIn.logout(function(result) {
                if (success) success(result);
            }, function(err) {
                if (error) error(err);
            });
        } else if (cordova.plugins.GoogleSignInPlugin) {
            cordova.plugins.GoogleSignInPlugin.signOut(function(result) {
                if (success) success(result);
            }, function(err) {
                if (error) error(err);
            });
        } else {
            if (success) success();
        }
   }
  gSobject.trySilentLogin = function(success, error) {
    if (cordova.plugins.i3GoogleSignIn) {
            cordova.plugins.i3GoogleSignIn.trySilentLogin(function(result) {
                success(result);
            }, function(err) {
                if (error) error(err);
            });
        } else {
            if (error) error('Silent login not available');
        }
   }
  gSobject.isAvailable = function() { return CordovaGoogleSignIn.isAvailable(); }
  gSobject['CordovaGoogleSignIn0'] = function(it) {
    gs.mc(document,"addEventListener",["deviceready", function(it) {
      if (!gs.bool(gs.mc(this,"isAvailable",[], gSobject))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["GoogleSignIn: Not Available"]);
        return null;
       } else {
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["GoogleSignIn: Available"]);
       };
     }]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaGoogleSignIn0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaGoogleSignIn.isAvailable = function() {
  return !!(cordova.plugins.i3GoogleSignIn || cordova.plugins.GoogleSignInPlugin);
 }

function TestAppScannerComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppScannerComponent', simpleName: 'TestAppScannerComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/scanner";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppScannerComponent: created"]);
    gs.sp(gSobject.scope,"scanResult","");
    gs.sp(gSobject.scope,"scanFormat","");
    gs.sp(gSobject.scope,"scanHistory",gs.list([]));
    gs.sp(gSobject.scope,"scanning",false);
    gs.sp(gSobject.scope,"error","");
    gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
    return gs.sp(gSobject.scope,"debugInfo","");
   }
  gSobject['afterMounted'] = function(it) {
    var qrAvail = TestAppScannerComponent.qrScannerAvailable();
    var bsAvail = TestAppScannerComponent.barcodeScannerAvailable();
    var permAvail = TestAppScannerComponent.permissionsAvailable();
    gs.sp(gSobject.scope,"debugInfo","isCordova: " + (gs.gp(gSobject.scope,"isCordova")) + ", qrScanner: " + (qrAvail) + ", barcodeScanner: " + (bsAvail) + ", permissions: " + (permAvail) + "");
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppScannerComponent: mounted - qrScanner=" + (qrAvail) + ", barcodeScanner=" + (bsAvail) + ", permissions=" + (permAvail) + ""]);
   }
  gSobject['scan'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppScannerComponent: scan() called"]);
    gs.sp(gSobject.scope,"scanning",true);
    gs.sp(gSobject.scope,"error","");
    if (TestAppScannerComponent.permissionsAvailable()) {
      return gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"checkPermission",["android.permission.CAMERA", function(status) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppScannerComponent: camera permission: " + (gs.gp(status,"hasPermission")) + ""]);
        if (gs.bool(gs.gp(status,"hasPermission"))) {
          return gs.mc(gSobject,"doScan",[]);
         } else {
          return gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"requestPermission",["android.permission.CAMERA", function(result) {
            if (gs.bool(gs.gp(result,"hasPermission"))) {
              return gs.mc(gSobject,"doScan",[]);
             } else {
              gs.sp(gSobject.scope,"error","Camera permission denied");
              return gs.sp(gSobject.scope,"scanning",false);
             };
           }, function(err) {
            gs.sp(gSobject.scope,"error","Permission request failed");
            return gs.sp(gSobject.scope,"scanning",false);
           }]);
         };
       }, function(err) {
        return gs.mc(gSobject,"doScan",[]);
       }]);
     } else {
      return gs.mc(gSobject,"doScan",[]);
     };
   }
  gSobject['doScan'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppScannerComponent: doScan - launching scanner"]);
    if (TestAppScannerComponent.qrScannerAvailable()) {
      return gs.mc(gs.fs('qrScanner', this, gSobject),"scan",[function(result) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppScannerComponent: result: cancelled=" + (gs.gp(result,"cancelled")) + ", text=" + (gs.gp(result,"text")) + ""]);
        gs.sp(gSobject.scope,"scanning",false);
        if (gs.bool(gs.gp(result,"cancelled"))) {
          gs.sp(gSobject.scope,"scanResult","Cancelled");
          gs.sp(gSobject.scope,"scanFormat","");
          return null;
         };
        gs.sp(gSobject.scope,"scanResult",gs.mc(gSobject,"upgradeUrl",[gs.gp(result,"text")]));
        gs.sp(gSobject.scope,"scanFormat",gs.gp(result,"format"));
        return gs.mc(gSobject,"addToHistory",[gs.mc(gSobject,"upgradeUrl",[gs.gp(result,"text")]), gs.gp(result,"format")]);
       }, function(error) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppScannerComponent: error: " + (error) + ""]);
        gs.sp(gSobject.scope,"scanning",false);
        return gs.sp(gSobject.scope,"error","Scan error: " + (error) + "");
       }]);
     } else {
      if (TestAppScannerComponent.barcodeScannerAvailable()) {
        return gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"barcodeScanner"),"scan",[function(result) {
          gs.sp(gSobject.scope,"scanning",false);
          if (gs.bool(gs.gp(result,"cancelled"))) {
            gs.sp(gSobject.scope,"scanResult","Cancelled");
            return null;
           };
          gs.sp(gSobject.scope,"scanResult",gs.mc(gSobject,"upgradeUrl",[gs.gp(result,"text")]));
          gs.sp(gSobject.scope,"scanFormat",gs.gp(result,"format"));
          return gs.mc(gSobject,"addToHistory",[gs.mc(gSobject,"upgradeUrl",[gs.gp(result,"text")]), gs.gp(result,"format")]);
         }, function(error) {
          gs.sp(gSobject.scope,"scanning",false);
          return gs.sp(gSobject.scope,"error","Scan error: " + (error) + "");
         }, gs.map().add("formats","QR_CODE,EAN_13,EAN_8,CODE_128").add("prompt","Place a barcode inside the scan area")]);
       } else {
        gs.sp(gSobject.scope,"scanning",false);
        return gs.sp(gSobject.scope,"error","No scanner available");
       };
     };
   }
  gSobject['upgradeUrl'] = function(text) {
    return (gs.mc(text,"startsWith",["http://"], null, true) ? gs.plus("https://", gs.mc(text,"substring",[7])) : text);
   }
  gSobject.qrScannerAvailable = function() { return TestAppScannerComponent.qrScannerAvailable(); }
  gSobject.barcodeScannerAvailable = function() { return TestAppScannerComponent.barcodeScannerAvailable(); }
  gSobject.permissionsAvailable = function() { return TestAppScannerComponent.permissionsAvailable(); }
  gSobject['addToHistory'] = function(text, format) {
    gs.sp(gSobject.scope,"scanHistory",(gs.plus(gs.list([gs.map().add("text",text).add("format",format).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"scanHistory"))));
    if (gs.mc(gs.gp(gSobject.scope,"scanHistory"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"scanHistory",(gs.rangeFromList(gs.gp(gSobject.scope,"scanHistory"), 0, 29)));
     };
   }
  gSobject['openUrl'] = function(url) {
    if (gs.mc(url,"startsWith",["http"])) {
      return gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[url, "_blank"]);
     };
   }
  gSobject['copyToClipboard'] = function(text) {
    return gs.mc(gSobject,"copyText",[text]);
   }
  gSobject.copyText = function(text) {
    navigator.clipboard.writeText(text);
   }
  gSobject['clearHistory'] = function(it) {
    gs.sp(gSobject.scope,"scanHistory",gs.list([]));
    gs.sp(gSobject.scope,"scanResult","");
    return gs.sp(gSobject.scope,"scanFormat","");
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppScannerComponent.qrScannerAvailable = function() {
  return typeof qrScanner !== 'undefined';
 }
TestAppScannerComponent.barcodeScannerAvailable = function() {
  return typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.barcodeScanner !== 'undefined';
 }
TestAppScannerComponent.permissionsAvailable = function() {
  return typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.permissions !== 'undefined';
 }

function TestAppPrinterComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppPrinterComponent', simpleName: 'TestAppPrinterComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/printer";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"log",gs.list([]));
    return gs.sp(gSobject.scope,"htmlContent","<h1>Test Print</h1><p>Printed from Dymico Test App</p>");
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 20) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 19)));
     };
   }
  gSobject['printHtml'] = function(it) {
    gs.mc(gSobject,"addLog",["Printing custom HTML..."]);
    return gs.mc(gs.fs('cordovaDevice', this, gSobject),"print",[gs.gp(gSobject.scope,"htmlContent"), gs.map(), function(result) {
      return gs.mc(gSobject,"addLog",["Done: " + (result) + ""]);
     }]);
   }
  gSobject['printInvoice'] = function(it) {
    var html = gs.plus((gs.plus("<html><head><style>body{font-family:sans-serif;padding:20px}h1{color:#2196F3}table{width:100%;border-collapse:collapse;margin-top:16px}th,td{border:1px solid #ddd;padding:8px;text-align:left}th{background:#f5f5f5}</style></head><body><h1>Invoice #1234</h1><p>Date: ", gs.mc(gs.date(),"format",["yyyy-MM-dd"]))), "</p><table><tr><th>Item</th><th>Qty</th><th>Price</th></tr><tr><td>Widget A</td><td>2</td><td>R150.00</td></tr><tr><td>Widget B</td><td>1</td><td>R300.00</td></tr><tr><td><strong>Total</strong></td><td></td><td><strong>R600.00</strong></td></tr></table></body></html>");
    gs.mc(gSobject,"addLog",["Printing sample invoice..."]);
    return gs.mc(gs.fs('cordovaDevice', this, gSobject),"print",[html, gs.map().add("name","Invoice-1234"), function(result) {
      return gs.mc(gSobject,"addLog",["Done: " + (result) + ""]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppOfflineTiles() {
  var gSobject = gs.init('TestAppOfflineTiles');
  gSobject.clazz = { name: 'TestAppOfflineTiles', simpleName: 'TestAppOfflineTiles'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.installOfflineTileLayer = function(x0,x1,x2) { return TestAppOfflineTiles.installOfflineTileLayer(x0,x1,x2); }
  gSobject.downloadArea = function(x0,x1,x2,x3,x4,x5,x6,x7,x8) { return TestAppOfflineTiles.downloadArea(x0,x1,x2,x3,x4,x5,x6,x7,x8); }
  gSobject.estimateTiles = function(x0,x1,x2,x3,x4,x5) { return TestAppOfflineTiles.estimateTiles(x0,x1,x2,x3,x4,x5); }
  gSobject.cacheStatus = function(x0) { return TestAppOfflineTiles.cacheStatus(x0); }
  gSobject.clearCache = function(x0) { return TestAppOfflineTiles.clearCache(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppOfflineTiles.installOfflineTileLayer = function(map, url, opts) {
  try {
            if (typeof L === 'undefined' || !map) return null;
            var options = opts || {};
            var CACHE = 'kruger-tiles-v1';
            function keyFor(u){ return u.replace(/\/\/[a-cA-C]\.tile\./, '//tile.'); }

            if (typeof caches === 'undefined' || typeof fetch === 'undefined') {
                return L.tileLayer(url, options).addTo(map);
            }

            var CacheTL = L.TileLayer.extend({
                createTile: function (coords, done) {
                    var img = document.createElement('img');
                    img.setAttribute('role', 'presentation');
                    img.alt = '';
                    var tileUrl = this.getTileUrl(coords);
                    var key = keyFor(tileUrl);

                    function fromNetworkDirect() {
                        img.onload = function () { done(null, img); };
                        img.onerror = function () { done(new Error('tile'), img); };
                        img.src = tileUrl;
                    }
                    function showBlob(b) {
                        img.onload = function () { done(null, img); };
                        img.onerror = function () { fromNetworkDirect(); };
                        img.src = URL.createObjectURL(b);
                    }

                    caches.open(CACHE).then(function (cache) {
                        cache.match(key).then(function (resp) {
                            if (resp) {
                                resp.blob().then(showBlob).catch(fromNetworkDirect);
                            } else {
                                fetch(tileUrl, { mode: 'cors' }).then(function (r) {
                                    if (r && r.ok) {
                                        try { cache.put(key, r.clone()); } catch (e) {}
                                        r.blob().then(showBlob).catch(fromNetworkDirect);
                                    } else {
                                        fromNetworkDirect();
                                    }
                                }).catch(fromNetworkDirect);
                            }
                        }).catch(fromNetworkDirect);
                    }).catch(fromNetworkDirect);

                    return img;
                }
            });

            var layer = new CacheTL(url, options);
            layer.addTo(map);
            return layer;
        } catch (e) {
            try { return L.tileLayer(url, opts || {}).addTo(map); } catch (e2) { return null; }
        }
 }
TestAppOfflineTiles.downloadArea = function(url, south, west, north, east, minZ, maxZ, progressCb, doneCb) {
  try {
            if (typeof caches === 'undefined' || typeof fetch === 'undefined') {
                if (doneCb) doneCb({ error: 'Cache API unavailable', total: 0, cached: 0 });
                return;
            }
            var CACHE = 'kruger-tiles-v1';
            var subs = ['a', 'b', 'c'];
            function lon2tile(lon, z) { return Math.floor((lon + 180) / 360 * Math.pow(2, z)); }
            function lat2tile(lat, z) { var r = lat * Math.PI / 180; return Math.floor((1 - Math.log(Math.tan(r) + 1 / Math.cos(r)) / Math.PI) / 2 * Math.pow(2, z)); }
            function keyFor(u) { return u.replace(/\/\/[a-cA-C]\.tile\./, '//tile.'); }

            var jobs = [];
            for (var z = minZ; z <= maxZ; z++) {
                var x0 = lon2tile(west, z), x1 = lon2tile(east, z);
                var y0 = lat2tile(north, z), y1 = lat2tile(south, z);
                for (var x = x0; x <= x1; x++) {
                    for (var y = y0; y <= y1; y++) { jobs.push({ z: z, x: x, y: y }); }
                }
            }
            var total = jobs.length, done = 0, cached = 0;

            caches.open(CACHE).then(function (cache) {
                function urlFor(t) {
                    return url.replace('{s}', subs[Math.abs(t.x + t.y) % 3])
                              .replace('{z}', t.z).replace('{x}', t.x).replace('{y}', t.y);
                }
                function next() {
                    if (!jobs.length) { return; }
                    var t = jobs.shift();
                    var u = urlFor(t), key = keyFor(u);
                    cache.match(key).then(function (m) {
                        if (m) {
                            done++; cached++;
                            if (progressCb) progressCb({ done: done, total: total, cached: cached });
                            if (done >= total && doneCb) doneCb({ total: total, cached: cached });
                            next();
                            return;
                        }
                        fetch(u, { mode: 'cors' }).then(function (r) {
                            if (r && r.ok) { try { cache.put(key, r.clone()); cached++; } catch (e) {} }
                            done++;
                            if (progressCb) progressCb({ done: done, total: total, cached: cached });
                            if (done >= total && doneCb) doneCb({ total: total, cached: cached });
                            next();
                        }).catch(function () {
                            done++;
                            if (progressCb) progressCb({ done: done, total: total, cached: cached });
                            if (done >= total && doneCb) doneCb({ total: total, cached: cached });
                            next();
                        });
                    });
                }
                if (total === 0) { if (doneCb) doneCb({ total: 0, cached: 0 }); return; }
                var conc = Math.min(4, total);
                for (var c = 0; c < conc; c++) next();
            }).catch(function (e) { if (doneCb) doneCb({ error: '' + e, total: total, cached: 0 }); });
        } catch (e) {
            if (doneCb) doneCb({ error: '' + e, total: 0, cached: 0 });
        }
 }
TestAppOfflineTiles.estimateTiles = function(south, west, north, east, minZ, maxZ) {
  function lon2tile(lon, z) { return Math.floor((lon + 180) / 360 * Math.pow(2, z)); }
        function lat2tile(lat, z) { var r = lat * Math.PI / 180; return Math.floor((1 - Math.log(Math.tan(r) + 1 / Math.cos(r)) / Math.PI) / 2 * Math.pow(2, z)); }
        var n = 0;
        for (var z = minZ; z <= maxZ; z++) {
            var w = (lon2tile(east, z) - lon2tile(west, z) + 1);
            var h = (lat2tile(south, z) - lat2tile(north, z) + 1);
            n += (w > 0 ? w : 0) * (h > 0 ? h : 0);
        }
        return n;
 }
TestAppOfflineTiles.cacheStatus = function(cb) {
  try {
            if (typeof caches === 'undefined') { if (cb) cb({ tiles: 0, approxMB: 0, available: false }); return; }
            caches.open('kruger-tiles-v1').then(function (cache) {
                cache.keys().then(function (keys) {
                    var n = keys.length;
                    if (cb) cb({ tiles: n, approxMB: Math.round(n * 22 / 1024 * 10) / 10, available: true });
                });
            }).catch(function () { if (cb) cb({ tiles: 0, approxMB: 0, available: false }); });
        } catch (e) { if (cb) cb({ tiles: 0, approxMB: 0, available: false }); }
 }
TestAppOfflineTiles.clearCache = function(cb) {
  try {
            if (typeof caches === 'undefined') { if (cb) cb(false); return; }
            caches.delete('kruger-tiles-v1').then(function (ok) { if (cb) cb(!!ok); }).catch(function () { if (cb) cb(false); });
        } catch (e) { if (cb) cb(false); }
 }

function VueListSearchComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueListSearchComponent', simpleName: 'VueListSearchComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.toJavascript(gs.list(["value" , "onFilter" , "onSelect" , "label" , "options" , "outlined" , "filled" , "standout" , "borderless" , "square" , "dark" , "clearable" , "required" , "style" , "onLabel" , "optionLabel"]));
  gSobject.data = function(it) {
    var self = this;
    return gs.map().add("objectValue",gs.gp(self,"value")).add("optionsList",gs.list([])).add("initOptions",gs.gp(self,"options")).add("optionLabelValue",gs.elvis(gs.bool(gs.gp(self,"optionLabel")) , gs.gp(self,"optionLabel") , "name"));
   };
  gSobject['mounted'] = function(it) {
    var self = this;
   }
  gSobject['watchValue'] = function(newValue, oldValue) {
    var self = this;
    return gs.sp(self,"objectValue",newValue);
   }
  gSobject['lookupObjects'] = function(val, update, abort) {
    if (val === undefined) val = null;
    if (update === undefined) update = function(it) {
      return gs.execCall(it, this, []);
     };
    if (abort === undefined) abort = null;
    var self = this;
    if (gs.bool(gs.gp(self,"options"))) {
      gs.execCall(update, this, [function(it) {
        gs.sp(self,"optionsList",gs.gp(self,"options"));
        return gs.mc(gSobject,"configLabel",[self]);
       }]);
      return null;
     };
    return gs.mc(self,"onFilter",[val, function(dbOptionsList) {
      return gs.execCall(update, this, [function(it) {
        gs.sp(self,"optionsList",dbOptionsList);
        return gs.mc(gSobject,"configLabel",[self]);
       }]);
     }]);
   }
  gSobject['configLabel'] = function(self) {
    if (gs.bool(gs.gp(self,"onLabel"))) {
      return gs.sp(self,"optionLabel",gs.gp(self,"onLabel"));
     };
   }
  gSobject['objectSelected'] = function(it) {
    var self = this;
    gs.mc(self,"$emit",["input", gs.gp(self,"objectValue")]);
    if (gs.bool(gs.gp(self,"onSelect"))) {
      return gs.mc(self,"onSelect",[gs.gp(self,"objectValue")]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppDeviceComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppDeviceComponent', simpleName: 'TestAppDeviceComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/device";
  gSobject.roles = gs.list([]);
  gSobject.pollInterval = null;
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppDeviceComponent: created"]);
    gs.sp(gSobject.scope,"device",gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"));
    gs.sp(gSobject.scope,"network",gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"network"));
    gs.sp(gSobject.scope,"battery",gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"battery"));
    gs.sp(gSobject.scope,"log",gs.list([]));
    return gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 29)));
     };
   }
  gSobject['vibrate'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"vibrate",[500]);
    return gs.mc(gSobject,"addLog",["Vibrated 500ms"]);
   }
  gSobject['vibratePattern'] = function(it) {
    var isIos = gs.equals(gs.mc(gs.gp(gs.gp(gSobject.scope,"device"),"platform",true),"toLowerCase",[], null, true), "ios");
    if (gs.bool(isIos)) {
      gs.mc(gs.fs('cordovaDevice', this, gSobject),"vibrate",[100]);
      gs.execStatic(Utils,'setTimeout', this,[function(it) {
        return gs.mc(gs.fs('cordovaDevice', this, gSobject),"vibrate",[100]);
       }, 300]);
      gs.execStatic(Utils,'setTimeout', this,[function(it) {
        return gs.mc(gs.fs('cordovaDevice', this, gSobject),"vibrate",[300]);
       }, 700]);
      return gs.mc(gSobject,"addLog",["iOS pattern: 3 sequential vibrations (no native pattern support)"]);
     } else {
      gs.mc(gs.fs('cordovaDevice', this, gSobject),"vibrate",[gs.list([100 , 200 , 100 , 200 , 300])]);
      return gs.mc(gSobject,"addLog",["Vibrate pattern: 100-200-100-200-300"]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppCaptureComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppCaptureComponent', simpleName: 'TestAppCaptureComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/capture";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppCaptureComponent: created"]);
    gs.sp(gSobject.scope,"imageUrl","");
    gs.sp(gSobject.scope,"meta",null);
    gs.sp(gSobject.scope,"errorMsg","");
    gs.sp(gSobject.scope,"capturing",false);
    gs.sp(gSobject.scope,"maxWidth",1280);
    gs.sp(gSobject.scope,"log",gs.list([]));
    return gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 20) {
      gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 19)));
     };
    return TestAppCaptureComponent.consoleLog(gs.plus("[Capture] ", msg));
   }
  gSobject['captureNow'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"imageUrl"))) {
      gs.mc(gSobject,"revokeUrl",[gs.gp(gSobject.scope,"imageUrl")]);
     };
    gs.sp(gSobject.scope,"capturing",true);
    gs.sp(gSobject.scope,"errorMsg","");
    gs.sp(gSobject.scope,"imageUrl","");
    gs.sp(gSobject.scope,"meta",null);
    gs.mc(gSobject,"addLog",["Capturing…"]);
    var maxW = TestAppCaptureComponent.parseIntSafe(gs.gp(gSobject.scope,"maxWidth"));
    var ticket = TestAppCaptureComponent.newTicket();
    gs.sp(gSobject.scope,"captureTicket",ticket);
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      if ((gs.equals(gs.gp(gSobject.scope,"captureTicket"), ticket)) && (gs.bool(gs.gp(gSobject.scope,"capturing")))) {
        gs.sp(gSobject.scope,"capturing",false);
        gs.sp(gSobject.scope,"errorMsg","Capture timed out after 20s");
        return gs.mc(gSobject,"addLog",["TIMEOUT"]);
       };
     }, 20000]);
    return gs.mc(gSobject,"nativeCapture",[maxW, function(blob, meta) {
      return gs.mc(gSobject,"handleCaptureSuccess",[ticket, blob, meta]);
     }, function(err) {
      return gs.mc(gSobject,"handleCaptureError",[ticket, err]);
     }]);
   }
  gSobject['handleCaptureSuccess'] = function(ticket, blob, meta) {
    if (gs.gp(gSobject.scope,"captureTicket") != ticket) {
      return null;
     };
    gs.sp(gSobject.scope,"capturing",false);
    var sizeKb = TestAppCaptureComponent.computeSizeKb(blob);
    gs.sp(gSobject.scope,"meta",gs.map().add("type",TestAppCaptureComponent.metaType(meta)).add("width",TestAppCaptureComponent.metaWidth(meta)).add("height",TestAppCaptureComponent.metaHeight(meta)).add("fallback",TestAppCaptureComponent.metaFallback(meta)).add("sizeKb",sizeKb));
    gs.sp(gSobject.scope,"imageUrl",gs.mc(gSobject,"blobToUrl",[blob]));
    return gs.mc(gSobject,"addLog",[gs.plus((gs.plus((gs.plus((gs.plus((gs.plus((gs.plus((gs.plus((gs.plus("OK: ", gs.gp(gs.gp(gSobject.scope,"meta"),"width"))), "x")), gs.gp(gs.gp(gSobject.scope,"meta"),"height"))), " ")), gs.gp(gs.gp(gSobject.scope,"meta"),"type"))), " ")), sizeKb)), "KB")]);
   }
  gSobject['handleCaptureError'] = function(ticket, err) {
    if (gs.gp(gSobject.scope,"captureTicket") != ticket) {
      return null;
     };
    gs.sp(gSobject.scope,"capturing",false);
    gs.sp(gSobject.scope,"errorMsg",TestAppCaptureComponent.errToString(err));
    return gs.mc(gSobject,"addLog",[gs.plus("Error: ", gs.gp(gSobject.scope,"errorMsg"))]);
   }
  gSobject['clearPreview'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"imageUrl"))) {
      gs.mc(gSobject,"revokeUrl",[gs.gp(gSobject.scope,"imageUrl")]);
     };
    gs.sp(gSobject.scope,"imageUrl","");
    gs.sp(gSobject.scope,"meta",null);
    gs.sp(gSobject.scope,"errorMsg","");
    return gs.mc(gSobject,"addLog",["Preview cleared"]);
   }
  gSobject['openInNewTab'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"imageUrl"))) {
      return null;
     };
    return gs.mc(gSobject,"nativeOpenInNewTab",[gs.gp(gSobject.scope,"imageUrl")]);
   }
  gSobject.nativeCapture = function(maxWidth, success, error) {
    function doCapture() {
            try {
                var node = document.documentElement;
                var w = Math.max(node.scrollWidth, document.body ? document.body.scrollWidth : 0, window.innerWidth);
                var scale = (maxWidth && w > maxWidth) ? (maxWidth / w) : 1;

                window.html2canvas(node, {
                    scale: scale,
                    useCORS: true,
                    allowTaint: false,
                    backgroundColor: '#ffffff',
                    logging: false,
                    foreignObjectRendering: false,
                    removeContainer: true
                }).then(function(canvas) {
                    var outW = canvas.width;
                    var outH = canvas.height;
                    canvas.toBlob(function(blob) {
                        if (blob) {
                            success(blob, { type:'image/png', width:outW, height:outH, fallback:false });
                        } else {
                            error('canvas.toBlob returned null (tainted?)');
                        }
                    }, 'image/png', 0.92);
                }).catch(function(e) {
                    error('html2canvas failed: ' + (e && e.message ? e.message : String(e)));
                });
            } catch(e) {
                error('capture exception: ' + (e && e.message ? e.message : String(e)));
            }
        }

        if (typeof window.html2canvas === 'function') {
            doCapture();
            return;
        }

        // Lazy-load html2canvas (one-shot; cached by browser after first load).
        var existing = document.getElementById('cw-html2canvas-script');
        if (existing) {
            // Already injected, just wait for it
            existing.addEventListener('load', doCapture);
            existing.addEventListener('error', function() { error('html2canvas script failed to load'); });
            return;
        }
        var s = document.createElement('script');
        s.id = 'cw-html2canvas-script';
        s.src = 'https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js';
        s.crossOrigin = 'anonymous';
        s.onload = function() {
            if (typeof window.html2canvas === 'function') doCapture();
            else error('html2canvas loaded but global is not defined');
        };
        s.onerror = function() {
            error('Failed to fetch html2canvas from CDN (offline?)');
        };
        document.head.appendChild(s);
   }
  gSobject.blobToUrl = function(blob) {
    try { return URL.createObjectURL(blob); } catch(e) { return ''; }
   }
  gSobject.revokeUrl = function(url) {
    try { URL.revokeObjectURL(url); } catch(e) {}
   }
  gSobject.nativeOpenInNewTab = function(url) {
    try { window.open(url, '_blank'); } catch(e) {}
   }
  gSobject.parseIntSafe = function(x0) { return TestAppCaptureComponent.parseIntSafe(x0); }
  gSobject.computeSizeKb = function(x0) { return TestAppCaptureComponent.computeSizeKb(x0); }
  gSobject.metaType = function(x0) { return TestAppCaptureComponent.metaType(x0); }
  gSobject.metaWidth = function(x0) { return TestAppCaptureComponent.metaWidth(x0); }
  gSobject.metaHeight = function(x0) { return TestAppCaptureComponent.metaHeight(x0); }
  gSobject.metaFallback = function(x0) { return TestAppCaptureComponent.metaFallback(x0); }
  gSobject.errToString = function(x0) { return TestAppCaptureComponent.errToString(x0); }
  gSobject.newTicket = function() { return TestAppCaptureComponent.newTicket(); }
  gSobject.consoleLog = function(x0) { return TestAppCaptureComponent.consoleLog(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppCaptureComponent.parseIntSafe = function(val) {
  var n = parseInt(val); return (isNaN(n) || n <= 0) ? 1280 : n;
 }
TestAppCaptureComponent.computeSizeKb = function(blob) {
  try {
            var sz = (blob && typeof blob.size === 'number') ? blob.size : 0;
            return Math.round(sz / 1024);
        } catch(e) { return 0; }
 }
TestAppCaptureComponent.metaType = function(m) {
  return (m && m.type)               ? String(m.type)   : 'unknown';
 }
TestAppCaptureComponent.metaWidth = function(m) {
  return (m && typeof m.width  === 'number') ? m.width  : 0;
 }
TestAppCaptureComponent.metaHeight = function(m) {
  return (m && typeof m.height === 'number') ? m.height : 0;
 }
TestAppCaptureComponent.metaFallback = function(m) {
  return !!(m && m.fallback);
 }
TestAppCaptureComponent.errToString = function(e) {
  try {
            if (e == null) return '(null)';
            if (typeof e === 'string') return e;
            if (e.message) return String(e.message);
            return JSON.stringify(e);
        } catch(_) { return String(e); }
 }
TestAppCaptureComponent.newTicket = function() {
  return Date.now() + ':' + Math.random().toString(36).slice(2,8);
 }
TestAppCaptureComponent.consoleLog = function(msg) {
  try { console.log(msg); } catch(_) {}
 }

function CordovaContacts() {
  var gSobject = gs.init('CordovaContacts');
  gSobject.clazz = { name: 'CordovaContacts', simpleName: 'CordovaContacts'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.findContacts = function(filterText, callback) {
    navigator.contacts.find(
            [
                navigator.contacts.fieldType.phoneNumbers,
                navigator.contacts.fieldType.displayName, 
                navigator.contacts.fieldType.name
            ],
            function(data) {
                callback(data);
            },
            function(error) {
                console.log('Error finding contacts: ', error);
            },
            {
                hasPhoneNumber: true,
                filter: filterText || '',
            }
        );
   }
  gSobject.newContact = function(callback) {
    let contact = navigator.contacts.create();
        callback(contact);
   }
  gSobject.saveContact = function(contact, callback) {
    contact.save(
            function(success) {
                console.log('CordovaContacts: Contact Saved: ', success);
                callback({status: true, message: 'Contact saved successfully', contact: success});
            },
            function(error) {
                console.log('CordovaContacts: Error Saving contacts: ', error);
                callback({status: false, message: 'Failed to save contact'});
            }
        );
   }
  gSobject.deleteContact = function(contact, callback) {
    contact.remove(
            function(success) {
                console.log('CordovaContacts: Contact Deleted: ', success);
                callback({status: true, message: 'Contact deleted successfully'});
            },
            function(error) {
                console.log('CordovaContacts: Failed to delete contact: ', error);
                callback({status: false, message: 'Failed to delete contact'});
            }
        );
   }
  gSobject.isAvailable = function() { return CordovaContacts.isAvailable(); }
  gSobject.getContactsInstance = function() { return CordovaContacts.getContactsInstance(); }
  gSobject['CordovaContacts0'] = function(it) {
    gs.mc(document,"addEventListener",["deviceReady", function(it) {
      if (!gs.bool(gs.mc(this,"isAvailable",[], gSobject))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova-plugin-contacts: Not Available"]);
        return null;
       } else {
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova-plugin-contacts: Available"]);
       };
     }]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaContacts0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaContacts.isAvailable = function() {
  // Contacts plugin is not available
        if (!navigator.contacts) return false;
        else return true;
 }
CordovaContacts.getContactsInstance = function() {
  return navigator.contacts;
 }

function SimulatorComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'SimulatorComponent', simpleName: 'SimulatorComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/simulatorComponent";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["SimulatorComponent: created"]);
    gs.sp(gSobject.scope,"appUrl",SimulatorComponent.loadLastUrl());
    gs.sp(gSobject.scope,"loaded",false);
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"jsCommand","Utils.isCordova()");
    gs.sp(gSobject.scope,"gpsLat","-26.2041");
    gs.sp(gSobject.scope,"gpsLng","28.0473");
    gs.sp(gSobject.scope,"gpsAlt","1400");
    gs.sp(gSobject.scope,"gpsSpeed","0");
    gs.sp(gSobject.scope,"gpsBearing","0");
    gs.sp(gSobject.scope,"gpsAccuracy","5");
    gs.sp(gSobject.scope,"fenceId","depot-1");
    gs.sp(gSobject.scope,"fenceLat","-26.2041");
    gs.sp(gSobject.scope,"fenceLng","28.0473");
    gs.sp(gSobject.scope,"fenceRadius","200");
    gs.sp(gSobject.scope,"fenceData","{\"name\":\"Main Depot\",\"zone\":\"secure\"}");
    gs.sp(gSobject.scope,"transitionTypes",gs.list([gs.map().add("label","ENTER (1)").add("value",1) , gs.map().add("label","EXIT (2)").add("value",2) , gs.map().add("label","DWELL (4)").add("value",4)]));
    gs.sp(gSobject.scope,"errorCode",1);
    gs.sp(gSobject.scope,"errorMessage","Permission denied");
    gs.sp(gSobject.scope,"errorCodes",gs.list([gs.map().add("label","PERMISSION_DENIED (1)").add("value",1) , gs.map().add("label","LOCATION_UNAVAILABLE (2)").add("value",2) , gs.map().add("label","TIMEOUT (3)").add("value",3)]));
    gs.sp(gSobject.scope,"authCode",1);
    gs.sp(gSobject.scope,"authStates",gs.list([gs.map().add("label","NOT_AUTHORIZED (0)").add("value",0) , gs.map().add("label","AUTHORIZED (1)").add("value",1) , gs.map().add("label","AUTHORIZED_FOREGROUND (2)").add("value",2)]));
    gs.sp(gSobject.scope,"statusRunning",false);
    gs.sp(gSobject.scope,"statusServicesEnabled",true);
    gs.sp(gSobject.scope,"httpAuthHeader",(gs.plus("Bearer sim-jwt-", gs.mc(gs.date(),"getTime",[]))));
    gs.sp(gSobject.scope,"scanText","https://example.com");
    gs.sp(gSobject.scope,"scanFormat","QR_CODE");
    gs.sp(gSobject.scope,"scanFormats",gs.list(["QR_CODE" , "EAN_13" , "EAN_8" , "CODE_128" , "CODE_39" , "DATA_MATRIX" , "PDF_417" , "UPC_A" , "UPC_E"]));
    gs.sp(gSobject.scope,"cameraUri","");
    gs.sp(gSobject.scope,"bleName","TestDevice");
    gs.sp(gSobject.scope,"bleAddress","AA:BB:CC:DD:EE:01");
    gs.sp(gSobject.scope,"bleRssi","-65");
    gs.sp(gSobject.scope,"deepLinkUrl","https://testapp.office.i3zone.com/deeplink/test?foo=bar");
    gs.sp(gSobject.scope,"batteryLevel",75);
    gs.sp(gSobject.scope,"batteryPlugged",false);
    gs.sp(gSobject.scope,"networkType","wifi");
    gs.sp(gSobject.scope,"networkOnline",true);
    gs.sp(gSobject.scope,"networkTypes",gs.list(["wifi" , "4g" , "3g" , "2g" , "ethernet" , "cellular" , "none" , "unknown"]));
    gs.sp(gSobject.scope,"pushTitle","Test Notification");
    gs.sp(gSobject.scope,"pushMessage","This is a simulated push notification");
    gs.sp(gSobject.scope,"mockContacts",gs.list([gs.map().add("displayName","John Doe").add("phoneNumbers",gs.list([gs.map().add("value","+27821234567").add("type","mobile")])).add("emails",gs.list([gs.map().add("value","john@example.com").add("type","home")])) , gs.map().add("displayName","Jane Smith").add("phoneNumbers",gs.list([gs.map().add("value","+27829876543").add("type","mobile") , gs.map().add("value","+27115551234").add("type","work")])).add("emails",gs.list([])) , gs.map().add("displayName","Bob Builder").add("phoneNumbers",gs.list([gs.map().add("value","+27831112233").add("type","mobile")])).add("emails",gs.list([gs.map().add("value","bob@build.co.za").add("type","work")]))]));
    gs.sp(gSobject.scope,"appleEmail","testuser@icloud.com");
    gs.sp(gSobject.scope,"appleName","Test User");
    gs.sp(gSobject.scope,"googleEmail","testuser@gmail.com");
    gs.sp(gSobject.scope,"googleName","Test User");
    gs.sp(gSobject.scope,"healthSteps",8500);
    gs.sp(gSobject.scope,"healthHeartRate",72);
    gs.sp(gSobject.scope,"healthSystolic",120);
    return gs.sp(gSobject.scope,"healthDiastolic",80);
   }
  gSobject['afterMounted'] = function(it) {
    return gs.mc(gSobject,"listenForIframeMessages",[]);
   }
  gSobject.listenForIframeMessages = function() {
    var self = this;
        window.addEventListener('message', function(event) {
            var msg = event.data;
            if (!msg) return;
            if (msg.type === 'cordova-sim-ready') {
                self.addLog('App ready: ' + msg.plugin + '.' + msg.action);
            }
            if (msg.type === 'cordova-sim-event') {
                if (msg.plugin === 'console' && msg.action === 'result') {
                    self.addLog('< ' + msg.data.result);
                } else if (msg.plugin === 'console' && msg.action === 'error') {
                    self.addLog('ERROR: ' + msg.data.error);
                } else {
                    self.addLog('App event: ' + msg.plugin + '.' + msg.action + ' ' + JSON.stringify(msg.data || {}));
                }
            }
        });
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 50) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 49)));
     };
   }
  gSobject['loadApp'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"appUrl"))) {
      return null;
     };
    if (gs.mc(gs.gp(gSobject.scope,"appUrl"),"startsWith",["http://"])) {
      gs.sp(gSobject.scope,"appUrl",gs.mc(gs.gp(gSobject.scope,"appUrl"),"replaceFirst",["http://", "https://"]));
     };
    var separator = (gs.mc(gs.gp(gSobject.scope,"appUrl"),"contains",["?"]) ? "&" : "?");
    gs.sp(gSobject.scope,"iframeUrl",(gs.plus((gs.plus(gs.gp(gSobject.scope,"appUrl"), separator)), "cordovaWrapperVersion=cordova.simulator.1.0.0")));
    gs.sp(gSobject.scope,"loaded",true);
    SimulatorComponent.saveLastUrl(gs.gp(gSobject.scope,"appUrl"));
    return gs.mc(gSobject,"addLog",["Loading: " + (gs.gp(gSobject.scope,"appUrl")) + ""]);
   }
  gSobject['sendToApp'] = function(plugin, action, data) {
    gs.mc(gSobject,"sendPostMessage",[plugin, action, data]);
    return gs.mc(gSobject,"addLog",["Sent: " + (plugin) + "." + (action) + ""]);
   }
  gSobject.sendPostMessage = function(plugin, action, data) {
    var iframe = document.getElementById('sim-app-frame');
        if (iframe && iframe.contentWindow) {
            // JSON round-trip strips GrooScript internal methods that can't be cloned by postMessage
            iframe.contentWindow.postMessage(JSON.parse(JSON.stringify({type: 'cordova-sim', plugin: plugin, action: action, data: data})), '*');
        } else {
            console.warn('[Simulator] No iframe found');
        }
   }
  gSobject['sendLocation'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "location", gs.map().add("latitude",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsLat"))).add("longitude",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsLng"))).add("altitude",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsAlt"))).add("speed",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsSpeed"))).add("bearing",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsBearing"))).add("accuracy",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsAccuracy"))).add("provider","simulator").add("time",gs.mc(gs.date(),"getTime",[]))]);
   }
  gSobject['sendScanResult'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["scanner", "result", gs.map().add("text",gs.gp(gSobject.scope,"scanText")).add("format",gs.gp(gSobject.scope,"scanFormat")).add("cancelled",false)]);
   }
  gSobject['sendScanCancel'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["scanner", "cancel", gs.map()]);
   }
  gSobject['sendCameraPhoto'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"cameraUri"))) {
      return gs.mc(gSobject,"sendToApp",["camera", "photo", gs.map().add("uri",gs.gp(gSobject.scope,"cameraUri"))]);
     };
   }
  gSobject.pickPhotoFile = function() {
    var input = document.createElement('input');
        input.type = 'file';
        input.accept = 'image/*';
        input.onchange = function(e) {
            var file = e.target.files[0];
            if (!file) return;
            var reader = new FileReader();
            reader.onload = function(evt) {
                vueScope.cameraUri = evt.target.result;  // base64 data URI
            };
            reader.readAsDataURL(file);
        };
        input.click();
   }
  gSobject['sendBleDevice'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["ble", "device", gs.map().add("name",gs.gp(gSobject.scope,"bleName")).add("address",gs.gp(gSobject.scope,"bleAddress")).add("rssi",SimulatorComponent.parseInt(gs.gp(gSobject.scope,"bleRssi")))]);
   }
  gSobject['sendDeepLink'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["deeplink", "trigger", gs.mc(gSobject,"parseDeepLinkUrl",[gs.gp(gSobject.scope,"deepLinkUrl")])]);
   }
  gSobject.parseDeepLinkUrl = function(url) {
    try {
            var a = document.createElement('a');
            a.href = url;
            var params = {};
            a.search.substring(1).split('&').forEach(function(p) {
                var kv = p.split('=');
                if(kv[0]) params[kv[0]] = decodeURIComponent(kv[1] || '');
            });
            return { url: url, scheme: a.protocol.replace(':',''), host: a.hostname, path: a.pathname, params: params, hash: a.hash };
        } catch(e) { return { url: url }; }
   }
  gSobject['sendBattery'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["battery", "status", gs.map().add("level",gs.gp(gSobject.scope,"batteryLevel")).add("isPlugged",gs.gp(gSobject.scope,"batteryPlugged"))]);
   }
  gSobject['sendNetwork'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["network", "status", gs.map().add("online",gs.gp(gSobject.scope,"networkOnline")).add("type",gs.gp(gSobject.scope,"networkType"))]);
   }
  gSobject['sendBiometricsPass'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["biometrics", "pass", gs.list([])]);
   }
  gSobject['sendBiometricsFail'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["biometrics", "fail", "User cancelled"]);
   }
  gSobject['sendBiometricsAvailable'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["biometrics", "available", gs.map().add("result",gs.map().add("biometryType","face"))]);
   }
  gSobject['sendPushNotification'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["push", "notification", gs.map().add("title",gs.gp(gSobject.scope,"pushTitle")).add("message",gs.gp(gSobject.scope,"pushMessage")).add("additionalData",gs.map().add("simulated",true))]);
   }
  gSobject['sendContacts'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["contacts", "results", gs.gp(gSobject.scope,"mockContacts")]);
   }
  gSobject['sendBackButton'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["backbutton", "press", gs.map()]);
   }
  gSobject['sendActivity'] = function(type) {
    return gs.mc(gSobject,"sendToApp",["gps", "activity", gs.map().add("type",type).add("confidence",100)]);
   }
  gSobject['sendStationary'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "stationary", gs.map().add("latitude",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsLat"))).add("longitude",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsLng"))).add("accuracy",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsAccuracy"))).add("radius",50)]);
   }
  gSobject['sendGeofence'] = function(transitionValue) {
    return gs.mc(gSobject,"sendToApp",["gps", "geofence", gs.map().add("fenceId",gs.gp(gSobject.scope,"fenceId")).add("transition",transitionValue).add("location",gs.map().add("latitude",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"fenceLat"))).add("longitude",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"fenceLng"))).add("accuracy",SimulatorComponent.parseFloat(gs.gp(gSobject.scope,"gpsAccuracy"))).add("time",gs.mc(gs.date(),"getTime",[]))).add("data",SimulatorComponent.parseFenceData(gs.gp(gSobject.scope,"fenceData"))).add("timestamp",gs.mc(gs.date(),"getTime",[]))]);
   }
  gSobject.parseFenceData = function(x0) { return SimulatorComponent.parseFenceData(x0); }
  gSobject['sendBgGeoStart'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "start", gs.map()]);
   }
  gSobject['sendBgGeoStop'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "stop", gs.map()]);
   }
  gSobject['sendBgGeoForeground'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "foreground", gs.map()]);
   }
  gSobject['sendBgGeoBackground'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "background", gs.map()]);
   }
  gSobject['sendBgGeoAbort'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "abort_requested", gs.map()]);
   }
  gSobject['sendBgGeoError'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "error", gs.map().add("code",gs.gp(gSobject.scope,"errorCode")).add("message",gs.gp(gSobject.scope,"errorMessage"))]);
   }
  gSobject['sendBgGeoAuthorization'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "authorization", gs.map().add("code",gs.gp(gSobject.scope,"authCode")).add("message",SimulatorComponent.authLabel(gs.gp(gSobject.scope,"authCode")))]);
   }
  gSobject.authLabel = function(x0) { return SimulatorComponent.authLabel(x0); }
  gSobject['sendBgGeoHttpAuth'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "http_authorization", gs.map().add("authorization",gs.gp(gSobject.scope,"httpAuthHeader"))]);
   }
  gSobject['sendBgGeoStatus'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["gps", "status", gs.map().add("isRunning",gs.gp(gSobject.scope,"statusRunning")).add("locationServicesEnabled",gs.gp(gSobject.scope,"statusServicesEnabled")).add("authorization",gs.gp(gSobject.scope,"authCode"))]);
   }
  gSobject['sendAppleSignInSuccess'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["appleSignIn", "success", gs.map().add("identityToken",gs.plus("sim.apple.jwt.token.", gs.mc(gs.date(),"getTime",[]))).add("authorizationCode",gs.plus("sim-auth-code-", gs.mc(gs.date(),"getTime",[]))).add("email",gs.gp(gSobject.scope,"appleEmail")).add("fullName",gs.map().add("givenName",gs.mc(gs.gp(gSobject.scope,"appleName"),"split",[" "])[0]).add("familyName",(gs.mc(gs.gp(gSobject.scope,"appleName"),"contains",[" "]) ? gs.mc(gs.gp(gSobject.scope,"appleName"),"split",[" "])[1] : ""))).add("user","sim-apple-user-001")]);
   }
  gSobject['sendAppleSignInFail'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["appleSignIn", "fail", "User cancelled"]);
   }
  gSobject['sendGoogleSignInSuccess'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["googleSignIn", "success", gs.map().add("idToken",gs.plus("sim.google.jwt.token.", gs.mc(gs.date(),"getTime",[]))).add("email",gs.gp(gSobject.scope,"googleEmail")).add("displayName",gs.gp(gSobject.scope,"googleName")).add("userId","sim-google-user-001").add("photoUrl","")]);
   }
  gSobject['sendGoogleSignInFail'] = function(it) {
    return gs.mc(gSobject,"sendToApp",["googleSignIn", "fail", "Sign in cancelled"]);
   }
  gSobject['sendHealthSteps'] = function(it) {
    var now = gs.date();
    var records = gs.list([]);
    gs.mc(gs.range(0, 6, true),"each",[function(i) {
      var dayMs = gs.minus(gs.mc(now,"getTime",[]), (gs.multiply(i, 86400000)));
      return gs.mc(records,'leftShift', gs.list([gs.map().add("value",gs.minus((gs.plus(gs.gp(gSobject.scope,"healthSteps"), gs.mc(this,"randomInt",[2000], gSobject))), 1000)).add("unit","count").add("startDate",dayMs).add("endDate",gs.plus(dayMs, 86400000))]));
     }]);
    gs.mc(gSobject,"sendToApp",["health", "queryResult", records]);
    return gs.mc(gSobject,"sendToApp",["health", "queryAggregatedResult", records]);
   }
  gSobject['sendHealthHeartRate'] = function(it) {
    var now = gs.mc(gs.date(),"getTime",[]);
    var records = gs.list([gs.map().add("value",gs.gp(gSobject.scope,"healthHeartRate")).add("unit","bpm").add("startDate",now).add("endDate",now)]);
    return gs.mc(gSobject,"sendToApp",["health", "queryResult", records]);
   }
  gSobject['sendHealthBloodPressure'] = function(it) {
    var now = gs.mc(gs.date(),"getTime",[]);
    var records = gs.list([gs.map().add("systolic",gs.gp(gSobject.scope,"healthSystolic")).add("diastolic",gs.gp(gSobject.scope,"healthDiastolic")).add("unit","mmHg").add("startDate",now).add("endDate",now)]);
    return gs.mc(gSobject,"sendToApp",["health", "queryResult", records]);
   }
  gSobject.randomInt = function(x0) { return SimulatorComponent.randomInt(x0); }
  gSobject.parseInt = function(x0) { return SimulatorComponent.parseInt(x0); }
  gSobject.parseFloat = function(x0) { return SimulatorComponent.parseFloat(x0); }
  gSobject.saveLastUrl = function(x0) { return SimulatorComponent.saveLastUrl(x0); }
  gSobject.loadLastUrl = function() { return SimulatorComponent.loadLastUrl(); }
  gSobject.execInIframe = function(code) {
    var iframe = document.getElementById('sim-app-frame');
        if (!iframe || !iframe.contentWindow) {
            this.addLog('ERROR: No iframe loaded');
            return;
        }
        this.addLog('> ' + code);
        iframe.contentWindow.postMessage({type: 'cordova-sim', plugin: 'console', action: 'eval', data: {code: code}}, '*');
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
SimulatorComponent.parseFenceData = function(text) {
  if (!text) return {};
        try { return JSON.parse(text); } catch(e) { return { raw: String(text) }; }
 }
SimulatorComponent.authLabel = function(code) {
  if (gs.equals(code, 0)) {
    return "NOT_AUTHORIZED";
   };
  if (gs.equals(code, 2)) {
    return "AUTHORIZED_FOREGROUND";
   };
  return "AUTHORIZED";
 }
SimulatorComponent.randomInt = function(max) {
  return Math.floor(Math.random() * max);
 }
SimulatorComponent.parseInt = function(val) {
  return parseInt(val) || 0;
 }
SimulatorComponent.parseFloat = function(val) {
  return parseFloat(val) || 0;
 }
SimulatorComponent.saveLastUrl = function(url) {
  try { localStorage.setItem('sim_last_url', url); } catch(e) {}
 }
SimulatorComponent.loadLastUrl = function() {
  try { return localStorage.getItem('sim_last_url') || ''; } catch(e) { return ''; }
 }

function CordovaErrorViewer() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'CordovaErrorViewer', simpleName: 'CordovaErrorViewer'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/cordovaErrors";
  gSobject.roles = gs.list(["ROLE_DEV_I3"]);
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"errors",gs.list([]));
    gs.sp(gSobject.scope,"filter",gs.map().add("uuid","").add("user","").add("type",""));
    gs.sp(gSobject.scope,"loading",false);
    gs.sp(gSobject.scope,"total",0);
    gs.sp(gSobject.scope,"selectedError",null);
    return gs.mc(gSobject,"loadErrors",[]);
   }
  gSobject['loadErrors'] = function(it) {
    gs.sp(gSobject.scope,"loading",true);
    var query = gs.map();
    if (gs.bool(gs.gp(gs.gp(gSobject.scope,"filter"),"uuid"))) {
      gs.sp(query,"uuid",gs.gp(gs.gp(gSobject.scope,"filter"),"uuid"));
     };
    if (gs.bool(gs.gp(gs.gp(gSobject.scope,"filter"),"user"))) {
      gs.sp(query,"user",gs.gp(gs.gp(gSobject.scope,"filter"),"user"));
     };
    if (gs.bool(gs.gp(gs.gp(gSobject.scope,"filter"),"type"))) {
      gs.sp(query,"type",gs.gp(gs.gp(gSobject.scope,"filter"),"type"));
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"userError"),"find",[query, gs.map().add("sort","_dateCreated").add("order","desc").add("limit",100), function(results) {
      gs.sp(gSobject.scope,"errors",gs.elvis(gs.bool(results) , results , gs.list([])));
      gs.sp(gSobject.scope,"total",gs.mc(gs.gp(gSobject.scope,"errors"),"size",[]));
      return gs.sp(gSobject.scope,"loading",false);
     }]);
   }
  gSobject['clearFilter'] = function(it) {
    gs.sp(gSobject.scope,"filter",gs.map().add("uuid","").add("user","").add("type",""));
    return gs.mc(gSobject,"loadErrors",[]);
   }
  gSobject['selectError'] = function(error) {
    return gs.sp(gSobject.scope,"selectedError",error);
   }
  gSobject['closeDetail'] = function(it) {
    return gs.sp(gSobject.scope,"selectedError",null);
   }
  gSobject['deleteError'] = function(error) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"userError"),"delete",[gs.gp(error,"_id"), function(it) {
      gs.sp(gSobject.scope,"selectedError",null);
      return gs.mc(gSobject,"loadErrors",[]);
     }]);
   }
  gSobject['deleteAll'] = function(it) {
    gs.mc(gs.gp(gSobject.scope,"errors"),"each",[function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"userError"),"delete",[gs.gp(it,"_id")]);
     }]);
    gs.sp(gSobject.scope,"selectedError",null);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"loadErrors",[]);
     }, 500]);
   }
  gSobject['screenshotUrl'] = function(error) {
    if (!gs.bool(gs.gp(error,"_id",true))) {
      return "";
     };
    return "/media/userError/screenshot/" + (gs.gp(error,"_id")) + "";
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaPushNotification() {
  var gSobject = gs.init('CordovaPushNotification');
  gSobject.clazz = { name: 'CordovaPushNotification', simpleName: 'CordovaPushNotification'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.pushService = null;
  gSobject.notificationListeners = gs.list([]);
  gSobject.pushConfig = gs.map().add("android",gs.map().add("icon","ic_notification")).add("ios",gs.map().add("alert","true").add("badge","true").add("sound","true")).add("windows",gs.map());
  gSobject['toLocation'] = function(path) {
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      if (!gs.bool(gs.mc(path,"startsWith",["http"]))) {
        path = (gs.plus((gs.plus((gs.mc(gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"location"),"href"),"toString",[]),"split",["#"])[0]), "#")), path));
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:path:" + (path) + ""]);
       };
      return gs.sp(gs.fs('window', this, gSobject),"location",path);
     }, 1000]);
   }
  gSobject['subscribe'] = function(callback) {
    return gs.mc(gSobject.notificationListeners,"add",[callback]);
   }
  gSobject.pluginInstalled = function() { return CordovaPushNotification.pluginInstalled(); }
  gSobject.hasNotificationPermission = function(x0) { return CordovaPushNotification.hasNotificationPermission(x0); }
  gSobject['CordovaPushNotification0'] = function(it) {
    gs.mc(document,"addEventListener",["deviceready", function(it) {
      if (!gs.bool(gs.mc(this,"pluginInstalled",[], gSobject))) {
        return null;
       };
      return gs.mc(gs.fs('legionUserService', this, gSobject),"loadLegionUser",[function(user) {
        gSobject.pushService = gs.mc(gs.fs('PushNotification', this, gSobject),"init",[gSobject.pushConfig]);
        gs.mc(gSobject.pushService,"on",["registration", function(data) {
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:registration:START:" + (gs.gp(user,"_id")) + ":" + (gs.execStatic(Utils,'deviceType', this,[])) + ":" + (gs.gp(data,"registrationId")) + ""]);
          gs.mc(this,"hasNotificationPermission",[function(status) {
            return gs.println("CordovaPushNotificationService:registration:STATUS:" + (gs.gp(user,"_id")) + ":" + (status) + "");
           }], gSobject);
          return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaDeviceNotificationService"),"registerDevice",[gs.gp(user,"_id"), gs.gp(data,"registrationId"), gs.execStatic(Utils,'deviceType', this,[]), function(it) {
            return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:registration:DONE:" + (gs.gp(user,"_id")) + ":" + (gs.execStatic(Utils,'deviceType', this,[])) + ":" + (gs.gp(data,"registrationId")) + ""]);
           }]);
         }]);
        gs.mc(gSobject.pushService,"on",["error", function(error) {
          return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:error:" + (error) + ""]);
         }]);
        return gs.mc(gSobject.pushService,"on",["notification", function(data) {
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["Notification received by device - " + (data) + ""]);
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[data]);
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:notification:1:" + (gs.gp(data,"message")) + ""]);
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:notification:2:" + (gs.gp(gs.gp(data,"additionalData"),"foreground")) + ""]);
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:notification:3:" + (gs.gp(gs.gp(data,"additionalData"),"url")) + ""]);
          if (gs.bool(gSobject.notificationListeners)) {
            gs.mc(gSobject.notificationListeners,"each",[function(callback) {
              return gs.execCall(callback, this, [data]);
             }]);
            return null;
           };
          if ((gs.equals(gs.gp(gs.gp(data,"additionalData"),"foreground"), false)) && (gs.bool(gs.gp(gs.gp(data,"additionalData"),"url")))) {
            return gs.mc(gSobject,"toLocation",[gs.gp(gs.gp(data,"additionalData"),"url")]);
           };
         }]);
       }]);
     }, false]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaPushNotification0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaPushNotification.pluginInstalled = function() {
  return ( typeof PushNotification !== 'undefined')
 }
CordovaPushNotification.hasNotificationPermission = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  
 }

function TestAppBleComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppBleComponent', simpleName: 'TestAppBleComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/ble";
  gSobject.roles = gs.list([]);
  gSobject.ble = null;
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBleComponent: created"]);
    gs.sp(gSobject.scope,"btStatus","unknown");
    gs.sp(gSobject.scope,"scanning",false);
    gs.sp(gSobject.scope,"devices",gs.list([]));
    gs.sp(gSobject.scope,"error","");
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
    return gSobject.ble = gs.execStatic(CordovaBle,'instance', this,[]);
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 50) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 49)));
     };
   }
  gSobject['initialize'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBleComponent: initialize"]);
    return gs.mc(gSobject.ble,"initialize",[function(result) {
      gs.sp(gSobject.scope,"btStatus",gs.gp(result,"status"));
      return gs.mc(gSobject,"addLog",["BT initialized: " + (gs.gp(result,"status")) + ""]);
     }]);
   }
  gSobject['startScan'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBleComponent: startScan"]);
    gs.sp(gSobject.scope,"devices",gs.list([]));
    gs.sp(gSobject.scope,"scanning",true);
    gs.sp(gSobject.scope,"error","");
    gs.mc(gSobject,"addLog",["Scanning started..."]);
    gs.mc(gSobject.ble,"startScan",[function(device) {
      gs.sp(gSobject.scope,"devices",(gs.plus(gs.gp(gSobject.scope,"devices"), gs.list([device]))));
      return gs.mc(gSobject,"addLog",["Found: " + (gs.gp(device,"name")) + " RSSI:" + (gs.gp(device,"rssi")) + ""]);
     }, function(err) {
      gs.sp(gSobject.scope,"error","Scan error: " + (err) + "");
      return gs.sp(gSobject.scope,"scanning",false);
     }]);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"stopScan",[]);
     }, 10000]);
   }
  gSobject['stopScan'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBleComponent: stopScan"]);
    return gs.mc(gSobject.ble,"stopScan",[function(r) {
      gs.sp(gSobject.scope,"scanning",false);
      return gs.mc(gSobject,"addLog",["Scan stopped. Found " + (gs.mc(gs.gp(gSobject.scope,"devices"),"size",[])) + " devices"]);
     }]);
   }
  gSobject['fetchAdapterInfo'] = function(it) {
    return gs.mc(gSobject.ble,"getAdapterInfo",[function(result) {
      return gs.mc(gSobject,"addLog",["Adapter: " + (gs.gp(result,"name")) + " addr:" + (gs.gp(result,"address")) + " init:" + (gs.gp(result,"isInitialized")) + " enabled:" + (gs.gp(result,"isEnabled")) + " scanning:" + (gs.gp(result,"isScanning")) + ""]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppHealthComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppHealthComponent', simpleName: 'TestAppHealthComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/health";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"available","unknown");
    gs.sp(gSobject.scope,"authorized",false);
    gs.sp(gSobject.scope,"steps",gs.list([]));
    gs.sp(gSobject.scope,"heartRate",gs.list([]));
    gs.sp(gSobject.scope,"bloodPressure",gs.list([]));
    return gs.sp(gSobject.scope,"log",gs.list([]));
   }
  gSobject['addLog'] = function(msg) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppHealth: " + (msg) + ""]);
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 29)));
     };
   }
  gSobject['checkAvailable'] = function(it) {
    gs.mc(gSobject,"addLog",["Checking availability..."]);
    return gs.mc(gs.fs('cordovaI3Health', this, gSobject),"testIsAvailable",[function(available) {
      gs.sp(gSobject.scope,"available",(gs.bool(available) ? "Available" : "Not available"));
      return gs.mc(gSobject,"addLog",["Health: " + (available) + ""]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["Error: " + (err) + ""]);
     }]);
   }
  gSobject['requestAuth'] = function(it) {
    gs.mc(gSobject,"addLog",["Requesting authorization..."]);
    return gs.mc(gs.fs('cordovaI3Health', this, gSobject),"requestPermissions",[function(result) {
      gs.sp(gSobject.scope,"authorized",true);
      return gs.mc(gSobject,"addLog",["Authorized"]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["Auth error: " + (err) + ""]);
     }]);
   }
  gSobject['querySteps'] = function(it) {
    var end = gs.date();
    var start = gs.date(gs.minus(gs.mc(end,"getTime",[]), 604800000));
    gs.mc(gSobject,"addLog",["Querying steps..."]);
    return gs.mc(gs.fs('cordovaI3Health', this, gSobject),"querySteps",[start, end, function(result) {
      gs.sp(gSobject.scope,"steps",gs.elvis(gs.bool(result) , result , gs.list([])));
      return gs.mc(gSobject,"addLog",["Steps: " + (gs.mc(gs.gp(gSobject.scope,"steps"),"size",[])) + " records"]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["Steps error: " + (err) + ""]);
     }]);
   }
  gSobject['queryHeartRate'] = function(it) {
    var end = gs.date();
    var start = gs.date(gs.minus(gs.mc(end,"getTime",[]), 604800000));
    gs.mc(gSobject,"addLog",["Querying heart rate..."]);
    return gs.mc(gs.fs('cordovaI3Health', this, gSobject),"queryHeartRate",[start, end, function(result) {
      gs.sp(gSobject.scope,"heartRate",gs.elvis(gs.bool(result) , result , gs.list([])));
      return gs.mc(gSobject,"addLog",["HR: " + (gs.mc(gs.gp(gSobject.scope,"heartRate"),"size",[])) + " records"]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["HR error: " + (err) + ""]);
     }]);
   }
  gSobject['queryBloodPressure'] = function(it) {
    var end = gs.date();
    var start = gs.date(gs.minus(gs.mc(end,"getTime",[]), 604800000));
    gs.mc(gSobject,"addLog",["Querying blood pressure..."]);
    return gs.mc(gs.fs('cordovaI3Health', this, gSobject),"queryBloodPressure",[start, end, function(result) {
      gs.sp(gSobject.scope,"bloodPressure",gs.elvis(gs.bool(result) , result , gs.list([])));
      return gs.mc(gSobject,"addLog",["BP: " + (gs.mc(gs.gp(gSobject.scope,"bloodPressure"),"size",[])) + " records"]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["BP error: " + (err) + ""]);
     }]);
   }
  gSobject['queryAggregatedSteps'] = function(it) {
    var end = gs.date();
    var start = gs.date(gs.minus(gs.mc(end,"getTime",[]), 604800000));
    gs.mc(gSobject,"addLog",["Querying daily steps..."]);
    return gs.mc(gs.fs('cordovaI3Health', this, gSobject),"queryAggregatedSteps",[start, end, function(result) {
      gs.sp(gSobject.scope,"steps",gs.elvis(gs.bool(result) , result , gs.list([])));
      return gs.mc(gSobject,"addLog",["Daily steps: " + (gs.mc(gs.gp(gSobject.scope,"steps"),"size",[])) + " days"]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["Agg error: " + (err) + ""]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function DymicoAuthService() {
  var gSobject = gs.init('DymicoAuthService');
  gSobject.clazz = { name: 'DymicoAuthService', simpleName: 'DymicoAuthService'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['auth'] = function(username, password, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"dymicoAuthService"),"authenticate",[username, password, function(authData) {
      gs.println("DymicoAuthService");
      gs.println(authData);
      if (gs.bool(gs.gp(authData,"authenticated"))) {
        gs.execStatic(Utils,'updateAuthTokenToSession', this,[authData]);
        gs.sp(gs.fs('session', this, gSobject),"authToken",gs.gp(gs.gp(authData,"zoner"),"token"));
        return null;
       };
      return gs.execCall(callback, this, [gs.gp(authData,"authenticated")]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppBatteryComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppBatteryComponent', simpleName: 'TestAppBatteryComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/battery";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBatteryComponent: created"]);
    gs.sp(gSobject.scope,"level",0);
    gs.sp(gSobject.scope,"isPlugged",false);
    gs.sp(gSobject.scope,"log",gs.list([]));
    return gs.sp(gSobject.scope,"listening",false);
   }
  gSobject['afterMounted'] = function(it) {
    if (TestAppBatteryComponent.cordovaDeviceAvailable()) {
      gs.sp(gSobject.scope,"level",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"battery"),"level",true)) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"battery"),"level",true) , 0));
      return gs.sp(gSobject.scope,"isPlugged",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"battery"),"isPlugged",true)) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"battery"),"isPlugged",true) , false));
     };
   }
  gSobject.cordovaDeviceAvailable = function() { return TestAppBatteryComponent.cordovaDeviceAvailable(); }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 29)));
     };
   }
  gSobject['startListening'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBatteryComponent: startListening"]);
    gs.sp(gSobject.scope,"listening",true);
    gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterystatus", function(status) {
      gs.sp(gSobject.scope,"level",gs.gp(status,"level"));
      gs.sp(gSobject.scope,"isPlugged",gs.gp(status,"isPlugged"));
      return gs.mc(gSobject,"addLog",["status: " + (gs.gp(status,"level")) + "% plugged:" + (gs.gp(status,"isPlugged")) + ""]);
     }, false]);
    gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterylow", function(status) {
      return gs.mc(gSobject,"addLog",["LOW: " + (gs.gp(status,"level")) + "%"]);
     }, false]);
    gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterycritical", function(status) {
      return gs.mc(gSobject,"addLog",["CRITICAL: " + (gs.gp(status,"level")) + "%"]);
     }, false]);
    return gs.mc(gSobject,"addLog",["Battery listeners registered"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppBatteryComponent.cordovaDeviceAvailable = function() {
  return typeof cordovaDevice !== 'undefined';
 }

function TestAppTripStore() {
  var gSobject = gs.init('TestAppTripStore');
  gSobject.clazz = { name: 'TestAppTripStore', simpleName: 'TestAppTripStore'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'FIX_KEY', { get: function() { return TestAppTripStore.FIX_KEY; }, set: function(gSval) { TestAppTripStore.FIX_KEY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'BATT_KEY', { get: function() { return TestAppTripStore.BATT_KEY; }, set: function(gSval) { TestAppTripStore.BATT_KEY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DIAG_KEY', { get: function() { return TestAppTripStore.DIAG_KEY; }, set: function(gSval) { TestAppTripStore.DIAG_KEY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MAX_FIXES', { get: function() { return TestAppTripStore.MAX_FIXES; }, set: function(gSval) { TestAppTripStore.MAX_FIXES = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MAX_BATT', { get: function() { return TestAppTripStore.MAX_BATT; }, set: function(gSval) { TestAppTripStore.MAX_BATT = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MAX_DIAG', { get: function() { return TestAppTripStore.MAX_DIAG; }, set: function(gSval) { TestAppTripStore.MAX_DIAG = gSval; }, enumerable: true });
  gSobject.addFix = function(x0) { return TestAppTripStore.addFix(x0); }
  gSobject.fixes = function() { return TestAppTripStore.fixes(); }
  gSobject.fixesForDay = function(x0,x1) { return TestAppTripStore.fixesForDay(x0,x1); }
  gSobject.unsyncedFixes = function() { return TestAppTripStore.unsyncedFixes(); }
  gSobject.markFixesSynced = function() { return TestAppTripStore.markFixesSynced(); }
  gSobject.clearFixes = function() { return TestAppTripStore.clearFixes(); }
  gSobject.addBattery = function(x0) { return TestAppTripStore.addBattery(x0); }
  gSobject.batteryForDay = function(x0,x1) { return TestAppTripStore.batteryForDay(x0,x1); }
  gSobject.clearBattery = function() { return TestAppTripStore.clearBattery(); }
  gSobject.addDiag = function(x0) { return TestAppTripStore.addDiag(x0); }
  gSobject.diag = function() { return TestAppTripStore.diag(); }
  gSobject.diagForDay = function(x0,x1) { return TestAppTripStore.diagForDay(x0,x1); }
  gSobject.clearDiag = function() { return TestAppTripStore.clearDiag(); }
  gSobject.counts = function() { return TestAppTripStore.counts(); }
  gSobject.clearAll = function() { return TestAppTripStore.clearAll(); }
  gSobject._append = function(x0,x1,x2) { return TestAppTripStore._append(x0,x1,x2); }
  gSobject._readAll = function(x0) { return TestAppTripStore._readAll(x0); }
  gSobject._readRange = function(x0,x1,x2) { return TestAppTripStore._readRange(x0,x1,x2); }
  gSobject._readUnsynced = function(x0) { return TestAppTripStore._readUnsynced(x0); }
  gSobject._markSynced = function(x0) { return TestAppTripStore._markSynced(x0); }
  gSobject._clear = function(x0) { return TestAppTripStore._clear(x0); }
  gSobject._count = function(x0) { return TestAppTripStore._count(x0); }
  gSobject._countUnsynced = function(x0) { return TestAppTripStore._countUnsynced(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppTripStore.addFix = function(fix) {
  return TestAppTripStore._append(TestAppTripStore.FIX_KEY, fix, TestAppTripStore.MAX_FIXES);
 }
TestAppTripStore.fixes = function(it) {
  return TestAppTripStore._readAll(TestAppTripStore.FIX_KEY);
 }
TestAppTripStore.fixesForDay = function(fromMs, toMs) {
  return TestAppTripStore._readRange(TestAppTripStore.FIX_KEY, fromMs, toMs);
 }
TestAppTripStore.unsyncedFixes = function(it) {
  return TestAppTripStore._readUnsynced(TestAppTripStore.FIX_KEY);
 }
TestAppTripStore.markFixesSynced = function(it) {
  return TestAppTripStore._markSynced(TestAppTripStore.FIX_KEY);
 }
TestAppTripStore.clearFixes = function(it) {
  return TestAppTripStore._clear(TestAppTripStore.FIX_KEY);
 }
TestAppTripStore.addBattery = function(sample) {
  return TestAppTripStore._append(TestAppTripStore.BATT_KEY, sample, TestAppTripStore.MAX_BATT);
 }
TestAppTripStore.batteryForDay = function(fromMs, toMs) {
  return TestAppTripStore._readRange(TestAppTripStore.BATT_KEY, fromMs, toMs);
 }
TestAppTripStore.clearBattery = function(it) {
  return TestAppTripStore._clear(TestAppTripStore.BATT_KEY);
 }
TestAppTripStore.addDiag = function(entry) {
  return TestAppTripStore._append(TestAppTripStore.DIAG_KEY, entry, TestAppTripStore.MAX_DIAG);
 }
TestAppTripStore.diag = function(it) {
  return TestAppTripStore._readAll(TestAppTripStore.DIAG_KEY);
 }
TestAppTripStore.diagForDay = function(fromMs, toMs) {
  return TestAppTripStore._readRange(TestAppTripStore.DIAG_KEY, fromMs, toMs);
 }
TestAppTripStore.clearDiag = function(it) {
  return TestAppTripStore._clear(TestAppTripStore.DIAG_KEY);
 }
TestAppTripStore.counts = function(it) {
  return gs.map().add("fixes",TestAppTripStore._count(TestAppTripStore.FIX_KEY)).add("battery",TestAppTripStore._count(TestAppTripStore.BATT_KEY)).add("diag",TestAppTripStore._count(TestAppTripStore.DIAG_KEY)).add("unsynced",TestAppTripStore._countUnsynced(TestAppTripStore.FIX_KEY));
 }
TestAppTripStore.clearAll = function(it) {
  TestAppTripStore._clear(TestAppTripStore.FIX_KEY);
  TestAppTripStore._clear(TestAppTripStore.BATT_KEY);
  return TestAppTripStore._clear(TestAppTripStore.DIAG_KEY);
 }
TestAppTripStore._append = function(key, item, max) {
  try {
            var raw = window.localStorage.getItem(key);
            var arr = raw ? JSON.parse(raw) : [];
            arr.push(item);
            // Time-based retention: keep ~7 days so a multi-day trip stays reviewable offline
            // via the Day Travel date picker, even if sync never happens.
            var RETAIN = 7 * 24 * 60 * 60 * 1000;
            var cutoff = (new Date().getTime()) - RETAIN;
            arr = arr.filter(function (x) { return x && (x.t == null || x.t >= cutoff); });
            // Hard count ceiling guards the localStorage quota (an overflow throws and would lose data).
            if (arr.length > max) arr = arr.slice(arr.length - max);
            window.localStorage.setItem(key, JSON.stringify(arr));
            return arr.length;
        } catch (e) { return -1; }
 }
TestAppTripStore._readAll = function(key) {
  try { var raw = window.localStorage.getItem(key); return raw ? JSON.parse(raw) : []; }
        catch (e) { return []; }
 }
TestAppTripStore._readRange = function(key, from, to) {
  try {
            var raw = window.localStorage.getItem(key);
            var arr = raw ? JSON.parse(raw) : [];
            return arr.filter(function (x) { return x && x.t >= from && x.t < to; });
        } catch (e) { return []; }
 }
TestAppTripStore._readUnsynced = function(key) {
  try {
            var raw = window.localStorage.getItem(key);
            var arr = raw ? JSON.parse(raw) : [];
            return arr.filter(function (x) { return x && !x.synced; });
        } catch (e) { return []; }
 }
TestAppTripStore._markSynced = function(key) {
  try {
            var raw = window.localStorage.getItem(key);
            var arr = raw ? JSON.parse(raw) : [];
            for (var i = 0; i < arr.length; i++) { arr[i].synced = 1; }
            window.localStorage.setItem(key, JSON.stringify(arr));
            return arr.length;
        } catch (e) { return -1; }
 }
TestAppTripStore._clear = function(key) {
  try { window.localStorage.removeItem(key); return true; } catch (e) { return false; }
 }
TestAppTripStore._count = function(key) {
  try { var raw = window.localStorage.getItem(key); return raw ? JSON.parse(raw).length : 0; }
        catch (e) { return 0; }
 }
TestAppTripStore._countUnsynced = function(key) {
  try {
            var raw = window.localStorage.getItem(key);
            var arr = raw ? JSON.parse(raw) : [];
            var n = 0; for (var i = 0; i < arr.length; i++) { if (!arr[i].synced) n++; }
            return n;
        } catch (e) { return 0; }
 }
TestAppTripStore.FIX_KEY = "testapp.trip.fixes";
TestAppTripStore.BATT_KEY = "testapp.trip.battery";
TestAppTripStore.DIAG_KEY = "testapp.trip.diag";
TestAppTripStore.MAX_FIXES = 20000;
TestAppTripStore.MAX_BATT = 3000;
TestAppTripStore.MAX_DIAG = 1500;

function DevReload() {
  var gSobject = gs.init('DevReload');
  gSobject.clazz = { name: 'DevReload', simpleName: 'DevReload'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'devMode', { get: function() { return DevReload.devMode; }, set: function(gSval) { DevReload.devMode = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'tagName', { get: function() { return DevReload.tagName; }, set: function(gSval) { DevReload.tagName = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'productIds', { get: function() { return DevReload.productIds; }, set: function(gSval) { DevReload.productIds = gSval; }, enumerable: true });
  gSobject.init = function() { return DevReload.init(); }
  gSobject.reloadCss = function(x0) { return DevReload.reloadCss(x0); }
  gSobject.reloadViews = function(x0) { return DevReload.reloadViews(x0); }
  gSobject.patchComponents = function(x0) { return DevReload.patchComponents(x0); }
  gSobject.reloadGrooscript = function(x0) { return DevReload.reloadGrooscript(x0); }
  gSobject.reloadFullBundle = function(x0) { return DevReload.reloadFullBundle(x0); }
  gSobject.forceRemount = function() { return DevReload.forceRemount(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
DevReload.init = function() {
  // Guard: only subscribe once per page lifetime.
        // The jsDynamo bundle is re-executed on every hot reload, so without this
        // guard each save would create a new setInterval and add duplicate subscriptions.
        if (window.__devReloadInitDone) return
        window.__devReloadInitDone = true

        console.log('DevReload: init(), tag=' + DevReload.tagName + ', devMode=' + DevReload.devMode + ', productIds=' + JSON.stringify(DevReload.productIds))
        if (!DevReload.devMode) return

        function handleMessage(message) {
            // Spring serialises via Jackson so body arrives JSON-quoted — unwrap first.
            var body = message.body || ''
            try { body = JSON.parse(body) } catch(e) {}

            console.log('DevReload: message received, body=' + body)

            if (body.indexOf('css:') === 0) {
                DevReload.reloadCss(body.substring(4))
            } else if (body.indexOf('view:') === 0) {
                DevReload.reloadViews(body.substring(5))
            } else if (body.indexOf('grooscript:') === 0) {
                DevReload.reloadGrooscript(body.substring(11))
            }
        }

        // Track the last STOMP client we subscribed to.
        // On WebSocket reconnect, socketConnect() creates a NEW Stomp client and assigns
        // it to Socket.websocketClient.  The old subscriptions are gone.  By comparing
        // the reference we detect the reconnect and re-subscribe automatically.
        var subscribedClient = null

        setInterval(function() {
            if (typeof Socket === 'undefined' || !Socket.websocketClient || !Socket.websocketClient.connected) return
            if (Socket.websocketClient === subscribedClient) return  // still the same connection — nothing to do

            subscribedClient = Socket.websocketClient

            var ids = DevReload.productIds || []
            ids.forEach(function(pid) {
                Socket.websocketClient.subscribe('/topic/devReload/' + pid, handleMessage)
                console.log('DevReload: subscribed to /topic/devReload/' + pid + ' (tag=' + DevReload.tagName + ')')
            })
        }, 500)
 }
DevReload.reloadCss = function(version) {
  console.log('DevReload: reloading CSS, v=' + version)
        document.querySelectorAll('link[rel="stylesheet"]').forEach(function(link) {
            if (!link.href.includes('/resourceBundle/')) return
            var base = link.href.split('?')[0]
            link.href = base + '?v=' + version
            console.log('DevReload: swapped CSS', base)
        })
 }
DevReload.reloadViews = function(version) {
  console.log('DevReload: reloadViews v=' + version)

        fetch('/resourceBundle/packCode/htmlBody?v=' + version)
            .then(function(res) { return res.text() })
            .then(function(html) {
                // Parse all x-template blocks and update the DOM
                var updatedHtmlMap = {}
                var regex = /<script\s[^>]*type="text\/x-template"[^>]*id="([^"]+)"[^>]*>([\s\S]*?)<\/script>/gi
                var match
                while ((match = regex.exec(html)) !== null) {
                    var el = document.getElementById(match[1])
                    if (el) {
                        el.innerHTML = match[2]
                        updatedHtmlMap[match[1]] = match[2]
                    }
                }
                console.log('DevReload: updated DOM templates:', Object.keys(updatedHtmlMap))

                DevReload.patchComponents(updatedHtmlMap)
                DevReload.forceRemount()
            })
            .catch(function(err) { console.error('DevReload: reloadViews failed', err) })
 }
DevReload.patchComponents = function(updatedHtmlMap) {
  var patched = []

        function patchComp(comp) {
            if (!comp || patched.indexOf(comp) >= 0) return

            var tid = null

            // Strategy 1: comp.template is still the '#id' selector
            if (comp.template && comp.template.charAt(0) === '#') {
                var sel = comp.template.substring(1)
                if (updatedHtmlMap[sel]) tid = sel
            }

            // Strategy 2: comp.template is inline HTML from a previous reload —
            // identify by name convention (vueComponentName + 'View')
            if (!tid && comp.vueComponentName) {
                var nameId = comp.vueComponentName + 'View'
                if (updatedHtmlMap[nameId]) tid = nameId
            }

            if (!tid) return

            comp.template = updatedHtmlMap[tid]
            delete comp.render
            delete comp.__vccOpts
            patched.push(comp)
            console.log('DevReload: patched component', comp.vueComponentName, '(template', tid + ')')
        }

        if (vue && vue.componentList) {
            vue.componentList.forEach(function(c) { patchComp(c) })
        }

        if (vue && vue.router && vue.router.getRoutes) {
            vue.router.getRoutes().forEach(function(route) {
                if (!route.components) return
                Object.keys(route.components).forEach(function(k) { patchComp(route.components[k]) })
            })
        }

        console.log('DevReload: patched', patched.length, 'component object(s)')
        if (patched.length === 0) {
            console.warn('DevReload: no components matched — possible naming mismatch')
        }
 }
DevReload.reloadGrooscript = function(payload) {
  var colonIdx = payload.indexOf(':')
        var version = colonIdx > 0 ? payload.substring(colonIdx + 1) : payload
        console.log('DevReload: reloading GrooScript, v=' + version)
        DevReload.reloadFullBundle(version)
 }
DevReload.reloadFullBundle = function(version) {
  console.log('DevReload: reloading jsDynamo bundle, v=' + version)

        vue.componentList.splice(0, vue.componentList.length)

        var script = document.createElement('script')
        script.src = '/resourceBundle/pack/jsDynamo?v=' + version
        script.onload = function() {
            console.log('DevReload: jsDynamo loaded —', vue.componentList.length, 'components')

            // Re-register all components globally
            vue.componentList.forEach(function(comp) {
                if (comp.vueComponentName) vue.vue.component(comp.vueComponentName, comp)
            })

            // Build name → new component lookup
            var nameToComp = {}
            vue.componentList.forEach(function(comp) {
                if (comp.vueComponentName) nameToComp[comp.vueComponentName] = comp
            })

            // Resync router route records to the new component objects
            var routesResynced = 0
            if (vue && vue.router && vue.router.getRoutes) {
                vue.router.getRoutes().forEach(function(route) {
                    if (!route.components) return
                    Object.keys(route.components).forEach(function(k) {
                        var oldComp = route.components[k]
                        var name = oldComp && oldComp.vueComponentName
                        if (name && nameToComp[name] && nameToComp[name] !== oldComp) {
                            route.components[k] = nameToComp[name]
                            routesResynced++
                        }
                    })
                })
            }
            console.log('DevReload: resynced', routesResynced, 'router route record(s)')

            // Re-apply current DOM innerHTML to every new component to preserve
            // any view edits made before this Grooscript save
            var domSynced = 0
            vue.componentList.forEach(function(comp) {
                if (!comp.template || comp.template.charAt(0) !== '#') return
                var el = document.getElementById(comp.template.substring(1))
                if (!el) return
                comp.template = el.innerHTML
                delete comp.render
                delete comp.__vccOpts
                domSynced++
            })
            console.log('DevReload: re-applied current DOM to', domSynced, 'component(s)')

            DevReload.forceRemount()
        }
        script.onerror = function() {
            console.error('DevReload: failed to load jsDynamo bundle')
        }
        document.head.appendChild(script)
 }
DevReload.forceRemount = function() {
  if (typeof vue === 'undefined' || !vue.router) return
        var currentPath = vue.router.currentRoute.value.fullPath
        console.log('DevReload: remounting', currentPath)
        vue.router.replace('/__devreload__').then(function() {
            return vue.router.replace(currentPath)
        }).then(function() {
            var matched = vue.router.currentRoute.value.matched
            for (var i = 0; i < matched.length; i++) {
                var component = matched[i].components && matched[i].components.default
                if (component && typeof component.created === 'function') {
                    var name = component.vueComponentName
                    var formattedName = name.charAt(0).toLowerCase() + name.slice(1)
                    eval(formattedName + '.created()')
                    console.log('DevReload: called created() on', formattedName)
                }
            }
        }).catch(function(err) {
            console.error('DevReload: navigation error', err)
        })
 }
DevReload.devMode = null;
DevReload.tagName = "dev";
DevReload.productIds = null;

function CordovaSimBridgeAuth() {
  var gSobject = gs.init('CordovaSimBridgeAuth');
  gSobject.clazz = { name: 'CordovaSimBridgeAuth', simpleName: 'CordovaSimBridgeAuth'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.active = false;
  gSobject.pendingCallbacks = gs.map();
  gSobject.shouldActivate = function() { return CordovaSimBridgeAuth.shouldActivate(); }
  gSobject['activate'] = function(it) {
    gSobject.active = true;
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaSimBridgeAuth: ACTIVE — adding auth, health, and media stubs"]);
    gs.mc(gSobject,"patchUserAgent",[]);
    gs.mc(gSobject,"addPluginStubs",[]);
    gs.mc(gSobject,"listenForMessages",[]);
    return gs.mc(gSobject,"patchUtilsIsCordova",[]);
   }
  gSobject.patchUserAgent = function() {
    // Append 'cordova.simulator' to the user agent so Utils.isCordova() returns true.
        // Utils.isCordova() checks: userAgent().contains('cordova')
        try {
            var originalUA = navigator.userAgent;
            Object.defineProperty(navigator, 'userAgent', {
                get: function() { return originalUA + ' cordova.simulator.1.0.0'; },
                configurable: true
            });
            console.log('[SimBridgeAuth] User agent patched — appended cordova.simulator.1.0.0');
        } catch(e) {
            console.warn('[SimBridgeAuth] Could not patch userAgent:', e);
        }
   }
  gSobject.addPluginStubs = function() {
    var bridge = this;

        // ===================== APPLE SIGN-IN =====================
        window.cordova.plugins.SignInWithApple = {
            signin: function(options, success, error) {
                bridge._storePending('appleSignIn', 'signin', success, error);
                console.log('[SimBridgeAuth] Apple Sign-In: waiting for simulated auth...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'appleSignIn', action:'signin'}, '*');
            }
        };

        // ===================== GOOGLE SIGN-IN =====================
        window.cordova.plugins.GoogleSignInPlugin = {
            signIn: function(success, error) {
                bridge._storePending('googleSignIn', 'signIn', success, error);
                console.log('[SimBridgeAuth] Google Sign-In: waiting for simulated auth...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'googleSignIn', action:'signIn'}, '*');
            },
            isSignedIn: function(success, error) {
                if (success) success({isSignedIn: false});
            },
            signOut: function(success, error) {
                console.log('[SimBridgeAuth] Google Sign-Out');
                if (success) success();
            },
            oneTapLogin: function(success, error) {
                bridge._storePending('googleSignIn', 'oneTap', success, error);
                console.log('[SimBridgeAuth] Google One-Tap: waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'googleSignIn', action:'oneTap'}, '*');
            },
        };

        // ===================== HEALTH =====================
        window.cordova.plugins.health = {
            isAvailable: function(success, error) {
                console.log('[SimBridgeAuth] Health: isAvailable -> true');
                if (success) success(true);
            },
            requestAuthorization: function(datatypes, success, error) {
                console.log('[SimBridgeAuth] Health: requestAuthorization granted');
                if (success) success(true);
            },
            isAuthorized: function(datatypes, success, error) {
                if (success) success(true);
            },
            query: function(params, success, error) {
                bridge._storePending('health', 'query', success, error);
                console.log('[SimBridgeAuth] Health query:', params.dataType, '— waiting for simulated data...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'health', action:'query', data:params}, '*');
            },
            queryAggregated: function(params, success, error) {
                bridge._storePending('health', 'queryAggregated', success, error);
                console.log('[SimBridgeAuth] Health queryAggregated:', params.dataType, '— waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'health', action:'queryAggregated', data:params}, '*');
            },
            store: function(data, success, error) {
                console.log('[SimBridgeAuth] Health store:', data);
                if (success) success();
            },
        };

        // ===================== MEDIA CAPTURE =====================
        window.navigator.device = window.navigator.device || {};
        window.navigator.device.capture = {
            captureImage: function(success, error, options) {
                bridge._storePending('media', 'captureImage', success, error);
                console.log('[SimBridgeAuth] Media captureImage: waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'media', action:'captureImage'}, '*');
            },
            captureAudio: function(success, error, options) {
                bridge._storePending('media', 'captureAudio', success, error);
                console.log('[SimBridgeAuth] Media captureAudio: waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'media', action:'captureAudio'}, '*');
            },
            captureVideo: function(success, error, options) {
                bridge._storePending('media', 'captureVideo', success, error);
                console.log('[SimBridgeAuth] Media captureVideo: waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'media', action:'captureVideo'}, '*');
            },
        };

        console.log('[SimBridgeAuth] Plugin stubs registered: SignInWithApple, GoogleSignInPlugin, health, media capture');
   }
  gSobject.listenForMessages = function() {
    var bridge = this;
        window.addEventListener('message', function(event) {
            var msg = event.data;
            if (!msg || msg.type !== 'cordova-sim') return;

            switch (msg.plugin) {
                case 'appleSignIn':
                    if (msg.action === 'success') bridge._firePending('appleSignIn', 'signin', msg.data);
                    if (msg.action === 'fail') bridge._firePendingError('appleSignIn', 'signin', msg.data || 'User cancelled');
                    break;

                case 'googleSignIn':
                    if (msg.action === 'success') bridge._firePending('googleSignIn', 'signIn', msg.data);
                    if (msg.action === 'oneTapSuccess') bridge._firePending('googleSignIn', 'oneTap', msg.data);
                    if (msg.action === 'fail') bridge._firePendingError('googleSignIn', 'signIn', msg.data || 'Sign in cancelled');
                    break;

                case 'health':
                    if (msg.action === 'queryResult') bridge._firePending('health', 'query', msg.data);
                    if (msg.action === 'queryAggregatedResult') bridge._firePending('health', 'queryAggregated', msg.data);
                    break;

                case 'media':
                    if (msg.action === 'capturedImage') bridge._firePending('media', 'captureImage', msg.data);
                    if (msg.action === 'capturedAudio') bridge._firePending('media', 'captureAudio', msg.data);
                    if (msg.action === 'capturedVideo') bridge._firePending('media', 'captureVideo', msg.data);
                    break;

                case 'console':
                    if (msg.action === 'eval') {
                        try {
                            var result = eval(msg.data.code);
                            window.parent.postMessage({type:'cordova-sim-event', plugin:'console', action:'result', data:{code: msg.data.code, result: JSON.stringify(result)}}, '*');
                        } catch(e) {
                            window.parent.postMessage({type:'cordova-sim-event', plugin:'console', action:'error', data:{code: msg.data.code, error: e.message}}, '*');
                        }
                    }
                    break;
            }
        });
        console.log('[SimBridgeAuth] postMessage listener registered for auth/health/media');
   }
  gSobject.patchUtilsIsCordova = function() {
    // Utils is loaded later by GrooScript. Poll until it exists, then patch.
        var attempts = 0;
        var patcher = setInterval(function() {
            attempts++;
            if (typeof Utils !== 'undefined' && Utils.isCordova) {
                Utils.isCordova = function() { return true; };
                Utils.cordovaDevice = function() { return true; };
                console.log('[SimBridgeAuth] Utils.isCordova patched to return true');
                clearInterval(patcher);
            }
            if (attempts > 100) clearInterval(patcher); // stop after ~10s
        }, 100);
   }
  gSobject._storePending = function(plugin, action, success, error) {
    var key = plugin + ':' + action;
        this.pendingCallbacks[key] = { success: success, error: error };
   }
  gSobject._firePending = function(plugin, action, data) {
    var key = plugin + ':' + action;
        var pending = this.pendingCallbacks[key];
        if (pending && pending.success) {
            pending.success(data);
            delete this.pendingCallbacks[key];
        }
   }
  gSobject._firePendingError = function(plugin, action, data) {
    var key = plugin + ':' + action;
        var pending = this.pendingCallbacks[key];
        if (pending && pending.error) {
            pending.error(data);
            delete this.pendingCallbacks[key];
        }
   }
  gSobject['CordovaSimBridgeAuth0'] = function(it) {
    if (CordovaSimBridgeAuth.shouldActivate()) {
      gs.mc(gSobject,"activate",[]);
     };
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaSimBridgeAuth0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaSimBridgeAuth.shouldActivate = function() {
  // Only activate if CordovaSimBridge already created the fake cordova object
        // i.e. we're in an iframe and window.cordova exists but is our fake one
        return (window.parent !== window) && (typeof window.cordova !== 'undefined') && (typeof window.device !== 'undefined' && window.device.platform === 'Simulator');
 }

function CordovaProblemReporter() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'CordovaProblemReporter', simpleName: 'CordovaProblemReporter'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/reportProblem";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"userMessage","");
    gs.sp(gSobject.scope,"severity","normal");
    gs.sp(gSobject.scope,"severities",gs.list(["low" , "normal" , "high" , "critical"]));
    gs.sp(gSobject.scope,"thumbnailUrl","");
    gs.sp(gSobject.scope,"submitting",false);
    gs.sp(gSobject.scope,"captureCountdown",0);
    gs.sp(gSobject.scope,"hasCapture",false);
    gs.sp(gSobject.scope,"userId",gs.elvis(gs.bool(gs.gp(gs.fs('session', this, gSobject),"userId")) , gs.gp(gs.fs('session', this, gSobject),"userId") , "(anonymous)"));
    gs.sp(gSobject.scope,"deviceUuid",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"uuid",true)) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"uuid",true) , ""));
    gs.sp(gSobject.scope,"platform",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"platform",true)) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"platform",true) , "browser"));
    return gs.mc(gSobject,"loadPendingCapture",[]);
   }
  gSobject['loadPendingCapture'] = function(it) {
    var pending = gs.mc(gSobject,"nativeReadPendingBlob",[]);
    if ((gs.bool(pending)) && (gs.bool(gs.gp(pending,"blob")))) {
      gs.sp(gSobject.scope,"hasCapture",true);
      return gs.sp(gSobject.scope,"thumbnailUrl",gs.mc(gSobject,"nativeBlobToObjectUrl",[gs.gp(pending,"blob")]));
     };
   }
  gSobject['captureWithCountdown'] = function(it) {
    gs.sp(gSobject.scope,"captureCountdown",3);
    return gs.mc(gSobject,"tick",[]);
   }
  gSobject['tick'] = function(it) {
    if (gs.gp(gSobject.scope,"captureCountdown") <= 0) {
      gs.mc(gSobject,"doCapture",[]);
      return null;
     };
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      gs.sp(gSobject.scope,"captureCountdown",(gs.minus(gs.gp(gSobject.scope,"captureCountdown"), 1)));
      return gs.mc(gSobject,"tick",[]);
     }, 1000]);
   }
  gSobject['doCapture'] = function(it) {
    return gs.mc(gs.fs('cordovaScreenCapture', this, gSobject),"capture",[function(blob, meta) {
      gs.mc(gSobject,"nativeStashBlob",[blob]);
      gs.sp(gSobject.scope,"hasCapture",true);
      return gs.sp(gSobject.scope,"thumbnailUrl",gs.mc(gSobject,"nativeBlobToObjectUrl",[blob]));
     }, function(err) {
      return gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Notify"),"create",[gs.map().add("type","negative").add("message","Capture failed: " + (err) + "")]);
     }]);
   }
  gSobject['submit'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"submitting"))) {
      return null;
     };
    if (!gs.bool(gs.mc(gs.gp(gSobject.scope,"userMessage"),"trim",[], null, true))) {
      gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Notify"),"create",[gs.map().add("type","warning").add("message","Please describe the problem")]);
      return null;
     };
    gs.sp(gSobject.scope,"submitting",true);
    var opts = gs.map().add("severity",gs.gp(gSobject.scope,"severity"));
    return gs.mc(gs.fs('cordovaScreenCapture', this, gSobject),"reportProblem",[gs.gp(gSobject.scope,"userMessage"), opts, function(reportId) {
      gs.sp(gSobject.scope,"submitting",false);
      gs.mc(gSobject,"nativeClearPendingBlob",[]);
      gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Notify"),"create",[gs.map().add("type","positive").add("message","Problem reported. Thanks!").add("actions",gs.list([gs.map().add("label","View").add("color","white").add("handler",function(it) {
        return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/cordovaErrors"]);
       })]))]);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"back",[]);
     }, function(err) {
      gs.sp(gSobject.scope,"submitting",false);
      return gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Notify"),"create",[gs.map().add("type","negative").add("message","Failed to send: " + (err) + "")]);
     }]);
   }
  gSobject['cancel'] = function(it) {
    gs.mc(gSobject,"nativeClearPendingBlob",[]);
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"back",[]);
   }
  gSobject.nativeReadPendingBlob = function() {
    return window._cwPendingReport || null;
   }
  gSobject.nativeStashBlob = function(blob) {
    window._cwPendingReport = { blob: blob, ts: Date.now() };
   }
  gSobject.nativeClearPendingBlob = function() {
    if (window._cwPendingReport && window._cwPendingReport.thumbnailUrl) {
            try { URL.revokeObjectURL(window._cwPendingReport.thumbnailUrl); } catch(_) {}
        }
        window._cwPendingReport = null;
   }
  gSobject.nativeBlobToObjectUrl = function(blob) {
    try { return URL.createObjectURL(blob); } catch(e) { return ''; }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function VueDocumentViewer() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueDocumentViewer', simpleName: 'VueDocumentViewer'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list(["oObject" , "oName" , "oPropName" , "download" , "filePreview" , "displayName" , "myStyle"]);
  gSobject.data = function(it) {
    return gs.map().add("showFullscreenDialog",false);
   };
  gSobject['mounted'] = function(it) {
    var self = this;
    var fileInfo = gs.gp(self,"oObject")[gs.gp(self,"oPropName")];
    var lastUpdated = gs.gp(gs.gp(self,"oObject"),"_lastUpdated");
    try {
      lastUpdated = gs.mc(lastUpdated,"getTime",[]);
     }
    catch (all) {
     }
    ;
    gs.sp(self,"pdfUrl","/media-cache/file/" + (gs.gp(gs.gp(self,"oObject"),"_id")) + "/" + (gs.gp(self,"oPropName")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "");
    gs.sp(self,"preview","/media-cache/filePreview/" + (gs.gp(gs.gp(self,"oObject"),"_id")) + "/" + (gs.gp(self,"oPropName")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "");
    if (!gs.bool(gs.gp(self,"download"))) {
      gs.sp(self,"download",false);
     };
    if (!gs.bool(gs.gp(self,"filePreview"))) {
      gs.sp(self,"filePreview",false);
     };
    if (!gs.bool(gs.gp(self,"displayName"))) {
      gs.sp(self,"displayName",false);
     };
    return gs.sp(self,"showFullscreenDialog",false);
   }
  gSobject['objectLoaded'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"oObject"))) {
      return false;
     };
    return true;
   }
  gSobject['show'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"filePreview"))) {
      return null;
     };
    gs.mc(gs.gp(gs.mc(gSobject,"getRefs",[]),"dialog"),"show",[]);
    gs.mc(gSobject,"nextTick",[function(it) {
      PdfJsHandler(gs.gp(self,"pdfUrl"));
      return HammerJsZoom("pdf_canvas");
     }]);
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      return gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["any"]);
     };
   }
  gSobject['hideFullscreenDialog'] = function(it) {
    gs.sp(gSobject.self,"showFullscreenDialog",false);
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      return gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["portrait"]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppShareComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppShareComponent', simpleName: 'TestAppShareComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/share";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppShareComponent: created"]);
    gs.sp(gSobject.scope,"message","Hello from Dymico Test App!");
    gs.sp(gSobject.scope,"subject","Dymico Test");
    gs.sp(gSobject.scope,"url","https://dymico.office.i3zone.com");
    gs.sp(gSobject.scope,"result","");
    gs.sp(gSobject.scope,"error","");
    return gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
   }
  gSobject['shareGeneric'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppShareComponent: shareGeneric"]);
    gs.sp(gSobject.scope,"error","");
    return gs.mc(gs.fs('cordovaShare', this, gSobject),"share",[gs.gp(gSobject.scope,"message"), gs.gp(gSobject.scope,"subject"), null, gs.gp(gSobject.scope,"url"), function(it) {
      return gs.sp(gSobject.scope,"result","Share completed");
     }, function(e) {
      return gs.sp(gSobject.scope,"error","Share failed: " + (e) + "");
     }]);
   }
  gSobject['shareViaEmail'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppShareComponent: shareViaEmail"]);
    gs.sp(gSobject.scope,"error","");
    return gs.mc(gs.fs('cordovaShare', this, gSobject),"shareViaEmail",[gs.gp(gSobject.scope,"message"), gs.gp(gSobject.scope,"subject"), gs.list([]), gs.list([]), gs.list([]), null, function(it) {
      return gs.sp(gSobject.scope,"result","Email share completed");
     }, function(e) {
      return gs.sp(gSobject.scope,"error","Email failed: " + (e) + "");
     }]);
   }
  gSobject['shareViaSMS'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppShareComponent: shareViaSMS"]);
    gs.sp(gSobject.scope,"error","");
    return gs.mc(gs.fs('cordovaShare', this, gSobject),"shareViaSMS",[gs.gp(gSobject.scope,"message"), "", function(it) {
      return gs.sp(gSobject.scope,"result","SMS share completed");
     }, function(e) {
      return gs.sp(gSobject.scope,"error","SMS failed: " + (e) + "");
     }]);
   }
  gSobject['shareViaWhatsApp'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppShareComponent: shareViaWhatsApp"]);
    gs.sp(gSobject.scope,"error","");
    return gs.mc(gs.fs('cordovaShare', this, gSobject),"shareViaWhatsApp",[gs.gp(gSobject.scope,"message"), null, gs.gp(gSobject.scope,"url"), function(it) {
      return gs.sp(gSobject.scope,"result","WhatsApp share completed");
     }, function(e) {
      return gs.sp(gSobject.scope,"error","WhatsApp failed: " + (e) + "");
     }]);
   }
  gSobject['checkCanShareVia'] = function(via) {
    return gs.mc(gs.fs('cordovaShare', this, gSobject),"canShareVia",[via, gs.gp(gSobject.scope,"message"), null, null, null, function(it) {
      return gs.sp(gSobject.scope,"result","" + (via) + " is available");
     }, function(it) {
      return gs.sp(gSobject.scope,"result","" + (via) + " is NOT available");
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppLocalNotifComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppLocalNotifComponent', simpleName: 'TestAppLocalNotifComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/localnotif";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppLocalNotifComponent: created"]);
    gs.sp(gSobject.scope,"hasPermission",false);
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"title","Test Reminder");
    gs.sp(gSobject.scope,"text","This is a local notification");
    return gs.sp(gSobject.scope,"delay",5);
   }
  gSobject['addLog'] = function(msg) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppLocalNotifComponent: " + (msg) + ""]);
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 20) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 19)));
     };
   }
  gSobject['afterMounted'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppLocalNotifComponent: afterMounted"]);
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppLocalNotifComponent: typeof cordovaLocalNotification = " + (TestAppLocalNotifComponent.checkLocalNotif()) + ""]);
    gs.mc(gSobject,"addLog",["Page loaded"]);
    try {
      gs.mc(gs.fs('cordovaLocalNotification', this, gSobject),"hasPermission",[function(granted) {
        gs.sp(gSobject.scope,"hasPermission",granted);
        gs.mc(gSobject,"addLog",["Permission: " + (granted) + ""]);
        if (!gs.bool(granted)) {
          return gs.mc(gs.fs('cordovaLocalNotification', this, gSobject),"requestPermission",[function(result) {
            gs.sp(gSobject.scope,"hasPermission",result);
            return gs.mc(gSobject,"addLog",["Permission requested: " + (result) + ""]);
           }]);
         };
       }]);
     }
    catch (e) {
      gs.mc(gSobject,"addLog",["hasPermission error: " + (gs.fs('e', this, gSobject)) + ""]);
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppLocalNotifComponent: hasPermission error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
    try {
      gs.mc(gs.fs('cordovaLocalNotification', this, gSobject),"on",["trigger", function(notif) {
        return gs.mc(gSobject,"addLog",["TRIGGERED: " + (gs.elvis(gs.bool(gs.gp(notif,"title",true)) , gs.gp(notif,"title",true) , notif)) + ""]);
       }]);
      gs.mc(gs.fs('cordovaLocalNotification', this, gSobject),"on",["click", function(notif) {
        return gs.mc(gSobject,"addLog",["CLICKED: " + (gs.elvis(gs.bool(gs.gp(notif,"title",true)) , gs.gp(notif,"title",true) , notif)) + ""]);
       }]);
     }
    catch (e) {
      gs.mc(gSobject,"addLog",["on() error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['requestPermission'] = function(it) {
    try {
      gs.mc(gs.fs('cordovaLocalNotification', this, gSobject),"requestPermission",[function(granted) {
        gs.sp(gSobject.scope,"hasPermission",granted);
        return gs.mc(gSobject,"addLog",["Permission: " + (granted) + ""]);
       }]);
     }
    catch (e) {
      gs.mc(gSobject,"addLog",["requestPermission error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['scheduleNotification'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppLocalNotifComponent: scheduleNotification"]);
    gs.mc(gSobject,"addLog",["Scheduling '" + (gs.gp(gSobject.scope,"title")) + "' in " + (gs.gp(gSobject.scope,"delay")) + "s..."]);
    try {
      gs.mc(gs.fs('cordovaLocalNotification', this, gSobject),"schedule",[gs.map().add("title",gs.gp(gSobject.scope,"title")).add("text",gs.gp(gSobject.scope,"text")).add("trigger",gs.map().add("in",gs.gp(gSobject.scope,"delay")).add("unit","second")), function(it) {
        return gs.mc(gSobject,"addLog",["Scheduled!"]);
       }]);
     }
    catch (e) {
      gs.mc(gSobject,"addLog",["schedule error: " + (gs.fs('e', this, gSobject)) + ""]);
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppLocalNotifComponent: schedule error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['scheduleRepeating'] = function(it) {
    try {
      gs.mc(gs.fs('cordovaLocalNotification', this, gSobject),"schedule",[gs.map().add("id",999).add("title","Repeating").add("text","Every minute").add("trigger",gs.map().add("in",1).add("unit","minute").add("every","minute")), function(it) {
        return gs.mc(gSobject,"addLog",["Repeating scheduled"]);
       }]);
     }
    catch (e) {
      gs.mc(gSobject,"addLog",["repeating error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['cancelAll'] = function(it) {
    try {
      gs.mc(gs.fs('cordovaLocalNotification', this, gSobject),"cancelAll",[function(it) {
        return gs.mc(gSobject,"addLog",["All cancelled"]);
       }]);
     }
    catch (e) {
      gs.mc(gSobject,"addLog",["cancelAll error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject.checkLocalNotif = function() { return TestAppLocalNotifComponent.checkLocalNotif(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppLocalNotifComponent.checkLocalNotif = function() {
  return typeof cordovaLocalNotification;
 }

function I3Media() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Media', simpleName: 'I3Media'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  Object.defineProperty(gSobject, 'PREVIEW_LIMIT', { get: function() { return I3Media.PREVIEW_LIMIT; }, set: function(gSval) { I3Media.PREVIEW_LIMIT = gSval; }, enumerable: true });
  gSobject.props = gs.map().add("object",Map).add("prop",String).add("objectName",String).add("serverWidth",String).add("serverHeight",String).add("placeholder",String).add("eager",Boolean).add("path",String).add("type",String).add("upload",Boolean).add("delete",Boolean).add("camera",Boolean).add("initCallback",gs.map().add("type",Function).add("default",function(it) {
   })).add("removedCallback",gs.map().add("type",Function).add("default",function(it) {
   })).add("callback",gs.map().add("type",Function).add("default",function(it) {
   })).add("base64",Boolean).add("embedText",Function).add("view",Boolean).add("download",Boolean).add("preview",Boolean).add("autoplay",Boolean).add("muted",Boolean).add("loop",Boolean).add("controls",Boolean).add("customControls",Boolean).add("fullscreenControl",Boolean).add("muteControl",Boolean).add("classes",String).add("width",String).add("height",String).add("maxWidth",String).add("maxHeight",String).add("borderRadius",String).add("ratio",String).add("fit",String).add("noSpinner",Boolean).add("noTransition",Boolean).add("noAnimation",Boolean).add("location",Boolean).add("grayScale",Boolean);
  gSobject.data = function(it) {
    return gs.map().add("mediaType","").add("uploadSpinner",false).add("viewDialog",false).add("videoPlaying",false).add("videoEnded",false).add("videoMuted",false).add("imageMetadata",gs.map());
   };
  gSobject['created'] = function(it) {
    gs.println("I3Media.created()");
    var self = this;
    return gs.mc(gSobject,"init",[self]);
   }
  gSobject['watchObject'] = function(it) {
    var self = this;
    return gs.mc(gSobject,"init",[self]);
   }
  gSobject['init'] = function(self) {
    gs.sp(self,"placeholderUrl","/statics/vue-wrapper/img/placeHolder.png");
    gs.sp(self,"mediaType","");
    gs.sp(self,"fileToUpload",null);
    gs.sp(self,"viewDialog",false);
    gs.sp(self,"uploadEnabled",false);
    gs.sp(self,"deleteEnabled",false);
    gs.sp(self,"downloadEnabled",false);
    gs.sp(self,"cameraEnabled",false);
    gs.sp(self,"ratioStyle",(gs.bool(gs.gp(self,"ratio")) ? gs.plus((gs.plus("padding-top:", (gs.multiply(Math.pow(gs.gp(self,"ratio"), -1), 100)))), "%") : ""));
    gs.sp(self,"ratioClass",(gs.bool(gs.gp(self,"ratio")) ? "absolute" : ""));
    gs.sp(self,"borderRadiusStyle",(gs.bool(gs.gp(self,"borderRadius")) ? gs.plus("border-radius:", gs.gp(self,"borderRadius")) : ""));
    gs.sp(self,"maxWidthStyle",(gs.bool(gs.gp(self,"maxWidth")) ? gs.plus("max-width:", gs.gp(self,"maxWidth")) : ""));
    gs.sp(self,"maxHeightStyle",(gs.bool(gs.gp(self,"maxHeight")) ? gs.plus("max-height:", gs.gp(self,"maxHeight")) : ""));
    gs.sp(self,"grayScaleStyle",(gs.bool(gs.gp(self,"grayScale")) ? "filter: grayscale(1)" : ""));
    gs.sp(self,"staticWidth",(gs.bool(gs.gp(self,"width")) ? gs.plus("width:", gs.gp(self,"width")) : ""));
    gs.sp(self,"staticHeight",(gs.bool(gs.gp(self,"height")) ? gs.plus("height:", gs.gp(self,"height")) : ""));
    gs.sp(self,"loading",(gs.bool(gs.gp(self,"eager")) ? "eager" : "lazy"));
    gs.sp(self,"videoMuted",gs.gp(self,"muted"));
    gs.sp(self,"accepted",gs.mc(gSobject,"resolveAcceptedType",[gs.gp(self,"type")]));
    if (gs.bool(gs.gp(self,"path"))) {
      return gs.sp(self,"previewUrl",gs.gp(self,"path"));
     };
    if (gs.bool(gs.gp(self,"placeholder"))) {
      gs.sp(self,"placeholderUrl",gs.gp(self,"placeholder"));
     };
    if ((!gs.bool(gs.gp(self,"object"))) || (!gs.bool(gs.gp(self,"prop")))) {
      return gs.sp(self,"previewUrl",gs.gp(self,"placeholderUrl"));
     };
    if (gs.bool(gs.gp(self,"upload"))) {
      gs.sp(self,"uploadEnabled",true);
     };
    if (gs.bool(gs.gp(self,"camera"))) {
      gs.sp(self,"cameraEnabled",((gs.execStatic(Utils,'isCordova', this,[])) && (gs.bool(gs.gp(self,"camera")))));
     };
    if (!gs.bool(gs.gp(self,"object")[gs.gp(self,"prop")])) {
      return gs.sp(self,"previewUrl",gs.gp(self,"placeholderUrl"));
     };
    if (gs.bool(gs.gp(self,"delete"))) {
      gs.sp(self,"deleteEnabled",true);
     };
    if (gs.bool(gs.gp(self,"download"))) {
      gs.sp(self,"downloadEnabled",true);
     };
    var fileInfo = gs.gp(self,"object")[gs.gp(self,"prop")];
    var lastUpdated = gs.gp(gs.gp(self,"object"),"_lastUpdated");
    try {
      lastUpdated = gs.mc(lastUpdated,"getTime",[]);
     }
    catch (all) {
     }
    ;
    if (gs.bool(gs.gp(self,"base64"))) {
      gs.sp(self,"mediaType","image");
      gs.sp(self,"previewUrl",(gs.gp(self,"object")[gs.gp(self,"prop")]));
      gs.sp(self,"downloadUrl",(gs.gp(self,"object")[gs.gp(self,"prop")]));
      gs.sp(self,"uploadSpinner",false);
      return null;
     };
    gs.sp(self,"mediaType",gs.mc(gSobject,"resolveMediaType",[fileInfo, gs.gp(self,"preview")]));
    var url = "/media-cache/filePreview/" + (gs.gp(gs.gp(self,"object"),"_id")) + "/" + (gs.gp(self,"prop")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "?";
    if (gs.bool(gs.gp(self,"serverWidth"))) {
      url += (gs.plus("&width=", gs.gp(self,"serverWidth")));
     };
    if (gs.bool(gs.gp(self,"serverHeight"))) {
      url += (gs.plus("&height=", gs.gp(self,"serverHeight")));
     };
    gs.sp(self,"previewUrl",url);
    gs.sp(self,"downloadUrl","/media-cache/file/" + (gs.gp(gs.gp(self,"object"),"_id")) + "/" + (gs.gp(self,"prop")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "");
    if (gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["svg"])) {
      gs.sp(self,"previewUrl",gs.gp(self,"downloadUrl"));
     };
    return gs.mc(gSobject,"loadFromBlob",[self]);
   }
  gSobject['loadFromBlob'] = function(self) {
    if (gs.equals(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"network"),"status"), "online")) {
      return null;
     };
    return gs.mc(gs.fs('cordovaFile', this, gSobject),"getBlobFromCachedFile",[gs.mc(gSobject,"objectName",[self]), gs.gp(self,"prop"), gs.gp(gs.gp(self,"object"),"_id"), function(entry) {
      if ((gs.bool(gs.gp(entry,"blob"))) && (gs.mc(gs.gp(entry,"type"),"startsWith",["image/"]))) {
        var blob = gs.gp(entry,"blob");
        return gs.execStatic(Utils,'blobToDataUrl', this,[blob, function(base64) {
          gs.sp(self,"previewUrl",base64);
          gs.sp(self,"downloadUrl",base64);
          gs.sp(self,"uploadSpinner",false);
          return gs.mc(gSobject,"refreshImage",[self]);
         }]);
       };
     }]);
   }
  gSobject['refreshImage'] = function(self) {
    var mediaType = gs.gp(self,"mediaType");
    gs.sp(self,"mediaType","");
    return gs.mc(gSobject,"nextTick",[function(it) {
      return gs.sp(self,"mediaType",mediaType);
     }]);
   }
  gSobject['objectName'] = function(self) {
    if (gs.bool(gs.gp(self,"objectName"))) {
      return gs.gp(self,"objectName");
     };
    return gs.mc(gs.gp(gs.gp(self,"object"),"_path"),"split",["/"])[2];
   }
  gSobject['openViewDialog'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"view"))) {
      return null;
     };
    if (!gs.bool(gs.mc(gSobject,"fileExists",[self]))) {
      return null;
     };
    gs.sp(self,"viewDialog",true);
    return gs.mc(gSobject,"nextTick",[function(it) {
      if (gs.equals(gs.gp(self,"mediaType"), "pdf")) {
        return gs.mc(PdfJsHandler(),"build",[gs.gp(self,"downloadUrl"), function(it) {
          return gs.execStatic(Utils,'setTimeout', this,[function(it) {
            return PinchToZoomHandler("pdf-viewer", "pdf");
           }, 3000]);
         }]);
       } else {
        return PinchToZoomHandler("viewer-id", "image");
       };
     }]);
   }
  gSobject['closeViewDialog'] = function(it) {
    var self = this;
    return gs.sp(self,"viewDialog",false);
   }
  gSobject['fileExists'] = function(self) {
    if (self === undefined) self = this;
    if (!gs.bool(self)) {
      self = this;
     };
    if (!gs.bool(gs.gp(self,"object"))) {
      return false;
     };
    return (gs.gp(self,"object")[gs.gp(self,"prop")] ? true : false);
   }
  gSobject['downloadFile'] = function(it) {
    var self = this;
    return gs.mc(gs.fs('window', this, gSobject),"open",[gs.gp(self,"downloadUrl"), "_system"]);
   }
  gSobject['saveFile'] = function(it) {
    var self = this;
    gs.sp(self,"uploadSpinner",true);
    gs.mc(self,"initCallback",[gs.gp(self,"object")]);
    gs.println("self.embedText()");
    gs.println(gs.gp(self,"embedText"));
    var embedText = "";
    if (gs.bool(gs.gp(self,"embedText"))) {
      embedText = gs.mc(self,"embedText",[]);
     };
    return gs.mc(gs.fs('cordovaFile', this, gSobject),"addFile",[gs.gp(self,"fileToUpload"), gs.mc(gSobject,"objectName",[self]), gs.gp(self,"prop"), gs.gp(gs.gp(self,"object"),"_id"), function(result, blob) {
      gs.mc(gSobject,"notify",["Media Uploaded"]);
      gs.sp(self,"uploadSpinner",false);
      return gs.mc(gSobject,"updateMedia",[self, gs.gp(gs.gp(self,"fileToUpload"),"name"), gs.gp(gs.gp(self,"fileToUpload"),"type")]);
     }, function(error) {
      gs.mc(gSobject,"notify",["Your offline. Upload will resume later..."]);
      return gs.mc(gSobject,"updateMedia",[self, gs.gp(gs.gp(self,"fileToUpload"),"name"), gs.gp(gs.gp(self,"fileToUpload"),"type")]);
     }]);
   }
  gSobject['deleteFile'] = function(it) {
    var self = this;
    gs.sp(gs.gp(self,"object"),"_lastUpdated",gs.date());
    (gs.gp(self,"object")[gs.gp(self,"prop")]) = null;
    gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"vueWrapperService"),"deleteFile",[gs.gp(gs.gp(self,"object"),"_id"), gs.gp(self,"prop")]),"do",[]);
    gs.mc(gs.fs('cordovaFile', this, gSobject),"deleteFile",[gs.mc(gSobject,"objectName",[self]), gs.gp(self,"prop"), gs.gp(gs.gp(self,"object"),"_id")]);
    gs.mc(gSobject,"init",[self]);
    return gs.mc(self,"removedCallback",[gs.gp(self,"object")]);
   }
  gSobject['startCamera'] = function(it) {
    var self = this;
    gs.sp(self,"uploadSpinner",true);
    gs.mc(self,"initCallback",[gs.gp(self,"object")]);
    return gs.mc(gs.fs('cordovaCamera', this, gSobject),"takePhotoAndUpload",[gs.mc(gSobject,"objectName",[self]), gs.gp(self,"prop"), gs.gp(gs.gp(self,"object"),"_id"), function(localFile, blob) {
      gs.mc(gSobject,"notify",["Photo Uploaded"]);
      gs.sp(self,"uploadSpinner",false);
      return gs.mc(gSobject,"updateMedia",[self, "blob", gs.gp(localFile,"type")]);
     }, function(error) {
      gs.mc(gSobject,"notify",["Photo Upload Failed", "negative"]);
      return gs.sp(self,"uploadSpinner",false);
     }]);
   }
  gSobject['updateMedia'] = function(self, filename, contentType) {
    gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"mediaCacheService"),"deleteCache",[gs.gp(gs.gp(self,"object"),"_id"), gs.gp(self,"prop")]),"do",[]);
    var fileInfo = gs.map().add("id","" + (gs.gp(gs.gp(self,"object"),"_id")) + "_" + (gs.gp(self,"prop")) + "").add("filename",filename).add("contentType",contentType);
    gs.sp(gs.gp(self,"object"),"_lastUpdated",gs.date());
    (gs.gp(self,"object")[gs.gp(self,"prop")]) = fileInfo;
    gs.mc(gSobject,"init",[self]);
    return gs.mc(self,"callback",[gs.gp(self,"object")]);
   }
  gSobject['resolveMediaType'] = function(fileInfo, preview) {
    if ((gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["image"], null, true)) || (gs.bool(preview))) {
      return "image";
     };
    if (gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["video"], null, true)) {
      return "video";
     };
    if (gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["audio"], null, true)) {
      return "audio";
     };
    if (gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["application"], null, true)) {
      return "pdf";
     };
    return "image";
   }
  gSobject['resolveAcceptedType'] = function(type) {
    if (gs.equals(type, "pdf")) {
      return "application/pdf";
     };
    if (gs.equals(type, "video")) {
      return "video/*";
     };
    if (gs.equals(type, "audio")) {
      return "audio/*";
     };
    if (gs.equals(type, "image")) {
      return "image/*";
     };
   }
  gSobject.clearPdfViewer = function() {
    const element = document.getElementById("pdf-viewer");
        while (element.firstChild) { element.removeChild(element.lastChild); }
   }
  gSobject['handlePlayback'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"customControls"))) {
      return null;
     };
    if (gs.bool(gs.gp(self,"videoEnded"))) {
      gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"play",[]);
     } else {
      if (gs.bool(gs.gp(self,"videoPlaying"))) {
        gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"pause",[]);
        gs.sp(self,"videoPlaying",false);
       } else {
        if (!gs.bool(gs.gp(self,"videoPlaying"))) {
          gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"play",[]);
          gs.sp(self,"videoPlaying",true);
         };
       };
     };
    return gs.sp(self,"videoEnded",false);
   }
  gSobject['playbackEnded'] = function(it) {
    var self = this;
    return gs.sp(self,"videoEnded",true);
   }
  gSobject['goFullscreen'] = function(it) {
    var self = this;
    var video = gs.gp(gs.gp(self,"$refs"),"video");
    if (gs.bool(gs.gp(video,"requestFullscreen"))) {
      return gs.mc(video,"requestFullscreen",[]);
     };
    if (gs.bool(gs.gp(video,"webkitRequestFullscreen"))) {
      return gs.mc(video,"webkitRequestFullscreen",[]);
     };
   }
  gSobject['handleMute'] = function(it) {
    var self = this;
    if (gs.bool(gs.gp(self,"videoMuted"))) {
      gs.sp(gs.gp(gs.gp(self,"$refs"),"video"),"muted",false);
      return gs.sp(self,"videoMuted",false);
     } else {
      gs.sp(gs.gp(gs.gp(self,"$refs"),"video"),"muted",true);
      return gs.sp(self,"videoMuted",true);
     };
   }
  gSobject['updateImageMetadata'] = function(metadata) {
    var self = this;
    return gs.sp(self,"imageMetadata",metadata);
   }
  gSobject['hasLocationData'] = function(it) {
    var self = this;
    return (gs.gp(gs.gp(self,"imageMetadata"),"latitude",true) != null) && (gs.gp(gs.gp(self,"imageMetadata"),"longitude",true) != null);
   }
  gSobject['loadGoogleMapsLink'] = function(it) {
    var self = this;
    return "https://www.google.com/maps?q=" + (gs.gp(gs.gp(self,"imageMetadata"),"latitude")) + "," + (gs.gp(gs.gp(self,"imageMetadata"),"longitude")) + "";
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
I3Media.PREVIEW_LIMIT = gs.multiply((gs.multiply(10, 1024)), 1024);

function TestAppOrientationComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppOrientationComponent', simpleName: 'TestAppOrientationComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/orientation";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppOrientationComponent: created"]);
    gs.sp(gSobject.scope,"current","unknown");
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"error","");
    return gs.sp(gSobject.scope,"isIOS",TestAppOrientationComponent.isIOS());
   }
  gSobject['afterMounted'] = function(it) {
    gs.sp(gSobject.scope,"current",TestAppOrientationComponent.currentOrientation());
    gs.mc(gSobject,"addLog",["Current: " + (gs.gp(gSobject.scope,"current")) + ""]);
    if (gs.bool(gs.gp(gSobject.scope,"isIOS"))) {
      return gs.mc(gSobject,"addLog",["iOS detected — programmatic orientation lock is not supported by WKWebView"]);
     };
   }
  gSobject.currentOrientation = function() { return TestAppOrientationComponent.currentOrientation(); }
  gSobject.isIOS = function() { return TestAppOrientationComponent.isIOS(); }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 20) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 19)));
     };
   }
  gSobject['lockPortrait'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"isIOS"))) {
      gs.sp(gSobject.scope,"error","Orientation lock is not supported on iOS (WKWebView limitation)");
      gs.mc(gSobject,"addLog",["Lock portrait: not supported on iOS"]);
      return null;
     };
    var result = gs.mc(gs.fs('cordovaDevice', this, gSobject),"lockPortrait",[]);
    if (gs.equals(result, "ok")) {
      gs.sp(gSobject.scope,"current","portrait");
      gs.sp(gSobject.scope,"error","");
      return gs.mc(gSobject,"addLog",["Locked to portrait"]);
     } else {
      gs.sp(gSobject.scope,"error",result);
      return gs.mc(gSobject,"addLog",["Lock failed: " + (result) + ""]);
     };
   }
  gSobject['lockLandscape'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"isIOS"))) {
      gs.sp(gSobject.scope,"error","Orientation lock is not supported on iOS (WKWebView limitation)");
      gs.mc(gSobject,"addLog",["Lock landscape: not supported on iOS"]);
      return null;
     };
    var result = gs.mc(gs.fs('cordovaDevice', this, gSobject),"lockLandscape",[]);
    if (gs.equals(result, "ok")) {
      gs.sp(gSobject.scope,"current","landscape");
      gs.sp(gSobject.scope,"error","");
      return gs.mc(gSobject,"addLog",["Locked to landscape"]);
     } else {
      gs.sp(gSobject.scope,"error",result);
      return gs.mc(gSobject,"addLog",["Lock failed: " + (result) + ""]);
     };
   }
  gSobject['unlock'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"isIOS"))) {
      gs.sp(gSobject.scope,"error","Orientation lock is not supported on iOS (WKWebView limitation)");
      gs.mc(gSobject,"addLog",["Unlock: not supported on iOS"]);
      return null;
     };
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"unlockOrientation",[]);
    gs.sp(gSobject.scope,"current",TestAppOrientationComponent.currentOrientation());
    return gs.mc(gSobject,"addLog",["Unlocked orientation"]);
   }
  gSobject['refresh'] = function(it) {
    gs.sp(gSobject.scope,"error","");
    gs.sp(gSobject.scope,"current",TestAppOrientationComponent.currentOrientation());
    return gs.mc(gSobject,"addLog",["Refreshed: " + (gs.gp(gSobject.scope,"current")) + ""]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppOrientationComponent.currentOrientation = function() {
  return screen.orientation ? screen.orientation.type : 'unknown';
 }
TestAppOrientationComponent.isIOS = function() {
  return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
 }

function TestAppGpsNavigationComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppGpsNavigationComponent', simpleName: 'TestAppGpsNavigationComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/gpsnav";
  gSobject.roles = gs.list([]);
  gSobject.gps = null;
  gSobject.leafletMap = null;
  gSobject.mapMarker = null;
  gSobject.accuracyCircle = null;
  gSobject.trailLine = null;
  gSobject.trailLatLngs = gs.list([]);
  gSobject.onlineHandler = null;
  gSobject.offlineHandler = null;
  gSobject.pauseHandler = null;
  gSobject.resumeHandler = null;
  gSobject.batteryHandler = null;
  gSobject.batteryTimer = null;
  gSobject.lastHeading = null;
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppGpsNavigationComponent: created"]);
    gs.sp(gSobject.scope,"location",gs.map());
    gs.sp(gSobject.scope,"tracking",false);
    gs.sp(gSobject.scope,"online",gs.gp(gs.fs('navigator', this, gSobject),"onLine"));
    gs.sp(gSobject.scope,"appState","foreground");
    gs.sp(gSobject.scope,"speedKmh",0);
    gs.sp(gSobject.scope,"alt",null);
    gs.sp(gSobject.scope,"headingDeg",0);
    gs.sp(gSobject.scope,"batteryLevel",null);
    gs.sp(gSobject.scope,"batteryPlugged",false);
    gs.sp(gSobject.scope,"followMap",true);
    gs.sp(gSobject.scope,"headingUp",false);
    gs.sp(gSobject.scope,"tileMode","online");
    gs.sp(gSobject.scope,"error","");
    gs.sp(gSobject.scope,"fixCount",0);
    gs.sp(gSobject.scope,"unsyncedCount",0);
    gs.sp(gSobject.scope,"stopCount",0);
    gs.sp(gSobject.scope,"lastStop","");
    gs.sp(gSobject.scope,"photoCount",0);
    gs.sp(gSobject.scope,"showDiag",false);
    gs.sp(gSobject.scope,"diagList",gs.list([]));
    gs.sp(gSobject.scope,"diagCount",0);
    gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
    return gSobject.gps = gs.execStatic(CordovaBgGps,'instance', this,[]);
   }
  gSobject['afterMounted'] = function(it) {
    gs.mc(gSobject,"startNetworkWatch",[]);
    gs.mc(gSobject,"startBatteryWatch",[]);
    gs.mc(gSobject,"startAppStateWatch",[]);
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"initMap",[]);
     }, 0]);
    gs.mc(gSobject,"fetchLocation",[]);
    gs.mc(gSobject,"startTracking",[]);
    gs.mc(gSobject,"refreshCounts",[]);
    return gs.mc(gSobject,"keepScreenAwake",[]);
   }
  gSobject['fetchLocation'] = function(it) {
    return gs.mc(gSobject.gps,"getCurrentLocation",[function(loc) {
      return gs.mc(gSobject,"handleFix",[loc, "one-shot"]);
     }, function(err) {
      gs.sp(gSobject.scope,"error","Location error: " + (gs.elvis(gs.bool(gs.gp(err,"message")) , gs.gp(err,"message") , err)) + "");
      return gs.mc(gSobject,"diag",["error", "getCurrentLocation: " + (gs.elvis(gs.bool(gs.gp(err,"message")) , gs.gp(err,"message") , err)) + ""]);
     }]);
   }
  gSobject['startTracking'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"tracking"))) {
      return null;
     };
    gs.sp(gSobject.scope,"error","");
    gs.mc(gs.mc(gs.mc(gs.mc(gs.mc(gSobject.gps,"config",[gs.map().add("desiredAccuracy",gs.gp(CordovaBgGps,"HIGH_ACCURACY")).add("debug",false).add("notificationTitle","Kruger trip tracking").add("notificationText","Recording your drive")]),"onLocation",[function(loc) {
      return gs.mc(gSobject,"handleFix",[loc, "stream"]);
     }]),"onStationary",[function(loc) {
      return gs.mc(gSobject,"handleStop",[loc]);
     }]),"onError",[function(err) {
      gs.sp(gSobject.scope,"error","Tracking error: " + (err) + "");
      return gs.mc(gSobject,"diag",["error", "tracking: " + (err) + ""]);
     }]),"start",[]);
    gs.sp(gSobject.scope,"tracking",true);
    return gs.mc(gSobject,"diag",["start", "Live tracking started (HIGH accuracy)"]);
   }
  gSobject['stopTracking'] = function(it) {
    gs.mc(gSobject.gps,"stop",[]);
    gs.sp(gSobject.scope,"tracking",false);
    return gs.mc(gSobject,"diag",["stop-track", "Live tracking stopped"]);
   }
  gSobject['handleFix'] = function(loc, source) {
    gs.sp(gSobject.scope,"location",loc);
    gs.sp(gSobject.scope,"speedKmh",(gs.gp(loc,"speed") != null ? Math.round(gs.multiply(gs.gp(loc,"speed"), 3.6)) : 0));
    gs.sp(gSobject.scope,"alt",(gs.gp(loc,"altitude") != null ? Math.round(gs.gp(loc,"altitude")) : null));
    gs.sp(gSobject.scope,"headingDeg",gs.mc(gSobject,"computeHeading",[loc]));
    gs.mc(gSobject,"updateMap",[loc]);
    var fix = gs.map().add("lat",gs.gp(loc,"latitude")).add("lng",gs.gp(loc,"longitude")).add("alt",gs.gp(loc,"altitude")).add("speed",gs.gp(loc,"speed")).add("bearing",gs.gp(loc,"bearing")).add("heading",gs.gp(gSobject.scope,"headingDeg")).add("accuracy",gs.gp(loc,"accuracy")).add("motion",gs.gp(loc,"motionState")).add("t",gs.elvis(gs.bool(gs.gp(loc,"unixTimeMs")) , gs.gp(loc,"unixTimeMs") , gs.mc(gs.date(),"getTime",[]))).add("synced",0);
    var n = gs.execStatic(TestAppTripStore,'addFix', this,[fix]);
    if (n > 0) {
      gs.sp(gSobject.scope,"fixCount",n);
     };
    gs.mc(gSobject,"diag",["fix", "" + (gs.gp(gSobject.scope,"speedKmh")) + " km/h  alt " + ((gs.equals(gs.gp(gSobject.scope,"alt"), null) ? "--" : gs.gp(gSobject.scope,"alt"))) + "m  (" + (source) + ")"]);
    gs.mc(gSobject,"refreshCounts",[]);
    if (gs.bool(gs.gp(gSobject.scope,"online"))) {
      return gs.mc(gSobject,"trySync",[]);
     };
   }
  gSobject['handleStop'] = function(loc) {
    gs.sp(gSobject.scope,"stopCount",(gs.plus(gs.gp(gSobject.scope,"stopCount"), 1)));
    gs.sp(gSobject.scope,"lastStop",gs.mc(gs.date(),"format",["HH:mm:ss"]));
    return gs.mc(gSobject,"diag",["stopped", "Stationary at " + (gs.mc(gSobject,"round6",[gs.gp(loc,"latitude")])) + ", " + (gs.mc(gSobject,"round6",[gs.gp(loc,"longitude")])) + ""]);
   }
  gSobject['computeHeading'] = function(loc) {
    var kmh = gs.multiply(gs.elvis(gs.bool(gs.gp(loc,"speed")) , gs.gp(loc,"speed") , 0), 3.6);
    var target = null;
    if (((kmh >= 8) && (gs.gp(loc,"bearing") != null)) && (gs.gp(loc,"bearing") > 0)) {
      target = gs.gp(loc,"bearing");
     } else {
      if (gs.equals(gSobject.lastHeading, null)) {
        target = gs.elvis(gs.bool(gs.gp(gSobject.gps,"compassHeading")) , gs.gp(gSobject.gps,"compassHeading") , gs.elvis(gs.bool(gs.gp(loc,"heading")) , gs.gp(loc,"heading") , gs.elvis(gs.bool(gs.gp(loc,"bearing")) , gs.gp(loc,"bearing") , 0)));
       };
     };
    if (gs.equals(target, null)) {
      return Math.round(gs.elvis(gs.bool(gSobject.lastHeading) , gSobject.lastHeading , 0));
     };
    var h = null;
    if (gs.equals(gSobject.lastHeading, null)) {
      h = target;
     } else {
      var d = gs.minus(target, gSobject.lastHeading);
      if (d > 180) {
        d = (gs.minus(d, 360));
       };
      if (d < -180) {
        d = (gs.plus(d, 360));
       };
      h = (gs.plus(gSobject.lastHeading, (gs.multiply(d, 0.5))));
      if (h < 0) {
        h = (gs.plus(h, 360));
       };
      if (h >= 360) {
        h = (gs.minus(h, 360));
       };
     };
    gSobject.lastHeading = h;
    return Math.round(h);
   }
  gSobject['startNetworkWatch'] = function(it) {
    gSobject.offlineHandler = function(it) {
      gs.sp(gSobject.scope,"online",false);
      gs.sp(gSobject.scope,"tileMode","offline");
      return gs.mc(gSobject,"diag",["offline", "Signal lost — buffering fixes locally"]);
     };
    gSobject.onlineHandler = function(it) {
      gs.sp(gSobject.scope,"online",true);
      gs.sp(gSobject.scope,"tileMode","online");
      gs.mc(gSobject,"diag",["online", "Signal restored — flushing buffered fixes"]);
      return gs.mc(gSobject,"trySync",[]);
     };
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["offline", gSobject.offlineHandler, false]);
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["online", gSobject.onlineHandler, false]);
    return gs.sp(gSobject.scope,"online",gs.gp(gs.fs('navigator', this, gSobject),"onLine"));
   }
  gSobject['trySync'] = function(it) {
    var pending = gs.execStatic(TestAppTripStore,'unsyncedFixes', this,[]);
    var len = (gs.bool(pending) ? gs.gp(pending,"length") : 0);
    if (gs.equals(len, 0)) {
      return null;
     };
    try {
      gs.mc(gs.range(0, len, false),"each",[function(i) {
        var f = pending[i];
        return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userLocation",[gs.map().add("latitude",gs.gp(f,"lat")).add("longitude",gs.gp(f,"lng")).add("altitude",gs.gp(f,"alt")).add("speed",gs.gp(f,"speed")).add("bearing",gs.gp(f,"bearing")).add("heading",gs.gp(f,"heading")).add("accuracy",gs.gp(f,"accuracy")).add("unixTimeMs",gs.gp(f,"t")).add("provider","buffer").add("fixId",gs.execStatic(Utils,'uuid', this,[]))]),"do",[]);
       }]);
      gs.execStatic(TestAppTripStore,'markFixesSynced', this,[]);
      gs.mc(gSobject,"diag",["sync", "Flushed " + (len) + " buffered fixes to server"]);
     }
    catch (e) {
      gs.mc(gSobject,"diag",["error", "sync failed: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
    return gs.mc(gSobject,"refreshCounts",[]);
   }
  gSobject['capturePhoto'] = function(it) {
    if (!gs.bool(TestAppGpsNavigationComponent.photoPluginAvailable())) {
      gs.sp(gSobject.scope,"error","Camera not available (device only)");
      gs.mc(gSobject,"diag",["photo", "camera plugin unavailable (browser)"]);
      return null;
     };
    var loc = gs.elvis(gs.bool(gs.gp(gSobject.gps,"lastLocation")) , gs.gp(gSobject.gps,"lastLocation") , gs.gp(gSobject.scope,"location"));
    var id = gs.execStatic(Utils,'uuid', this,[]);
    var t = gs.mc(gs.date(),"getTime",[]);
    return gs.mc(gs.fs('cordovaPhoto', this, gSobject),"takePhotoBlob",[function(blob) {
      gs.mc(gs.fs('cordovaFile', this, gSobject),"addFile",[blob, "tripPhoto", "photo", id, function(it) {
        return gs.mc(gSobject,"diag",["photo", "photo saved/queued @ " + (gs.mc(gSobject,"round6",[gs.gp(loc,"latitude",true)])) + ", " + (gs.mc(gSobject,"round6",[gs.gp(loc,"longitude",true)])) + ""]);
       }, function(err) {
        return gs.mc(gSobject,"diag",["error", "photo file: " + (err) + ""]);
       }]);
      gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"tripPhotoService"),"savePhoto",[gs.map().add("clientId",id).add("lat",gs.gp(loc,"latitude",true)).add("lng",gs.gp(loc,"longitude",true)).add("altitude",gs.gp(loc,"altitude",true)).add("takenAt",t).add("uuid",gs.mc(this,"deviceUuid",[], gSobject))]),"do",[]);
      return gs.sp(gSobject.scope,"photoCount",(gs.plus(gs.elvis(gs.bool(gs.gp(gSobject.scope,"photoCount")) , gs.gp(gSobject.scope,"photoCount") , 0), 1)));
     }, function(err) {
      gs.sp(gSobject.scope,"error","Camera error: " + (err) + "");
      return gs.mc(gSobject,"diag",["error", "camera: " + (err) + ""]);
     }]);
   }
  gSobject.photoPluginAvailable = function() { return TestAppGpsNavigationComponent.photoPluginAvailable(); }
  gSobject.deviceUuid = function() { return TestAppGpsNavigationComponent.deviceUuid(); }
  gSobject['startBatteryWatch'] = function(it) {
    gSobject.batteryHandler = function(status) {
      gs.sp(gSobject.scope,"batteryLevel",gs.gp(status,"level"));
      gs.sp(gSobject.scope,"batteryPlugged",gs.gp(status,"isPlugged"));
      gs.execStatic(TestAppTripStore,'addBattery', this,[gs.map().add("level",gs.gp(status,"level")).add("plugged",gs.gp(status,"isPlugged")).add("t",gs.mc(gs.date(),"getTime",[]))]);
      return gs.mc(gSobject,"diag",["battery", "" + (gs.gp(status,"level")) + "% " + ((gs.bool(gs.gp(status,"isPlugged")) ? "(charging)" : "")) + ""]);
     };
    gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterystatus", gSobject.batteryHandler, false]);
    if (TestAppGpsNavigationComponent.cordovaDeviceAvailable()) {
      gs.sp(gSobject.scope,"batteryLevel",gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"battery"),"level",true));
      gs.sp(gSobject.scope,"batteryPlugged",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"battery"),"isPlugged",true)) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"battery"),"isPlugged",true) , false));
     };
    return gSobject.batteryTimer = gs.execStatic(Utils,'setInterval', this,[function(it) {
      if (gs.gp(gSobject.scope,"batteryLevel") != null) {
        return gs.execStatic(TestAppTripStore,'addBattery', this,[gs.map().add("level",gs.gp(gSobject.scope,"batteryLevel")).add("plugged",gs.gp(gSobject.scope,"batteryPlugged")).add("t",gs.mc(gs.date(),"getTime",[]))]);
       };
     }, 120000]);
   }
  gSobject.cordovaDeviceAvailable = function() { return TestAppGpsNavigationComponent.cordovaDeviceAvailable(); }
  gSobject['startAppStateWatch'] = function(it) {
    gSobject.pauseHandler = function(it) {
      gs.sp(gSobject.scope,"appState","background");
      return gs.mc(gSobject,"diag",["pause", "App backgrounded — native tracking continues"]);
     };
    gSobject.resumeHandler = function(it) {
      gs.sp(gSobject.scope,"appState","foreground");
      gs.mc(gSobject,"diag",["resume", "App foregrounded — refreshing position"]);
      gs.mc(gSobject,"fetchLocation",[]);
      return gs.mc(gSobject,"keepScreenAwake",[]);
     };
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["pause", gSobject.pauseHandler, false]);
    return gs.mc(gs.fs('document', this, gSobject),"addEventListener",["resume", gSobject.resumeHandler, false]);
   }
  gSobject.keepScreenAwake = function() {
    try {
            if (!('wakeLock' in navigator)) { try { console.log('[HUD] Wake Lock API not available'); } catch(e){} return; }
            window._hudWakeWanted = true;
            window._hudWakeAcquire = function() {
                if (!window._hudWakeWanted || document.visibilityState !== 'visible') return;
                navigator.wakeLock.request('screen').then(function(wl) {
                    window._hudWakeLock = wl;
                    try { console.log('[HUD] screen wake lock ON'); } catch(e){}
                }).catch(function(e){ try { console.log('[HUD] wake lock failed: ' + e); } catch(_){} });
            };
            if (!window._hudWakeVisBound) {
                window._hudWakeVisBound = true;
                document.addEventListener('visibilitychange', function() {
                    if (document.visibilityState === 'visible' && window._hudWakeWanted) window._hudWakeAcquire();
                });
            }
            window._hudWakeAcquire();
        } catch(e) { try { console.log('[HUD] keepScreenAwake error: ' + e); } catch(_){} }
   }
  gSobject.releaseScreenAwake = function() {
    try {
            window._hudWakeWanted = false;
            if (window._hudWakeLock) { try { window._hudWakeLock.release(); } catch(e){} window._hudWakeLock = null; }
            try { console.log('[HUD] screen wake lock OFF'); } catch(e){}
        } catch(e) {}
   }
  gSobject['initMap'] = function(it) {
    if (!gs.bool(gs.gp(gs.fs('window', this, gSobject),"L"))) {
      gs.mc(gSobject,"diag",["error", "Leaflet failed to load"]);
      return null;
     };
    gSobject.leafletMap = gs.mc(gs.mc(gs.fs('L', this, gSobject),"map",["navMapContainer"]),"setView",[gs.list([-24.0 , 31.5]), 8]);
    gs.execStatic(TestAppOfflineTiles,'installOfflineTileLayer', this,[gSobject.leafletMap, gs.execStatic(TestAppMapDefaults,'osmTileUrl', this,[]), gs.map().add("attribution","&copy; OpenStreetMap").add("maxZoom",19).add("maxNativeZoom",gs.execStatic(TestAppMapDefaults,'offlineMaxZoom', this,[]))]);
    if (gs.bool(gs.gp(gs.gp(gSobject.scope,"location"),"latitude",true))) {
      return gs.mc(gSobject,"updateMap",[gs.gp(gSobject.scope,"location")]);
     };
   }
  gSobject['updateMap'] = function(loc) {
    if (((!gs.bool(gSobject.leafletMap)) || (!gs.bool(gs.gp(loc,"latitude",true)))) || (!gs.bool(gs.gp(loc,"longitude",true)))) {
      return null;
     };
    var latlng = gs.list([gs.gp(loc,"latitude") , gs.gp(loc,"longitude")]);
    gs.mc(gSobject.trailLatLngs,'leftShift', gs.list([latlng]));
    if (!gs.bool(gSobject.trailLine)) {
      gSobject.trailLine = gs.mc(gs.mc(gs.fs('L', this, gSobject),"polyline",[gSobject.trailLatLngs, gs.map().add("color","#2196F3").add("weight",4).add("opacity",0.7)]),"addTo",[gSobject.leafletMap]);
     } else {
      gs.mc(gSobject.trailLine,"setLatLngs",[gSobject.trailLatLngs]);
     };
    if (!gs.bool(gSobject.mapMarker)) {
      gSobject.mapMarker = gs.mc(gs.mc(gs.fs('L', this, gSobject),"marker",[latlng, gs.map().add("icon",TestAppGpsNavigationComponent.positionIcon(gs.gp(gSobject.scope,"headingDeg")))]),"addTo",[gSobject.leafletMap]);
      gs.mc(gSobject.leafletMap,"setView",[latlng, gs.execStatic(TestAppMapDefaults,'offlineMaxZoom', this,[])]);
     } else {
      gs.mc(gSobject.mapMarker,"setLatLng",[latlng]);
      gs.mc(gSobject.mapMarker,"setIcon",[TestAppGpsNavigationComponent.positionIcon(gs.gp(gSobject.scope,"headingDeg"))]);
     };
    if (gs.bool(gs.gp(loc,"accuracy"))) {
      if (!gs.bool(gSobject.accuracyCircle)) {
        gSobject.accuracyCircle = gs.mc(gs.mc(gs.fs('L', this, gSobject),"circle",[latlng, gs.map().add("radius",gs.gp(loc,"accuracy")).add("color","#2196F3").add("weight",1).add("fillOpacity",0.1)]),"addTo",[gSobject.leafletMap]);
       } else {
        gs.mc(gSobject.accuracyCircle,"setLatLng",[latlng]);
        gs.mc(gSobject.accuracyCircle,"setRadius",[gs.gp(loc,"accuracy")]);
       };
     };
    if (gs.bool(gs.gp(gSobject.scope,"followMap"))) {
      gs.mc(gSobject.leafletMap,"panTo",[latlng]);
     };
    if (gs.bool(gs.gp(gSobject.scope,"headingUp"))) {
      return gs.mc(gSobject,"applyCourseUp",[true, gs.gp(gSobject.scope,"headingDeg")]);
     };
   }
  gSobject['recenterMap'] = function(it) {
    if ((gs.bool(gSobject.leafletMap)) && (gs.bool(gs.gp(gs.gp(gSobject.scope,"location"),"latitude",true)))) {
      return gs.mc(gSobject.leafletMap,"setView",[gs.list([gs.gp(gs.gp(gSobject.scope,"location"),"latitude") , gs.gp(gs.gp(gSobject.scope,"location"),"longitude")]), gs.execStatic(TestAppMapDefaults,'offlineMaxZoom', this,[])]);
     };
   }
  gSobject['toggleFollow'] = function(it) {
    gs.sp(gSobject.scope,"followMap",!gs.gp(gSobject.scope,"followMap"));
    if (((gs.bool(gs.gp(gSobject.scope,"followMap"))) && (gs.bool(gSobject.leafletMap))) && (gs.bool(gs.gp(gs.gp(gSobject.scope,"location"),"latitude",true)))) {
      return gs.mc(gSobject.leafletMap,"panTo",[gs.list([gs.gp(gs.gp(gSobject.scope,"location"),"latitude") , gs.gp(gs.gp(gSobject.scope,"location"),"longitude")])]);
     };
   }
  gSobject['toggleHeadingUp'] = function(it) {
    gs.sp(gSobject.scope,"headingUp",!gs.gp(gSobject.scope,"headingUp"));
    if (gs.bool(gs.gp(gSobject.scope,"headingUp"))) {
      gs.sp(gSobject.scope,"followMap",true);
     };
    gs.mc(gSobject,"applyCourseUp",[gs.gp(gSobject.scope,"headingUp"), gs.gp(gSobject.scope,"headingDeg")]);
    if (gs.bool(gSobject.leafletMap)) {
      return gs.execStatic(Utils,'setTimeout', this,[function(it) {
        gs.mc(gSobject.leafletMap,"invalidateSize",[]);
        if (gs.bool(gs.gp(gs.gp(gSobject.scope,"location"),"latitude",true))) {
          return gs.mc(gSobject.leafletMap,"panTo",[gs.list([gs.gp(gs.gp(gSobject.scope,"location"),"latitude") , gs.gp(gs.gp(gSobject.scope,"location"),"longitude")])]);
         };
       }, 320]);
     };
   }
  gSobject.applyCourseUp = function(headingUp, heading) {
    try {
            var el = document.getElementById('navMapContainer');
            if (!el) return;
            if (headingUp) {
                if (el.getAttribute('data-courseup') !== '1') {
                    el.style.width = '170%'; el.style.height = '170%';
                    el.style.top = '-35%'; el.style.left = '-35%';
                    el.setAttribute('data-courseup', '1');
                }
                el.style.transform = 'rotate(' + (-(heading || 0)) + 'deg)';
            } else {
                el.style.transform = 'rotate(0deg)';
                el.style.width = '100%'; el.style.height = '100%';
                el.style.top = '0'; el.style.left = '0';
                el.removeAttribute('data-courseup');
            }
        } catch(e) {}
   }
  gSobject.positionIcon = function(x0) { return TestAppGpsNavigationComponent.positionIcon(x0); }
  gSobject['openDayTravel'] = function(it) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/daytravel"]);
   }
  gSobject['toggleDiag'] = function(it) {
    return gs.sp(gSobject.scope,"showDiag",!gs.gp(gSobject.scope,"showDiag"));
   }
  gSobject['refreshCounts'] = function(it) {
    var c = gs.execStatic(TestAppTripStore,'counts', this,[]);
    gs.sp(gSobject.scope,"fixCount",gs.gp(c,"fixes"));
    gs.sp(gSobject.scope,"unsyncedCount",gs.gp(c,"unsynced"));
    return gs.sp(gSobject.scope,"diagCount",gs.gp(c,"diag"));
   }
  gSobject['diag'] = function(cat, msg) {
    var entry = gs.map().add("cat",cat).add("msg",msg).add("t",gs.mc(gs.date(),"getTime",[])).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]));
    gs.execStatic(TestAppTripStore,'addDiag', this,[entry]);
    gs.sp(gSobject.scope,"diagList",(gs.plus(gs.list([entry]), gs.gp(gSobject.scope,"diagList"))));
    if (gs.mc(gs.gp(gSobject.scope,"diagList"),"size",[]) > 60) {
      gs.sp(gSobject.scope,"diagList",(gs.rangeFromList(gs.gp(gSobject.scope,"diagList"), 0, 59)));
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["GPSNav[" + (cat) + "]: " + (msg) + ""]);
   }
  gSobject['round6'] = function(v) {
    return (gs.equals(v, null) ? "--" : gs.div(Math.round(gs.multiply(v, 1000000)), 1000000));
   }
  gSobject['destroyed'] = function(it) {
    gs.mc(gSobject,"releaseScreenAwake",[]);
    if (gs.bool(gSobject.offlineHandler)) {
      gs.mc(gs.fs('document', this, gSobject),"removeEventListener",["offline", gSobject.offlineHandler]);
     };
    if (gs.bool(gSobject.onlineHandler)) {
      gs.mc(gs.fs('document', this, gSobject),"removeEventListener",["online", gSobject.onlineHandler]);
     };
    if (gs.bool(gSobject.pauseHandler)) {
      gs.mc(gs.fs('document', this, gSobject),"removeEventListener",["pause", gSobject.pauseHandler]);
     };
    if (gs.bool(gSobject.resumeHandler)) {
      gs.mc(gs.fs('document', this, gSobject),"removeEventListener",["resume", gSobject.resumeHandler]);
     };
    if (gs.bool(gSobject.batteryHandler)) {
      gs.mc(gs.fs('window', this, gSobject),"removeEventListener",["batterystatus", gSobject.batteryHandler]);
     };
    if (gs.bool(gSobject.batteryTimer)) {
      gs.execStatic(Utils,'clearInterval', this,[gSobject.batteryTimer]);
     };
    if (gs.bool(gs.gp(gSobject.scope,"tracking"))) {
      gs.mc(gSobject.gps,"stop",[]);
     };
    if (gs.bool(gSobject.leafletMap)) {
      gs.mc(gSobject.leafletMap,"remove",[]);
      return gSobject.leafletMap = null;
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppGpsNavigationComponent.photoPluginAvailable = function() {
  return typeof cordovaPhoto !== 'undefined' && typeof cordovaFile !== 'undefined';
 }
TestAppGpsNavigationComponent.deviceUuid = function() {
  try { return (typeof cordovaDevice !== 'undefined' && cordovaDevice.device) ? cordovaDevice.device.uuid : ''; }
        catch (e) { return ''; }
 }
TestAppGpsNavigationComponent.cordovaDeviceAvailable = function() {
  return typeof cordovaDevice !== 'undefined';
 }
TestAppGpsNavigationComponent.positionIcon = function(heading) {
  var h = heading || 0;
        return L.divIcon({
            className: 'gps-pos-marker',
            iconSize: [30, 30],
            iconAnchor: [15, 15],
            html: '<div style="width:30px;height:30px;transform:rotate(' + h + 'deg);transform-origin:50% 50%;">'
                + '<svg width="30" height="30" viewBox="0 0 30 30">'
                + '<circle cx="15" cy="15" r="12" fill="#2196F3" fill-opacity="0.2" stroke="#1976D2" stroke-width="1"/>'
                + '<path d="M15 3 L22 24 L15 19 L8 24 Z" fill="#2196F3" stroke="#ffffff" stroke-width="1.5" stroke-linejoin="round"/>'
                + '</svg></div>'
        });
 }

function TestAppDayTravelComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppDayTravelComponent', simpleName: 'TestAppDayTravelComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/daytravel";
  gSobject.roles = gs.list([]);
  gSobject.leafletMap = null;
  gSobject.trailLine = null;
  gSobject.markers = gs.list([]);
  gSobject.photoMarkers = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppDayTravelComponent: created"]);
    gs.sp(gSobject.scope,"stops",gs.list([]));
    gs.sp(gSobject.scope,"battery",gs.list([]));
    gs.sp(gSobject.scope,"batterySpark","");
    gs.sp(gSobject.scope,"photoCount",0);
    gs.sp(gSobject.scope,"summary",gs.map().add("points",0).add("distanceKm",0).add("movingMin",0).add("stoppedMin",0).add("maxSpeedKmh",0).add("firstTime","").add("lastTime",""));
    gs.sp(gSobject.scope,"selectedDate",gs.mc(gs.date(),"format",["yyyy-MM-dd"]));
    gs.sp(gSobject.scope,"todayStr",gs.gp(gSobject.scope,"selectedDate"));
    gs.sp(gSobject.scope,"isToday",true);
    gs.sp(gSobject.scope,"dayLabel",gs.gp(gSobject.scope,"selectedDate"));
    gs.sp(gSobject.scope,"empty",true);
    gs.sp(gSobject.scope,"offlineBusy",false);
    gs.sp(gSobject.scope,"offlineProgress","");
    gs.sp(gSobject.scope,"offlineTiles",0);
    return gs.sp(gSobject.scope,"offlineMB",0);
   }
  gSobject['afterMounted'] = function(it) {
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"initMap",[]);
     }, 0]);
    return gs.mc(gSobject,"refreshOfflineStatus",[]);
   }
  gSobject['loadDay'] = function(it) {
    gs.sp(gSobject.scope,"isToday",(gs.equals(gs.gp(gSobject.scope,"selectedDate"), gs.gp(gSobject.scope,"todayStr"))));
    gs.sp(gSobject.scope,"dayLabel",gs.gp(gSobject.scope,"selectedDate"));
    var from = TestAppDayTravelComponent.dayStartMsFor(gs.gp(gSobject.scope,"selectedDate"));
    var to = gs.plus(from, 86400000);
    var fixes = gs.execStatic(TestAppTripStore,'fixesForDay', this,[from, to]);
    var battery = gs.execStatic(TestAppTripStore,'batteryForDay', this,[from, to]);
    gs.sp(gSobject.scope,"empty",((!gs.bool(fixes)) || (gs.equals(gs.gp(fixes,"length"), 0))));
    gs.sp(gSobject.scope,"summary",TestAppDayTravelComponent.computeSummary(fixes));
    gs.sp(gSobject.scope,"stops",TestAppDayTravelComponent.computeStops(fixes));
    gs.sp(gSobject.scope,"battery",battery);
    gs.sp(gSobject.scope,"batterySpark",TestAppDayTravelComponent.computeSpark(battery, 320, 60));
    gs.mc(gSobject,"drawTrail",[fixes]);
    gs.mc(gSobject,"drawStops",[gs.gp(gSobject.scope,"stops")]);
    if (gs.bool(gs.gp(gs.fs('navigator', this, gSobject),"onLine"))) {
      return gs.mc(gSobject,"loadServerPhotos",[from, to]);
     };
   }
  gSobject['reload'] = function(it) {
    return gs.mc(gSobject,"loadDay",[]);
   }
  gSobject['shiftDay'] = function(delta) {
    if ((delta > 0) && (gs.equals(gs.gp(gSobject.scope,"selectedDate"), gs.gp(gSobject.scope,"todayStr")))) {
      return null;
     };
    gs.sp(gSobject.scope,"selectedDate",TestAppDayTravelComponent.addDays(gs.gp(gSobject.scope,"selectedDate"), delta));
    return gs.mc(gSobject,"loadDay",[]);
   }
  gSobject['goToday'] = function(it) {
    gs.sp(gSobject.scope,"selectedDate",gs.gp(gSobject.scope,"todayStr"));
    return gs.mc(gSobject,"loadDay",[]);
   }
  gSobject['onDatePicked'] = function(it) {
    return gs.mc(gSobject,"loadDay",[]);
   }
  gSobject['clearDay'] = function(it) {
    if (gs.mc(this,"confirm",["Delete the on-device track, battery and diagnostics buffer for all days?"], gSobject)) {
      gs.execStatic(TestAppTripStore,'clearAll', this,[]);
      return gs.mc(gSobject,"loadDay",[]);
     };
   }
  gSobject['downloadOfflineMap'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"offlineBusy"))) {
      return null;
     };
    var b = gs.execStatic(TestAppMapDefaults,'krugerBounds', this,[]);
    var minZ = gs.execStatic(TestAppMapDefaults,'offlineMinZoom', this,[]);
    var maxZ = gs.execStatic(TestAppMapDefaults,'offlineMaxZoom', this,[]);
    var est = gs.execStatic(TestAppOfflineTiles,'estimateTiles', this,[b[0], b[1], b[2], b[3], minZ, maxZ]);
    var mb = Math.round(gs.div((gs.multiply(est, 22)), 1024));
    gs.sp(gSobject.scope,"offlineBusy",true);
    gs.sp(gSobject.scope,"offlineProgress","Starting… ~" + (est) + " tiles (~" + (mb) + " MB)");
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["OfflineMap: download start " + (est) + " tiles z" + (minZ) + "-" + (maxZ) + " (~" + (mb) + "MB)"]);
    return gs.execStatic(TestAppOfflineTiles,'downloadArea', this,[gs.execStatic(TestAppMapDefaults,'osmTileUrl', this,[]), b[0], b[1], b[2], b[3], minZ, maxZ, function(p) {
      return gs.sp(gSobject.scope,"offlineProgress","Downloading " + (gs.gp(p,"done")) + " / " + (gs.gp(p,"total")) + "");
     }, function(r) {
      gs.sp(gSobject.scope,"offlineBusy",false);
      gs.sp(gSobject.scope,"offlineProgress",(gs.bool(gs.gp(r,"error")) ? "Failed: " + (gs.gp(r,"error")) + "" : "Done — cached " + (gs.gp(r,"cached")) + " / " + (gs.gp(r,"total")) + " tiles"));
      gs.mc(gSobject,"refreshOfflineStatus",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["OfflineMap: done cached=" + (gs.gp(r,"cached")) + "/" + (gs.gp(r,"total")) + " err=" + (gs.gp(r,"error")) + ""]);
     }]);
   }
  gSobject['refreshOfflineStatus'] = function(it) {
    return gs.execStatic(TestAppOfflineTiles,'cacheStatus', this,[function(s) {
      gs.sp(gSobject.scope,"offlineTiles",gs.gp(s,"tiles"));
      return gs.sp(gSobject.scope,"offlineMB",gs.gp(s,"approxMB"));
     }]);
   }
  gSobject['clearOfflineMap'] = function(it) {
    if (!gs.bool(gs.mc(this,"confirm",["Delete the downloaded offline map tiles?"], gSobject))) {
      return null;
     };
    return gs.execStatic(TestAppOfflineTiles,'clearCache', this,[function(ok) {
      return gs.mc(gSobject,"refreshOfflineStatus",[]);
     }]);
   }
  gSobject['backToHud'] = function(it) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/gpsnav"]);
   }
  gSobject['loadServerPhotos'] = function(from, to) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"tripPhotoService"),"dayPhotos",[gs.map().add("from",from).add("to",to), function(res) {
      var photos = gs.gp(res,"photos",true);
      gs.sp(gSobject.scope,"photoCount",(gs.bool(photos) ? gs.gp(photos,"length") : 0));
      return gs.mc(gSobject,"drawPhotos",[photos]);
     }]);
   }
  gSobject['drawPhotos'] = function(photos) {
    if ((!gs.bool(gSobject.leafletMap)) || (!gs.bool(photos))) {
      return null;
     };
    gs.mc(gSobject,"clearPhotoMarkers",[]);
    var len = gs.elvis(gs.bool(gs.gp(photos,"length")) , gs.gp(photos,"length") , 0);
    return gs.mc(gs.range(0, len, false),"each",[function(i) {
      var p = photos[i];
      if ((gs.gp(p,"lat") != null) && (gs.gp(p,"lng") != null)) {
        var m = gs.mc(gs.mc(gs.fs('L', this, gSobject),"circleMarker",[gs.list([gs.gp(p,"lat") , gs.gp(p,"lng")]), gs.map().add("radius",8).add("color","#00695c").add("fillColor","#26a69a").add("weight",2).add("fillOpacity",0.9)]),"addTo",[gSobject.leafletMap]);
        gs.mc(m,"bindPopup",["<div style='text-align:center'><img src='" + (gs.gp(p,"url")) + "' style='width:150px;border-radius:4px' /><br/><small>" + (gs.mc(gSobject,"fmtTime",[gs.gp(p,"takenAt")])) + "" + ((gs.bool(gs.gp(p,"note")) ? gs.plus(" &middot; ", gs.gp(p,"note")) : "")) + "</small></div>"]);
        return gs.mc(gSobject.photoMarkers,'leftShift', gs.list([m]));
       };
     }]);
   }
  gSobject['clearPhotoMarkers'] = function(it) {
    var len = (gs.bool(gSobject.photoMarkers) ? gs.mc(gSobject.photoMarkers,"size",[]) : 0);
    gs.mc(gs.range(0, len, false),"each",[function(i) {
      return gs.mc(gSobject.leafletMap,"removeLayer",[gSobject.photoMarkers[i]]);
     }]);
    return gSobject.photoMarkers = gs.list([]);
   }
  gSobject['initMap'] = function(it) {
    if (!gs.bool(gs.gp(gs.fs('window', this, gSobject),"L"))) {
      return null;
     };
    gSobject.leafletMap = gs.mc(gs.mc(gs.fs('L', this, gSobject),"map",["dayMapContainer"]),"setView",[gs.list([-24.0 , 31.5]), 8]);
    gs.execStatic(TestAppOfflineTiles,'installOfflineTileLayer', this,[gSobject.leafletMap, gs.execStatic(TestAppMapDefaults,'osmTileUrl', this,[]), gs.map().add("attribution","&copy; OpenStreetMap").add("maxZoom",19).add("maxNativeZoom",gs.execStatic(TestAppMapDefaults,'offlineMaxZoom', this,[]))]);
    gs.mc(gSobject,"drawPois",[]);
    return gs.mc(gSobject,"loadDay",[]);
   }
  gSobject['drawTrail'] = function(fixes) {
    if (!gs.bool(gSobject.leafletMap)) {
      return null;
     };
    if (gs.bool(gSobject.trailLine)) {
      gs.mc(gSobject.leafletMap,"removeLayer",[gSobject.trailLine]);
      gSobject.trailLine = null;
     };
    var latlngs = TestAppDayTravelComponent.toLatLngs(fixes);
    if (gs.gp(latlngs,"length") > 1) {
      gSobject.trailLine = gs.mc(gs.mc(gs.fs('L', this, gSobject),"polyline",[latlngs, gs.map().add("color","#2196F3").add("weight",4).add("opacity",0.7)]),"addTo",[gSobject.leafletMap]);
      return gs.mc(gSobject.leafletMap,"fitBounds",[gs.mc(gSobject.trailLine,"getBounds",[]), gs.map().add("padding",gs.list([30 , 30]))]);
     };
   }
  gSobject['drawStops'] = function(stops) {
    if (!gs.bool(gSobject.leafletMap)) {
      return null;
     };
    gs.mc(gSobject,"clearMarkers",[]);
    var len = (gs.bool(stops) ? gs.gp(stops,"length") : 0);
    return gs.mc(gs.range(0, len, false),"each",[function(i) {
      var s = stops[i];
      var m = gs.mc(gs.mc(gs.fs('L', this, gSobject),"marker",[gs.list([gs.gp(s,"lat") , gs.gp(s,"lng")])]),"addTo",[gSobject.leafletMap]);
      gs.mc(m,"bindPopup",["Stopped " + (gs.mc(gSobject,"formatDur",[gs.gp(s,"durationMs")])) + "<br/>" + (gs.mc(gSobject,"fmtTime",[gs.gp(s,"arrival")])) + " - " + (gs.mc(gSobject,"fmtTime",[gs.gp(s,"departure")])) + ""]);
      return gs.mc(gSobject.markers,'leftShift', gs.list([m]));
     }]);
   }
  gSobject['clearMarkers'] = function(it) {
    var len = (gs.bool(gSobject.markers) ? gs.mc(gSobject.markers,"size",[]) : 0);
    gs.mc(gs.range(0, len, false),"each",[function(i) {
      return gs.mc(gSobject.leafletMap,"removeLayer",[gSobject.markers[i]]);
     }]);
    return gSobject.markers = gs.list([]);
   }
  gSobject['drawPois'] = function(it) {
    if (!gs.bool(gSobject.leafletMap)) {
      return null;
     };
    return gs.mc(gs.mc(gSobject,"krugerPois",[]),"each",[function(p) {
      var c = gs.mc(gSobject,"poiColor",[gs.gp(p,"t")]);
      var m = gs.mc(gs.mc(gs.fs('L', this, gSobject),"circleMarker",[gs.list([gs.gp(p,"lat") , gs.gp(p,"lng")]), gs.map().add("radius",5).add("color",c).add("fillColor",c).add("weight",1).add("fillOpacity",0.85)]),"addTo",[gSobject.leafletMap]);
      return gs.mc(m,"bindTooltip",[gs.gp(p,"n"), gs.map().add("direction","top").add("opacity",0.9)]);
     }]);
   }
  gSobject['poiColor'] = function(t) {
    if (gs.equals(t, "camp")) {
      return "#6d4c41";
     };
    if (gs.equals(t, "gate")) {
      return "#c62828";
     };
    return "#1565c0";
   }
  gSobject['krugerPois'] = function(it) {
    return gs.list([gs.map().add("n","Skukuza").add("t","camp").add("lat",-24.9948).add("lng",31.5969) , gs.map().add("n","Lower Sabie").add("t","camp").add("lat",-25.1200).add("lng",31.9167) , gs.map().add("n","Satara").add("t","camp").add("lat",-24.3925).add("lng",31.7783) , gs.map().add("n","Olifants").add("t","camp").add("lat",-24.0057).add("lng",31.7389) , gs.map().add("n","Letaba").add("t","camp").add("lat",-23.8533).add("lng",31.5758) , gs.map().add("n","Mopani").add("t","camp").add("lat",-23.5219).add("lng",31.3939) , gs.map().add("n","Shingwedzi").add("t","camp").add("lat",-23.1108).add("lng",31.4336) , gs.map().add("n","Punda Maria").add("t","camp").add("lat",-22.6939).add("lng",31.0206) , gs.map().add("n","Berg-en-Dal").add("t","camp").add("lat",-25.4306).add("lng",31.4531) , gs.map().add("n","Crocodile Bridge").add("t","camp").add("lat",-25.3586).add("lng",31.8936) , gs.map().add("n","Pretoriuskop").add("t","camp").add("lat",-25.1717).add("lng",31.2683) , gs.map().add("n","Orpen").add("t","camp").add("lat",-24.4756).add("lng",31.3906) , gs.map().add("n","Paul Kruger Gate").add("t","gate").add("lat",-24.9820).add("lng",31.4867) , gs.map().add("n","Phabeni Gate").add("t","gate").add("lat",-25.0106).add("lng",31.2356) , gs.map().add("n","Numbi Gate").add("t","gate").add("lat",-25.1522).add("lng",31.2019) , gs.map().add("n","Malelane Gate").add("t","gate").add("lat",-25.4622).add("lng",31.5153) , gs.map().add("n","Orpen Gate").add("t","gate").add("lat",-24.4750).add("lng",31.3781) , gs.map().add("n","Phalaborwa Gate").add("t","gate").add("lat",-23.9456).add("lng",31.2169) , gs.map().add("n","Punda Maria Gate").add("t","gate").add("lat",-22.7350).add("lng",31.0056) , gs.map().add("n","Pafuri Gate").add("t","gate").add("lat",-22.4531).add("lng",31.2169)]);
   }
  gSobject['formatDur'] = function(ms) {
    var totalMin = Math.round(gs.div(ms, 60000));
    var h = Math.floor(gs.div(totalMin, 60));
    var m = gs.minus(totalMin, (gs.multiply(h, 60)));
    return (h > 0 ? "" + (h) + "h " + (m) + "m" : "" + (m) + "m");
   }
  gSobject['fmtTime'] = function(ms) {
    return TestAppDayTravelComponent._fmtTime(ms);
   }
  gSobject.dayStartMs = function() { return TestAppDayTravelComponent.dayStartMs(); }
  gSobject.dayStartMsFor = function(x0) { return TestAppDayTravelComponent.dayStartMsFor(x0); }
  gSobject.addDays = function(x0,x1) { return TestAppDayTravelComponent.addDays(x0,x1); }
  gSobject._fmtTime = function(x0) { return TestAppDayTravelComponent._fmtTime(x0); }
  gSobject.toLatLngs = function(x0) { return TestAppDayTravelComponent.toLatLngs(x0); }
  gSobject.computeSummary = function(x0) { return TestAppDayTravelComponent.computeSummary(x0); }
  gSobject.computeStops = function(x0) { return TestAppDayTravelComponent.computeStops(x0); }
  gSobject.computeSpark = function(x0,x1,x2) { return TestAppDayTravelComponent.computeSpark(x0,x1,x2); }
  gSobject['destroyed'] = function(it) {
    if (gs.bool(gSobject.leafletMap)) {
      gs.mc(gSobject.leafletMap,"remove",[]);
      return gSobject.leafletMap = null;
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppDayTravelComponent.dayStartMs = function() {
  var d = new Date(); d.setHours(0, 0, 0, 0); return d.getTime();
 }
TestAppDayTravelComponent.dayStartMsFor = function(dateStr) {
  try { var d = new Date(dateStr + 'T00:00:00'); d.setHours(0,0,0,0); return d.getTime(); }
        catch (e) { var t = new Date(); t.setHours(0,0,0,0); return t.getTime(); }
 }
TestAppDayTravelComponent.addDays = function(dateStr, delta) {
  try {
            var d = new Date(dateStr + 'T00:00:00');
            d.setDate(d.getDate() + delta);
            function p(n){ return n < 10 ? '0'+n : ''+n; }
            return d.getFullYear() + '-' + p(d.getMonth()+1) + '-' + p(d.getDate());
        } catch (e) { return dateStr; }
 }
TestAppDayTravelComponent._fmtTime = function(ms) {
  try { var d = new Date(ms); function p(n){ return n < 10 ? '0'+n : ''+n; } return p(d.getHours())+':'+p(d.getMinutes()); }
        catch (e) { return '--:--'; }
 }
TestAppDayTravelComponent.toLatLngs = function(fixes) {
  try {
            var out = [];
            for (var i = 0; i < fixes.length; i++) { var f = fixes[i]; if (f && f.lat != null && f.lng != null) out.push([f.lat, f.lng]); }
            return out;
        } catch (e) { return []; }
 }
TestAppDayTravelComponent.computeSummary = function(fixes) {
  function hav(a, b) {
            var R = 6371000, toR = Math.PI / 180;
            var dLat = (b.lat - a.lat) * toR, dLng = (b.lng - a.lng) * toR;
            var la1 = a.lat * toR, la2 = b.lat * toR;
            var x = Math.sin(dLat/2)*Math.sin(dLat/2) + Math.cos(la1)*Math.cos(la2)*Math.sin(dLng/2)*Math.sin(dLng/2);
            return 2 * R * Math.asin(Math.min(1, Math.sqrt(x)));
        }
        var out = { points: 0, distanceKm: 0, movingMin: 0, stoppedMin: 0, maxSpeedKmh: 0, firstTime: '', lastTime: '' };
        if (!fixes || !fixes.length) return out;
        out.points = fixes.length;
        var dist = 0, movingMs = 0, stoppedMs = 0, maxKmh = 0;
        for (var i = 0; i < fixes.length; i++) {
            var f = fixes[i];
            var kmh = (f.speed != null ? f.speed * 3.6 : 0);
            if (kmh > maxKmh) maxKmh = kmh;
            if (i > 0) {
                var p = fixes[i-1];
                if (p.lat != null && f.lat != null) dist += hav(p, f);
                var dt = (f.t - p.t);
                if (dt > 0 && dt < 600000) { if (kmh >= 3) movingMs += dt; else stoppedMs += dt; }
            }
        }
        function fmt(ms){ var d = new Date(ms); function p(n){ return n<10?'0'+n:''+n; } return p(d.getHours())+':'+p(d.getMinutes()); }
        out.distanceKm = Math.round(dist / 100) / 10;
        out.movingMin = Math.round(movingMs / 60000);
        out.stoppedMin = Math.round(stoppedMs / 60000);
        out.maxSpeedKmh = Math.round(maxKmh);
        out.firstTime = fmt(fixes[0].t);
        out.lastTime = fmt(fixes[fixes.length-1].t);
        return out;
 }
TestAppDayTravelComponent.computeStops = function(fixes) {
  function hav(a, b) {
            var R = 6371000, toR = Math.PI / 180;
            var dLat = (b.lat - a.lat) * toR, dLng = (b.lng - a.lng) * toR;
            var la1 = a.lat * toR, la2 = b.lat * toR;
            var x = Math.sin(dLat/2)*Math.sin(dLat/2) + Math.cos(la1)*Math.cos(la2)*Math.sin(dLng/2)*Math.sin(dLng/2);
            return 2 * R * Math.asin(Math.min(1, Math.sqrt(x)));
        }
        var RADIUS = 60, MIN_MS = 180000;
        var stops = [];
        if (!fixes || !fixes.length) return stops;
        var i = 0, n = fixes.length;
        while (i < n) {
            var anchor = fixes[i], j = i + 1, sumLat = anchor.lat, sumLng = anchor.lng, cnt = 1;
            while (j < n) {
                if (fixes[j].lat == null) { j++; continue; }
                if (hav(anchor, fixes[j]) <= RADIUS) { sumLat += fixes[j].lat; sumLng += fixes[j].lng; cnt++; j++; }
                else break;
            }
            var dur = fixes[j-1].t - anchor.t;
            if (dur >= MIN_MS) {
                stops.push({ lat: sumLat/cnt, lng: sumLng/cnt, arrival: anchor.t, departure: fixes[j-1].t, durationMs: dur });
                i = j;
            } else { i++; }
        }
        return stops;
 }
TestAppDayTravelComponent.computeSpark = function(battery, w, h) {
  try {
            if (!battery || battery.length < 2) return '';
            var t0 = battery[0].t, t1 = battery[battery.length-1].t, span = (t1 - t0) || 1;
            var pts = [];
            for (var i = 0; i < battery.length; i++) {
                var b = battery[i];
                var x = Math.round(((b.t - t0) / span) * (w - 4)) + 2;
                var y = Math.round((1 - ((b.level || 0) / 100)) * (h - 4)) + 2;
                pts.push(x + ',' + y);
            }
            return pts.join(' ');
        } catch (e) { return ''; }
 }

function I3Chart() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Chart', simpleName: 'I3Chart'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("labels",Array).add("values",Array).add("data",Array).add("datasets",Array).add("id",String).add("type",String).add("title",String).add("legend",Boolean).add("borderWidth",Number).add("borderRadius",Number).add("borderColor",String).add("backgroundColor",String).add("color",String).add("tension",Number).add("filled",Boolean).add("horizontal",Boolean).add("xHide",Boolean).add("xStacked",Boolean).add("xGridHide",Boolean).add("yHide",Boolean).add("yStacked",Boolean).add("yGridHide",Boolean).add("rHide",Boolean).add("rGridHide",Boolean).add("yScaleLabel",String).add("yScalePos",String).add("min",Number).add("max",Number).add("yScaleType",String).add("pointStyle",String).add("pointRadius",Number).add("dashedLine",Array).add("stepped",Boolean).add("alternate",Boolean).add("transparent",Boolean);
  gSobject.colors = gs.list(["#37a2eb" , "#ff6383" , "#4ac1c0" , "#fca048" , "#9966ff" , "#ffce56" , "#c9cbcf"]);
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
    return gs.mc(gSobject,"init",[self]);
   }
  gSobject['init'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gSobject,"loadChart",[self, true]);
   }
  gSobject['loadChart'] = function(self, newChart) {
    if (self === undefined) self = this;
    if (newChart === undefined) newChart = false;
    var labels = gs.list([]);
    gs.mc(gs.range(0, 4, true),"each",[function(it) {
      return gs.mc(labels,"add",[it]);
     }]);
    var options = gs.map().add("responsive",true).add("animation",true).add("indexAxis",(gs.bool(gs.gp(self,"horizontal")) ? "y" : "x")).add("plugins",gs.toJavascript(gs.mc(gSobject,"plugins",[self]))).add("scales",gs.toJavascript(gs.mc(gSobject,"scales",[self])));
    var data = gs.map();
    gs.sp(data,"labels",(gs.bool(gs.gp(self,"labels")) ? gs.toJavascript(gs.gp(self,"labels")) : gs.toJavascript(labels)));
    gs.sp(data,"datasets",gs.toJavascript(gs.mc(gSobject,"datasets",[self])));
    return gs.mc(gSobject,"nextTick",[function(it) {
      if (gs.bool(newChart)) {
        return gs.execStatic(I3Chart,'paintChart', this,[gs.gp(self,"id"), data, options, gs.gp(self,"type")]);
       } else {
        return gs.execStatic(I3Chart,'updateData', this,[gs.gp(self,"id"), gs.gp(self,"labels"), gs.gp(self,"values")]);
       };
     }]);
   }
  gSobject['dataset'] = function(self, data, index) {
    if (self === undefined) self = this;
    if (index === undefined) index = 0;
    var dataset = gs.map();
    gs.sp(dataset,"label",gs.elvis(gs.bool(gs.gp(self,"label")) , gs.gp(self,"label") , ""));
    gs.sp(dataset,"data",data);
    gs.sp(dataset,"borderWidth",gs.elvis(gs.bool(gs.gp(self,"borderWidth")) , gs.gp(self,"borderWidth") , 1));
    gs.sp(dataset,"borderRadius",gs.elvis(gs.bool(gs.gp(self,"borderRadius")) , gs.gp(self,"borderRadius") , 0));
    gs.sp(dataset,"borderSkipped",false);
    if (gs.bool(gs.gp(self,"data"))) {
      gs.sp(dataset,"borderColor",gs.elvis(gs.bool(gs.gp(self,"borderColor")) , gs.gp(self,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors)));
      gs.sp(dataset,"pointBackgroundColor",gs.elvis(gs.bool(gs.gp(self,"borderColor")) , gs.gp(self,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors)));
      var color = gs.elvis(gs.bool(gs.gp(self,"backgroundColor")) , gs.gp(self,"backgroundColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors));
      gs.sp(dataset,"backgroundColor",color);
     };
    if (gs.bool(gs.gp(self,"datasets"))) {
      var color = gs.elvis(gs.bool(gs.gp(self,"borderColor")) , gs.gp(self,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors));
      gs.sp(dataset,"borderColor",(gs.mc(color,"contains",["#"]) ? color : color[(gs.mod(index, gs.gp(color,"length")))]));
      gs.sp(dataset,"pointBackgroundColor",color);
      color = gs.elvis(gs.bool(gs.gp(self,"backgroundColor")) , gs.gp(self,"backgroundColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors));
      gs.sp(dataset,"backgroundColor",(gs.mc(color,"contains",["#"]) ? color : color[(gs.mod(index, gs.gp(color,"length")))]));
     };
    gs.sp(dataset,"tension",gs.elvis(gs.bool(gs.gp(self,"tension")) , gs.gp(self,"tension") , 0.1));
    gs.sp(dataset,"fill",gs.elvis(gs.bool(gs.gp(self,"filled")) , gs.gp(self,"filled") , false));
    gs.sp(dataset,"pointStyle",gs.elvis(gs.bool(gs.gp(self,"pointStyle")) , gs.gp(self,"pointStyle") , false));
    gs.sp(dataset,"pointRadius",gs.elvis(gs.bool(gs.gp(self,"pointRadius")) , gs.gp(self,"pointRadius") , 0));
    gs.sp(dataset,"stepped",gs.elvis(gs.bool(gs.gp(self,"stepped")) , gs.gp(self,"stepped") , false));
    gs.sp(dataset,"borderDash",gs.elvis(gs.bool(gs.gp(self,"dashedLine")) , gs.gp(self,"dashedLine") , gs.list([0 , 0])));
    return dataset;
   }
  gSobject['datasets'] = function(self) {
    if (self === undefined) self = this;
    var datasets = gs.list([]);
    if (gs.bool(gs.gp(self,"data"))) {
      gs.mc(datasets,"add",[gs.mc(gSobject,"dataset",[self, gs.gp(self,"data")])]);
     };
    if (gs.bool(gs.gp(self,"datasets"))) {
      gs.mc(gs.toJavascript(gs.gp(self,"datasets")),"eachWithIndex",[function(data, index) {
        return gs.mc(datasets,"add",[gs.mc(gSobject,"dataset",[self, data, index])]);
       }]);
     };
    return datasets;
   }
  gSobject['plugins'] = function(self) {
    if (self === undefined) self = this;
    var title = gs.map();
    if (gs.bool(gs.gp(self,"title"))) {
      gs.sp(title,"display",true);
      gs.sp(title,"text",gs.gp(self,"title"));
     };
    var legend = gs.map();
    gs.sp(legend,"display",gs.gp(self,"legend"));
    var plugins = gs.map();
    gs.sp(plugins,"legend",legend);
    gs.sp(plugins,"title",title);
    return plugins;
   }
  gSobject['scales'] = function(self) {
    if (self === undefined) self = this;
    var xScale = gs.map();
    gs.sp(xScale,"display",(gs.bool(gs.gp(self,"xHide")) ? false : true));
    gs.sp(xScale,"stacked",gs.elvis(gs.bool(gs.gp(self,"xStacked")) , gs.gp(self,"xStacked") , false));
    gs.sp(xScale,"grid",gs.map());
    gs.sp(gs.gp(xScale,"grid"),"display",(gs.bool(gs.gp(self,"xGridHide")) ? false : true));
    var yScale = gs.map();
    gs.sp(yScale,"display",(gs.bool(gs.gp(self,"yHide")) ? false : true));
    gs.sp(yScale,"stacked",gs.elvis(gs.bool(gs.gp(self,"yStacked")) , gs.gp(self,"yStacked") , false));
    if (gs.bool(gs.gp(self,"min"))) {
      gs.sp(yScale,"suggestedMin",gs.gp(self,"min"));
     };
    if (gs.bool(gs.gp(self,"max"))) {
      gs.sp(yScale,"suggestedMax",gs.gp(self,"max"));
     };
    gs.sp(yScale,"grid",gs.map());
    gs.sp(gs.gp(yScale,"grid"),"display",(gs.bool(gs.gp(self,"yGridHide")) ? false : true));
    var rScale = gs.map();
    gs.sp(rScale,"display",(gs.bool(gs.gp(self,"rHide")) ? false : true));
    gs.sp(rScale,"grid",gs.map());
    gs.sp(gs.gp(rScale,"grid"),"display",(gs.bool(gs.gp(self,"rGridHide")) ? false : true));
    var scales = gs.map();
    if (gs.mc(gs.list(["radar" , "polarArea"]),"includes",[gs.gp(self,"type")])) {
      gs.sp(scales,"r",gs.toJavascript(rScale));
     };
    if (!gs.bool(gs.mc(gs.list(["doughnut" , "pie" , "polarArea" , "radar"]),"includes",[gs.gp(self,"type")]))) {
      gs.sp(scales,"x",gs.toJavascript(xScale));
      gs.sp(scales,"y",gs.toJavascript(yScale));
     };
    return scales;
   }
  gSobject.paintChart = function(x0,x1,x2,x3) { return I3Chart.paintChart(x0,x1,x2,x3); }
  gSobject.updateData = function(x0,x1,x2) { return I3Chart.updateData(x0,x1,x2); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
I3Chart.paintChart = function(chartId, data, options, type) {
  if (type === undefined) type = "line";
  const oldChart = Chart.getChart(chartId)
        if (oldChart != undefined) oldChart.destroy()
        const config = { 
            type: type,
            data: data,
            options: options,
        }
        const myChart = new Chart( document.getElementById(chartId), config)
 }
I3Chart.updateData = function(chartId, chartLabels, dataSet) {
  let chart = Chart.getChart(chartId);
        chart.data.datasets[0].data =  gs.toJavascript(dataSet)
        chart.data.labels = gs.toJavascript(chartLabels)
        chart.update()
 }

function VueMediaUploadComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueMediaUploadComponent', simpleName: 'VueMediaUploadComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list(["oObject" , "oName" , "oPropName" , "label" , "width" , "height" , "mimeType" , "upload" , "controls" , "autoplay" , "playOnHover" , "muted" , "fit" , "controlsList" , "previewOnly" , "loop" , "customControls" , "trapezoid" , "fill" , "radius" , "downloadFile" , "zoom" , "uploadCallback" , "showFileName" , "staticHeight"]);
  gSobject.data = function(it) {
    return gs.map().add("mediaUrl","").add("myStyle","").add("acceptFiles","").add("contentType","").add("showPlayer",false).add("isCordova",false).add("playing",false).add("muted",false).add("fullscreen",false).add("showImageDialog",false);
   };
  gSobject['mounted'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"playOnHover"))) {
      gs.sp(self,"playOnHover",false);
     };
    if (!gs.bool(gs.gp(self,"upload"))) {
      gs.sp(self,"upload",false);
     };
    if (!gs.bool(gs.gp(self,"controls"))) {
      gs.sp(self,"controls",false);
     };
    if (!gs.bool(gs.gp(self,"muted"))) {
      gs.sp(self,"muted",false);
     };
    if (!gs.bool(gs.gp(self,"autoplay"))) {
      gs.sp(self,"autoplay",false);
     };
    if (gs.bool(gs.gp(self,"previewOnly"))) {
      gs.sp(self,"previewOnly",true);
     } else {
      gs.sp(self,"previewOnly",false);
     };
    if (!gs.bool(gs.gp(self,"loop"))) {
      gs.sp(self,"loop",false);
     };
    if (!gs.bool(gs.gp(self,"trapezoid"))) {
      gs.sp(self,"trapezoid",false);
     };
    if (!gs.bool(gs.gp(self,"fit"))) {
      gs.sp(self,"fit","cover");
     };
    if (!gs.bool(gs.gp(self,"fill"))) {
      gs.sp(self,"fill","fill");
     };
    if (!gs.bool(gs.gp(self,"downloadFile"))) {
      gs.sp(self,"downloadFile",false);
     };
    if (!gs.bool(gs.gp(self,"zoom"))) {
      gs.sp(self,"zoom",false);
     };
    if (!gs.bool(gs.gp(self,"showFileName"))) {
      gs.sp(self,"showFileName",false);
     };
    if (!gs.bool(gs.gp(self,"controlsList"))) {
      gs.sp(self,"controlsList","nofullscreen nodownload");
     };
    if (!gs.bool(gs.gp(self,"customControls"))) {
      gs.sp(self,"customControls",false);
     };
    gs.sp(self,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
    if (((!gs.bool(gs.gp(self,"previewOnly"))) && (!gs.bool(gs.gp(self,"playOnHover")))) && (gs.mc(gSobject,"isType",["media", self]))) {
      gs.sp(self,"showPlayer",true);
     };
    gs.sp(self,"showImageDialog",false);
    gs.mc(gSobject,"setupUrls",[self]);
    return gs.mc(gSobject,"setupZoomView",[self]);
   }
  gSobject['watchOObject'] = function(val, oldVal) {
    var self = this;
    gs.mc(gSobject,"setupUrls",[self]);
    return gs.mc(gSobject,"setupZoomView",[self]);
   }
  gSobject['created'] = function(it) {
   }
  gSobject['mouseover'] = function(it) {
    return gs.mc(gSobject,"videoControl",[this, true]);
   }
  gSobject['mouseout'] = function(it) {
    return gs.mc(gSobject,"videoControl",[this, false]);
   }
  gSobject['videoControl'] = function(self, playNow) {
    if (gs.bool(gs.gp(self,"playOnHover"))) {
      gs.sp(self,"showPlayer",playNow);
      if (gs.bool(playNow)) {
        return gs.mc(gSobject,"nextTick",[function(it) {
          return gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"play",[]);
         }]);
       };
     };
   }
  gSobject['play'] = function(it) {
    var self = this;
    gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"play",[]);
    gs.sp(self,"playing",true);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"metricService"),"add",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"legionUser"),"_id",true), "fitworld.video.play", gs.gp(gs.gp(self,"oObject"),"_id")]),"do",[]);
   }
  gSobject['pause'] = function(it) {
    var self = this;
    gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"pause",[]);
    return gs.sp(self,"playing",false);
   }
  gSobject['show'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"zoom"))) {
      return null;
     };
    gs.sp(self,"showImageDialog",true);
    gs.mc(gSobject,"nextTick",[function(it) {
     }]);
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      return gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["any"]);
     };
   }
  gSobject['hideImageDialog'] = function(it) {
    gs.sp(gSobject.self,"showImageDialog",false);
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      return gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["portrait"]);
     };
   }
  gSobject['changeFullscreen'] = function(it) {
    gs.println("fullscreen");
    var self = this;
    gs.sp(self,"fullscreen",true);
    var video = gs.gp(gs.gp(self,"$refs"),"video");
    var onfullscreenchange = function(it) {
      gs.println("onfullscreenchange");
      gs.sp(self,"fullscreen",!gs.gp(self,"fullscreen"));
      return gs.println(gs.gp(self,"fullscreen"));
     };
    gs.sp(video,"onfullscreenchange",onfullscreenchange);
    gs.sp(video,"mozfullscreenchange",onfullscreenchange);
    gs.sp(video,"webkitfullscreenchange",onfullscreenchange);
    gs.sp(video,"msfullscreenchange",onfullscreenchange);
    if (gs.bool(gs.gp(video,"requestFullScreen"))) {
      return gs.mc(video,"requestFullScreen",[]);
     };
    if (gs.bool(gs.gp(video,"webkitEnterFullScreen"))) {
      return gs.mc(video,"webkitEnterFullScreen",[]);
     };
    if (gs.bool(gs.gp(video,"webkitRequestFullScreen"))) {
      return gs.mc(video,"webkitRequestFullScreen",[]);
     };
    if (gs.bool(gs.gp(video,"mozRequestFullScreen"))) {
      return gs.mc(video,"mozRequestFullScreen",[]);
     };
    if (gs.bool(gs.gp(video,"msRequestFullscreen"))) {
      return gs.mc(video,"msRequestFullscreen",[]);
     };
   }
  gSobject['mute'] = function(it) {
    var self = this;
    gs.sp(gs.gp(gs.gp(self,"$refs"),"video"),"muted",true);
    return gs.sp(self,"muted",true);
   }
  gSobject['unmute'] = function(it) {
    var self = this;
    gs.sp(gs.gp(gs.gp(self,"$refs"),"video"),"muted",false);
    return gs.sp(self,"muted",false);
   }
  gSobject['download'] = function(it) {
    var self = this;
    return gs.mc(gs.fs('window', this, gSobject),"open",[gs.gp(self,"downloadUrl"), "_system", "closebuttoncaption=DONE&location=no"]);
   }
  gSobject['isProcessing'] = function(it) {
    return (gs.bool(gs.gp(gSobject.self,"oObject"))) && (gs.equals(gs.gp(gs.gp(gSobject.self,"oObject")[gs.gp(gSobject.self,"oPropName")],"processing",true), true));
   }
  gSobject['setupUrls'] = function(self) {
    gs.sp(self,"placeHolderUrl","/statics/vue-wrapper/img/placeHolder.png?" + ((gs.bool(gs.gp(self,"width")) ? gs.plus("&width=", gs.gp(self,"width")) : "")) + "" + ((gs.bool(gs.gp(self,"height")) ? gs.plus("&height=", gs.gp(self,"height")) : "")) + ";" + ((gs.bool(gs.gp(self,"staticHeight")) ? gs.plus("height:", gs.gp(self,"staticHeight")) : "")) + ";");
    gs.sp(self,"myStyle","" + ((gs.bool(gs.gp(self,"width")) ? gs.plus((gs.plus("min-width:", gs.gp(self,"width"))), "px") : "")) + ";" + ((gs.bool(gs.gp(self,"height")) ? gs.plus((gs.plus("min-height:", gs.gp(self,"height"))), "px") : "")) + ";" + ((gs.bool(gs.gp(self,"radius")) ? gs.plus((gs.plus("border-radius:", gs.gp(self,"radius"))), "px") : "")) + ";" + ((gs.bool(gs.gp(self,"staticHeight")) ? gs.plus("height:", gs.gp(self,"staticHeight")) : "")) + ";");
    gs.sp(self,"acceptFiles",gs.elvis(gs.bool(gs.gp(self,"mimeType")) , gs.gp(self,"mimeType") , "image/*"));
    if ((!gs.bool(gs.gp(self,"oObject"))) || (!gs.bool(gs.gp(self,"oObject")[gs.gp(self,"oPropName")]))) {
      gs.println("NO OBJECT");
      gs.sp(self,"previewUrl",gs.gp(self,"placeHolder"));
      gs.sp(self,"downloadUrl",gs.gp(self,"placeHolderUrl"));
      gs.println(gs.gp(self,"previewUrl"));
      gs.println(gs.gp(self,"downloadUrl"));
      return null;
     };
    if (gs.mc(gSobject,"isProcessing",[])) {
      gs.println("isProcessing");
      gs.sp(self,"placeHolderUrl","/statics/vue-wrapper/img/spinner.gif");
      gs.sp(self,"previewUrl",gs.gp(self,"placeHolder"));
      gs.sp(self,"downloadUrl",gs.gp(self,"placeHolderUrl"));
      gs.println(gs.gp(self,"previewUrl"));
      gs.println(gs.gp(self,"downloadUrl"));
      return null;
     };
    gs.println("ALL GOOD");
    var fileInfo = gs.gp(self,"oObject")[gs.gp(self,"oPropName")];
    gs.sp(self,"contentType",gs.gp(fileInfo,"contentType"));
    var objectId = gs.gp(gs.gp(self,"oObject"),"_id");
    var lastUpdated = gs.gp(gs.gp(self,"oObject"),"_lastUpdated");
    try {
      lastUpdated = gs.mc(lastUpdated,"getTime",[]);
     }
    catch (all) {
     }
    ;
    gs.sp(self,"previewUrl","/media-cache/filePreview/" + (objectId) + "/" + (gs.gp(self,"oPropName")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "?" + ((gs.bool(gs.gp(self,"width")) ? gs.plus("&width=", gs.gp(self,"width")) : "")) + "" + ((gs.bool(gs.gp(self,"height")) ? gs.plus("&height=", gs.gp(self,"height")) : "")) + "");
    gs.sp(self,"downloadUrl","/media-cache/file/" + (objectId) + "/" + (gs.gp(self,"oPropName")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "");
    gs.println(gs.gp(self,"previewUrl"));
    return gs.println(gs.gp(self,"downloadUrl"));
   }
  gSobject['setupZoomView'] = function(self) {
    return gs.sp(self,"hammerRef",(gs.bool(gs.gp(self,"oObject")) ? gs.plus((gs.plus((gs.plus("hammerRef:", gs.gp(gs.gp(self,"oObject"),"_id"))), ":")), gs.gp(self,"oPropName")) : ""));
   }
  gSobject['isType'] = function(testType, self) {
    if (self === undefined) self = this;
    if (!gs.bool(gs.gp(self,"oObject"))) {
      if (gs.equals(testType, "empty")) {
        return true;
       };
      return false;
     };
    var fileInfo = gs.gp(self,"oObject")[gs.gp(self,"oPropName")];
    if ((gs.equals(testType, "empty")) && (!gs.bool(fileInfo))) {
      return true;
     };
    if (!gs.bool(fileInfo)) {
      return false;
     };
    if (gs.equals(testType, "image")) {
      return gs.mc(gs.gp(fileInfo,"contentType"),"startsWith",["image"]);
     };
    if (gs.equals(testType, "media")) {
      return (gs.mc(gs.gp(fileInfo,"contentType"),"startsWith",["video"])) || (gs.mc(gs.gp(fileInfo,"contentType"),"startsWith",["audio"]));
     };
    if (gs.equals(testType, "application/pdf")) {
      return gs.mc(gs.gp(fileInfo,"contentType"),"startsWith",["application/pdf"]);
     };
    return false;
   }
  gSobject['saveFile'] = function(newFile) {
    var self = this;
    var uploadFile = gs.gp(gs.gp(newFile,"target"),"files")[0];
    return gs.execStatic(Utils,'post', this,[uploadFile, gs.fs('oPropName', this, gSobject), gs.fs('oName', this, gSobject), gs.gp(gs.fs('oObject', this, gSobject),"_id"), function(data) {
      gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"mediaCacheService"),"deleteCache",[gs.gp(gs.gp(self,"oObject"),"_id"), gs.gp(self,"oPropName")]),"do",[]);
      var fileInfo = gs.map().add("id","" + (gs.gp(gs.gp(self,"oObject"),"_id")) + "_" + (gs.gp(self,"oPropName")) + "").add("filename",gs.gp(uploadFile,"name")).add("contentType",gs.gp(uploadFile,"type"));
      gs.sp(gs.gp(self,"oObject"),"_lastUpdated",gs.date());
      (gs.gp(self,"oObject")[gs.gp(self,"oPropName")]) = fileInfo;
      gs.mc(gSobject,"setupUrls",[self]);
      if (gs.bool(gs.gp(self,"uploadCallback"))) {
        return gs.mc(self,"uploadCallback",[]);
       };
     }]);
   }
  gSobject['beforeUnmount'] = function(it) {
    var self = this;
    return gs.sp(self,"showPlayer",false);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaSimBridge() {
  var gSobject = gs.init('CordovaSimBridge');
  gSobject.clazz = { name: 'CordovaSimBridge', simpleName: 'CordovaSimBridge'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.active = false;
  gSobject.pendingCallbacks = gs.map();
  gSobject.eventListeners = gs.map();
  gSobject.shouldActivate = function() { return CordovaSimBridge.shouldActivate(); }
  gSobject['activate'] = function(it) {
    gSobject.active = true;
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaSimBridge: ACTIVE — running in simulator mode"]);
    gs.mc(gSobject,"setupFakeCordova",[]);
    gs.mc(gSobject,"setupMessageListener",[]);
    return gs.mc(gSobject,"fireDeviceReady",[]);
   }
  gSobject['setupFakeCordova'] = function(it) {
    gs.mc(gSobject,"createFakePlugins",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaSimBridge: fake plugin globals created"]);
   }
  gSobject.createFakePlugins = function() {
    var bridge = this;

        // Core cordova object
        window.cordova = window.cordova || {};
        window.cordova.plugins = window.cordova.plugins || {};

        // --- Scanner ---
        window.cordova.plugins.barcodeScanner = {
            scan: function(success, error, config) {
                bridge._storePending('scanner', 'scan', success, error);
                console.log('[SimBridge] Scanner: waiting for simulated scan...');
                // Notify parent we're waiting
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'scanner', action:'scan'}, '*');
            }
        };

        // --- BackgroundGeolocation (cordova-plugin-i3-bggeo) ---
        window.BackgroundGeolocation = {
            events: ['location','stationary','activity','start','stop','error','authorization','foreground','background','abort_requested','http_authorization','geofence'],
            AUTHORIZED: 1, NOT_AUTHORIZED: 0, AUTHORIZED_FOREGROUND: 2,
            HIGH_ACCURACY: 0, MEDIUM_ACCURACY: 100, LOW_ACCURACY: 1000, PASSIVE_ACCURACY: 10000,
            BACKGROUND_MODE: 0, FOREGROUND_MODE: 1,
            GEOFENCE_TRANSITION_ENTER: 1, GEOFENCE_TRANSITION_EXIT: 2, GEOFENCE_TRANSITION_DWELL: 4,
            PERMISSION_DENIED: 1, LOCATION_UNAVAILABLE: 2, TIMEOUT: 3,
            DISTANCE_FILTER_PROVIDER: 0, ACTIVITY_PROVIDER: 1, RAW_PROVIDER: 2,
            LOG_ERROR: 'ERROR', LOG_WARN: 'WARN', LOG_INFO: 'INFO', LOG_DEBUG: 'DEBUG', LOG_TRACE: 'TRACE',
            _listeners: {},
            _config: {},
            _geofences: [],
            _geofenceQueue: [],
            _status: { isRunning: false, locationServicesEnabled: true, authorization: 1 },
            configure: function(config, success, failure) {
                var bg = window.BackgroundGeolocation;
                for (var k in (config || {})) bg._config[k] = config[k];
                console.log('[SimBridge] BgGeo configured', config);
                if(success) success();
            },
            getConfig: function(success, failure) { if(success) success(window.BackgroundGeolocation._config || {}); },
            start: function(s,f) { window.BackgroundGeolocation._status.isRunning = true; console.log('[SimBridge] BgGeo started'); if(s) s(); },
            stop: function(s,f) { window.BackgroundGeolocation._status.isRunning = false; console.log('[SimBridge] BgGeo stopped'); if(s) s(); },
            switchMode: function(m,s,f) { console.log('[SimBridge] BgGeo switchMode', m); if(s) s(); },
            getCurrentLocation: function(success, failure, options) {
                bridge._storePending('gps', 'currentLocation', success, failure);
                console.log('[SimBridge] GPS: waiting for simulated location...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'gps', action:'currentLocation'}, '*');
            },
            on: function(event, fn) {
                var bg = window.BackgroundGeolocation;
                if (!bg._listeners[event]) bg._listeners[event] = [];
                bg._listeners[event].push(fn);
                return { remove: function() {
                    var arr = bg._listeners[event] || [];
                    for (var i = arr.length - 1; i >= 0; i--) if (arr[i] === fn) arr.splice(i, 1);
                }};
            },
            removeAllListeners: function(event) {
                var bg = window.BackgroundGeolocation;
                if(event) bg._listeners[event] = []; else bg._listeners = {};
            },
            checkStatus: function(cb) {
                var s = window.BackgroundGeolocation._status;
                if(cb) cb({isRunning: s.isRunning, locationServicesEnabled: s.locationServicesEnabled, authorization: s.authorization});
            },
            showAppSettings: function() { console.log('[SimBridge] BgGeo showAppSettings'); },
            showLocationSettings: function() { console.log('[SimBridge] BgGeo showLocationSettings'); },
            addGeofence: function(fence, s, e) {
                var fences = window.BackgroundGeolocation._geofences;
                for (var i = fences.length - 1; i >= 0; i--) if (fence && fences[i].id === fence.id) fences.splice(i, 1);
                if (fence) fences.push(fence);
                console.log('[SimBridge] BgGeo addGeofence', fence);
                if(s) s();
            },
            addGeofences: function(arr, s, e) {
                var fences = window.BackgroundGeolocation._geofences;
                arr = arr || [];
                for (var j = 0; j < arr.length; j++) {
                    var fence = arr[j];
                    for (var i = fences.length - 1; i >= 0; i--) if (fences[i].id === fence.id) fences.splice(i, 1);
                    fences.push(fence);
                }
                console.log('[SimBridge] BgGeo addGeofences count=' + arr.length);
                if(s) s();
            },
            removeGeofence: function(id, s, e) {
                var fences = window.BackgroundGeolocation._geofences;
                for (var i = fences.length - 1; i >= 0; i--) if (fences[i].id === id) fences.splice(i, 1);
                console.log('[SimBridge] BgGeo removeGeofence', id);
                if(s) s();
            },
            removeGeofences: function(ids, s, e) {
                var fences = window.BackgroundGeolocation._geofences;
                ids = ids || [];
                var idSet = {};
                for (var k = 0; k < ids.length; k++) idSet[ids[k]] = true;
                for (var i = fences.length - 1; i >= 0; i--) if (idSet[fences[i].id]) fences.splice(i, 1);
                console.log('[SimBridge] BgGeo removeGeofences count=' + ids.length);
                if(s) s();
            },
            removeAllGeofences: function(s, e) {
                window.BackgroundGeolocation._geofences = [];
                console.log('[SimBridge] BgGeo removeAllGeofences');
                if(s) s();
            },
            getGeofences: function(cb) { if(cb) cb((window.BackgroundGeolocation._geofences || []).slice()); },
            getGeofenceEvents: function(cb) {
                var bg = window.BackgroundGeolocation;
                var q = (bg._geofenceQueue || []).slice();
                bg._geofenceQueue = [];
                if(cb) cb(q);
            },
            getStationaryLocation: function(s, f) { if(s) s(null); },
            // Backward-compat no-ops (matched to plugin's own stubs)
            getLocations:       function(s, f) { if(s) s([]); },
            getValidLocations:  function(s, f) { if(s) s([]); },
            deleteLocation:     function(id, s, f) { if(s) s(); },
            deleteAllLocations: function(s, f) { if(s) s(); },
            getLogEntries: function() {
                var args = arguments;
                for (var i = 0; i < args.length; i++) if (typeof args[i] === 'function') { args[i]([]); return; }
            },
            startTask:    function(s, f) { if(s) s(0); },
            endTask:      function(k, s, f) { if(s) s(); },
            headlessTask: function(fn, s, f) { if(s) s(); },
            forceSync:    function(s, f) { if(s) s(); },
            isLocationEnabled: function(s, f) { if(s) s(window.BackgroundGeolocation._status.locationServicesEnabled ? 1 : 0); },
        };

        // --- Bluetooth LE ---
        window.bluetoothle = {
            _scanCallback: null,
            initialize: function(success, params) {
                if(success) success({status: 'enabled'});
            },
            isInitialized: function(cb) { if(cb) cb({isInitialized: true}); },
            isEnabled: function(cb) { if(cb) cb({isEnabled: true}); },
            enable: function(s,e) { if(s) s(); },
            startScan: function(success, error, params) {
                window.bluetoothle._scanCallback = success;
                if(success) success({status: 'scanStarted'});
                console.log('[SimBridge] BLE: scanning, waiting for simulated devices...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'ble', action:'scan'}, '*');
            },
            stopScan: function(success, error) {
                window.bluetoothle._scanCallback = null;
                if(success) success({status: 'scanStopped'});
            },
            isScanning: function(cb) { if(cb) cb({isScanning: !!window.bluetoothle._scanCallback}); },
            getAdapterInfo: function(cb) {
                if(cb) cb({name:'Simulated Adapter', address:'00:00:00:00:00:00', isInitialized:true, isEnabled:true, isScanning:false, isDiscoverable:false});
            },
            connect: function(s,e,p) { if(s) s({status:'connected', address:p.address}); },
            disconnect: function(s,e,p) { if(s) s({status:'disconnected', address:p.address}); },
            close: function(s,e,p) { if(s) s({status:'closed'}); },
            discover: function(s,e,p) { if(s) s({status:'discovered', services:[]}); },
            read: function(s,e,p) { if(s) s({status:'read', value:'AAAA'}); },
            write: function(s,e,p) { if(s) s({status:'written'}); },
            subscribe: function(s,e,p) { if(s) s({status:'subscribed'}); },
            unsubscribe: function(s,e,p) { if(s) s({status:'unsubscribed'}); },
        };

        // --- Social Sharing ---
        window.plugins = window.plugins || {};
        window.plugins.socialsharing = {
            share: function(msg, subj, files, url, success, failure) {
                console.log('[SimBridge] Share:', msg, subj, url);
                if(success) success();
            },
            shareViaEmail: function(msg, subj, to, cc, bcc, files, success, failure) {
                console.log('[SimBridge] Email:', msg, subj, to);
                if(success) success();
            },
            shareViaSMS: function(opts, phone, success, failure) {
                console.log('[SimBridge] SMS:', opts, phone);
                if(success) success();
            },
            shareViaWhatsApp: function(msg, files, url, success, failure) {
                console.log('[SimBridge] WhatsApp:', msg);
                if(success) success();
            },
            canShareVia: function(via, msg, subj, files, url, success, failure) {
                if(success) success();
            },
            available: function(cb) { if(cb) cb(true); },
            saveToPhotoAlbum: function(files, s, e) { if(s) s(); },
        };

        // --- InAppBrowser ---
        window.cordova.InAppBrowser = {
            open: function(url, target, options) {
                console.log('[SimBridge] Browser:', url, target);
                if (target === '_system' || target === '_blank') {
                    window.parent.postMessage({type:'cordova-sim-event', plugin:'browser', action:'open', data:{url:url, target:target}}, '*');
                }
                return {
                    addEventListener: function(e,cb) {},
                    removeEventListener: function(e,cb) {},
                    close: function() {},
                    show: function() {},
                    hide: function() {},
                    executeScript: function(d,cb) { if(cb) cb([]); },
                };
            }
        };

        // --- Contacts ---
        window.navigator.contacts = window.navigator.contacts || {
            find: function(fields, success, error, options) {
                bridge._storePending('contacts', 'find', success, error);
                console.log('[SimBridge] Contacts: waiting for simulated contacts...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'contacts', action:'find', data:{filter: options ? options.filter : ''}}, '*');
            },
            pickContact: function(success, error) {
                bridge._storePending('contacts', 'pick', success, error);
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'contacts', action:'pick'}, '*');
            },
            create: function(props) { return props || {}; },
            fieldType: { displayName:'displayName', phoneNumbers:'phoneNumbers', emails:'emails', name:'name' },
        };

        // --- Deep Links ---
        window.universalLinks = {
            _callbacks: {},
            subscribe: function(event, cb) { this._callbacks[event] = cb; },
            unsubscribe: function(event) { delete this._callbacks[event]; },
            checkDeepLink: function(ms) {
                return { then: function(cb) { return { catch: function(e) {} }; } };
            },
        };

        // --- Camera ---
        window.navigator.camera = {
            getPicture: function(success, failure, opts) {
                bridge._storePending('camera', 'photo', success, failure);
                console.log('[SimBridge] Camera: waiting for simulated photo...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'camera', action:'photo'}, '*');
            },
            cleanup: function() {},
            DestinationType: { FILE_URI: 1, DATA_URL: 0 },
            PictureSourceType: { CAMERA: 1, PHOTOLIBRARY: 0 },
        };
        window.Camera = { EncodingType: { JPEG: 0, PNG: 1 } };

        // --- i3 Spinner ---
        window.i3Spinner = {
            show: function(opts, success, error) {
                console.log('[SimBridge] Spinner show:', opts);
                window.parent.postMessage({type:'cordova-sim-event', plugin:'spinner', action:'show', data:opts}, '*');
                if(success) success();
            },
            hide: function(success, error) {
                console.log('[SimBridge] Spinner hide');
                window.parent.postMessage({type:'cordova-sim-event', plugin:'spinner', action:'hide'}, '*');
                if(success) success();
            },
        };

        // --- Fingerprint / Biometrics ---
        window.Fingerprint = {
            isAvailable: function(success, error) {
                bridge._storePending('biometrics', 'available', success, error);
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'biometrics', action:'available'}, '*');
            },
            show: function(params, success, error) {
                bridge._storePending('biometrics', 'auth', success, error);
                console.log('[SimBridge] Biometrics: waiting for simulated auth...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'biometrics', action:'auth'}, '*');
            },
            registerBiometricSecret: function(params, success, error) { if(success) success('registered'); },
            loadBiometricSecret: function(params, success, error) { if(success) success('sim-secret-123'); },
        };

        // --- Device ---
        window.device = {
            platform: 'Simulator', model: 'Desktop Browser', version: '1.0',
            manufacturer: 'Dymico', uuid: 'sim-' + Date.now(), serial: 'SIM000',
            cordova: '12.0.0', isVirtual: true,
        };

        // --- StatusBar ---
        window.StatusBar = {
            show: function() { console.log('[SimBridge] StatusBar show'); },
            hide: function() { console.log('[SimBridge] StatusBar hide'); },
            overlaysWebView: function(v) { console.log('[SimBridge] StatusBar overlay', v); },
            styleDefault: function() {},
            styleLightContent: function() {},
            backgroundColorByName: function(n) {},
            backgroundColorByHexString: function(h) {},
        };

        // --- Battery (navigator.battery is set by cordova-plugin-battery-status) ---
        window.navigator.battery = { level: 75, isPlugged: false };

        // --- Permissions ---
        window.cordova.plugins.permissions = {
            checkPermission: function(perm, success, error) {
                if(success) success({hasPermission: true});
            },
            requestPermission: function(perm, success, error) {
                if(success) success({hasPermission: true});
            },
        };

        // --- Push ---
        window.PushNotification = {
            init: function(opts) {
                var _handlers = {};
                var pushObj = {
                    on: function(event, cb) { _handlers[event] = cb; },
                    _handlers: _handlers,
                };
                // Fire registration after a tick
                setTimeout(function() {
                    if(_handlers.registration) _handlers.registration({registrationId: 'sim-push-token-' + Date.now()});
                }, 500);
                bridge._simPush = pushObj;
                return pushObj;
            }
        };

        // --- Screen Orientation ---
        // screen.orientation is already available in browsers

        // --- SpinnerDialog (legacy fallback) ---
        window.SpinnerDialog = {
            show: function(t,m,c) { window.i3Spinner.show({message: m || t || '', cancelable: !!c}); },
            hide: function() { window.i3Spinner.hide(); },
        };

        // --- Media ---
        window.Media = function(src, onSuccess, onError, onStatus) {
            return {
                startRecord: function() { console.log('[SimBridge] Media record:', src); },
                stopRecord: function() { console.log('[SimBridge] Media stop record'); if(onSuccess) onSuccess(); },
                play: function() { console.log('[SimBridge] Media play:', src); },
                stop: function() { console.log('[SimBridge] Media stop'); },
                release: function() {},
                getDuration: function() { return 0; },
                getCurrentPosition: function(cb) { if(cb) cb(0); },
            };
        };

        console.log('[SimBridge] All fake Cordova plugins registered');
   }
  gSobject['setupMessageListener'] = function(it) {
    return gs.mc(gSobject,"listenForMessages",[]);
   }
  gSobject.listenForMessages = function() {
    var bridge = this;
        window.addEventListener('message', function(event) {
            var msg = event.data;
            if (!msg || msg.type !== 'cordova-sim') return;

            console.log('[SimBridge] Received:', msg.plugin, msg.action, msg.data);

            switch(msg.plugin) {
                case 'scanner':
                    if (msg.action === 'result') bridge._firePending('scanner', 'scan', msg.data);
                    if (msg.action === 'cancel') bridge._firePending('scanner', 'scan', {text:'', format:'', cancelled:true});
                    break;

                case 'gps':
                    if (msg.action === 'location') {
                        bridge._firePending('gps', 'currentLocation', msg.data);
                        var listeners = window.BackgroundGeolocation._listeners['location'] || [];
                        for (var i = 0; i < listeners.length; i++) { listeners[i](msg.data); }
                    }
                    if (msg.action === 'stationary') {
                        var sListeners = window.BackgroundGeolocation._listeners['stationary'] || [];
                        for (var i = 0; i < sListeners.length; i++) { sListeners[i](msg.data); }
                    }
                    if (msg.action === 'activity') {
                        var aListeners = window.BackgroundGeolocation._listeners['activity'] || [];
                        for (var i = 0; i < aListeners.length; i++) { aListeners[i](msg.data); }
                    }
                    if (msg.action === 'geofence') {
                        var fenceEvent = {
                            fenceId:    msg.data.fenceId || msg.data.id,
                            transition: msg.data.transition,
                            location:   msg.data.location || null,
                            data:       msg.data.data || null,
                            timestamp:  msg.data.timestamp || Date.now()
                        };
                        var bgGf = window.BackgroundGeolocation;
                        bgGf._geofenceQueue = bgGf._geofenceQueue || [];
                        bgGf._geofenceQueue.push(fenceEvent);
                        var gListeners = bgGf._listeners['geofence'] || [];
                        for (var i = 0; i < gListeners.length; i++) { gListeners[i](fenceEvent); }
                    }
                    if (msg.action === 'start' || msg.action === 'stop' ||
                        msg.action === 'foreground' || msg.action === 'background' ||
                        msg.action === 'abort_requested') {
                        if (msg.action === 'start') window.BackgroundGeolocation._status.isRunning = true;
                        if (msg.action === 'stop')  window.BackgroundGeolocation._status.isRunning = false;
                        var lListeners = window.BackgroundGeolocation._listeners[msg.action] || [];
                        for (var i = 0; i < lListeners.length; i++) { lListeners[i](msg.data || {}); }
                    }
                    if (msg.action === 'error') {
                        var eListeners = window.BackgroundGeolocation._listeners['error'] || [];
                        for (var i = 0; i < eListeners.length; i++) { eListeners[i](msg.data); }
                    }
                    if (msg.action === 'authorization') {
                        if (msg.data && typeof msg.data.code !== 'undefined') {
                            window.BackgroundGeolocation._status.authorization = msg.data.code;
                        }
                        var auListeners = window.BackgroundGeolocation._listeners['authorization'] || [];
                        for (var i = 0; i < auListeners.length; i++) { auListeners[i](msg.data); }
                    }
                    if (msg.action === 'http_authorization') {
                        var hListeners = window.BackgroundGeolocation._listeners['http_authorization'] || [];
                        for (var i = 0; i < hListeners.length; i++) { hListeners[i](msg.data || {}); }
                    }
                    if (msg.action === 'status') {
                        if (msg.data && typeof msg.data === 'object') {
                            var st = window.BackgroundGeolocation._status;
                            for (var k in msg.data) st[k] = msg.data[k];
                        }
                    }
                    break;

                case 'ble':
                    if (msg.action === 'device' && window.bluetoothle._scanCallback) {
                        window.bluetoothle._scanCallback({status:'scanResult', name:msg.data.name, address:msg.data.address, rssi:msg.data.rssi});
                    }
                    break;

                case 'camera':
                    if (msg.action === 'photo') bridge._firePending('camera', 'photo', msg.data.uri || msg.data);
                    break;

                case 'contacts':
                    if (msg.action === 'results') bridge._firePending('contacts', 'find', msg.data);
                    if (msg.action === 'picked') bridge._firePending('contacts', 'pick', msg.data);
                    break;

                case 'deeplink':
                    if (msg.action === 'trigger') {
                        var dl = window.universalLinks._callbacks;
                        for (var key in dl) { if (dl[key]) dl[key](msg.data); }
                    }
                    break;

                case 'battery':
                    if (msg.action === 'status') {
                        window.navigator.battery = msg.data;
                        var evt = new CustomEvent('batterystatus', {detail: msg.data});
                        window.dispatchEvent(evt);
                    }
                    break;

                case 'network':
                    if (msg.action === 'status') {
                        var evtName = msg.data.online ? 'online' : 'offline';
                        document.dispatchEvent(new Event(evtName));
                    }
                    break;

                case 'biometrics':
                    if (msg.action === 'available') bridge._firePending('biometrics', 'available', msg.data.result || {biometryType:'face'});
                    if (msg.action === 'pass') bridge._firePending('biometrics', 'auth', msg.data || 'success');
                    if (msg.action === 'fail') bridge._firePendingError('biometrics', 'auth', msg.data || 'cancelled');
                    break;

                case 'push':
                    if (msg.action === 'notification' && bridge._simPush && bridge._simPush._handlers.notification) {
                        bridge._simPush._handlers.notification(msg.data);
                    }
                    break;
            }
        });
        console.log('[SimBridge] postMessage listener registered');
   }
  gSobject['fireDeviceReady'] = function(it) {
    return gs.mc(gSobject,"fireDeviceReadyEvent",[]);
   }
  gSobject.fireDeviceReadyEvent = function() {
    // Fire deviceready after a short delay so all plugins are set up
        setTimeout(function() {
            document.dispatchEvent(new Event('deviceready'));
            console.log('[SimBridge] deviceready fired');
        }, 500);
   }
  gSobject._storePending = function(plugin, action, success, error) {
    var key = plugin + ':' + action;
        this.pendingCallbacks[key] = { success: success, error: error };
   }
  gSobject._firePending = function(plugin, action, data) {
    var key = plugin + ':' + action;
        var pending = this.pendingCallbacks[key];
        if (pending && pending.success) {
            pending.success(data);
            delete this.pendingCallbacks[key];
        }
   }
  gSobject._firePendingError = function(plugin, action, data) {
    var key = plugin + ':' + action;
        var pending = this.pendingCallbacks[key];
        if (pending && pending.error) {
            pending.error(data);
            delete this.pendingCallbacks[key];
        }
   }
  gSobject['CordovaSimBridge0'] = function(it) {
    if (CordovaSimBridge.shouldActivate()) {
      gs.mc(gSobject,"activate",[]);
     };
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaSimBridge0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaSimBridge.shouldActivate = function() {
  // Activate in iframe without real Cordova, or when simulator flag is set by /cordova/header
        return (window.parent !== window) && ((typeof window.cordova === 'undefined') || window.__dymicoSimulator === true);
 }

function LegionRegisterComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'LegionRegisterComponent', simpleName: 'LegionRegisterComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/register";
  gSobject['created'] = function(it) {
    gs.println("LegionRegisterComponent.created()");
    gs.sp(gSobject.scope,"email","");
    gs.sp(gSobject.scope,"phoneNumber","");
    return gs.sp(gSobject.scope,"processing",false);
   }
  gSobject['generatePin'] = function(it) {
    gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username",gs.elvis(gs.bool(gs.gp(gSobject.scope,"email")) , gs.gp(gSobject.scope,"email") , gs.gp(gSobject.scope,"phoneNumber")));
    if (!gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"))) {
      gs.mc(gSobject,"notify",["Please enter details", "negative"]);
      return null;
     };
    gs.sp(gSobject.scope,"processing",true);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"generatePinForNewOrExistingUser",[gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"), true, (gs.bool(gs.gp(gSobject.scope,"phoneNumber")) ? true : false)]),"then",[function(it) {
      gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/legionPin"]);
      gs.mc(gSobject,"notify",["Pin Sent"]);
      return gs.sp(gSobject.scope,"processing",false);
     }, function(error) {
      gs.mc(gSobject,"notify",[gs.gp(error,"message"), "negative"]);
      return gs.sp(gSobject.scope,"processing",false);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppContactsComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppContactsComponent', simpleName: 'TestAppContactsComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/contacts";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppContactsComponent: created"]);
    gs.sp(gSobject.scope,"contacts",gs.list([]));
    gs.sp(gSobject.scope,"searchText","");
    gs.sp(gSobject.scope,"loading",false);
    gs.sp(gSobject.scope,"error","");
    gs.sp(gSobject.scope,"selectedContact",null);
    return gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
   }
  gSobject['searchContacts'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppContactsComponent: searchContacts: " + (gs.gp(gSobject.scope,"searchText")) + ""]);
    gs.sp(gSobject.scope,"loading",true);
    gs.sp(gSobject.scope,"error","");
    gs.sp(gSobject.scope,"contacts",gs.list([]));
    return gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"contacts"),"find",[gs.list(["displayName" , "phoneNumbers" , "emails" , "name"]), function(contactsArr) {
      gs.sp(gSobject.scope,"contacts",gs.elvis(gs.bool(contactsArr) , contactsArr , gs.list([])));
      gs.sp(gSobject.scope,"loading",false);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppContactsComponent: success - found " + (gs.elvis(gs.bool(gs.gp(contactsArr,"length",true)) , gs.gp(contactsArr,"length",true) , 0)) + " contacts"]);
     }, function(err) {
      gs.sp(gSobject.scope,"loading",false);
      gs.sp(gSobject.scope,"error","Find error: " + (gs.elvis(gs.bool(gs.gp(err,"code",true)) , gs.gp(err,"code",true) , err)) + "");
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppContactsComponent: error: " + (gs.elvis(gs.bool(gs.gp(err,"code",true)) , gs.gp(err,"code",true) , err)) + ""]);
     }, gs.map().add("filter",gs.elvis(gs.bool(gs.gp(gSobject.scope,"searchText")) , gs.gp(gSobject.scope,"searchText") , "")).add("multiple",true).add("hasPhoneNumber",false)]);
   }
  gSobject['selectContact'] = function(contact) {
    return gs.sp(gSobject.scope,"selectedContact",contact);
   }
  gSobject['closeDetail'] = function(it) {
    return gs.sp(gSobject.scope,"selectedContact",null);
   }
  gSobject['pickContact'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppContactsComponent: pickContact"]);
    return gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"contacts"),"pickContact",[function(contact) {
      return gs.sp(gSobject.scope,"selectedContact",contact);
     }, function(e) {
      return gs.sp(gSobject.scope,"error","Pick error: " + (e) + "");
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppCalendarComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppCalendarComponent', simpleName: 'TestAppCalendarComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/calendar";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"title","Test Event");
    gs.sp(gSobject.scope,"location","Office");
    gs.sp(gSobject.scope,"notes","Created from test app");
    return gs.sp(gSobject.scope,"log",gs.list([]));
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 20) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 19)));
     };
   }
  gSobject['createEvent'] = function(it) {
    var start = gs.date(gs.plus(gs.mc(gs.date(),"getTime",[]), 3600000));
    var end = gs.date(gs.plus(gs.mc(start,"getTime",[]), 3600000));
    gs.mc(gSobject,"addLog",["Creating: " + (gs.gp(gSobject.scope,"title")) + ""]);
    return gs.mc(gs.fs('cordovaCalendar', this, gSobject),"createEvent",[gs.gp(gSobject.scope,"title"), gs.gp(gSobject.scope,"location"), gs.gp(gSobject.scope,"notes"), start, end, function(id) {
      return gs.mc(gSobject,"addLog",["Created: " + (id) + ""]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["Error: " + (err) + ""]);
     }]);
   }
  gSobject['createInteractive'] = function(it) {
    var start = gs.date(gs.plus(gs.mc(gs.date(),"getTime",[]), 3600000));
    var end = gs.date(gs.plus(gs.mc(start,"getTime",[]), 3600000));
    gs.mc(gSobject,"addLog",["Opening editor..."]);
    return gs.mc(gs.fs('cordovaCalendar', this, gSobject),"createEventInteractively",[gs.gp(gSobject.scope,"title"), gs.gp(gSobject.scope,"location"), gs.gp(gSobject.scope,"notes"), start, end, function(id) {
      return gs.mc(gSobject,"addLog",["Created: " + (id) + ""]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["Error: " + (err) + ""]);
     }]);
   }
  gSobject['findEvents'] = function(it) {
    var end = gs.date();
    var start = gs.date(gs.minus(gs.mc(end,"getTime",[]), 604800000));
    return gs.mc(gs.fs('cordovaCalendar', this, gSobject),"findEvent",[gs.gp(gSobject.scope,"title"), null, null, start, end, function(events) {
      return gs.mc(gSobject,"addLog",["Found: " + (gs.elvis(gs.mc(events,"size",[], null, true) , gs.mc(events,"size",[], null, true) , 0)) + ""]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["Error: " + (err) + ""]);
     }]);
   }
  gSobject['listCalendars'] = function(it) {
    return gs.mc(gs.fs('cordovaCalendar', this, gSobject),"listCalendars",[function(cals) {
      return gs.mc(gSobject,"addLog",["Calendars: " + (gs.elvis(gs.mc(cals,"size",[], null, true) , gs.mc(cals,"size",[], null, true) , 0)) + ""]);
     }, function(err) {
      return gs.mc(gSobject,"addLog",["Error: " + (err) + ""]);
     }]);
   }
  gSobject['openCalendar'] = function(it) {
    gs.mc(gs.fs('cordovaCalendar', this, gSobject),"openCalendar",[]);
    return gs.mc(gSobject,"addLog",["Opened calendar"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function VueAdComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueAdComponent', simpleName: 'VueAdComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list(["canNavigate" , "rootDomain" , "vertical"]);
  gSobject.timer = null;
  gSobject['mounted'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"canNavigate"))) {
      gs.sp(self,"canNavigate",true);
     };
    if (!gs.bool(gs.gp(self,"rootDomain"))) {
      gs.sp(self,"rootDomain","");
     };
    if (!gs.bool(gs.gp(self,"vertical"))) {
      return gs.sp(self,"vertical",false);
     };
   }
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"adIndex",0);
    gs.sp(gSobject.scope,"ad",gs.map());
    gs.mc(gSobject,"loadAd",[]);
    if (!gs.bool(gs.mc(gSobject,"isTimerSet",[]))) {
      return gSobject.timer = gs.execStatic(Utils,'setInterval', this,[function(it) {
        return gs.mc(gSobject,"loadAd",[]);
       }, 60000]);
     };
   }
  gSobject['openAd'] = function(ad) {
    gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"metricService"),"add",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"legionUser"),"_id",true), "fitworld.ad.click", gs.gp(ad,"_id")]),"do",[]);
    if (!gs.bool(gs.gp(ad,"url"))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[gs.gp(ad,"url"), "_system", "location=yes"]);
   }
  gSobject['unmounted'] = function(it) {
    return gs.mc(gSobject,"killTimer",[]);
   }
  gSobject['loadAd'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"vueWrapperService"),"loadAd",[gs.gp(gSobject.scope,"adIndex"), function(result) {
      gs.sp(gSobject.scope,"adIndex",gs.gp(result,"index"));
      gs.sp(gSobject.scope,"ad",gs.gp(result,"ad"));
      return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"metricService"),"add",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"legionUser"),"_id",true), "fitworld.ad.show", gs.gp(gs.gp(result,"ad"),"_id")]),"do",[]);
     }]);
   }
  gSobject['killTimer'] = function(it) {
    if (gs.equals(gSobject.timer, null)) {
      return null;
     };
    gs.execStatic(Utils,'clearInterval', this,[gSobject.timer]);
    return gSobject.timer = null;
   }
  gSobject['isTimerSet'] = function(it) {
    return !gs.equals(gSobject.timer, null);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppStatusBarComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppStatusBarComponent', simpleName: 'TestAppStatusBarComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/statusbar";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppStatusBarComponent: created"]);
    gs.sp(gSobject.scope,"visible",true);
    gs.sp(gSobject.scope,"overlays",false);
    gs.sp(gSobject.scope,"log",gs.list([]));
    return gs.sp(gSobject.scope,"available",false);
   }
  gSobject['afterMounted'] = function(it) {
    gs.sp(gSobject.scope,"available",gs.execStatic(CordovaDevice,'cordovaPluginStatusBarInstalled', this,[]));
    return gs.mc(gSobject,"addLog",["StatusBar available: " + (gs.gp(gSobject.scope,"available")) + ""]);
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 20) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 19)));
     };
   }
  gSobject['show'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarShow",[]);
    gs.sp(gSobject.scope,"visible",true);
    return gs.mc(gSobject,"addLog",["Shown"]);
   }
  gSobject['hide'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarHide",[]);
    gs.sp(gSobject.scope,"visible",false);
    return gs.mc(gSobject,"addLog",["Hidden"]);
   }
  gSobject['overlayOn'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarOverlay",[true]);
    gs.sp(gSobject.scope,"overlays",true);
    return gs.mc(gSobject,"addLog",["Overlay ON"]);
   }
  gSobject['overlayOff'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarOverlay",[false]);
    gs.sp(gSobject.scope,"overlays",false);
    return gs.mc(gSobject,"addLog",["Overlay OFF"]);
   }
  gSobject['bgDefault'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarStyleDark",[]);
    return gs.mc(gSobject,"addLog",["Style: default (dark text)"]);
   }
  gSobject['bgLight'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarStyleLight",[]);
    return gs.mc(gSobject,"addLog",["Style: light content (white text)"]);
   }
  gSobject['bgBlack'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarColor",["#000000"]);
    return gs.mc(gSobject,"addLog",["BG: black"]);
   }
  gSobject['bgWhite'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarColor",["#FFFFFF"]);
    return gs.mc(gSobject,"addLog",["BG: white"]);
   }
  gSobject['bgRed'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarColor",["#e53935"]);
    return gs.mc(gSobject,"addLog",["BG: red"]);
   }
  gSobject['bgBlue'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarColor",["#2196F3"]);
    return gs.mc(gSobject,"addLog",["BG: blue"]);
   }
  gSobject['bgCharcoal'] = function(it) {
    gs.mc(gs.fs('cordovaDevice', this, gSobject),"statusBarColor",["#404e5c"]);
    return gs.mc(gSobject,"addLog",["BG: charcoal"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppNetworkComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppNetworkComponent', simpleName: 'TestAppNetworkComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/network";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppNetworkComponent: created"]);
    gs.sp(gSobject.scope,"connectionType","unknown");
    gs.sp(gSobject.scope,"online",true);
    return gs.sp(gSobject.scope,"log",gs.list([]));
   }
  gSobject['afterMounted'] = function(it) {
    gs.sp(gSobject.scope,"connectionType",TestAppNetworkComponent.connectionType());
    gs.sp(gSobject.scope,"online",TestAppNetworkComponent.isOnline());
    return gs.mc(gSobject,"addLog",["Type: " + (gs.gp(gSobject.scope,"connectionType")) + ", Online: " + (gs.gp(gSobject.scope,"online")) + ""]);
   }
  gSobject.connectionType = function() { return TestAppNetworkComponent.connectionType(); }
  gSobject.isOnline = function() { return TestAppNetworkComponent.isOnline(); }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 29)));
     };
   }
  gSobject['refresh'] = function(it) {
    gs.sp(gSobject.scope,"connectionType",TestAppNetworkComponent.connectionType());
    gs.sp(gSobject.scope,"online",TestAppNetworkComponent.isOnline());
    return gs.mc(gSobject,"addLog",["Refreshed - Type: " + (gs.gp(gSobject.scope,"connectionType")) + ", Online: " + (gs.gp(gSobject.scope,"online")) + ""]);
   }
  gSobject['startListening'] = function(it) {
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["online", function(it) {
      gs.sp(gSobject.scope,"online",true);
      gs.sp(gSobject.scope,"connectionType",gs.mc(this,"connectionType",[], gSobject));
      return gs.mc(gSobject,"addLog",["ONLINE - type: " + (gs.gp(gSobject.scope,"connectionType")) + ""]);
     }, false]);
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["offline", function(it) {
      gs.sp(gSobject.scope,"online",false);
      return gs.mc(gSobject,"addLog",["OFFLINE"]);
     }, false]);
    return gs.mc(gSobject,"addLog",["Network listeners registered"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppNetworkComponent.connectionType = function() {
  return navigator.connection ? navigator.connection.type : 'unknown';
 }
TestAppNetworkComponent.isOnline = function() {
  return navigator.onLine;
 }

function TestAppKrugerPoi() {
  var gSobject = gs.init('TestAppKrugerPoi');
  gSobject.clazz = { name: 'TestAppKrugerPoi', simpleName: 'TestAppKrugerPoi'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.pois = function() { return TestAppKrugerPoi.pois(); }
  gSobject.colorFor = function(x0) { return TestAppKrugerPoi.colorFor(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppKrugerPoi.pois = function(it) {
  return gs.list([gs.map().add("n","Skukuza").add("t","camp").add("lat",-24.9948).add("lng",31.5969) , gs.map().add("n","Lower Sabie").add("t","camp").add("lat",-25.1200).add("lng",31.9167) , gs.map().add("n","Satara").add("t","camp").add("lat",-24.3925).add("lng",31.7783) , gs.map().add("n","Olifants").add("t","camp").add("lat",-24.0057).add("lng",31.7389) , gs.map().add("n","Letaba").add("t","camp").add("lat",-23.8533).add("lng",31.5758) , gs.map().add("n","Mopani").add("t","camp").add("lat",-23.5219).add("lng",31.3939) , gs.map().add("n","Shingwedzi").add("t","camp").add("lat",-23.1108).add("lng",31.4336) , gs.map().add("n","Punda Maria").add("t","camp").add("lat",-22.6939).add("lng",31.0206) , gs.map().add("n","Berg-en-Dal").add("t","camp").add("lat",-25.4306).add("lng",31.4531) , gs.map().add("n","Crocodile Bridge").add("t","camp").add("lat",-25.3586).add("lng",31.8936) , gs.map().add("n","Pretoriuskop").add("t","camp").add("lat",-25.1717).add("lng",31.2683) , gs.map().add("n","Orpen").add("t","camp").add("lat",-24.4756).add("lng",31.3906) , gs.map().add("n","Paul Kruger Gate").add("t","gate").add("lat",-24.9820).add("lng",31.4867) , gs.map().add("n","Phabeni Gate").add("t","gate").add("lat",-25.0106).add("lng",31.2356) , gs.map().add("n","Numbi Gate").add("t","gate").add("lat",-25.1522).add("lng",31.2019) , gs.map().add("n","Malelane Gate").add("t","gate").add("lat",-25.4622).add("lng",31.5153) , gs.map().add("n","Orpen Gate").add("t","gate").add("lat",-24.4750).add("lng",31.3781) , gs.map().add("n","Phalaborwa Gate").add("t","gate").add("lat",-23.9456).add("lng",31.2169) , gs.map().add("n","Punda Maria Gate").add("t","gate").add("lat",-22.7350).add("lng",31.0056) , gs.map().add("n","Pafuri Gate").add("t","gate").add("lat",-22.4531).add("lng",31.2169)]);
 }
TestAppKrugerPoi.colorFor = function(t) {
  if (gs.equals(t, "camp")) {
    return "#6d4c41";
   };
  if (gs.equals(t, "gate")) {
    return "#c62828";
   };
  return "#1565c0";
 }

function TestAppHome() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppHome', simpleName: 'TestAppHome'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = gs.list(["/" , "/home"]);
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppHome: created"]);
    gs.sp(gSobject.scope,"scanResult","");
    gs.sp(gSobject.scope,"errorMessage","");
    gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
    return gs.sp(gSobject.scope,"scanning",false);
   }
  gSobject['scanQR'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppHome: scanQR called"]);
    if (!gs.bool(gs.gp(gSobject.scope,"isCordova"))) {
      gs.sp(gSobject.scope,"errorMessage","QR scanning requires the Cordova app. Open this in the i3 Test App on a device.");
      return null;
     };
    gs.sp(gSobject.scope,"scanning",true);
    gs.sp(gSobject.scope,"errorMessage","");
    gs.sp(gSobject.scope,"scanResult","");
    if (TestAppHome.permissionsAvailable()) {
      return gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"checkPermission",["android.permission.CAMERA", function(status) {
        if (gs.bool(gs.gp(status,"hasPermission"))) {
          return gs.mc(gSobject,"doScan",[]);
         } else {
          return gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"requestPermission",["android.permission.CAMERA", function(result) {
            if (gs.bool(gs.gp(result,"hasPermission"))) {
              return gs.mc(gSobject,"doScan",[]);
             } else {
              gs.sp(gSobject.scope,"errorMessage","Camera permission denied");
              return gs.sp(gSobject.scope,"scanning",false);
             };
           }, function(err) {
            gs.sp(gSobject.scope,"errorMessage","Permission request failed");
            return gs.sp(gSobject.scope,"scanning",false);
           }]);
         };
       }, function(err) {
        return gs.mc(gSobject,"doScan",[]);
       }]);
     } else {
      return gs.mc(gSobject,"doScan",[]);
     };
   }
  gSobject.permissionsAvailable = function() { return TestAppHome.permissionsAvailable(); }
  gSobject['upgradeUrl'] = function(text) {
    return (gs.mc(text,"startsWith",["http://"], null, true) ? gs.plus("https://", gs.mc(text,"substring",[7])) : text);
   }
  gSobject['doScan'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppHome: doScan"]);
    return gs.mc(gs.fs('qrScanner', this, gSobject),"scan",[function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppHome: scan result: " + (result) + ""]);
      if ((!gs.bool(gs.gp(result,"cancelled"))) && (gs.bool(gs.gp(result,"text")))) {
        var url = gs.mc(gSobject,"upgradeUrl",[gs.gp(result,"text")]);
        if (gs.mc(url,"startsWith",["http"])) {
          return gs.mc(gSobject,"navigateTo",[url]);
         } else {
          gs.sp(gSobject.scope,"scanResult",gs.gp(result,"text"));
          gs.sp(gSobject.scope,"errorMessage","Scanned value is not a URL: " + (gs.gp(result,"text")) + "");
          return gs.sp(gSobject.scope,"scanning",false);
         };
       } else {
        gs.sp(gSobject.scope,"scanResult","Cancelled");
        return gs.sp(gSobject.scope,"scanning",false);
       };
     }, function(error) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppHome: scan error: " + (error) + ""]);
      gs.sp(gSobject.scope,"errorMessage","Scan error: " + (error) + "");
      return gs.sp(gSobject.scope,"scanning",false);
     }]);
   }
  gSobject['enterUrl'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppHome: enterUrl called"]);
    if (gs.bool(gs.gp(gSobject.scope,"manualUrl"))) {
      var url = gs.gp(gSobject.scope,"manualUrl");
      if (gs.mc(url,"indexOf",["http"]) != 0) {
        url = (gs.plus("https://", url));
       };
      url = gs.mc(gSobject,"upgradeUrl",[url]);
      return gs.mc(gSobject,"navigateTo",[url]);
     };
   }
  gSobject.navigateTo = function(url) {
    window.location.href = url;
   }
  gSobject['TestAppHome0'] = function(it) {
    gs.sp(session,"userId",gs.elvis(gs.bool(gs.gp(session,"userId")) , gs.gp(session,"userId") , gs.execStatic(Utils,'uuid', this,[])));
    return this;
  }
  if (arguments.length==0) {gSobject.TestAppHome0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppHome.permissionsAvailable = function() {
  return typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.permissions !== 'undefined';
 }

function PdfJsHandler() {
  var gSobject = gs.init('PdfJsHandler');
  gSobject.clazz = { name: 'PdfJsHandler', simpleName: 'PdfJsHandler'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'rendering', { get: function() { return PdfJsHandler.rendering; }, set: function(gSval) { PdfJsHandler.rendering = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'numberPending', { get: function() { return PdfJsHandler.numberPending; }, set: function(gSval) { PdfJsHandler.numberPending = gSval; }, enumerable: true });
  gSobject['build'] = function(filePath, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return PdfJsHandler.paintWholePdf(filePath, callback);
   }
  gSobject.paintWholePdf = function(x0,x1) { return PdfJsHandler.paintWholePdf(x0,x1); }
  gSobject.renderPageScroll = function(x0,x1) { return PdfJsHandler.renderPageScroll(x0,x1); }
  gSobject.paintPdf = function(x0,x1) { return PdfJsHandler.paintPdf(x0,x1); }
  gSobject.renderPage = function(x0,x1) { return PdfJsHandler.renderPage(x0,x1); }
  gSobject['PdfJsHandler1'] = function(filePath) {
    if (filePath === undefined) filePath = "";
    if (!gs.bool(filePath)) {
      return null;
     };
    gs.mc(this,"paintWholePdf",[filePath], gSobject);
    return this;
  }
  if (arguments.length==1) {gSobject.PdfJsHandler1(arguments[0]); }
  
  return gSobject;
 };
PdfJsHandler.paintWholePdf = function(filePath, callback) {
  spinnerDiv = document.createElement('div');
        spinnerDiv.setAttribute("id", "spinner");
        spinnerDiv.setAttribute("class", "fixed-center")
        spinner = document.createElement('div');
        spinner.setAttribute("class", "i3-media-pdf-spinner");
        spinnerDiv.append(spinner);
        $('#pdf-viewer').append(spinnerDiv);
        
        pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.10.111/pdf.worker.min.js';
        var loadPdf = pdfjsLib.getDocument(filePath);
        loadPdf.promise.then(function(pdf) {
            
            const maxPage = pdf._pdfInfo.numPages;
        
            for (var i = 1; i <= maxPage; i++) {
                PdfJsHandler.renderPageScroll(pdf, i);
            }
            document.getElementById('spinner').remove();
            callback()
        })
 }
PdfJsHandler.renderPageScroll = function(pdf, number) {
  pdf.getPage(number).then(function(page) {
        
            const canvasId = 'pdf_viewer-' + number;
            $('#pdf-viewer').append($('<canvas/>', {'id': canvasId, 'style': 'object-fit:contain', 'class':'full-width'}));
            // $('#pdf-viewer').append($('<canvas/>', {'id': canvasId}));
            const canvas = document.getElementById(canvasId);
            const viewport = page.getViewport({scale: 1});
            const context = canvas.getContext("2d");
            
            canvas.height = viewport.height;
            canvas.width = viewport.width;
            
            var renderContext = {
                canvasContext: context,
                viewport: viewport
            };
            
            const renderTask = page.render(renderContext);
        });
 }
PdfJsHandler.paintPdf = function(filePath, getPage) {
  pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.10.111/pdf.worker.min.js';
            var loadPdf = pdfjsLib.getDocument(filePath);
            loadPdf.promise.then(function(pdf) {
                
                const minPage = 1;
                const maxPage = pdf._pdfInfo.numPages;
                let currentPage = 1;
                PdfJsHandler.rendering = false;
                PdfJsHandler.numberPending = null;
                PdfJsHandler.renderPage(pdf, currentPage);
                
                document.getElementById("pdfPageNumber").innerHTML = `Page ${currentPage} of ${maxPage}`;
                document.getElementById("pdfPrev").addEventListener("click", () => {
                    if (currentPage > minPage) {
                        currentPage = currentPage - 1
                        PdfJsHandler.renderPage(pdf, currentPage);
                        document.getElementById("pdfPageNumber").innerHTML = `Page ${currentPage} of ${maxPage}`;
                    }
                })
                document.getElementById("pdfNext").addEventListener("click", () => {
                    if (currentPage < maxPage) {
                        currentPage = currentPage + 1
                        PdfJsHandler.renderPage(pdf, currentPage);
                        document.getElementById("pdfPageNumber").innerHTML = `Page ${currentPage} of ${maxPage}`;
                    }
                })
            })
 }
PdfJsHandler.renderPage = function(pdf, number) {
  console.log('renderPage with ' + number + ', ' + PdfJsHandler.rendering + ', ' + PdfJsHandler.numberPending)
        if (PdfJsHandler.rendering) {
            PdfJsHandler.numberPending = number;
        } else {
            PdfJsHandler.rendering = true;
            pdf.getPage(number).then(function(page) {
            
                const canvas = document.getElementById("pdf_canvas");
                const viewport = page.getViewport({scale: 1});
                const context = canvas.getContext("2d");
                
                canvas.height = viewport.height;
                canvas.width = viewport.width;
                
                var renderContext = {
                    canvasContext: context,
                    viewport: viewport
                };
                
                const renderTask = page.render(renderContext);
                
                renderTask.promise.then(function() {
                    PdfJsHandler.rendering = false;
                    if (PdfJsHandler.numberPending !== null) {
                        PdfJsHandler.renderPage(pdf, number);
                        PdfJsHandler.numberPending = null;
                    }
                });
            });
        }
 }
PdfJsHandler.rendering = false;
PdfJsHandler.numberPending = null;

function CordovaBle() {
  var gSobject = gs.init('CordovaBle');
  gSobject.clazz = { name: 'CordovaBle', simpleName: 'CordovaBle'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'singletonInstance', { get: function() { return CordovaBle.singletonInstance; }, set: function(gSval) { CordovaBle.singletonInstance = gSval; }, enumerable: true });
  gSobject.initialized = false;
  gSobject.scanning = false;
  gSobject.discoveredDevices = gs.map();
  gSobject.connectedDevices = gs.map();
  gSobject.instance = function() { return CordovaBle.instance(); }
  gSobject['initialize'] = function(callback, params) {
    if (callback === undefined) callback = function(it) {
     };
    if (params === undefined) params = gs.map().add("request",true).add("statusReceiver",false);
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBle: bluetoothle not installed"]);
      gs.execCall(callback, this, [gs.map().add("status","unavailable")]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"initialize",[function(result) {
        gSobject.initialized = (gs.equals(gs.gp(result,"status"), "enabled"));
        return gs.execCall(callback, this, [result]);
       }, params]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBle.initialize error: " + (gs.fs('e', this, gSobject)) + ""]);
      gs.execCall(callback, this, [gs.map().add("status","error").add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['isEnabled'] = function(callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map().add("isEnabled",false)]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"isEnabled",[callback]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("isEnabled",false)]);
     }
    ;
    return this;
   }
  gSobject['enable'] = function(success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(error, this, [gs.map().add("message","BLE not installed")]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"enable",[success, error]);
     }
    catch (e) {
      gs.execCall(error, this, [gs.map().add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['startScan'] = function(onDevice, onError, params) {
    if (onDevice === undefined) onDevice = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("services",gs.list([])).add("allowDuplicates",false);
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(onError, this, [gs.map().add("message","BLE not installed")]);
      return this;
     };
    gSobject.discoveredDevices = gs.map();
    gSobject.scanning = true;
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"startScan",[function(result) {
        if (gs.equals(gs.gp(result,"status"), "scanStarted")) {
          return null;
         };
        if (gs.equals(gs.gp(result,"status"), "scanResult")) {
          if (!gs.bool(gs.mc(gSobject.discoveredDevices,"containsKey",[gs.gp(result,"address")]))) {
            var dev = gs.map().add("name",gs.elvis(gs.bool(gs.gp(result,"name")) , gs.gp(result,"name") , "Unknown")).add("address",gs.gp(result,"address")).add("rssi",gs.gp(result,"rssi"));
            (gSobject.discoveredDevices[gs.gp(result,"address")]) = dev;
            return gs.execCall(onDevice, this, [dev]);
           };
         };
       }, function(e) {
        gSobject.scanning = false;
        return gs.execCall(onError, this, [e]);
       }, params]);
     }
    catch (e) {
      gSobject.scanning = false;
      gs.execCall(onError, this, [gs.map().add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['stopScan'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"stopScan",[function(r) {
        gSobject.scanning = false;
        return gs.execCall(callback, this, [r]);
       }, function(e) {
        gSobject.scanning = false;
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }]);
     }
    catch (e) {
      gSobject.scanning = false;
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['isScanning'] = function(callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map().add("isScanning",false)]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"isScanning",[callback]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("isScanning",gSobject.scanning)]);
     }
    ;
    return this;
   }
  gSobject['getAdapterInfo'] = function(callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"getAdapterInfo",[callback]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['connect'] = function(address, onStatus, onError) {
    if (onStatus === undefined) onStatus = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(onError, this, [gs.map().add("message","BLE not installed")]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"connect",[function(result) {
        if (gs.equals(gs.gp(result,"status"), "connected")) {
          (gSobject.connectedDevices[address]) = result;
         };
        if (gs.equals(gs.gp(result,"status"), "disconnected")) {
          gs.mc(gSobject.connectedDevices,"remove",[address]);
         };
        return gs.execCall(onStatus, this, [result]);
       }, onError, gs.map().add("address",address)]);
     }
    catch (e) {
      gs.execCall(onError, this, [gs.map().add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['disconnect'] = function(address, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(error, this, [gs.map().add("message","BLE not installed")]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"disconnect",[function(r) {
        gs.mc(gSobject.connectedDevices,"remove",[address]);
        gs.mc(gs.fs('bluetoothle', this, gSobject),"close",[function(it) {
         }, function(it) {
         }, gs.map().add("address",address)]);
        return gs.execCall(success, this, [r]);
       }, error, gs.map().add("address",address)]);
     }
    catch (e) {
      gs.execCall(error, this, [gs.map().add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['discoverServices'] = function(address, callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"discover",[callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }, gs.map().add("address",address)]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['read'] = function(address, service, characteristic, callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"read",[callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }, gs.map().add("address",address).add("service",service).add("characteristic",characteristic)]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['write'] = function(address, service, characteristic, value, callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"write",[callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }, gs.map().add("address",address).add("service",service).add("characteristic",characteristic).add("value",value)]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['subscribe'] = function(address, service, characteristic, onNotify) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"subscribe",[onNotify, function(e) {
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["subscribe error: " + (e) + ""]);
       }, gs.map().add("address",address).add("service",service).add("characteristic",characteristic)]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["subscribe: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
    return this;
   }
  gSobject['unsubscribe'] = function(address, service, characteristic, callback) {
    if (callback === undefined) callback = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"unsubscribe",[callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }, gs.map().add("address",address).add("service",service).add("characteristic",characteristic)]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject.bleInstalled = function() { return CordovaBle.bleInstalled(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaBle.instance = function(it) {
  if (!gs.bool(CordovaBle.singletonInstance)) {
    CordovaBle.singletonInstance = CordovaBle();
   };
  return CordovaBle.singletonInstance;
 }
CordovaBle.bleInstalled = function() {
  return typeof window.bluetoothle !== 'undefined';
 }
CordovaBle.singletonInstance = null;

function CordovaMedia() {
  var gSobject = gs.init('CordovaMedia');
  gSobject.clazz = { name: 'CordovaMedia', simpleName: 'CordovaMedia'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['processFile'] = function(onSuccess, onError, mediaFiles) {
    var file = mediaFiles[0];
    return gs.mc(gs.fs('cordovaFile', this, gSobject),"blobFromFileUrl",[gs.gp(file,"fullPath"), function(blob) {
      return gs.execCall(onSuccess, this, [blob]);
     }, onError]);
   }
  gSobject['captureAudio'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"device"),"capture"),"captureAudio",[function(mediaFiles) {
      return gs.mc(gSobject,"processFile",[onSuccess, onError, mediaFiles]);
     }, onError, gs.map().add("limit",1).add("duration",120)]);
   }
  gSobject['captureImage'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"device"),"capture"),"captureImage",[function(mediaFiles) {
      return gs.mc(gSobject,"processFile",[onSuccess, onError, mediaFiles]);
     }, onError, gs.map().add("limit",1)]);
   }
  gSobject['captureVideo'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"device"),"capture"),"captureVideo",[function(mediaFiles) {
      return gs.mc(gSobject,"processFile",[onSuccess, onError, mediaFiles]);
     }, onError, gs.map().add("limit",1).add("duration",120).add("quality",0.6)]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppBrowserComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppBrowserComponent', simpleName: 'TestAppBrowserComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/browser";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBrowserComponent: created"]);
    gs.sp(gSobject.scope,"url","https://i3.co.za");
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"error","");
    return gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 29)));
     };
   }
  gSobject['openInApp'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBrowserComponent: openInApp " + (gs.gp(gSobject.scope,"url")) + ""]);
    gs.mc(gs.fs('cordovaBrowser', this, gSobject),"openInApp",[gs.gp(gSobject.scope,"url")]);
    return gs.mc(gSobject,"addLog",["Opened in-app: " + (gs.gp(gSobject.scope,"url")) + ""]);
   }
  gSobject['openSystem'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBrowserComponent: openSystem " + (gs.gp(gSobject.scope,"url")) + ""]);
    gs.mc(gs.fs('cordovaBrowser', this, gSobject),"openSystem",[gs.gp(gSobject.scope,"url")]);
    return gs.mc(gSobject,"addLog",["Opened in system browser: " + (gs.gp(gSobject.scope,"url")) + ""]);
   }
  gSobject['openHidden'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppBrowserComponent: openHidden " + (gs.gp(gSobject.scope,"url")) + ""]);
    gs.mc(gs.fs('cordovaBrowser', this, gSobject),"openHidden",[gs.gp(gSobject.scope,"url"), function(event) {
      return gs.mc(gSobject,"addLog",["Hidden load complete: " + (gs.gp(event,"url")) + ""]);
     }]);
    return gs.mc(gSobject,"addLog",["Opening hidden: " + (gs.gp(gSobject.scope,"url")) + ""]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaLocalNotification() {
  var gSobject = gs.init('CordovaLocalNotification');
  gSobject.clazz = { name: 'CordovaLocalNotification', simpleName: 'CordovaLocalNotification'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['hasPermission'] = function(callback) {
    return gs.mc(gSobject,"nativeHasPermission",[callback]);
   }
  gSobject['requestPermission'] = function(callback) {
    return gs.mc(gSobject,"nativeRequestPermission",[callback]);
   }
  gSobject['schedule'] = function(options, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"nativeSchedule",[options, callback]);
   }
  gSobject['cancel'] = function(id, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"nativeCancel",[id, callback]);
   }
  gSobject['cancelAll'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"nativeCancelAll",[callback]);
   }
  gSobject['on'] = function(event, callback) {
    return gs.mc(gSobject,"nativeOn",[event, callback]);
   }
  gSobject['getAll'] = function(callback) {
    return gs.mc(gSobject,"nativeGetAll",[callback]);
   }
  gSobject.nativeHasPermission = function(callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.hasPermission) { p.hasPermission(callback); }
        else { console.log('[LocalNotif] hasPermission: no plugin'); if (callback) callback(false); }
   }
  gSobject.nativeRequestPermission = function(callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.requestPermission) { p.requestPermission(callback); }
        else { console.log('[LocalNotif] requestPermission: no plugin'); if (callback) callback(false); }
   }
  gSobject.nativeSchedule = function(options, callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.schedule) { 
            console.log('[LocalNotif] scheduling:', JSON.stringify(options));
            p.schedule(options, callback); 
        }
        else { console.log('[LocalNotif] schedule: no plugin. keys:', typeof cordova !== 'undefined' && cordova.plugins ? Object.keys(cordova.plugins).join(',') : 'n/a'); if (callback) callback(); }
   }
  gSobject.nativeCancel = function(id, callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.cancel) { p.cancel(id, callback); }
        else { if (callback) callback(); }
   }
  gSobject.nativeCancelAll = function(callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.cancelAll) { p.cancelAll(callback); }
        else { if (callback) callback(); }
   }
  gSobject.nativeOn = function(event, callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.on) { p.on(event, callback); }
        else { console.log('[LocalNotif] on(' + event + '): no plugin'); }
   }
  gSobject.nativeGetAll = function(callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.getScheduledIds) { p.getScheduledIds(callback); }
        else { if (callback) callback([]); }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function LegionPinComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'LegionPinComponent', simpleName: 'LegionPinComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/legionPin";
  gSobject['created'] = function(it) {
    gs.println("LegionPinComponent.created()");
    gs.sp(gSobject.scope,"pin","");
    return gs.sp(gSobject.scope,"processing",false);
   }
  gSobject['pinAuth'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"pin"))) {
      gs.mc(gSobject,"notify",["Please enter pin", "negative"]);
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"))) {
      gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/login"]);
     };
    gs.sp(gSobject.scope,"processing",true);
    return gs.mc(gs.fs('legionUserService', this, gSobject),"authWithPin",[gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"), gs.gp(gSobject.scope,"pin"), function(result) {
      gs.println("result");
      gs.println(result);
      gs.sp(gs.fs('session', this, gSobject),"user",gs.gp(gs.fs('session', this, gSobject),"legionUser"));
      gs.sp(gs.fs('session', this, gSobject),"userId",gs.gp(gs.fs('session', this, gSobject),"legionUserId"));
      gs.sp(gSobject.scope,"processing",false);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/"]);
     }, function(error) {
      gs.mc(gSobject,"notify",[gs.gp(error,"message"), "negative"]);
      return gs.sp(gSobject.scope,"processing",false);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppPermissionsComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppPermissionsComponent', simpleName: 'TestAppPermissionsComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/permissions";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppPermissionsComponent: created"]);
    gs.sp(gSobject.scope,"log",gs.list([]));
    gs.sp(gSobject.scope,"permissions",gs.list([gs.map().add("name","Camera").add("key","android.permission.CAMERA") , gs.map().add("name","Fine Location").add("key","android.permission.ACCESS_FINE_LOCATION") , gs.map().add("name","Coarse Location").add("key","android.permission.ACCESS_COARSE_LOCATION") , gs.map().add("name","Bg Location").add("key","android.permission.ACCESS_BACKGROUND_LOCATION") , gs.map().add("name","Read Contacts").add("key","android.permission.READ_CONTACTS") , gs.map().add("name","Write Contacts").add("key","android.permission.WRITE_CONTACTS") , gs.map().add("name","Read Storage").add("key","android.permission.READ_EXTERNAL_STORAGE") , gs.map().add("name","Record Audio").add("key","android.permission.RECORD_AUDIO") , gs.map().add("name","Bluetooth Scan").add("key","android.permission.BLUETOOTH_SCAN") , gs.map().add("name","Bluetooth Connect").add("key","android.permission.BLUETOOTH_CONNECT") , gs.map().add("name","Notifications").add("key","android.permission.POST_NOTIFICATIONS")]));
    return gs.sp(gSobject.scope,"available",false);
   }
  gSobject['afterMounted'] = function(it) {
    return gs.sp(gSobject.scope,"available",gs.execStatic(CordovaDevice,'permissionsInstalled', this,[]));
   }
  gSobject['addLog'] = function(msg) {
    gs.sp(gSobject.scope,"log",(gs.plus(gs.list([gs.map().add("message",msg).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"log"))));
    if (gs.mc(gs.gp(gSobject.scope,"log"),"size",[]) > 30) {
      return gs.sp(gSobject.scope,"log",(gs.rangeFromList(gs.gp(gSobject.scope,"log"), 0, 29)));
     };
   }
  gSobject['checkPermission'] = function(perm) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppPermissionsComponent: check " + (gs.gp(perm,"name")) + ""]);
    return gs.mc(gs.fs('cordovaDevice', this, gSobject),"hasPermission",[gs.gp(perm,"key"), function(status) {
      return gs.mc(gSobject,"addLog",["" + (gs.gp(perm,"name")) + ": " + ((gs.bool(gs.gp(status,"hasPermission")) ? "GRANTED" : "DENIED")) + ""]);
     }]);
   }
  gSobject['requestPermission'] = function(perm) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppPermissionsComponent: request " + (gs.gp(perm,"name")) + ""]);
    return gs.mc(gs.fs('cordovaDevice', this, gSobject),"requestPermission",[gs.gp(perm,"key"), function(status) {
      return gs.mc(gSobject,"addLog",["" + (gs.gp(perm,"name")) + " request: " + ((gs.bool(gs.gp(status,"hasPermission")) ? "GRANTED" : "DENIED")) + ""]);
     }]);
   }
  gSobject['checkAll'] = function(it) {
    return gs.mc(gs.gp(gSobject.scope,"permissions"),"each",[function(perm) {
      return gs.mc(gSobject,"checkPermission",[perm]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppMapDefaults() {
  var gSobject = gs.init('TestAppMapDefaults');
  gSobject.clazz = { name: 'TestAppMapDefaults', simpleName: 'TestAppMapDefaults'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.osmTileUrl = function() { return TestAppMapDefaults.osmTileUrl(); }
  gSobject.krugerCenter = function() { return TestAppMapDefaults.krugerCenter(); }
  gSobject.krugerZoom = function() { return TestAppMapDefaults.krugerZoom(); }
  gSobject.krugerBounds = function() { return TestAppMapDefaults.krugerBounds(); }
  gSobject.offlineMinZoom = function() { return TestAppMapDefaults.offlineMinZoom(); }
  gSobject.offlineMaxZoom = function() { return TestAppMapDefaults.offlineMaxZoom(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppMapDefaults.osmTileUrl = function(it) {
  return "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png";
 }
TestAppMapDefaults.krugerCenter = function(it) {
  return gs.list([-24.0 , 31.5]);
 }
TestAppMapDefaults.krugerZoom = function(it) {
  return 8;
 }
TestAppMapDefaults.krugerBounds = function(it) {
  return gs.list([-25.55 , 30.85 , -22.30 , 32.05]);
 }
TestAppMapDefaults.offlineMinZoom = function(it) {
  return 8;
 }
TestAppMapDefaults.offlineMaxZoom = function(it) {
  return 13;
 }

function TestAppPlugins() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppPlugins', simpleName: 'TestAppPlugins'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/plugins";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppPlugins: created"]);
    gs.sp(gSobject.scope,"buildVersion",(gs.plus((gs.plus("ui 0.3.0 ", gs.mc(gs.date(),"format",["yyyy-MM-dd HH:mm"]))), (TestAppPlugins.hasTelemetry() ? " • telemetry✓" : ""))));
    gs.sp(gSobject.scope,"results",gs.list([]));
    gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
    gs.sp(gSobject.scope,"sections",gs.list(["Dymico Plugins" , "Cordova Wrappers" , "Standard Plugins"]));
    gs.sp(gSobject.scope,"plugins",gs.list([gs.map().add("name","QR Scanner").add("key","scanner").add("icon","qr_code_scanner").add("desc","QR/Barcode scanning").add("route","/scanner").add("section","Dymico Plugins") , gs.map().add("name","BLE").add("key","ble").add("icon","bluetooth").add("desc","Bluetooth LE scanning").add("route","/ble").add("section","Dymico Plugins") , gs.map().add("name","GPS").add("key","gps").add("icon","location_on").add("desc","GPS, Compass, Speed, Tracking").add("route","/gps").add("section","Dymico Plugins") , gs.map().add("name","GPS Navigation").add("key","gpsnav").add("icon","navigation").add("desc","Driving HUD + trip recorder").add("route","/gpsnav").add("section","Dymico Plugins") , gs.map().add("name","Share").add("key","share").add("icon","share").add("desc","Social sharing sheet").add("route","/share").add("section","Dymico Plugins") , gs.map().add("name","Contacts").add("key","contacts").add("icon","contacts").add("desc","Search and browse contacts").add("route","/contacts").add("section","Dymico Plugins") , gs.map().add("name","Browser").add("key","browser").add("icon","open_in_browser").add("desc","In-App Browser modes").add("route","/browser").add("section","Dymico Plugins") , gs.map().add("name","DeepLinks").add("key","deeplinks").add("icon","link").add("desc","Universal/Deep link listener").add("route","/deeplinks").add("section","Dymico Plugins") , gs.map().add("name","Spinner").add("key","spinner").add("icon","hourglass_top").add("desc","Native loading spinner").add("route","/spinner").add("section","Dymico Plugins") , gs.map().add("name","Screenshot").add("key","screenshot").add("icon","screenshot_monitor").add("desc","Screenshot prevention/detection").add("route","/screenshot").add("section","Dymico Plugins") , gs.map().add("name","Capture Screen").add("key","capture").add("icon","photo_camera").add("desc","DOM-to-PNG screen capture").add("route","/capture").add("section","Cordova Wrappers") , gs.map().add("name","Camera").add("key","camera").add("icon","camera_alt").add("desc","Photo capture and gallery").add("route","/camera").add("section","Cordova Wrappers") , gs.map().add("name","Biometrics").add("key","biometrics").add("icon","fingerprint").add("desc","Fingerprint / Face ID auth").add("route","/biometrics").add("section","Cordova Wrappers") , gs.map().add("name","Device").add("key","device").add("icon","phone_android").add("desc","Hardware, battery, network").add("route","/device").add("section","Cordova Wrappers") , gs.map().add("name","Battery").add("key","battery").add("icon","battery_full").add("desc","Battery level and charging").add("route","/battery").add("section","Standard Plugins") , gs.map().add("name","Network").add("key","network").add("icon","wifi").add("desc","Connection type and status").add("route","/network").add("section","Standard Plugins") , gs.map().add("name","Orientation").add("key","orientation").add("icon","screen_rotation").add("desc","Lock/unlock screen orientation").add("route","/orientation").add("section","Standard Plugins") , gs.map().add("name","Status Bar").add("key","statusbar").add("icon","web_asset").add("desc","Show/hide, colors, overlay").add("route","/statusbar").add("section","Standard Plugins") , gs.map().add("name","Permissions").add("key","permissions").add("icon","security").add("desc","Android permission checks").add("route","/permissions").add("section","Standard Plugins") , gs.map().add("name","Media").add("key","media").add("icon","audiotrack").add("desc","Audio record/play, video capture").add("route","/media").add("section","Standard Plugins") , gs.map().add("name","Push").add("key","push").add("icon","notifications").add("desc","Push notification registration").add("route","/push").add("section","Standard Plugins") , gs.map().add("name","Printer").add("key","printer").add("icon","print").add("desc","Print HTML via native dialog").add("route","/printer").add("section","Standard Plugins") , gs.map().add("name","Health").add("key","health").add("icon","favorite").add("desc","HealthKit / Health Connect").add("route","/health").add("section","Cordova Wrappers") , gs.map().add("name","Notifications").add("key","localnotif").add("icon","notifications_active").add("desc","Local scheduled notifications").add("route","/localnotif").add("section","Standard Plugins") , gs.map().add("name","Calendar").add("key","calendar").add("icon","event").add("desc","Create and find events").add("route","/calendar").add("section","Standard Plugins") , gs.map().add("name","Error Test").add("key","errortest").add("icon","bug_report").add("desc","Trigger test errors").add("route","/errortest").add("section","Cordova Wrappers")]));
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppPlugins: loaded " + (gs.mc(gs.gp(gSobject.scope,"plugins"),"size",[])) + " plugins"]);
   }
  gSobject['afterMounted'] = function(it) {
    return TestAppPlugins.nativeAppInfo(function(info) {
      if ((gs.bool(info)) && (gs.bool(gs.gp(info,"version")))) {
        return gs.sp(gSobject.scope,"buildVersion",(gs.plus((gs.plus((gs.plus((gs.plus("app v", gs.gp(info,"version"))), (gs.bool(gs.gp(info,"build")) ? gs.plus((gs.plus(" (", gs.gp(info,"build"))), ")") : ""))), " • ui 0.3.0")), (gs.mc(this,"hasTelemetry",[], gSobject) ? " • telemetry✓" : ""))));
       };
     });
   }
  gSobject.nativeAppInfo = function(x0) { return TestAppPlugins.nativeAppInfo(x0); }
  gSobject['openPlugin'] = function(route) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",[route]);
   }
  gSobject['filterPlugins'] = function(section) {
    return gs.mc(gs.gp(gSobject.scope,"plugins"),"findAll",[function(it) {
      return gs.equals(gs.gp(it,"section"), section);
     }]);
   }
  gSobject['addCheck'] = function(name, available) {
    return gs.sp(gSobject.scope,"results",(gs.plus(gs.gp(gSobject.scope,"results"), gs.list([gs.map().add("name",name).add("status",(gs.bool(available) ? "OK" : "MISSING")).add("message",(gs.bool(available) ? "Loaded" : "Not found")).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]))));
   }
  gSobject['checkAll'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppPlugins: checkAll"]);
    gs.sp(gSobject.scope,"results",gs.list([]));
    gs.mc(gSobject,"addCheck",["QR Scanner", TestAppPlugins.hasQrScanner()]);
    gs.mc(gSobject,"addCheck",["BLE", TestAppPlugins.hasBluetooth()]);
    gs.mc(gSobject,"addCheck",["GPS", TestAppPlugins.hasBgGeo()]);
    gs.mc(gSobject,"addCheck",["GPS Navigation", TestAppPlugins.hasBgGeo()]);
    gs.mc(gSobject,"addCheck",["Telemetry", TestAppPlugins.hasTelemetry()]);
    gs.mc(gSobject,"addCheck",["Share", TestAppPlugins.hasShare()]);
    gs.mc(gSobject,"addCheck",["Contacts", TestAppPlugins.hasContacts()]);
    gs.mc(gSobject,"addCheck",["Browser", TestAppPlugins.hasBrowser()]);
    gs.mc(gSobject,"addCheck",["DeepLinks", TestAppPlugins.hasDeepLinks()]);
    gs.mc(gSobject,"addCheck",["Camera", TestAppPlugins.hasCamera()]);
    gs.mc(gSobject,"addCheck",["Biometrics", TestAppPlugins.hasBiometrics()]);
    gs.mc(gSobject,"addCheck",["Device", TestAppPlugins.hasDevice()]);
    gs.mc(gSobject,"addCheck",["Battery", TestAppPlugins.hasBatteryApi()]);
    gs.mc(gSobject,"addCheck",["Network", TestAppPlugins.hasNetwork()]);
    gs.mc(gSobject,"addCheck",["Orientation", TestAppPlugins.hasOrientation()]);
    gs.mc(gSobject,"addCheck",["Status Bar", TestAppPlugins.hasStatusBar()]);
    gs.mc(gSobject,"addCheck",["Permissions", TestAppPlugins.hasPermissions()]);
    gs.mc(gSobject,"addCheck",["Media", TestAppPlugins.hasMedia()]);
    gs.mc(gSobject,"addCheck",["Spinner", TestAppPlugins.hasSpinner()]);
    gs.mc(gSobject,"addCheck",["Push", TestAppPlugins.hasPush()]);
    gs.mc(gSobject,"addCheck",["Screenshot", TestAppPlugins.hasScreenshot()]);
    gs.mc(gSobject,"addCheck",["Printer", TestAppPlugins.hasPrinter()]);
    gs.mc(gSobject,"addCheck",["Health", TestAppPlugins.hasHealth()]);
    gs.mc(gSobject,"addCheck",["Notifications", TestAppPlugins.hasLocalNotif()]);
    return gs.mc(gSobject,"addCheck",["Calendar", TestAppPlugins.hasCalendar()]);
   }
  gSobject.hasQrScanner = function() { return TestAppPlugins.hasQrScanner(); }
  gSobject.hasBluetooth = function() { return TestAppPlugins.hasBluetooth(); }
  gSobject.hasBgGeo = function() { return TestAppPlugins.hasBgGeo(); }
  gSobject.hasTelemetry = function() { return TestAppPlugins.hasTelemetry(); }
  gSobject.hasShare = function() { return TestAppPlugins.hasShare(); }
  gSobject.hasContacts = function() { return TestAppPlugins.hasContacts(); }
  gSobject.hasBrowser = function() { return TestAppPlugins.hasBrowser(); }
  gSobject.hasDeepLinks = function() { return TestAppPlugins.hasDeepLinks(); }
  gSobject.hasCamera = function() { return TestAppPlugins.hasCamera(); }
  gSobject.hasBiometrics = function() { return TestAppPlugins.hasBiometrics(); }
  gSobject.hasDevice = function() { return TestAppPlugins.hasDevice(); }
  gSobject.hasBatteryApi = function() { return TestAppPlugins.hasBatteryApi(); }
  gSobject.hasNetwork = function() { return TestAppPlugins.hasNetwork(); }
  gSobject.hasOrientation = function() { return TestAppPlugins.hasOrientation(); }
  gSobject.hasStatusBar = function() { return TestAppPlugins.hasStatusBar(); }
  gSobject.hasPermissions = function() { return TestAppPlugins.hasPermissions(); }
  gSobject.hasMedia = function() { return TestAppPlugins.hasMedia(); }
  gSobject.hasSpinner = function() { return TestAppPlugins.hasSpinner(); }
  gSobject.hasPush = function() { return TestAppPlugins.hasPush(); }
  gSobject.hasScreenshot = function() { return TestAppPlugins.hasScreenshot(); }
  gSobject.hasPrinter = function() { return TestAppPlugins.hasPrinter(); }
  gSobject.hasHealth = function() { return TestAppPlugins.hasHealth(); }
  gSobject.hasLocalNotif = function() { return TestAppPlugins.hasLocalNotif(); }
  gSobject.hasCalendar = function() { return TestAppPlugins.hasCalendar(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TestAppPlugins.nativeAppInfo = function(cb) {
  try {
            if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.dymicoApp && cordova.plugins.dymicoApp.getInfo) {
                cordova.plugins.dymicoApp.getInfo(function (info) { cb(info); }, function (e) { cb(null); });
            } else { cb(null); }
        } catch (e) { cb(null); }
 }
TestAppPlugins.hasQrScanner = function() {
  return typeof qrScanner !== 'undefined';
 }
TestAppPlugins.hasBluetooth = function() {
  return typeof bluetoothle !== 'undefined';
 }
TestAppPlugins.hasBgGeo = function() {
  return typeof BackgroundGeolocation !== 'undefined';
 }
TestAppPlugins.hasTelemetry = function() {
  return typeof DymicoTelemetry !== 'undefined';
 }
TestAppPlugins.hasShare = function() {
  return typeof window.plugins !== 'undefined' && typeof window.plugins.socialsharing !== 'undefined';
 }
TestAppPlugins.hasContacts = function() {
  return typeof cordovaContacts !== 'undefined';
 }
TestAppPlugins.hasBrowser = function() {
  return typeof cordova !== 'undefined' && typeof cordova.InAppBrowser !== 'undefined';
 }
TestAppPlugins.hasDeepLinks = function() {
  return typeof cordovaDeepLink !== 'undefined';
 }
TestAppPlugins.hasCamera = function() {
  return typeof cordovaCamera !== 'undefined';
 }
TestAppPlugins.hasBiometrics = function() {
  return typeof Fingerprint !== 'undefined';
 }
TestAppPlugins.hasDevice = function() {
  return typeof device !== 'undefined' || typeof window.device !== 'undefined';
 }
TestAppPlugins.hasBatteryApi = function() {
  return typeof device !== 'undefined' || typeof window.device !== 'undefined';
 }
TestAppPlugins.hasNetwork = function() {
  return typeof navigator.connection !== 'undefined';
 }
TestAppPlugins.hasOrientation = function() {
  return typeof screen.orientation !== 'undefined';
 }
TestAppPlugins.hasStatusBar = function() {
  return typeof StatusBar !== 'undefined';
 }
TestAppPlugins.hasPermissions = function() {
  return typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.permissions !== 'undefined';
 }
TestAppPlugins.hasMedia = function() {
  return typeof Media !== 'undefined';
 }
TestAppPlugins.hasSpinner = function() {
  return typeof window.dymicoSpinner !== 'undefined';
 }
TestAppPlugins.hasPush = function() {
  return typeof PushNotification !== 'undefined';
 }
TestAppPlugins.hasScreenshot = function() {
  return typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.dymicoScreenshot !== 'undefined';
 }
TestAppPlugins.hasPrinter = function() {
  return typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.printer !== 'undefined';
 }
TestAppPlugins.hasHealth = function() {
  return typeof cordovaI3Health !== 'undefined';
 }
TestAppPlugins.hasLocalNotif = function() {
  return typeof cordovaLocalNotification !== 'undefined';
 }
TestAppPlugins.hasCalendar = function() {
  return typeof cordovaCalendar !== 'undefined';
 }

function I3QrCode() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3QrCode', simpleName: 'I3QrCode'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("text",gs.map().add("default","")).add("width",gs.map().add("default",300)).add("height",gs.map().add("default",300));
  gSobject.qRCodeObject = null;
  gSobject['created'] = function(it) {
    return gSobject.self = this;
   }
  gSobject['afterMounted'] = function(it) {
    if (gs.bool(gs.gp(gSobject.self,"text"))) {
      return gs.mc(gSobject,"generateQrCode",[]);
     };
   }
  gSobject['watchText'] = function(it) {
    if ((gs.bool(gs.gp(gSobject.self,"text"))) && (gs.bool(gs.gp(gSobject.refs,"qrCodeRef")))) {
      return gs.mc(gSobject,"generateQrCode",[]);
     };
   }
  gSobject['generateQrCode'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.refs,"qrCodeRef"))) {
      return null;
     };
    if (gs.bool(gSobject.qRCodeObject)) {
      gs.mc(gSobject.qRCodeObject,"clear",[]);
     };
    gSobject.qRCodeObject = gs.mc(gSobject,"newQrCode",[gs.gp(gSobject.refs,"qrCodeRef"), gs.gp(gSobject.self,"text"), gs.gp(gSobject.self,"width"), gs.gp(gSobject.self,"height")]);
    return gs.mc(gSobject.qRCodeObject,"makeCode",[gs.gp(gSobject.self,"text")]);
   }
  gSobject.newQrCode = function(element, text, width, height) {
    return new QRCode(element, {
            text: text,
            width: width,
            height: height,
            colorDark: '#000000',
            colorLight: '#ffffff',
            correctLevel: QRCode.CorrectLevel.H
        })
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function HammerJsZoom() {
  var gSobject = gs.init('HammerJsZoom');
  gSobject.clazz = { name: 'HammerJsZoom', simpleName: 'HammerJsZoom'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.showHammerZoom = function(x0) { return HammerJsZoom.showHammerZoom(x0); }
  gSobject['HammerJsZoom1'] = function(elmName) {
    HammerJsZoom.showHammerZoom(elmName);
    return this;
  }
  if (arguments.length==1) {gSobject.HammerJsZoom1(arguments[0]); }
  
  return gSobject;
 };
HammerJsZoom.showHammerZoom = function(name) {
  var elm = document.getElementById(name);
        var hammertime = new Hammer(elm, {});
        hammertime.get('pinch').set({
            enable: true
        });
        
        console.log('hammertime')
        console.log(hammertime)
        
        var posX = 0,
            posY = 0,
            scale = 1,
            last_scale = 1,
            last_posX = 0,
            last_posY = 0,
            max_pos_x = 0,
            max_pos_y = 0,
            transform = "",
            el = elm;
            
        hammertime.on('doubletap pinch pan panend pinchend', function(ev) {
            console.log('event')
            console.log(ev)
            if (ev.type == "doubletap") {
                console.log('doubletapped')
                transform = 
                    "translate3d(0, 0, 0) " +
                    "sacle3d(2, 2, 1) ";
                scale = 2;
                last_sacle = 2;
                
                try{
                    if (window.getComputedStyle(el, null).getPropertyValue('-webkit-transform').toString() != "matrix(1, 0, 0, 1, 0, 0)") {
                        transform = 
                            "translate3d(0, 0, 0) " +
                            "scale3d(1, 1, 1) ";
                        scale = 1;
                        last_scale = 1;
                    }
                } catch (err){}
                
                el.style.webkitTransform = transform;
                transform = ""
            }
            
            //pan
            if (scale != 1) {
                console.log('pan')
                posX = last_posX + ev.deltaX;
                posY = last_posY + ev.deltaY;
                max_pos_x = Math.ceil((scale - 1) * el.clientWidth / 2);
                max_pos_y = Math.ceil((scale - 1) * el.clientHeight / 2);
                if (posX > max_pos_x) {
                    posX = max_pos_x;
                }
                if (posX < -max_pos_x) {
                    posX = -max_pos_x;
                }
                if (posY > max_pos_y) {
                    posY = max_pos_y;
                }
                if (posY < -max_pos_y) {
                    posY = -max_pos_y;
                }
            }
            
            //pinch
            if (ev.type == "pinch") {
                console.log('pinch')
                scale = Math.max(.999, Math.min(last_scale * (ev.scale), 4));
            }
            if(ev.type == "pinchend"){last_scale = scale;}
    
            //panend
            if(ev.type == "panend"){
                console.log('panend')
                last_posX = posX < max_pos_x ? posX : max_pos_x;
                last_posY = posY < max_pos_y ? posY : max_pos_y;
            }
    
            if (scale != 1) {
                console.log('scale not 1')
                transform =
                    "translate3d(" + posX + "px," + posY + "px, 0) " +
                    "scale3d(" + scale + ", " + scale + ", 1)";
            }
    
            if (transform) {
                console.log('transform')
                el.style.webkitTransform = transform;
            }
        });
 }

function CordovaShare() {
  var gSobject = gs.init('CordovaShare');
  gSobject.clazz = { name: 'CordovaShare', simpleName: 'CordovaShare'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['share'] = function(message, subject, files, url, success, failure) {
    if (subject === undefined) subject = null;
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"share",[message, subject, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaEmail'] = function(message, subject, to, cc, bcc, files, success, failure) {
    if (subject === undefined) subject = "";
    if (to === undefined) to = gs.list([]);
    if (cc === undefined) cc = gs.list([]);
    if (bcc === undefined) bcc = gs.list([]);
    if (files === undefined) files = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaEmail",[message, subject, to, cc, bcc, files, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaSMS'] = function(message, phoneNumbers, success, failure) {
    if (phoneNumbers === undefined) phoneNumbers = "";
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaSMS",[gs.map().add("message",message), phoneNumbers, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaWhatsApp'] = function(message, files, url, success, failure) {
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaWhatsApp",[message, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaTwitter'] = function(message, files, url, success, failure) {
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaTwitter",[message, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaFacebook'] = function(message, files, url, success, failure) {
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaFacebook",[message, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['canShareVia'] = function(via, message, subject, files, url, success, failure) {
    if (message === undefined) message = "";
    if (subject === undefined) subject = null;
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"canShareVia",[via, message, subject, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['saveToPhotoAlbum'] = function(files, success, failure) {
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"saveToPhotoAlbum",[files, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['available'] = function(callback) {
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(callback, this, [false]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"available",[callback]);
     }
    catch (e) {
      gs.execCall(callback, this, [false]);
     }
    ;
   }
  gSobject.shareInstalled = function() { return CordovaShare.shareInstalled(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaShare.shareInstalled = function() {
  return typeof window.plugins !== 'undefined' && typeof window.plugins.socialsharing !== 'undefined';
 }

function I3DatePicker() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3DatePicker', simpleName: 'I3DatePicker'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("date",Date).add("clearable",Boolean).add("label",String).add("disable",Boolean).add("readonly",Boolean).add("filled",Boolean).add("outlined",Boolean).add("borderless",Boolean).add("standout",Boolean).add("rounded",Boolean).add("square",Boolean).add("dense",Boolean).add("landscape",Boolean).add("todayBtn",Boolean).add("minimal",Boolean).add("mask",String);
  gSobject.data = function(it) {
    return gs.map().add("dateString","").add("formatString","DD MMM YYYY").add("datePickerDialog",false);
   };
  gSobject['created'] = function(it) {
    var self = this;
    gs.println("self.date");
    gs.println(gs.gp(self,"date"));
    return gs.mc(gSobject,"init",[self]);
   }
  gSobject['init'] = function(self) {
    if (gs.bool(gs.gp(self,"mask"))) {
      gs.sp(self,"formatString",gs.gp(self,"mask"));
     };
    return gs.sp(self,"dateString",(gs.bool(gs.gp(self,"date")) ? gs.mc(gs.mc(gSobject,"moment",[gs.gp(self,"date")]),"format",["YYYY-MM-DD"]) : null));
   }
  gSobject['openDatePickerDialog'] = function(it) {
    var self = this;
    return gs.sp(self,"datePickerDialog",true);
   }
  gSobject['selectDate'] = function(val) {
    var self = this;
    gs.println("val");
    gs.println(val);
    var date = gs.date(val);
    gs.println("date");
    gs.println(date);
    gs.sp(self,"dateString",(gs.bool(date) ? gs.mc(gs.mc(gSobject,"moment",[date]),"format",["YYYY-MM-DD"]) : null));
    gs.sp(self,"datePickerDialog",false);
    return gs.mc(gSobject,"emit",["update:date", date]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TestAppDeepLinkComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'TestAppDeepLinkComponent', simpleName: 'TestAppDeepLinkComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/deeplinks";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppDeepLinkComponent: created"]);
    gs.sp(gSobject.scope,"listening",false);
    gs.sp(gSobject.scope,"events",gs.list([]));
    gs.sp(gSobject.scope,"error","");
    return gs.sp(gSobject.scope,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
   }
  gSobject['startListening'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppDeepLinkComponent: startListening"]);
    gs.mc(gs.fs('cordovaDeepLink', this, gSobject),"registerCallback",[function(eventData) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppDeepLinkComponent: deep link received: " + (gs.gp(eventData,"url")) + ""]);
      return gs.sp(gSobject.scope,"events",(gs.plus(gs.list([gs.map().add("url",gs.gp(eventData,"url")).add("scheme",gs.gp(eventData,"scheme")).add("host",gs.gp(eventData,"host")).add("path",gs.gp(eventData,"path")).add("params",gs.gp(eventData,"params")).add("hash",gs.gp(eventData,"hash")).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"events"))));
     }]);
    return gs.sp(gSobject.scope,"listening",true);
   }
  gSobject['checkDeepLink'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["TestAppDeepLinkComponent: checkDeepLink"]);
    return gs.mc(gs.mc(gs.mc(gs.fs('universalLinks', this, gSobject),"checkDeepLink",[2000]),"then",[function(data) {
      if (gs.bool(data)) {
        return gs.sp(gSobject.scope,"events",(gs.plus(gs.list([gs.map().add("url",gs.gp(data,"url")).add("scheme",gs.gp(data,"scheme")).add("host",gs.gp(data,"host")).add("path",gs.gp(data,"path")).add("params",gs.gp(data,"params")).add("hash",gs.gp(data,"hash")).add("time",gs.mc(gs.date(),"format",["HH:mm:ss"]))]), gs.gp(gSobject.scope,"events"))));
       } else {
        return gs.sp(gSobject.scope,"error","No pending deep link found");
       };
     }]),"catch",[function(e) {
      return gs.sp(gSobject.scope,"error","Check error: " + (e) + "");
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaI3Health() {
  var gSobject = gs.init('CordovaI3Health');
  gSobject.clazz = { name: 'CordovaI3Health', simpleName: 'CordovaI3Health'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'HEALTH_PERMISSIONS', { get: function() { return CordovaI3Health.HEALTH_PERMISSIONS; }, set: function(gSval) { CordovaI3Health.HEALTH_PERMISSIONS = gSval; }, enumerable: true });
  gSobject['testIsAvailable'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeIsAvailable",[function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.isAvailable -> " + (result) + ""]);
      return gs.execCall(onSuccess, this, [gs.elvis(gs.bool(gs.gp(result,"available",true)) , gs.gp(result,"available",true) , false)]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.isAvailable error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['requestPermissions'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.requestPermissions: requesting via Android permissions plugin"]);
    return gs.mc(gSobject,"nativeRequestPermissions",[function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.requestPermissions -> " + (result) + ""]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.requestPermissions error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['querySteps'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeQuery",["steps", startDate, endDate, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.query steps -> " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryHeartRate'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeQuery",["heartRate", startDate, endDate, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.query heartRate -> " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryBloodPressure'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeQuery",["bloodPressure", startDate, endDate, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.query bloodPressure -> " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryAggregatedSteps'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeQueryAggregated",["steps", startDate, endDate, "day", function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.queryAggregated steps -> success"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['store'] = function(dataType, data, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeStore",[dataType, data, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.store " + (dataType) + " -> success"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject.nativeIsAvailable = function(successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            if (!cordova.plugins.dymicoHealth) { errorCallback("dymicoHealth plugin not installed"); return; }
            cordova.plugins.dymicoHealth.isAvailable(
                function(result) { successCallback(result); },
                function(err) { errorCallback(err ? err.toString() : "Unknown error"); }
            );
        } catch (e) {
            console.error('dymicoHealth.isAvailable exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeRequestPermissions = function(successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            var permissions = cordova.plugins.permissions;
            if (!permissions) { errorCallback("Android permissions plugin not available"); return; }

            var perms = CordovaI3Health.HEALTH_PERMISSIONS;
            console.log('dymicoHealth: requesting', perms.length, 'permissions');

            permissions.requestPermissions(perms, function(status) {
                console.log('dymicoHealth: permissions result:', status);
                successCallback({ authorized: status.hasPermission });
            }, function(err) {
                console.error('dymicoHealth: permissions error:', err);
                errorCallback(err ? err.toString() : "Permission request failed");
            });
        } catch (e) {
            console.error('dymicoHealth.requestPermissions exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeQuery = function(dataType, startDate, endDate, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            if (!cordova.plugins.dymicoHealth) { errorCallback("dymicoHealth plugin not installed"); return; }
            cordova.plugins.dymicoHealth.query(
                dataType,
                startDate instanceof Date ? startDate : new Date(startDate),
                endDate instanceof Date ? endDate : new Date(endDate),
                function(result) { successCallback(result); },
                function(err) { errorCallback(err ? err.toString() : "Unknown error"); }
            );
        } catch (e) {
            console.error('dymicoHealth.query exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeQueryAggregated = function(dataType, startDate, endDate, bucket, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            if (!cordova.plugins.dymicoHealth) { errorCallback("dymicoHealth plugin not installed"); return; }
            cordova.plugins.dymicoHealth.queryAggregated(
                dataType,
                startDate instanceof Date ? startDate : new Date(startDate),
                endDate instanceof Date ? endDate : new Date(endDate),
                bucket || 'day',
                function(result) { successCallback(result); },
                function(err) { errorCallback(err ? err.toString() : "Unknown error"); }
            );
        } catch (e) {
            console.error('dymicoHealth.queryAggregated exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeStore = function(dataType, data, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            if (!cordova.plugins.dymicoHealth) { errorCallback("dymicoHealth plugin not installed"); return; }
            cordova.plugins.dymicoHealth.store(
                dataType, data,
                function(result) { successCallback(result); },
                function(err) { errorCallback(err ? err.toString() : "Unknown error"); }
            );
        } catch (e) {
            console.error('dymicoHealth.store exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject['CordovaI3Health0'] = function(it) {
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaI3Health0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaI3Health.HEALTH_PERMISSIONS = gs.list(["android.permission.health.READ_STEPS" , "android.permission.health.WRITE_STEPS" , "android.permission.health.READ_HEART_RATE" , "android.permission.health.WRITE_HEART_RATE" , "android.permission.health.READ_BLOOD_PRESSURE" , "android.permission.health.WRITE_BLOOD_PRESSURE" , "android.permission.health.READ_BLOOD_GLUCOSE" , "android.permission.health.WRITE_BLOOD_GLUCOSE" , "android.permission.health.READ_WEIGHT" , "android.permission.health.WRITE_WEIGHT" , "android.permission.health.READ_HEIGHT" , "android.permission.health.WRITE_HEIGHT" , "android.permission.health.READ_SLEEP" , "android.permission.health.WRITE_SLEEP" , "android.permission.health.READ_ACTIVE_CALORIES_BURNED" , "android.permission.health.WRITE_ACTIVE_CALORIES_BURNED"]);

function TransmissionBootstrapEnd() {
  var gSobject = gs.init('TransmissionBootstrapEnd');
  gSobject.clazz = { name: 'TransmissionBootstrapEnd', simpleName: 'TransmissionBootstrapEnd'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'session', { get: function() { return TransmissionBootstrapEnd.session; }, set: function(gSval) { TransmissionBootstrapEnd.session = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'transmissionReadyCallbackList', { get: function() { return TransmissionBootstrapEnd.transmissionReadyCallbackList; }, set: function(gSval) { TransmissionBootstrapEnd.transmissionReadyCallbackList = gSval; }, enumerable: true });
  gSobject['startApp'] = function(it) {
    return gs.execStatic(Utils,'documentReady', this,[function(it) {
      gs.println("TransmissionBootstrapEnd:startApp:Utils.documentReady");
      return gs.execStatic(LocalDB,'getInstance', this,[function(it) {
        gs.println("TransmissionBootstrapEnd:startApp:LocalDB.getInstance");
        gs.mc(gs.fs('startupParams', this, gSobject),"beforeSocketInit",[]);
        gs.execStatic(Socket,'initSocket', this,[gs.gp(gs.fs('startupParams', this, gSobject),"afterSocketInit")]);
        return gs.mc(gs.gp(gs.fs('transmission', this, gSobject),"onReady"),"runCallbacks",[]);
       }]);
     }]);
   }
  gSobject['TransmissionBootstrapEnd0'] = function(it) {
    gs.println("TransmissionBootstrapEnd:start");
    if (gs.execStatic(Socket,'isDymicoSystemUpdating', this,[])) {
      return null;
     };
    gs.mc(gSobject,"startApp",[]);
    gs.println("TransmissionBootstrapEnd:end");
    return this;
  }
  if (arguments.length==0) {gSobject.TransmissionBootstrapEnd0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TransmissionBootstrapEnd.session = gs.execStatic(Session,'instance', this,[]);
TransmissionBootstrapEnd.transmissionReadyCallbackList = gs.list([]);
gs.println("GROOSCRIPT START : TransmissionBootstrapStart");
var transmission = Transmission;
var startupParams = StartupParams();
gs.mc(startupParams,"checkStartupAuth",[]);

gs.toGroovy = function(obj, objClass) {
    var result = obj;
    if (obj !== undefined && !(typeof(obj) === "function") && !(obj instanceof Date)) {
        if (obj instanceof Array) {
            result = gs.list([]);
            var i;
            for (i = 0; i < obj.length; i++) {
                result.add(gs.toGroovy(obj[i], objClass));
            }
        } else if (obj instanceof Date) {
            // console.log(obj);
            
        } else if (obj instanceof Object) {
            var ob;
            result = (objClass ? objClass() : gs.map());
            for (ob in obj) {
                result[ob] = gs.toGroovy(obj[ob]);
            }
        }
    }
    return result;
};
;

Array.prototype.add = function(pos, element) {
    if (element === undefined) {
        this.push(pos);
    } else {
        this.splice(pos, 0, element);
    }
    return this;
};
;
var session = gs.execStatic(Session,'instance', this,[]);
gs.sp(Socket,"window",window);
gs.sp(Socket,"navigator",navigator);
gs.execStatic(Socket,'init', this,[]);
gs.mc(window,"addEventListener",["online", function(it) {
  gs.println("ONLINE");
  return gs.execStatic(Socket,'reconnect', this,[]);
 }]);
gs.mc(gs.gp(window,"document"),"addEventListener",["visibilitychange", function(it) {
  if (gs.equals(gs.gp(gs.gp(gs.fs('window', this),"document"),"visibilityState"), "visible")) {
    gs.println("VISIBLE");
    return gs.execStatic(Socket,'reconnect', this,[]);
   };
 }]);
gs.mc(window,"addEventListener",["focus", function(it) {
  gs.println("FOCUS");
  return gs.execStatic(Socket,'reconnect', this,[]);
 }]);

Date.prototype.toJSON = function(){
    return moment(this).utc().toISOString();
};
;

String.prototype.endsWith = function(a) {
    return this.substring(this.length - a.length) === a;
};
;
gs.sp(Utils,"window",window);
gs.sp(Utils,"document",document);
var o = ObjectFinder();
var cordovaAppleSignIn = CordovaAppleSignIn();
var qrScanner = QRScanner();
var cordovaCamera = CordovaCamera();

if (!window.__devReloadInitDone) {
    vue = new VueApp()
    StartupParams.offlineStartFunction = vue.init
    StartupParams.onlineStartNoAuthFunction = vue.init
    StartupParams.onlineStartAuthSuccessFunction = vue.init
    vue.scope.toggleDarkMode = vue.toggleDarkMode
}
;

var sfcModuleLoadOptions = {
  moduleCache: {
    vue: Vue
  },
  async getFile(url) {
    
    const res = await fetch(url);
    if ( !res.ok )
      throw Object.assign(new Error(res.statusText + ' ' + url), { res });
    return {
      getContentData: asBinary => asBinary ? res.arrayBuffer() : res.text(),
    }
  },
  addStyle(textContent) {

    const style = Object.assign(document.createElement('style'), { textContent });
    const ref = document.head.getElementsByTagName('style')[0] || null;
    document.head.insertBefore(style, ref);
  },
}

var { loadModule } = window['vue3-sfc-loader'];
;
var legionLoginComponent = gs.mc(gs.mc(LegionLoginComponent(),"register",[]),"registerAsAuthComponent",[]);
gs.sp(startupParams,"onlineStartTokenAuthFailedFunction",gs.gp(vue,"init"));
var legionUserService = LegionUserService();
var cordovaDevice = CordovaDevice();
var cordovaDeepLink = CordovaDeepLink();
var cordovaFile = CordovaFile();
gs.mc(TestAppMediaComponent(),"register",[]);
var cordovaBiometrics = CordovaBiometrics();
var cordovaBrowser = CordovaBrowser();
var cordovaScreenCapture = CordovaScreenCapture();
var cordovaHealth = CordovaHealth();
gs.mc(TestAppCameraComponent(),"register",[]);
var cordovaCalendar = CordovaCalendar();
gs.mc(VueDateComponent(),"register",[]);
gs.mc(TestAppSpinnerComponent(),"register",[]);
gs.mc(TestAppGpsComponent(),"register",[]);
gs.mc(TestAppScreenshotComponent(),"register",[]);
gs.mc(TestAppBiometricsComponent(),"register",[]);
gs.mc(TestAppErrorComponent(),"register",[]);
gs.mc(TestAppPushComponent(),"register",[]);
var cordovaPhoto = CordovaPhoto();
var cordovaGoogleSignIn = CordovaGoogleSignIn();
gs.mc(TestAppScannerComponent(),"register",[]);
gs.mc(TestAppPrinterComponent(),"register",[]);
var vueListSearchComponent = gs.mc(VueListSearchComponent(),"register",[]);
var testAppDeviceComponent = gs.mc(TestAppDeviceComponent(),"register",[]);
gs.mc(TestAppCaptureComponent(),"register",[]);
var cordovaContacts = CordovaContacts();
gs.mc(SimulatorComponent(),"register",[]);
gs.mc(CordovaErrorViewer(),"register",[]);
var cordovaPushNotification = CordovaPushNotification();
gs.mc(TestAppBleComponent(),"register",[]);
gs.mc(TestAppHealthComponent(),"register",[]);
var dymicoAuthService = DymicoAuthService();
gs.mc(TestAppBatteryComponent(),"register",[]);
gs.execStatic(DevReload,'init', this,[]);
var cordovaSimBridgeAuth = CordovaSimBridgeAuth();
gs.mc(CordovaProblemReporter(),"register",[]);
gs.mc(VueDocumentViewer(),"register",[]);
gs.mc(TestAppShareComponent(),"register",[]);
gs.mc(TestAppLocalNotifComponent(),"register",[]);
gs.mc(I3Media(),"register",[]);
gs.mc(TestAppOrientationComponent(),"register",[]);
gs.mc(TestAppGpsNavigationComponent(),"register",[]);
gs.mc(TestAppDayTravelComponent(),"register",[]);
gs.mc(I3Chart(),"register",[]);
gs.mc(VueMediaUploadComponent(),"register",[]);
var cordovaSimBridge = CordovaSimBridge();
var legionRegisterComponent = gs.mc(LegionRegisterComponent(),"register",[]);
gs.mc(TestAppContactsComponent(),"register",[]);
gs.mc(TestAppCalendarComponent(),"register",[]);
gs.mc(VueAdComponent(),"register",[]);
gs.mc(TestAppStatusBarComponent(),"register",[]);
gs.mc(TestAppNetworkComponent(),"register",[]);
var testAppHome = gs.mc(TestAppHome(),"register",[]);
var cordovaBle = gs.execStatic(CordovaBle,'instance', this,[]);
var cordovaMedia = CordovaMedia();
gs.mc(TestAppBrowserComponent(),"register",[]);
var cordovaLocalNotification = CordovaLocalNotification();
var legionPinComponent = gs.mc(LegionPinComponent(),"register",[]);
gs.mc(TestAppPermissionsComponent(),"register",[]);
gs.mc(TestAppPlugins(),"register",[]);
gs.mc(I3QrCode(),"register",[]);
var cordovaShare = CordovaShare();
gs.mc(I3DatePicker(),"register",[]);
gs.mc(TestAppDeepLinkComponent(),"register",[]);
var cordovaI3Health = CordovaI3Health();
TransmissionBootstrapEnd();
gs.println("GROOSCRIPT END");

//# sourceMappingURL=/convert/dymicoScriptV2Map