@nestia/sdk 0.1.0

package/lib/executable/internal/NestiaSdkConfig.js

@@ -0,0 +1,539 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestiaSdkConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const runner = __importStar(require("ts-node"));
+const Singleton_1 = require("tstl/thread/Singleton");
+const typia_1 = require("typia");
+var NestiaSdkConfig;
+(function (NestiaSdkConfig) {
+    function get() {
+        return singleton.get();
+    }
+    NestiaSdkConfig.get = get;
+    const singleton = new Singleton_1.Singleton(() => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (fs_1.default.existsSync("nestia.config.ts") === false)
+            return null;
+        runner.register({
+            emit: false,
+            compilerOptions: {
+                module: "CommonJS",
+                noEmit: true,
+            },
+        });
+        const loaded = yield (_a = path_1.default.resolve("nestia.config.ts"), Promise.resolve().then(() => __importStar(require(_a))));
+        if (typeof loaded !== "object")
+            throw new Error("Error on NestiaConfig.get(): failed to load data");
+        const config = typeof loaded.default === "object" ? loaded.default : loaded;
+        const cloned = JSON.parse(JSON.stringify(config));
+        return (input => {
+            const $guard = typia_1.assert.guard;
+            const $join = typia_1.assert.join;
+            ((input, path, exceptionable) => {
+                const $ao0 = (input, path, exceptionable) => (null !== input.input || $guard(exceptionable, {
+                    path: path + ".input",
+                    expected: "(Array<string> | Resolve<INestiaConfig.IInput> | string)",
+                    value: input.input
+                })) && (undefined !== input.input || $guard(exceptionable, {
+                    path: path + ".input",
+                    expected: "(Array<string> | Resolve<INestiaConfig.IInput> | string)",
+                    value: input.input
+                })) && ("string" === typeof input.input || (Array.isArray(input.input) || $guard(exceptionable, {
+                    path: path + ".input",
+                    expected: "(Array<string> | Resolve<INestiaConfig.IInput> | string)",
+                    value: input.input
+                })) && input.input.every((elem, index1) => "string" === typeof elem || $guard(exceptionable, {
+                    path: path + ".input[" + index1 + "]",
+                    expected: "string",
+                    value: elem
+                })) || ("object" === typeof input.input && null !== input.input || $guard(exceptionable, {
+                    path: path + ".input",
+                    expected: "(Array<string> | Resolve<INestiaConfig.IInput> | string)",
+                    value: input.input
+                })) && $ao1(input.input, path + ".input", true && exceptionable)) && (undefined === input.output || "string" === typeof input.output || $guard(exceptionable, {
+                    path: path + ".output",
+                    expected: "(string | undefined)",
+                    value: input.output
+                })) && (undefined === input.compilerOptions || ("object" === typeof input.compilerOptions && null !== input.compilerOptions || $guard(exceptionable, {
+                    path: path + ".compilerOptions",
+                    expected: "(Resolve<StripEnums<ts.CompilerOptions>> | undefined)",
+                    value: input.compilerOptions
+                })) && $ao2(input.compilerOptions, path + ".compilerOptions", true && exceptionable)) && (undefined === input.assert || "boolean" === typeof input.assert || $guard(exceptionable, {
+                    path: path + ".assert",
+                    expected: "(boolean | undefined)",
+                    value: input.assert
+                })) && (undefined === input.json || "boolean" === typeof input.json || $guard(exceptionable, {
+                    path: path + ".json",
+                    expected: "(boolean | undefined)",
+                    value: input.json
+                })) && (undefined === input.primitive || "boolean" === typeof input.primitive || $guard(exceptionable, {
+                    path: path + ".primitive",
+                    expected: "(boolean | undefined)",
+                    value: input.primitive
+                })) && (undefined === input.swagger || ("object" === typeof input.swagger && null !== input.swagger || $guard(exceptionable, {
+                    path: path + ".swagger",
+                    expected: "(Resolve<INestiaConfig.ISwagger> | undefined)",
+                    value: input.swagger
+                })) && $ao4(input.swagger, path + ".swagger", true && exceptionable));
+                const $ao1 = (input, path, exceptionable) => (Array.isArray(input.include) || $guard(exceptionable, {
+                    path: path + ".include",
+                    expected: "Array<string>",
+                    value: input.include
+                })) && input.include.every((elem, index2) => "string" === typeof elem || $guard(exceptionable, {
+                    path: path + ".include[" + index2 + "]",
+                    expected: "string",
+                    value: elem
+                })) && (undefined === input.exclude || (Array.isArray(input.exclude) || $guard(exceptionable, {
+                    path: path + ".exclude",
+                    expected: "(Array<string> | undefined)",
+                    value: input.exclude
+                })) && input.exclude.every((elem, index3) => "string" === typeof elem || $guard(exceptionable, {
+                    path: path + ".exclude[" + index3 + "]",
+                    expected: "string",
+                    value: elem
+                })));
+                const $ao2 = (input, path, exceptionable) => (undefined === input.allowJs || "boolean" === typeof input.allowJs || $guard(exceptionable, {
+                    path: path + ".allowJs",
+                    expected: "(boolean | undefined)",
+                    value: input.allowJs
+                })) && (undefined === input.allowSyntheticDefaultImports || "boolean" === typeof input.allowSyntheticDefaultImports || $guard(exceptionable, {
+                    path: path + ".allowSyntheticDefaultImports",
+                    expected: "(boolean | undefined)",
+                    value: input.allowSyntheticDefaultImports
+                })) && (undefined === input.allowUmdGlobalAccess || "boolean" === typeof input.allowUmdGlobalAccess || $guard(exceptionable, {
+                    path: path + ".allowUmdGlobalAccess",
+                    expected: "(boolean | undefined)",
+                    value: input.allowUmdGlobalAccess
+                })) && (undefined === input.allowUnreachableCode || "boolean" === typeof input.allowUnreachableCode || $guard(exceptionable, {
+                    path: path + ".allowUnreachableCode",
+                    expected: "(boolean | undefined)",
+                    value: input.allowUnreachableCode
+                })) && (undefined === input.allowUnusedLabels || "boolean" === typeof input.allowUnusedLabels || $guard(exceptionable, {
+                    path: path + ".allowUnusedLabels",
+                    expected: "(boolean | undefined)",
+                    value: input.allowUnusedLabels
+                })) && (undefined === input.alwaysStrict || "boolean" === typeof input.alwaysStrict || $guard(exceptionable, {
+                    path: path + ".alwaysStrict",
+                    expected: "(boolean | undefined)",
+                    value: input.alwaysStrict
+                })) && (undefined === input.baseUrl || "string" === typeof input.baseUrl || $guard(exceptionable, {
+                    path: path + ".baseUrl",
+                    expected: "(string | undefined)",
+                    value: input.baseUrl
+                })) && (undefined === input.charset || "string" === typeof input.charset || $guard(exceptionable, {
+                    path: path + ".charset",
+                    expected: "(string | undefined)",
+                    value: input.charset
+                })) && (undefined === input.checkJs || "boolean" === typeof input.checkJs || $guard(exceptionable, {
+                    path: path + ".checkJs",
+                    expected: "(boolean | undefined)",
+                    value: input.checkJs
+                })) && (undefined === input.declaration || "boolean" === typeof input.declaration || $guard(exceptionable, {
+                    path: path + ".declaration",
+                    expected: "(boolean | undefined)",
+                    value: input.declaration
+                })) && (undefined === input.declarationMap || "boolean" === typeof input.declarationMap || $guard(exceptionable, {
+                    path: path + ".declarationMap",
+                    expected: "(boolean | undefined)",
+                    value: input.declarationMap
+                })) && (undefined === input.emitDeclarationOnly || "boolean" === typeof input.emitDeclarationOnly || $guard(exceptionable, {
+                    path: path + ".emitDeclarationOnly",
+                    expected: "(boolean | undefined)",
+                    value: input.emitDeclarationOnly
+                })) && (undefined === input.declarationDir || "string" === typeof input.declarationDir || $guard(exceptionable, {
+                    path: path + ".declarationDir",
+                    expected: "(string | undefined)",
+                    value: input.declarationDir
+                })) && (undefined === input.disableSizeLimit || "boolean" === typeof input.disableSizeLimit || $guard(exceptionable, {
+                    path: path + ".disableSizeLimit",
+                    expected: "(boolean | undefined)",
+                    value: input.disableSizeLimit
+                })) && (undefined === input.disableSourceOfProjectReferenceRedirect || "boolean" === typeof input.disableSourceOfProjectReferenceRedirect || $guard(exceptionable, {
+                    path: path + ".disableSourceOfProjectReferenceRedirect",
+                    expected: "(boolean | undefined)",
+                    value: input.disableSourceOfProjectReferenceRedirect
+                })) && (undefined === input.disableSolutionSearching || "boolean" === typeof input.disableSolutionSearching || $guard(exceptionable, {
+                    path: path + ".disableSolutionSearching",
+                    expected: "(boolean | undefined)",
+                    value: input.disableSolutionSearching
+                })) && (undefined === input.disableReferencedProjectLoad || "boolean" === typeof input.disableReferencedProjectLoad || $guard(exceptionable, {
+                    path: path + ".disableReferencedProjectLoad",
+                    expected: "(boolean | undefined)",
+                    value: input.disableReferencedProjectLoad
+                })) && (undefined === input.downlevelIteration || "boolean" === typeof input.downlevelIteration || $guard(exceptionable, {
+                    path: path + ".downlevelIteration",
+                    expected: "(boolean | undefined)",
+                    value: input.downlevelIteration
+                })) && (undefined === input.emitBOM || "boolean" === typeof input.emitBOM || $guard(exceptionable, {
+                    path: path + ".emitBOM",
+                    expected: "(boolean | undefined)",
+                    value: input.emitBOM
+                })) && (undefined === input.emitDecoratorMetadata || "boolean" === typeof input.emitDecoratorMetadata || $guard(exceptionable, {
+                    path: path + ".emitDecoratorMetadata",
+                    expected: "(boolean | undefined)",
+                    value: input.emitDecoratorMetadata
+                })) && (undefined === input.exactOptionalPropertyTypes || "boolean" === typeof input.exactOptionalPropertyTypes || $guard(exceptionable, {
+                    path: path + ".exactOptionalPropertyTypes",
+                    expected: "(boolean | undefined)",
+                    value: input.exactOptionalPropertyTypes
+                })) && (undefined === input.experimentalDecorators || "boolean" === typeof input.experimentalDecorators || $guard(exceptionable, {
+                    path: path + ".experimentalDecorators",
+                    expected: "(boolean | undefined)",
+                    value: input.experimentalDecorators
+                })) && (undefined === input.forceConsistentCasingInFileNames || "boolean" === typeof input.forceConsistentCasingInFileNames || $guard(exceptionable, {
+                    path: path + ".forceConsistentCasingInFileNames",
+                    expected: "(boolean | undefined)",
+                    value: input.forceConsistentCasingInFileNames
+                })) && (undefined === input.importHelpers || "boolean" === typeof input.importHelpers || $guard(exceptionable, {
+                    path: path + ".importHelpers",
+                    expected: "(boolean | undefined)",
+                    value: input.importHelpers
+                })) && true && (undefined === input.inlineSourceMap || "boolean" === typeof input.inlineSourceMap || $guard(exceptionable, {
+                    path: path + ".inlineSourceMap",
+                    expected: "(boolean | undefined)",
+                    value: input.inlineSourceMap
+                })) && (undefined === input.inlineSources || "boolean" === typeof input.inlineSources || $guard(exceptionable, {
+                    path: path + ".inlineSources",
+                    expected: "(boolean | undefined)",
+                    value: input.inlineSources
+                })) && (undefined === input.isolatedModules || "boolean" === typeof input.isolatedModules || $guard(exceptionable, {
+                    path: path + ".isolatedModules",
+                    expected: "(boolean | undefined)",
+                    value: input.isolatedModules
+                })) && true && (undefined === input.keyofStringsOnly || "boolean" === typeof input.keyofStringsOnly || $guard(exceptionable, {
+                    path: path + ".keyofStringsOnly",
+                    expected: "(boolean | undefined)",
+                    value: input.keyofStringsOnly
+                })) && (undefined === input.lib || (Array.isArray(input.lib) || $guard(exceptionable, {
+                    path: path + ".lib",
+                    expected: "(Array<string> | undefined)",
+                    value: input.lib
+                })) && input.lib.every((elem, index4) => "string" === typeof elem || $guard(exceptionable, {
+                    path: path + ".lib[" + index4 + "]",
+                    expected: "string",
+                    value: elem
+                }))) && (undefined === input.locale || "string" === typeof input.locale || $guard(exceptionable, {
+                    path: path + ".locale",
+                    expected: "(string | undefined)",
+                    value: input.locale
+                })) && (undefined === input.mapRoot || "string" === typeof input.mapRoot || $guard(exceptionable, {
+                    path: path + ".mapRoot",
+                    expected: "(string | undefined)",
+                    value: input.mapRoot
+                })) && true && true && true && (undefined === input.moduleSuffixes || (Array.isArray(input.moduleSuffixes) || $guard(exceptionable, {
+                    path: path + ".moduleSuffixes",
+                    expected: "(Array<string> | undefined)",
+                    value: input.moduleSuffixes
+                })) && input.moduleSuffixes.every((elem, index5) => "string" === typeof elem || $guard(exceptionable, {
+                    path: path + ".moduleSuffixes[" + index5 + "]",
+                    expected: "string",
+                    value: elem
+                }))) && true && true && (undefined === input.noEmit || "boolean" === typeof input.noEmit || $guard(exceptionable, {
+                    path: path + ".noEmit",
+                    expected: "(boolean | undefined)",
+                    value: input.noEmit
+                })) && (undefined === input.noEmitHelpers || "boolean" === typeof input.noEmitHelpers || $guard(exceptionable, {
+                    path: path + ".noEmitHelpers",
+                    expected: "(boolean | undefined)",
+                    value: input.noEmitHelpers
+                })) && (undefined === input.noEmitOnError || "boolean" === typeof input.noEmitOnError || $guard(exceptionable, {
+                    path: path + ".noEmitOnError",
+                    expected: "(boolean | undefined)",
+                    value: input.noEmitOnError
+                })) && (undefined === input.noErrorTruncation || "boolean" === typeof input.noErrorTruncation || $guard(exceptionable, {
+                    path: path + ".noErrorTruncation",
+                    expected: "(boolean | undefined)",
+                    value: input.noErrorTruncation
+                })) && (undefined === input.noFallthroughCasesInSwitch || "boolean" === typeof input.noFallthroughCasesInSwitch || $guard(exceptionable, {
+                    path: path + ".noFallthroughCasesInSwitch",
+                    expected: "(boolean | undefined)",
+                    value: input.noFallthroughCasesInSwitch
+                })) && (undefined === input.noImplicitAny || "boolean" === typeof input.noImplicitAny || $guard(exceptionable, {
+                    path: path + ".noImplicitAny",
+                    expected: "(boolean | undefined)",
+                    value: input.noImplicitAny
+                })) && (undefined === input.noImplicitReturns || "boolean" === typeof input.noImplicitReturns || $guard(exceptionable, {
+                    path: path + ".noImplicitReturns",
+                    expected: "(boolean | undefined)",
+                    value: input.noImplicitReturns
+                })) && (undefined === input.noImplicitThis || "boolean" === typeof input.noImplicitThis || $guard(exceptionable, {
+                    path: path + ".noImplicitThis",
+                    expected: "(boolean | undefined)",
+                    value: input.noImplicitThis
+                })) && (undefined === input.noStrictGenericChecks || "boolean" === typeof input.noStrictGenericChecks || $guard(exceptionable, {
+                    path: path + ".noStrictGenericChecks",
+                    expected: "(boolean | undefined)",
+                    value: input.noStrictGenericChecks
+                })) && (undefined === input.noUnusedLocals || "boolean" === typeof input.noUnusedLocals || $guard(exceptionable, {
+                    path: path + ".noUnusedLocals",
+                    expected: "(boolean | undefined)",
+                    value: input.noUnusedLocals
+                })) && (undefined === input.noUnusedParameters || "boolean" === typeof input.noUnusedParameters || $guard(exceptionable, {
+                    path: path + ".noUnusedParameters",
+                    expected: "(boolean | undefined)",
+                    value: input.noUnusedParameters
+                })) && (undefined === input.noImplicitUseStrict || "boolean" === typeof input.noImplicitUseStrict || $guard(exceptionable, {
+                    path: path + ".noImplicitUseStrict",
+                    expected: "(boolean | undefined)",
+                    value: input.noImplicitUseStrict
+                })) && (undefined === input.noPropertyAccessFromIndexSignature || "boolean" === typeof input.noPropertyAccessFromIndexSignature || $guard(exceptionable, {
+                    path: path + ".noPropertyAccessFromIndexSignature",
+                    expected: "(boolean | undefined)",
+                    value: input.noPropertyAccessFromIndexSignature
+                })) && (undefined === input.assumeChangesOnlyAffectDirectDependencies || "boolean" === typeof input.assumeChangesOnlyAffectDirectDependencies || $guard(exceptionable, {
+                    path: path + ".assumeChangesOnlyAffectDirectDependencies",
+                    expected: "(boolean | undefined)",
+                    value: input.assumeChangesOnlyAffectDirectDependencies
+                })) && (undefined === input.noLib || "boolean" === typeof input.noLib || $guard(exceptionable, {
+                    path: path + ".noLib",
+                    expected: "(boolean | undefined)",
+                    value: input.noLib
+                })) && (undefined === input.noResolve || "boolean" === typeof input.noResolve || $guard(exceptionable, {
+                    path: path + ".noResolve",
+                    expected: "(boolean | undefined)",
+                    value: input.noResolve
+                })) && (undefined === input.noUncheckedIndexedAccess || "boolean" === typeof input.noUncheckedIndexedAccess || $guard(exceptionable, {
+                    path: path + ".noUncheckedIndexedAccess",
+                    expected: "(boolean | undefined)",
+                    value: input.noUncheckedIndexedAccess
+                })) && (undefined === input.out || "string" === typeof input.out || $guard(exceptionable, {
+                    path: path + ".out",
+                    expected: "(string | undefined)",
+                    value: input.out
+                })) && (undefined === input.outDir || "string" === typeof input.outDir || $guard(exceptionable, {
+                    path: path + ".outDir",
+                    expected: "(string | undefined)",
+                    value: input.outDir
+                })) && (undefined === input.outFile || "string" === typeof input.outFile || $guard(exceptionable, {
+                    path: path + ".outFile",
+                    expected: "(string | undefined)",
+                    value: input.outFile
+                })) && (undefined === input.paths || ("object" === typeof input.paths && null !== input.paths || $guard(exceptionable, {
+                    path: path + ".paths",
+                    expected: "(Resolve<ts.MapLike<Array<string>>> | undefined)",
+                    value: input.paths
+                })) && $ao3(input.paths, path + ".paths", true && exceptionable)) && (undefined === input.preserveConstEnums || "boolean" === typeof input.preserveConstEnums || $guard(exceptionable, {
+                    path: path + ".preserveConstEnums",
+                    expected: "(boolean | undefined)",
+                    value: input.preserveConstEnums
+                })) && (undefined === input.noImplicitOverride || "boolean" === typeof input.noImplicitOverride || $guard(exceptionable, {
+                    path: path + ".noImplicitOverride",
+                    expected: "(boolean | undefined)",
+                    value: input.noImplicitOverride
+                })) && (undefined === input.preserveSymlinks || "boolean" === typeof input.preserveSymlinks || $guard(exceptionable, {
+                    path: path + ".preserveSymlinks",
+                    expected: "(boolean | undefined)",
+                    value: input.preserveSymlinks
+                })) && (undefined === input.preserveValueImports || "boolean" === typeof input.preserveValueImports || $guard(exceptionable, {
+                    path: path + ".preserveValueImports",
+                    expected: "(boolean | undefined)",
+                    value: input.preserveValueImports
+                })) && (undefined === input.project || "string" === typeof input.project || $guard(exceptionable, {
+                    path: path + ".project",
+                    expected: "(string | undefined)",
+                    value: input.project
+                })) && (undefined === input.reactNamespace || "string" === typeof input.reactNamespace || $guard(exceptionable, {
+                    path: path + ".reactNamespace",
+                    expected: "(string | undefined)",
+                    value: input.reactNamespace
+                })) && (undefined === input.jsxFactory || "string" === typeof input.jsxFactory || $guard(exceptionable, {
+                    path: path + ".jsxFactory",
+                    expected: "(string | undefined)",
+                    value: input.jsxFactory
+                })) && (undefined === input.jsxFragmentFactory || "string" === typeof input.jsxFragmentFactory || $guard(exceptionable, {
+                    path: path + ".jsxFragmentFactory",
+                    expected: "(string | undefined)",
+                    value: input.jsxFragmentFactory
+                })) && (undefined === input.jsxImportSource || "string" === typeof input.jsxImportSource || $guard(exceptionable, {
+                    path: path + ".jsxImportSource",
+                    expected: "(string | undefined)",
+                    value: input.jsxImportSource
+                })) && (undefined === input.composite || "boolean" === typeof input.composite || $guard(exceptionable, {
+                    path: path + ".composite",
+                    expected: "(boolean | undefined)",
+                    value: input.composite
+                })) && (undefined === input.incremental || "boolean" === typeof input.incremental || $guard(exceptionable, {
+                    path: path + ".incremental",
+                    expected: "(boolean | undefined)",
+                    value: input.incremental
+                })) && (undefined === input.tsBuildInfoFile || "string" === typeof input.tsBuildInfoFile || $guard(exceptionable, {
+                    path: path + ".tsBuildInfoFile",
+                    expected: "(string | undefined)",
+                    value: input.tsBuildInfoFile
+                })) && (undefined === input.removeComments || "boolean" === typeof input.removeComments || $guard(exceptionable, {
+                    path: path + ".removeComments",
+                    expected: "(boolean | undefined)",
+                    value: input.removeComments
+                })) && (undefined === input.rootDir || "string" === typeof input.rootDir || $guard(exceptionable, {
+                    path: path + ".rootDir",
+                    expected: "(string | undefined)",
+                    value: input.rootDir
+                })) && (undefined === input.rootDirs || (Array.isArray(input.rootDirs) || $guard(exceptionable, {
+                    path: path + ".rootDirs",
+                    expected: "(Array<string> | undefined)",
+                    value: input.rootDirs
+                })) && input.rootDirs.every((elem, index6) => "string" === typeof elem || $guard(exceptionable, {
+                    path: path + ".rootDirs[" + index6 + "]",
+                    expected: "string",
+                    value: elem
+                }))) && (undefined === input.skipLibCheck || "boolean" === typeof input.skipLibCheck || $guard(exceptionable, {
+                    path: path + ".skipLibCheck",
+                    expected: "(boolean | undefined)",
+                    value: input.skipLibCheck
+                })) && (undefined === input.skipDefaultLibCheck || "boolean" === typeof input.skipDefaultLibCheck || $guard(exceptionable, {
+                    path: path + ".skipDefaultLibCheck",
+                    expected: "(boolean | undefined)",
+                    value: input.skipDefaultLibCheck
+                })) && (undefined === input.sourceMap || "boolean" === typeof input.sourceMap || $guard(exceptionable, {
+                    path: path + ".sourceMap",
+                    expected: "(boolean | undefined)",
+                    value: input.sourceMap
+                })) && (undefined === input.sourceRoot || "string" === typeof input.sourceRoot || $guard(exceptionable, {
+                    path: path + ".sourceRoot",
+                    expected: "(string | undefined)",
+                    value: input.sourceRoot
+                })) && (undefined === input.strict || "boolean" === typeof input.strict || $guard(exceptionable, {
+                    path: path + ".strict",
+                    expected: "(boolean | undefined)",
+                    value: input.strict
+                })) && (undefined === input.strictFunctionTypes || "boolean" === typeof input.strictFunctionTypes || $guard(exceptionable, {
+                    path: path + ".strictFunctionTypes",
+                    expected: "(boolean | undefined)",
+                    value: input.strictFunctionTypes
+                })) && (undefined === input.strictBindCallApply || "boolean" === typeof input.strictBindCallApply || $guard(exceptionable, {
+                    path: path + ".strictBindCallApply",
+                    expected: "(boolean | undefined)",
+                    value: input.strictBindCallApply
+                })) && (undefined === input.strictNullChecks || "boolean" === typeof input.strictNullChecks || $guard(exceptionable, {
+                    path: path + ".strictNullChecks",
+                    expected: "(boolean | undefined)",
+                    value: input.strictNullChecks
+                })) && (undefined === input.strictPropertyInitialization || "boolean" === typeof input.strictPropertyInitialization || $guard(exceptionable, {
+                    path: path + ".strictPropertyInitialization",
+                    expected: "(boolean | undefined)",
+                    value: input.strictPropertyInitialization
+                })) && (undefined === input.stripInternal || "boolean" === typeof input.stripInternal || $guard(exceptionable, {
+                    path: path + ".stripInternal",
+                    expected: "(boolean | undefined)",
+                    value: input.stripInternal
+                })) && (undefined === input.suppressExcessPropertyErrors || "boolean" === typeof input.suppressExcessPropertyErrors || $guard(exceptionable, {
+                    path: path + ".suppressExcessPropertyErrors",
+                    expected: "(boolean | undefined)",
+                    value: input.suppressExcessPropertyErrors
+                })) && (undefined === input.suppressImplicitAnyIndexErrors || "boolean" === typeof input.suppressImplicitAnyIndexErrors || $guard(exceptionable, {
+                    path: path + ".suppressImplicitAnyIndexErrors",
+                    expected: "(boolean | undefined)",
+                    value: input.suppressImplicitAnyIndexErrors
+                })) && true && (undefined === input.traceResolution || "boolean" === typeof input.traceResolution || $guard(exceptionable, {
+                    path: path + ".traceResolution",
+                    expected: "(boolean | undefined)",
+                    value: input.traceResolution
+                })) && (undefined === input.useUnknownInCatchVariables || "boolean" === typeof input.useUnknownInCatchVariables || $guard(exceptionable, {
+                    path: path + ".useUnknownInCatchVariables",
+                    expected: "(boolean | undefined)",
+                    value: input.useUnknownInCatchVariables
+                })) && (undefined === input.resolveJsonModule || "boolean" === typeof input.resolveJsonModule || $guard(exceptionable, {
+                    path: path + ".resolveJsonModule",
+                    expected: "(boolean | undefined)",
+                    value: input.resolveJsonModule
+                })) && (undefined === input.types || (Array.isArray(input.types) || $guard(exceptionable, {
+                    path: path + ".types",
+                    expected: "(Array<string> | undefined)",
+                    value: input.types
+                })) && input.types.every((elem, index7) => "string" === typeof elem || $guard(exceptionable, {
+                    path: path + ".types[" + index7 + "]",
+                    expected: "string",
+                    value: elem
+                }))) && (undefined === input.typeRoots || (Array.isArray(input.typeRoots) || $guard(exceptionable, {
+                    path: path + ".typeRoots",
+                    expected: "(Array<string> | undefined)",
+                    value: input.typeRoots
+                })) && input.typeRoots.every((elem, index8) => "string" === typeof elem || $guard(exceptionable, {
+                    path: path + ".typeRoots[" + index8 + "]",
+                    expected: "string",
+                    value: elem
+                }))) && (undefined === input.esModuleInterop || "boolean" === typeof input.esModuleInterop || $guard(exceptionable, {
+                    path: path + ".esModuleInterop",
+                    expected: "(boolean | undefined)",
+                    value: input.esModuleInterop
+                })) && (undefined === input.useDefineForClassFields || "boolean" === typeof input.useDefineForClassFields || $guard(exceptionable, {
+                    path: path + ".useDefineForClassFields",
+                    expected: "(boolean | undefined)",
+                    value: input.useDefineForClassFields
+                })) && (false === exceptionable || Object.keys(input).every(key => {
+                    const value = input[key];
+                    if (undefined === value)
+                        return true;
+                    if (RegExp(/(.*)/).test(key))
+                        return true;
+                    return true;
+                }));
+                const $ao3 = (input, path, exceptionable) => false === exceptionable || Object.keys(input).every(key => {
+                    const value = input[key];
+                    if (undefined === value)
+                        return true;
+                    if (RegExp(/(.*)/).test(key))
+                        return (Array.isArray(value) || $guard(exceptionable, {
+                            path: path + $join(key),
+                            expected: "Array<string>",
+                            value: value
+                        })) && value.every((elem, index9) => "string" === typeof elem || $guard(exceptionable, {
+                            path: path + $join(key) + "[" + index9 + "]",
+                            expected: "string",
+                            value: elem
+                        }));
+                    return true;
+                });
+                const $ao4 = (input, path, exceptionable) => "string" === typeof input.output || $guard(exceptionable, {
+                    path: path + ".output",
+                    expected: "string",
+                    value: input.output
+                });
+                return ("object" === typeof input && null !== input || $guard(true, {
+                    path: path + "",
+                    expected: "Resolve<INestiaConfig>",
+                    value: input
+                })) && $ao0(input, path + "", true);
+            })(input, "$input", true);
+            return input;
+        })(cloned);
+    }));
+})(NestiaSdkConfig = exports.NestiaSdkConfig || (exports.NestiaSdkConfig = {}));
+//# sourceMappingURL=NestiaSdkConfig.js.map

