@akylas/nativescript-cli 8.7.2

package/lib/common/host-info.js

@@ -0,0 +1,133 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostInfo = void 0;
+const decorators_1 = require("./decorators");
+const _ = require("lodash");
+const yok_1 = require("./yok");
+class HostInfo {
+    get $childProcess() {
+        return this.$injector.resolve("childProcess");
+    }
+    get $osInfo() {
+        return this.$injector.resolve("osInfo");
+    }
+    get $logger() {
+        return this.$injector.resolve("logger");
+    }
+    constructor($errors, $injector) {
+        this.$errors = $errors;
+        this.$injector = $injector;
+    }
+    get isWindows() {
+        return process.platform === HostInfo.WIN32_NAME;
+    }
+    get isWindows64() {
+        return (this.isWindows &&
+            (process.arch === "x64" ||
+                process.env.hasOwnProperty(HostInfo.PROCESSOR_ARCHITEW6432)));
+    }
+    get isWindows32() {
+        return this.isWindows && !this.isWindows64;
+    }
+    get isDarwin() {
+        return process.platform === HostInfo.DARWIN_OS_NAME;
+    }
+    get isLinux() {
+        return process.platform === HostInfo.LINUX_OS_NAME;
+    }
+    get isLinux64() {
+        return this.isLinux && process.config.variables.host_arch === "x64";
+    }
+    getMacOSVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isDarwin) {
+                return null;
+            }
+            const systemProfileCommand = "system_profiler SPSoftwareDataType -detailLevel mini";
+            this.$logger.trace("Trying to get macOS version.");
+            let macOSVersion;
+            try {
+                const systemProfileOutput = yield this.$childProcess.exec(systemProfileCommand);
+                const versionRegExp = /System Version:\s+?macOS\s+?(\d+\.\d+)(\.\d+)?\s+/g;
+                const regExpMatchers = versionRegExp.exec(systemProfileOutput);
+                macOSVersion = regExpMatchers && regExpMatchers[1];
+                if (macOSVersion) {
+                    this.$logger.trace(`macOS version based on system_profiler is ${macOSVersion}.`);
+                    return macOSVersion;
+                }
+                this.$logger.trace(`Unable to get macOS version from ${systemProfileCommand} output.`);
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to get macOS version from ${systemProfileCommand}. Error is: ${err}`);
+            }
+            const osRelease = this.$osInfo.release();
+            const majorVersion = osRelease && _.first(osRelease.split("."));
+            macOSVersion = majorVersion && `10.${+majorVersion - 4}`;
+            this.$logger.trace(`macOS version based on os.release() (${osRelease}) is ${macOSVersion}.`);
+            return macOSVersion;
+        });
+    }
+    dotNetVersion() {
+        if (this.isWindows) {
+            return new Promise((resolve, reject) => {
+                const Winreg = require("winreg");
+                const regKey = new Winreg({
+                    hive: Winreg.HKLM,
+                    key: HostInfo.DOT_NET_REGISTRY_PATH,
+                });
+                regKey.get("Version", (err, value) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(value.value);
+                    }
+                });
+            });
+        }
+        else {
+            return Promise.resolve(null);
+        }
+    }
+    isDotNet40Installed(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isWindows) {
+                try {
+                    yield this.dotNetVersion();
+                    return true;
+                }
+                catch (e) {
+                    this.$errors.fail(message || "An error occurred while reading the registry.");
+                }
+            }
+            else {
+                return false;
+            }
+        });
+    }
+}
+HostInfo.WIN32_NAME = "win32";
+HostInfo.PROCESSOR_ARCHITEW6432 = "PROCESSOR_ARCHITEW6432";
+HostInfo.DARWIN_OS_NAME = "darwin";
+HostInfo.LINUX_OS_NAME = "linux";
+HostInfo.DOT_NET_REGISTRY_PATH = "\\Software\\Microsoft\\NET Framework Setup\\NDP\\v4\\Client";
+__decorate([
+    (0, decorators_1.cache)()
+], HostInfo.prototype, "getMacOSVersion", null);
+exports.HostInfo = HostInfo;
+yok_1.injector.register("hostInfo", HostInfo);

package/lib/common/http-client.js

@@ -0,0 +1,173 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const _ = require("lodash");
+const os_1 = require("os");
+const util = require("util");
+const yok_1 = require("./yok");
+const axios_1 = require("axios");
+const constants_1 = require("./constants");
+const tunnel = require("tunnel");
+class HttpClient {
+    constructor($logger, $proxyService, $staticConfig) {
+        this.$logger = $logger;
+        this.$proxyService = $proxyService;
+        this.$staticConfig = $staticConfig;
+    }
+    httpRequest(options, proxySettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.httpRequestCore(options, proxySettings);
+                return {
+                    response: result,
+                    body: result.body,
+                    headers: result.headers,
+                };
+            }
+            catch (err) {
+                if (err.message === HttpClient.STUCK_REQUEST_ERROR_MESSAGE ||
+                    err.message === HttpClient.STUCK_RESPONSE_ERROR_MESSAGE) {
+                    this.$logger.warn("%s Retrying request to %s...", err.message, options.url || options);
+                    const retryResult = yield this.httpRequestCore(options, proxySettings);
+                    return {
+                        response: retryResult,
+                        body: retryResult.body,
+                        headers: retryResult.headers,
+                    };
+                }
+                throw err;
+            }
+        });
+    }
+    httpRequestCore(options, proxySettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (_.isString(options)) {
+                options = {
+                    url: options,
+                    method: "GET",
+                };
+            }
+            const cliProxySettings = yield this.$proxyService.getCache();
+            const requestProto = options.proto || "http";
+            options.headers = options.headers || {};
+            const headers = options.headers;
+            yield this.useProxySettings(proxySettings, cliProxySettings, options, headers, requestProto);
+            if (!headers["User-Agent"]) {
+                if (!this.defaultUserAgent) {
+                    this.defaultUserAgent = `${this.$staticConfig.USER_AGENT_NAME}/${this.$staticConfig.version} (Node.js ${process.versions.node}; ${process.platform}; ${process.arch})`;
+                    this.$logger.trace("User-Agent: %s", this.defaultUserAgent);
+                }
+                headers["User-Agent"] = this.defaultUserAgent;
+            }
+            if (!headers["Accept-Encoding"]) {
+                headers["Accept-Encoding"] = "gzip,deflate";
+            }
+            this.$logger.trace("httpRequest: %s", util.inspect(options));
+            let agent;
+            if (cliProxySettings) {
+                agent = tunnel.httpsOverHttp({
+                    proxy: {
+                        host: cliProxySettings.hostname,
+                        port: parseInt(cliProxySettings.port),
+                    },
+                });
+            }
+            const result = yield (0, axios_1.default)({
+                url: options.url,
+                headers: options.headers,
+                method: options.method,
+                proxy: false,
+                httpAgent: agent,
+                data: options.body,
+            }).catch((err) => {
+                this.$logger.trace("An error occurred while sending the request:", err);
+                if (err.response) {
+                    const errorMessage = this.getErrorMessage(err.response.status, null);
+                    err.proxyAuthenticationRequired =
+                        err.response.status === constants_1.HttpStatusCodes.PROXY_AUTHENTICATION_REQUIRED;
+                    err.message = errorMessage || err.message;
+                }
+                else if (err.request) {
+                }
+                else {
+                }
+                throw err;
+            });
+            if (result) {
+                this.$logger.trace("httpRequest: Done. code = %d", result.status.toString());
+                return {
+                    response: result,
+                    body: JSON.stringify(result.data),
+                    headers: result.headers,
+                };
+            }
+        });
+    }
+    getErrorMessage(statusCode, body) {
+        if (statusCode === constants_1.HttpStatusCodes.PROXY_AUTHENTICATION_REQUIRED) {
+            const clientNameLowerCase = this.$staticConfig.CLIENT_NAME.toLowerCase();
+            this.$logger.error(`You can run ${os_1.EOL}\t${clientNameLowerCase} proxy set <url> <username> <password>.${os_1.EOL}In order to supply ${clientNameLowerCase} with the credentials needed.`);
+            return "Your proxy requires authentication.";
+        }
+        else if (statusCode === constants_1.HttpStatusCodes.PAYMENT_REQUIRED) {
+            return "Your subscription has expired.";
+        }
+        else if (statusCode === constants_1.HttpStatusCodes.CONFLICTING_RESOURCE) {
+            return "The request conflicts with the current state of the server.";
+        }
+        else {
+            this.$logger.trace("Request was unsuccessful. Server returned: ", body);
+            try {
+                const err = JSON.parse(body);
+                if (_.isString(err)) {
+                    return err;
+                }
+                if (err && err.ExceptionMessage) {
+                    return err.ExceptionMessage;
+                }
+                if (err && err.Message) {
+                    return err.Message;
+                }
+            }
+            catch (parsingFailed) {
+                this.$logger.trace("Failed to get error from http request: ", parsingFailed);
+                return `The server returned unexpected response: ${body}`;
+            }
+            return body;
+        }
+    }
+    useProxySettings(proxySettings, cliProxySettings, options, headers, requestProto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isLocalRequest = options.host === "localhost" || options.host === "127.0.0.1";
+            if (!isLocalRequest && (proxySettings || cliProxySettings)) {
+                const proto = (proxySettings && proxySettings.protocol) ||
+                    cliProxySettings.protocol ||
+                    "http:";
+                const host = (proxySettings && proxySettings.hostname) || cliProxySettings.hostname;
+                const port = (proxySettings && proxySettings.port) || cliProxySettings.port;
+                let credentialsPart = "";
+                if (cliProxySettings.username && cliProxySettings.password) {
+                    credentialsPart = `${cliProxySettings.username}:${cliProxySettings.password}@`;
+                }
+                options.proxy = `${proto}//${credentialsPart}${host}:${port}`;
+                options.rejectUnauthorized = proxySettings
+                    ? proxySettings.rejectUnauthorized
+                    : cliProxySettings.rejectUnauthorized;
+                this.$logger.trace("Using proxy: %s", options.proxy);
+            }
+        });
+    }
+}
+HttpClient.STUCK_REQUEST_ERROR_MESSAGE = "The request can't receive any response.";
+HttpClient.STUCK_RESPONSE_ERROR_MESSAGE = "Can't receive all parts of the response.";
+exports.HttpClient = HttpClient;
+yok_1.injector.register("httpClient", HttpClient);

