(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('@iotize/tap-scripts/ext'), require('@iotize/common/byte-converter'), require('@iotize/ionic'), require('@iotize/tap-scripts'), require('rxjs'), require('rxjs/operators')) :
    typeof define === 'function' && define.amd ? define('@iotize/ionic/scripts', ['exports', '@angular/core', '@angular/common', '@iotize/tap-scripts/ext', '@iotize/common/byte-converter', '@iotize/ionic', '@iotize/tap-scripts', 'rxjs', 'rxjs/operators'], factory) :
    (global = global || self, factory((global.iotize = global.iotize || {}, global.iotize.ionic = global.iotize.ionic || {}, global.iotize.ionic.scripts = {}), global.ng.core, global.ng.common, null, global.byteConverter, global.iotize.ionic, global.tapScripts, global.rxjs, global.rxjs.operators));
}(this, (function (exports, core, common, ext, byteConverter, ionic, tapScripts, rxjs, operators) { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */
    /* global Reflect, Promise */

    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    var __assign = function() {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };

    function __rest(s, e) {
        var t = {};
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
            t[p] = s[p];
        if (s != null && typeof Object.getOwnPropertySymbols === "function")
            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                    t[p[i]] = s[p[i]];
            }
        return t;
    }

    function __decorate(decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    }

    function __param(paramIndex, decorator) {
        return function (target, key) { decorator(target, key, paramIndex); }
    }

    function __metadata(metadataKey, metadataValue) {
        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
    }

    function __awaiter(thisArg, _arguments, P, generator) {
        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
        return new (P || (P = Promise))(function (resolve, reject) {
            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
            step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
    }

    function __generator(thisArg, body) {
        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f) throw new TypeError("Generator is already executing.");
            while (_) try {
                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
                if (y = 0, t) op = [op[0] & 2, t.value];
                switch (op[0]) {
                    case 0: case 1: t = op; break;
                    case 4: _.label++; return { value: op[1], done: false };
                    case 5: _.label++; y = op[1]; op = [0]; continue;
                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
                    default:
                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                        if (t[2]) _.ops.pop();
                        _.trys.pop(); continue;
                }
                op = body.call(thisArg, _);
            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
        }
    }

    function __createBinding(o, m, k, k2) {
        if (k2 === undefined) k2 = k;
        o[k2] = m[k];
    }

    function __exportStar(m, exports) {
        for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
    }

    function __values(o) {
        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
        if (m) return m.call(o);
        if (o && typeof o.length === "number") return {
            next: function () {
                if (o && i >= o.length) o = void 0;
                return { value: o && o[i++], done: !o };
            }
        };
        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
    }

    function __read(o, n) {
        var m = typeof Symbol === "function" && o[Symbol.iterator];
        if (!m) return o;
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
        }
        catch (error) { e = { error: error }; }
        finally {
            try {
                if (r && !r.done && (m = i["return"])) m.call(i);
            }
            finally { if (e) throw e.error; }
        }
        return ar;
    }

    function __spread() {
        for (var ar = [], i = 0; i < arguments.length; i++)
            ar = ar.concat(__read(arguments[i]));
        return ar;
    }

    function __spreadArrays() {
        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
        for (var r = Array(s), k = 0, i = 0; i < il; i++)
            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
                r[k] = a[j];
        return r;
    };

    function __await(v) {
        return this instanceof __await ? (this.v = v, this) : new __await(v);
    }

    function __asyncGenerator(thisArg, _arguments, generator) {
        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
        var g = generator.apply(thisArg, _arguments || []), i, q = [];
        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
        function fulfill(value) { resume("next", value); }
        function reject(value) { resume("throw", value); }
        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
    }

    function __asyncDelegator(o) {
        var i, p;
        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
    }

    function __asyncValues(o) {
        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
        var m = o[Symbol.asyncIterator], i;
        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
    }

    function __makeTemplateObject(cooked, raw) {
        if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
        return cooked;
    };

    function __importStar(mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
        result.default = mod;
        return result;
    }

    function __importDefault(mod) {
        return (mod && mod.__esModule) ? mod : { default: mod };
    }

    function __classPrivateFieldGet(receiver, privateMap) {
        if (!privateMap.has(receiver)) {
            throw new TypeError("attempted to get private field on non-instance");
        }
        return privateMap.get(receiver);
    }

    function __classPrivateFieldSet(receiver, privateMap, value) {
        if (!privateMap.has(receiver)) {
            throw new TypeError("attempted to set private field on non-instance");
        }
        privateMap.set(receiver, value);
        return value;
    }

    /**
     * @fileoverview added by tsickle
     * Generated from: lib/tap-script.module.ts
     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var TapScriptModule = /** @class */ (function () {
        function TapScriptModule() {
        }
        TapScriptModule.decorators = [
            { type: core.NgModule, args: [{
                        declarations: [],
                        imports: [
                            common.CommonModule
                        ]
                    },] }
        ];
        return TapScriptModule;
    }());

    /**
     * @fileoverview added by tsickle
     * Generated from: lib/tap-script-runner.service.ts
     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @record
     */
    function ScriptOutputType() { }
    if (false) {
        /** @type {?} */
        ScriptOutputType.prototype.level;
        /** @type {?} */
        ScriptOutputType.prototype.message;
    }
    var TapScriptRunnerService = /** @class */ (function () {
        function TapScriptRunnerService(events) {
            var _this = this;
            this.events = events;
            this.scriptTypes = {
                NORMAL: 1,
                CONFIGURATION: 2
            };
            this._outputMessages = [];
            this._errors = new rxjs.Subject();
            this.output = new rxjs.Subject();
            /**
             * The ScriptRunner object is given options with what is done with values retrieved by the script
             * The output property defines the actions to perform on data retrieving.
             * The display property defines how to log informations given back by the scriptRunner.
             * @see {ScriptRunner}
             */
            this.scriptRunnerOptions = {
                output: (/**
                 * @param {?=} response
                 * @return {?}
                 */
                function (response) {
                    /**
                     * Waiting for ScriptRunner update, display tweak
                     * If response is 1 or 2 bytes or contains 0, displays it as an hex string
                     * else displays it as an ASCII string
                     */
                    if (response) {
                        /** @type {?} */
                        var responseDisplayed = void 0;
                        /** @type {?} */
                        var responseBody = response.body();
                        if (responseBody.length <= 2 || responseBody.includes(0)) {
                            responseDisplayed = byteConverter.bufferToHexString(responseBody);
                        }
                        else {
                            responseDisplayed = byteConverter.bufferToAsciiString(responseBody);
                        }
                        _this.addOutput('info', "" + responseDisplayed);
                    }
                }),
                display: (/**
                 * @param {?} level
                 * @param {?} content
                 * @return {?}
                 */
                function (level, content) {
                    console.log("[" + level + "] : " + content);
                    if (level == 'message') {
                        _this.addOutput('info', "" + content);
                        return;
                    }
                    _this.addOutput(level, content);
                })
            };
            this.scriptFile = {
                name: '',
                scriptString: ''
            };
            this.scriptType = this.scriptTypes.NORMAL;
        }
        Object.defineProperty(TapScriptRunnerService.prototype, "isRunning", {
            get: /**
             * @return {?}
             */
            function () {
                return this.scriptRunner !== undefined && this.scriptRunner.isRunning();
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TapScriptRunnerService.prototype, "hasScript", {
            get: /**
             * @return {?}
             */
            function () {
                return this.scriptFile.scriptString !== '';
            },
            enumerable: true,
            configurable: true
        });
        /**
         * Converts script content, read as a string, into a list of instructions
         * @param scriptString content of the loaded script file
         * @returns
         */
        /**
         * Converts script content, read as a string, into a list of instructions
         * @param {?} scriptString content of the loaded script file
         * @return {?}
         */
        TapScriptRunnerService.prototype.getProgInstructions = /**
         * Converts script content, read as a string, into a list of instructions
         * @param {?} scriptString content of the loaded script file
         * @return {?}
         */
        function (scriptString) {
            return tapScripts.GrammarHelper.toProgInstructions(scriptString);
        };
        /**
         * @param {?} instructions
         * @param {?} tap
         * @return {?}
         */
        TapScriptRunnerService.prototype.runScript = /**
         * @param {?} instructions
         * @param {?} tap
         * @return {?}
         */
        function (instructions, tap) {
            this._outputMessages = [];
            return this.executeScriptFromInstructions(tap, instructions);
        };
        /**
         * @return {?}
         */
        TapScriptRunnerService.prototype.stopScript = /**
         * @return {?}
         */
        function () {
            // TODO
        };
        Object.defineProperty(TapScriptRunnerService.prototype, "errors", {
            get: /**
             * @return {?}
             */
            function () {
                return this._errors;
            },
            enumerable: true,
            configurable: true
        });
        /**
         * Reads and executes the given instruction list.
         * @param instructions
         */
        /**
         * Reads and executes the given instruction list.
         * @param {?} tap
         * @param {?} instructions
         * @return {?}
         */
        TapScriptRunnerService.prototype.executeScriptFromInstructions = /**
         * Reads and executes the given instruction list.
         * @param {?} tap
         * @param {?} instructions
         * @return {?}
         */
        function (tap, instructions) {
            var _this = this;
            this._outputMessages = [];
            /** @type {?} */
            var checkErrorCount = 0;
            /** @type {?} */
            var scriptRunner = this.scriptRunner = new tapScripts.ScriptRunner(this.scriptRunnerOptions);
            scriptRunner.errorHandler = (/**
             * @param {?} error
             * @return {?}
             */
            function (error) {
                // this.addOutput('error', error.message);
                _this._errors.next(error);
                // console.error(error);
                if (/Check instruction/.test(error.message)) {
                    checkErrorCount++;
                }
            });
            return scriptRunner.run(instructions, tap)
                .pipe(
            // rxTap({
            //   next: (event: ScriptRunnerEvent) => {
            //     console.warn(event);
            //     if (event.type == 'after') {
            //       if ('cmd' in event.instruction) {
            //         // this.addOutput('verbose', `Command ${event.instruction['cmd'].toString()}`);
            //       }
            //     }
            //   },
            //   complete: () => {
            //     console.log("Script execution: DONE");
            //     // this.addOutput('info', '\n');
            //     // this.addOutput('info', '--------Script execution: DONE--------');
            //     if (checkErrorCount > 0) {
            //       // this.addOutput('error', `Failed Check instructions: ${checkErrorCount}`);
            //     }
            //     // this.isRunning = false;
            //   },
            //   error: (error) => {
            //     console.error(error);
            //     // this.isRunning = false;
            //   }
            // }),
            operators.share());
        };
        /**
         * @return {?}
         */
        TapScriptRunnerService.prototype.stop = /**
         * @return {?}
         */
        function () {
            if (this.scriptRunner) {
                this.scriptRunner.stop();
            }
        };
        /**
         * @param {?} level
         * @param {?} message
         * @return {?}
         */
        TapScriptRunnerService.prototype.addOutput = /**
         * @param {?} level
         * @param {?} message
         * @return {?}
         */
        function (level, message) {
            console.info('SCRIPT', level, message);
            this._outputMessages.push({
                level: level,
                message: message
            });
            this.output.next(this._outputMessages);
        };
        /**
         * Converts, reads and executes instructions from the raw content of a script file.
         * In the configuration routine, script execution is preceded by:
         * - Log as admin
         * - Factory reset
         * - Wait time
         * And succeeded with
         * - Wait time
         * - Configuration reload
         * - Wait time
         *
         * The configuration routine has succeeded if all these steps did.
         *
         * TODO remove as it's in library
         *
         * @param scriptString
         */
        /**
         * Converts, reads and executes instructions from the raw content of a script file.
         * In the configuration routine, script execution is preceded by:
         * - Log as admin
         * - Factory reset
         * - Wait time
         * And succeeded with
         * - Wait time
         * - Configuration reload
         * - Wait time
         *
         * The configuration routine has succeeded if all these steps did.
         *
         * TODO remove as it's in library
         *
         * @param {?} scriptString
         * @param {?} tap
         * @return {?}
         */
        TapScriptRunnerService.prototype.executeConfigurationScriptRoutine = /**
         * Converts, reads and executes instructions from the raw content of a script file.
         * In the configuration routine, script execution is preceded by:
         * - Log as admin
         * - Factory reset
         * - Wait time
         * And succeeded with
         * - Wait time
         * - Configuration reload
         * - Wait time
         *
         * The configuration routine has succeeded if all these steps did.
         *
         * TODO remove as it's in library
         *
         * @param {?} scriptString
         * @param {?} tap
         * @return {?}
         */
        function (scriptString, tap) {
            return __awaiter(this, void 0, void 0, function () {
                var waitingTime, instructions, factoryResetResponse, result, error_1, error_2, reloadResponse, error_3;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            waitingTime = 400;
                            instructions = this.getProgInstructions(scriptString);
                            _a.label = 1;
                        case 1:
                            _a.trys.push([1, 4, , 5]);
                            console.log('@@@@@@@@@ Logging as admin @@@@@@@@@');
                            // TODO only if not already logged in as an admin
                            return [4 /*yield*/, tap.auth.login({
                                    username: 'admin',
                                    password: 'admin'
                                })];
                        case 2:
                            // TODO only if not already logged in as an admin
                            _a.sent();
                            console.log('@@@@@@@@@  factory reset @@@@@@@@@');
                            this.events.publish('configuration', 'factory reset');
                            factoryResetResponse = tap.service.device.factoryReset();
                            return [4 /*yield*/, factoryResetResponse];
                        case 3:
                            result = (_a.sent()).body();
                            console.log("factoryReset : " + result);
                            return [3 /*break*/, 5];
                        case 4:
                            error_1 = _a.sent();
                            console.error(error_1);
                            throw new Error('factory reset failed');
                        case 5:
                            this.events.publish('configuration', 'executing script');
                            console.log('@@@@@@@@@  Wait after factory reset, before script execution @@@@@@@@@');
                            return [4 /*yield*/, this.sleep(waitingTime)];
                        case 6:
                            _a.sent();
                            _a.label = 7;
                        case 7:
                            _a.trys.push([7, 9, , 10]);
                            return [4 /*yield*/, this.executeScriptFromInstructions(tap, instructions)];
                        case 8:
                            _a.sent();
                            return [3 /*break*/, 10];
                        case 9:
                            error_2 = _a.sent();
                            console.error(error_2);
                            throw new Error('Script execution failed');
                        case 10:
                            _a.trys.push([10, 13, , 14]);
                            console.log('@@@@@@@@@  Wait after script execution, before reloading config @@@@@@@@@');
                            //  5. wait 400ms
                            return [4 /*yield*/, this.sleep(waitingTime)];
                        case 11:
                            //  5. wait 400ms
                            _a.sent();
                            //  6. reload config. Custom call to post /1024//10 while reloadConfig method is not implemented
                            reloadResponse = tap.service.interface.reloadConfig();
                            console.log('Waiting for reloadResponse');
                            return [4 /*yield*/, reloadResponse];
                        case 12:
                            _a.sent();
                            return [3 /*break*/, 14];
                        case 13:
                            error_3 = _a.sent();
                            console.error(error_3);
                            throw new Error('Reloading config failed');
                        case 14: 
                        //  7. wait 400ms
                        return [4 /*yield*/, this.sleep(waitingTime)];
                        case 15:
                            //  7. wait 400ms
                            _a.sent();
                            console.log('@@@@@@@@@ configuration complete @@@@@@@@@');
                            this.events.publish('configuration', 'configuration completed');
                            return [2 /*return*/];
                    }
                });
            });
        };
        /**
         * Executes currently loaded script, if no script is running, using the routine defined by the scriptType property
         */
        /**
         * Executes currently loaded script, if no script is running, using the routine defined by the scriptType property
         * @param {?} tap
         * @return {?}
         */
        TapScriptRunnerService.prototype.executeLoadedScript = /**
         * Executes currently loaded script, if no script is running, using the routine defined by the scriptType property
         * @param {?} tap
         * @return {?}
         */
        function (tap) {
            if (this.isRunning) {
                console.error('Another script is running');
                return;
            }
            if (this.scriptType === this.scriptTypes.CONFIGURATION) {
                return this.executeConfigurationScriptRoutine(this.scriptFile.scriptString, tap);
            }
            if (this.scriptType === this.scriptTypes.NORMAL) {
                return this.executeScriptFromInstructions(tap, this.getProgInstructions(this.scriptFile.scriptString));
            }
        };
        /**
         * Returns a promise that resolve after given time in milliseconds
         * @param milliseconds
         * @returns
         */
        /**
         * Returns a promise that resolve after given time in milliseconds
         * @param {?} milliseconds
         * @return {?}
         */
        TapScriptRunnerService.prototype.sleep = /**
         * Returns a promise that resolve after given time in milliseconds
         * @param {?} milliseconds
         * @return {?}
         */
        function (milliseconds) {
            return new Promise((/**
             * @param {?} resolve
             * @return {?}
             */
            function (resolve) {
                setTimeout((/**
                 * @return {?}
                 */
                function () { return resolve(); }), milliseconds);
            }));
        };
        TapScriptRunnerService.decorators = [
            { type: core.Injectable, args: [{
                        providedIn: 'root'
                    },] }
        ];
        /** @nocollapse */
        TapScriptRunnerService.ctorParameters = function () { return [
            { type: ionic.GlobalEventsService }
        ]; };
        /** @nocollapse */ TapScriptRunnerService.ɵprov = core.ɵɵdefineInjectable({ factory: function TapScriptRunnerService_Factory() { return new TapScriptRunnerService(core.ɵɵinject(ionic.GlobalEventsService)); }, token: TapScriptRunnerService, providedIn: "root" });
        return TapScriptRunnerService;
    }());
    if (false) {
        /** @type {?} */
        TapScriptRunnerService.prototype.scriptTypes;
        /** @type {?} */
        TapScriptRunnerService.prototype.scriptRunner;
        /** @type {?} */
        TapScriptRunnerService.prototype._outputMessages;
        /** @type {?} */
        TapScriptRunnerService.prototype._errors;
        /** @type {?} */
        TapScriptRunnerService.prototype.output;
        /**
         * The ScriptRunner object is given options with what is done with values retrieved by the script
         * The output property defines the actions to perform on data retrieving.
         * The display property defines how to log informations given back by the scriptRunner.
         * @see {ScriptRunner}
         * @type {?}
         */
        TapScriptRunnerService.prototype.scriptRunnerOptions;
        /** @type {?} */
        TapScriptRunnerService.prototype.scriptFile;
        /** @type {?} */
        TapScriptRunnerService.prototype.scriptType;
        /** @type {?} */
        TapScriptRunnerService.prototype.events;
    }

    /**
     * @fileoverview added by tsickle
     * Generated from: lib/definitions.ts
     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /**
     * @record
     */
    function ScriptFile() { }
    if (false) {
        /** @type {?} */
        ScriptFile.prototype.name;
        /** @type {?} */
        ScriptFile.prototype.scriptString;
    }

    exports.TapScriptModule = TapScriptModule;
    exports.TapScriptRunnerService = TapScriptRunnerService;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=iotize-ionic-scripts.umd.js.map