package/lib/executable/internal/NestiaSdkConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NestiaSdkConfig.js","sourceRoot":"","sources":["../../../src/executable/internal/NestiaSdkConfig.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4CAAoB;AACpB,gDAAwB;AACxB,gDAAkC;AAClC,qDAAkD;AAClD,iCAA+B;AAI/B,IAAiB,eAAe,CA0B/B;AA1BD,WAAiB,eAAe;IAC5B,SAAgB,GAAG;QACf,OAAO,SAAS,CAAC,GAAG,EAAE,CAAC;IAC3B,CAAC;IAFe,mBAAG,MAElB,CAAA;IAED,MAAM,SAAS,GAAG,IAAI,qBAAS,CAAC,GAAS,EAAE;;QACvC,IAAI,YAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC,KAAK,KAAK;YAAE,OAAO,IAAI,CAAC;QAE7D,MAAM,CAAC,QAAQ,CAAC;YACZ,IAAI,EAAE,KAAK;YACX,eAAe,EAAE;gBACb,MAAM,EAAE,UAAU;gBAClB,MAAM,EAAE,IAAI;aACf;SACJ,CAAC,CAAC;QAEH,MAAM,MAAM,GACR,YAAa,cAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,0DAAC,CAAC;QACnD,IAAI,OAAO,MAAM,KAAK,QAAQ;YAC1B,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QAExE,MAAM,MAAM,GACR,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;QACjE,MAAM,MAAM,GAAkB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QACjE;2BAAO,cAAM;0BAAN,cAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAC,MAAM,EAAE;IAC1B,CAAC,CAAA,CAAC,CAAC;AACP,CAAC,EA1BgB,eAAe,GAAf,uBAAe,KAAf,uBAAe,QA0B/B"}

package/lib/executable/internal/nestia.config.getter.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/executable/internal/nestia.config.getter.js

@@ -0,0 +1,24 @@
+"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 });
+const WorkerServer_1 = require("tgrid/protocols/workers/WorkerServer");
+const NestiaSdkConfig_1 = require("./NestiaSdkConfig");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = new WorkerServer_1.WorkerServer();
+        yield worker.open(NestiaSdkConfig_1.NestiaSdkConfig);
+    });
+}
+main().catch((exp) => {
+    console.log(exp);
+    process.exit(-1);
+});
+//# sourceMappingURL=nestia.config.getter.js.map

package/lib/executable/internal/nestia.config.getter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestia.config.getter.js","sourceRoot":"","sources":["../../../src/executable/internal/nestia.config.getter.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,uEAAoE;AAEpE,uDAAoD;AAEpD,SAAe,IAAI;;QACf,MAAM,MAAM,GAAG,IAAI,2BAAY,EAAE,CAAC;QAClC,MAAM,MAAM,CAAC,IAAI,CAAC,iCAAe,CAAC,CAAC;IACvC,CAAC;CAAA;AACD,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACjB,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AACrB,CAAC,CAAC,CAAC"}

package/lib/executable/sdk.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};