package/lib/common/logger/appenders/cli-appender.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configure = void 0;
+const constants_1 = require("../../../constants");
+function cliAppender(layout) {
+    const appender = (loggingEvent) => {
+        if (loggingEvent && loggingEvent.data) {
+            const stream = loggingEvent.context[constants_1.LoggerConfigData.useStderr]
+                ? process.stderr
+                : process.stdout;
+            const preparedData = layout(loggingEvent);
+            stream.write(preparedData);
+        }
+    };
+    return appender;
+}
+function configure(config, layouts) {
+    let layout = layouts.messagePassThroughLayout;
+    if (config.layout) {
+        layout = layouts.layout(config.layout.type, config.layout);
+    }
+    return cliAppender(layout);
+}
+exports.configure = configure;

package/lib/common/logger/appenders/emit-appender.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configure = void 0;
+const constants_1 = require("../../../constants");
+function emitAppender(layout, emitter) {
+    const appender = (loggingEvent) => {
+        emitter.emit(constants_1.EMIT_APPENDER_EVENT_NAME, {
+            loggingEvent,
+            formattedMessage: layout(loggingEvent),
+        });
+    };
+    appender.shutdown = () => {
+        emitter.removeAllListeners(constants_1.EMIT_APPENDER_EVENT_NAME);
+    };
+    return appender;
+}
+function configure(config, layouts) {
+    if (!config.emitter) {
+        throw new Error("Emitter must be passed to emit-appender");
+    }
+    if (!config.emitter.emit || typeof config.emitter.emit !== "function") {
+        throw new Error("The passed emitter must be instance of EventEmitter");
+    }
+    let layout = layouts.messagePassThroughLayout;
+    if (config.layout) {
+        layout = layouts.layout(config.layout.type, config.layout);
+    }
+    return emitAppender(layout, config.emitter);
+}
+exports.configure = configure;

package/lib/common/logger/layouts/cli-layout.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.layout = void 0;
+const util_1 = require("util");
+const helpers_1 = require("../../helpers");
+const constants_1 = require("../../../constants");
+const os_1 = require("os");
+const color_1 = require("../../../color");
+function layout(config) {
+    return function (logEvent) {
+        let msg = util_1.format.apply(null, logEvent.data);
+        if (logEvent.context[constants_1.LoggerConfigData.wrapMessageWithBorders]) {
+            msg = (0, helpers_1.getMessageWithBorders)(msg);
+        }
+        if (!logEvent.context[constants_1.LoggerConfigData.skipNewLine]) {
+            msg += os_1.EOL;
+        }
+        if (logEvent.level.isEqualTo(constants_1.LoggerLevel.INFO)) {
+            return msg;
+        }
+        if (logEvent.level.isEqualTo(constants_1.LoggerLevel.ERROR)) {
+            return color_1.color.red.bold(msg);
+        }
+        if (logEvent.level.isEqualTo(constants_1.LoggerLevel.WARN)) {
+            return color_1.color.yellow(msg);
+        }
+        if (logEvent.level.isEqualTo(constants_1.LoggerLevel.TRACE)) {
+            return color_1.color.grey(msg);
+        }
+        return msg;
+    };
+}
+exports.layout = layout;

package/lib/common/logger/logger.js

@@ -0,0 +1,199 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const log4js = require("log4js");
+const util = require("util");
+const readline = require("readline");
+const stream = require("stream");
+const marked_1 = require("marked");
+const _ = require("lodash");
+const decorators_1 = require("../decorators");
+const cli_layout_1 = require("./layouts/cli-layout");
+const constants_1 = require("../../constants");
+const yok_1 = require("../yok");
+const color_1 = require("../../color");
+const TerminalRenderer = require("marked-terminal");
+class Logger {
+    constructor($config) {
+        this.$config = $config;
+        this.log4jsLogger = null;
+        this.passwordRegex = /(password=).*?(['&,]|$)|(password["']?\s*:\s*["']).*?(["'])/i;
+        this.passwordReplacement = "$1$3*******$2$4";
+        this.defaultLogLevel = this.$config.DEBUG
+            ? constants_1.LoggerLevel.TRACE
+            : constants_1.LoggerLevel.INFO;
+    }
+    initialize(opts) {
+        opts = opts || {};
+        const { appenderOptions: appenderOpts, level } = opts;
+        const appender = {
+            type: "console",
+            layout: {
+                type: "messagePassThrough",
+            },
+        };
+        if (appenderOpts) {
+            _.merge(appender, appenderOpts);
+        }
+        const appenders = {
+            out: appender,
+        };
+        const categories = {
+            default: {
+                appenders: ["out"],
+                level: level || this.defaultLogLevel,
+            },
+        };
+        log4js.configure({ appenders, categories });
+        this.log4jsLogger = log4js.getLogger();
+        if (level === constants_1.LoggerLevel.TRACE || level === constants_1.LoggerLevel.ALL) {
+            this.warn(`The "${level}" log level might print some sensitive data like secrets or access tokens in request URLs. Be careful when you share this output.`, { wrapMessageWithBorders: true });
+        }
+    }
+    initializeCliLogger(opts) {
+        log4js.addLayout("cli", cli_layout_1.layout);
+        this.initialize({
+            appenderOptions: {
+                type: constants_1.LoggerAppenders.cliAppender,
+                layout: { type: "cli" },
+            },
+            level: opts.level || this.defaultLogLevel,
+        });
+    }
+    getLevel() {
+        this.initialize();
+        return this.log4jsLogger.level.toString();
+    }
+    fatal(...args) {
+        this.logMessage(args, constants_1.LoggerLevel.FATAL);
+    }
+    error(...args) {
+        args.push({ [constants_1.LoggerConfigData.useStderr]: true });
+        this.logMessage(args, constants_1.LoggerLevel.ERROR);
+    }
+    warn(...args) {
+        this.logMessage(args, constants_1.LoggerLevel.WARN);
+    }
+    info(...args) {
+        this.logMessage(args, constants_1.LoggerLevel.INFO);
+    }
+    debug(...args) {
+        const encodedArgs = this.getPasswordEncodedArguments(args);
+        this.logMessage(encodedArgs, constants_1.LoggerLevel.DEBUG);
+    }
+    trace(...args) {
+        const encodedArgs = this.getPasswordEncodedArguments(args);
+        this.logMessage(encodedArgs, constants_1.LoggerLevel.TRACE);
+    }
+    prepare(item) {
+        if (typeof item === "undefined" || item === null) {
+            return "[no content]";
+        }
+        if (typeof item === "string") {
+            return item;
+        }
+        if (item instanceof stream.Readable) {
+            return "[ReadableStream]";
+        }
+        if (item instanceof Buffer) {
+            return "[Buffer]";
+        }
+        return JSON.stringify(item);
+    }
+    printMarkdown(...args) {
+        const opts = {
+            unescape: true,
+            link: color_1.color.red,
+            strong: color_1.color.green.bold,
+            firstHeading: color_1.color.blue.bold,
+            tableOptions: {
+                chars: { mid: "", "left-mid": "", "mid-mid": "", "right-mid": "" },
+                style: {
+                    "padding-left": 1,
+                    "padding-right": 1,
+                    head: ["green", "bold"],
+                    border: ["grey"],
+                    compact: false,
+                },
+            },
+        };
+        marked_1.marked.setOptions({ renderer: new TerminalRenderer(opts) });
+        const formattedMessage = (0, marked_1.marked)(util.format.apply(null, args));
+        this.info(formattedMessage, { [constants_1.LoggerConfigData.skipNewLine]: true });
+    }
+    isVerbose() {
+        return log4js.levels.DEBUG.isGreaterThanOrEqualTo(this.getLevel());
+    }
+    clearScreen() {
+        const repeatCount = process.stdout.rows - 2;
+        const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+        console.log(blank);
+        readline.cursorTo(process.stdout, 0, 0);
+        readline.clearScreenDown(process.stdout);
+    }
+    logMessage(inputData, logMethod) {
+        this.initialize();
+        const logOpts = this.getLogOptionsForMessage(inputData);
+        const data = logOpts.data;
+        delete logOpts.data;
+        for (const prop in logOpts) {
+            this.log4jsLogger.addContext(prop, logOpts[prop]);
+        }
+        this.log4jsLogger[logMethod.toLowerCase()].apply(this.log4jsLogger, data);
+        for (const prop in logOpts) {
+            this.log4jsLogger.removeContext(prop);
+        }
+    }
+    getLogOptionsForMessage(data) {
+        const loggerOptionKeys = _.keys(constants_1.LoggerConfigData);
+        const dataToCheck = data.filter((el) => {
+            if (!!el &&
+                typeof el === "object" &&
+                el.hasOwnProperty &&
+                typeof el.hasOwnProperty === "function") {
+                for (const key of loggerOptionKeys) {
+                    if (el.hasOwnProperty(key)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        });
+        const result = {
+            data: _.difference(data, dataToCheck),
+        };
+        for (const element of dataToCheck) {
+            if (loggerOptionKeys.length === 0) {
+                break;
+            }
+            const remainingOpts = _.cloneDeep(loggerOptionKeys);
+            for (const prop of remainingOpts) {
+                const hasProp = element && element.hasOwnProperty(prop);
+                if (hasProp) {
+                    loggerOptionKeys.splice(loggerOptionKeys.indexOf(prop), 1);
+                    result[prop] = element[prop];
+                }
+            }
+        }
+        return result;
+    }
+    getPasswordEncodedArguments(args) {
+        return _.map(args, (argument) => {
+            if (typeof argument === "string" && !!argument.match(/password/i)) {
+                argument = argument.replace(this.passwordRegex, this.passwordReplacement);
+            }
+            return argument;
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], Logger.prototype, "initialize", null);
+exports.Logger = Logger;
+yok_1.injector.register("logger", Logger);

package/lib/common/messages/messages.interface.d.ts

@@ -0,0 +1,10 @@
+//
+// automatically generated code; do not edit manually!
+//
+interface IMessages {
+	Devices: {
+		NotFoundDeviceByIdentifierErrorMessage: string;
+		NotFoundDeviceByIdentifierErrorMessageWithIdentifier: string;
+		NotFoundDeviceByIndexErrorMessage: string;
+	};
+}

package/lib/common/messages/messages.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Messages = void 0;
+const yok_1 = require("../yok");
+class Messages {
+    constructor() {
+        this.Devices = {
+            NotFoundDeviceByIdentifierErrorMessage: "Devices.NotFoundDeviceByIdentifierErrorMessage",
+            NotFoundDeviceByIdentifierErrorMessageWithIdentifier: "Devices.NotFoundDeviceByIdentifierErrorMessageWithIdentifier",
+            NotFoundDeviceByIndexErrorMessage: "Devices.NotFoundDeviceByIndexErrorMessage",
+        };
+    }
+}
+exports.Messages = Messages;
+yok_1.injector.register("messages", Messages);