nestia 2.1.13 → 2.2.0-dev.20220625

package/lib/executable/internal/NestiaConfig.js

@@ -58,17 +58,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __values = (this && this.__values) || function(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.");
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -77,10 +66,9 @@ exports.NestiaConfig = void 0;
 var fs_1 = __importDefault(require("fs"));
 var path_1 = __importDefault(require("path"));
 var runner = __importStar(require("ts-node"));
-var InvalidArgument_1 = require("tstl/exception/InvalidArgument");
 var nestia_fetcher_1 = require("nestia-fetcher");
 var Singleton_1 = require("tstl/thread/Singleton");
-var typescript_is_1 = require("typescript-is");
+var typescript_json_1 = require("typescript-json");
 var NestiaConfig;
 (function (NestiaConfig) {
     var _this = this;
@@ -88,166 +76,8 @@ var NestiaConfig;
         return singleton.get();
     }
     NestiaConfig.get = get;
-    function assert(config) {
-        (0, typescript_is_1.assertType)(config, function (object) { var path = ["config"]; function _undefined(object) { ; if (object !== undefined)
-            return { message: "validation failed at " + path.join(".") + ": expected undefined", path: path.slice(), reason: { type: "undefined" } };
-        else
-            return null; } function _string(object) { ; if (typeof object !== "string")
-            return { message: "validation failed at " + path.join(".") + ": expected a string", path: path.slice(), reason: { type: "string" } };
-        else
-            return null; } function _null(object) { ; if (object !== null)
-            return { message: "validation failed at " + path.join(".") + ": expected null", path: path.slice(), reason: { type: "null" } };
-        else
-            return null; } function su__undefined__string_eu(object) {
-            var e_1, _a;
-            var conditions = [_undefined, _string];
-            try {
-                for (var conditions_1 = __values(conditions), conditions_1_1 = conditions_1.next(); !conditions_1_1.done; conditions_1_1 = conditions_1.next()) {
-                    var condition = conditions_1_1.value;
-                    var error = condition(object);
-                    if (!error)
-                        return null;
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (conditions_1_1 && !conditions_1_1.done && (_a = conditions_1.return)) _a.call(conditions_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            return { message: "validation failed at " + path.join(".") + ": there are no valid alternatives", path: path.slice(), reason: { type: "union" } };
-        } function _false(object) { ; if (object !== false)
-            return { message: "validation failed at " + path.join(".") + ": expected false", path: path.slice(), reason: { type: "boolean-literal", value: false } };
-        else
-            return null; } function _true(object) { ; if (object !== true)
-            return { message: "validation failed at " + path.join(".") + ": expected true", path: path.slice(), reason: { type: "boolean-literal", value: true } };
-        else
-            return null; } function su__undefined__5__6_eu(object) {
-            var e_2, _a;
-            var conditions = [_undefined, _false, _true];
-            try {
-                for (var conditions_2 = __values(conditions), conditions_2_1 = conditions_2.next(); !conditions_2_1.done; conditions_2_1 = conditions_2.next()) {
-                    var condition = conditions_2_1.value;
-                    var error = condition(object);
-                    if (!error)
-                        return null;
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (conditions_2_1 && !conditions_2_1.done && (_a = conditions_2.return)) _a.call(conditions_2);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            return { message: "validation failed at " + path.join(".") + ": there are no valid alternatives", path: path.slice(), reason: { type: "union" } };
-        } function _8(object) { ; if (typeof object !== "object" || object === null || Array.isArray(object))
-            return { message: "validation failed at " + path.join(".") + ": expected an object", path: path.slice(), reason: { type: "object" } }; {
-            if ("output" in object) {
-                path.push("output");
-                var error = _string(object["output"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-            else
-                return { message: "validation failed at " + path.join(".") + ": expected 'output' in object", path: path.slice(), reason: { type: "missing-property", property: "output" } };
-        } return null; } function su__undefined__8_eu(object) {
-            var e_3, _a;
-            var conditions = [_undefined, _8];
-            try {
-                for (var conditions_3 = __values(conditions), conditions_3_1 = conditions_3.next(); !conditions_3_1.done; conditions_3_1 = conditions_3.next()) {
-                    var condition = conditions_3_1.value;
-                    var error = condition(object);
-                    if (!error)
-                        return null;
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (conditions_3_1 && !conditions_3_1.done && (_a = conditions_3.return)) _a.call(conditions_3);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            return { message: "validation failed at " + path.join(".") + ": there are no valid alternatives", path: path.slice(), reason: { type: "union" } };
-        } function _0(object) { ; if (typeof object !== "object" || object === null || Array.isArray(object))
-            return { message: "validation failed at " + path.join(".") + ": expected an object", path: path.slice(), reason: { type: "object" } }; {
-            if ("output" in object) {
-                path.push("output");
-                var error = su__undefined__string_eu(object["output"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-        } {
-            if ("assert" in object) {
-                path.push("assert");
-                var error = su__undefined__5__6_eu(object["assert"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-        } {
-            if ("json" in object) {
-                path.push("json");
-                var error = su__undefined__5__6_eu(object["json"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-        } {
-            if ("swagger" in object) {
-                path.push("swagger");
-                var error = su__undefined__8_eu(object["swagger"]);
-                path.pop();
-                if (error)
-                    return error;
-            }
-        } return null; } return _0(object); });
-        if ((0, typescript_is_1.is)(config.input, function (object) { function _string(object) { ; if (typeof object !== "string")
-            return {};
-        else
-            return null; } return _string(object); }) === false &&
-            (0, typescript_is_1.is)(config.input, function (object) { function _string(object) { ; if (typeof object !== "string")
-                return {};
-            else
-                return null; } function sa__string_ea_2(object) { ; if (!Array.isArray(object))
-                return {}; for (var i = 0; i < object.length; i++) {
-                var error = _string(object[i]);
-                if (error)
-                    return error;
-            } return null; } return sa__string_ea_2(object); }) === false &&
-            (0, typescript_is_1.is)(config.input, function (object) { function _string(object) { ; if (typeof object !== "string")
-                return {};
-            else
-                return null; } function sa__string_ea_3(object) { ; if (!Array.isArray(object))
-                return {}; for (var i = 0; i < object.length; i++) {
-                var error = _string(object[i]);
-                if (error)
-                    return error;
-            } return null; } function _0(object) { ; if (typeof object !== "object" || object === null || Array.isArray(object))
-                return {}; {
-                if ("include" in object) {
-                    var error = sa__string_ea_3(object["include"]);
-                    if (error)
-                        return error;
-                }
-                else
-                    return {};
-            } {
-                if ("exclude" in object) {
-                    var error = sa__string_ea_3(object["exclude"]);
-                    if (error)
-                        return error;
-                }
-            } return null; } return _0(object); }) === false)
-            throw new InvalidArgument_1.InvalidArgument("Error on NestiaConfig.get(): invalid input type.");
-        return config;
-    }
     var singleton = new Singleton_1.Singleton(function () { return __awaiter(_this, void 0, void 0, function () {
-        var config, trial;
+        var loaded, config;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -261,18 +91,576 @@ var NestiaConfig;
                     });
                     return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require(path_1.default.resolve("nestia.config.ts"))); })];
                 case 1:
-                    config = _a.sent();
-                    try {
-                        return [2 /*return*/, assert(nestia_fetcher_1.Primitive.clone(config))];
-                    }
-                    catch (exp) {
-                        trial = config;
-                        if (trial.default && typeof trial.default === "object")
-                            return [2 /*return*/, assert(nestia_fetcher_1.Primitive.clone(trial.default))];
-                        else
-                            throw exp;
-                    }
-                    return [2 /*return*/];
+                    loaded = _a.sent();
+                    if (typeof loaded !== "object")
+                        throw new Error("Error on NestiaConfig.get(): failed to load data");
+                    config = typeof loaded.default === "object" ? loaded.default : loaded;
+                    return [2 /*return*/, (function (input) { (function (input, path) {
+                            if (path === void 0) { path = "$input"; }
+                            var assert = [
+                                function (input, path, exceptionable) { return true && (true && null !== input.input && undefined !== input.input && (false || typeof input.input === "string" || Array.isArray(input.input) && (false || input.input.every(function (elem, index) { return true && null !== elem && undefined !== elem && typeof elem === "string"; })) || true && null !== input.input && typeof input.input === "object" && assert[1](input.input, path + ".input", false && exceptionable))) && (function () {
+                                    var success = true && null !== input.output && (false || undefined === input.output || typeof input.output === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".output\"", input.output);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.compilerOptions && (false || undefined === input.compilerOptions || true && null !== input.compilerOptions && typeof input.compilerOptions === "object" && assert[2](input.compilerOptions, path + ".compilerOptions", true && exceptionable));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".compilerOptions\"", input.compilerOptions);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.assert && (false || undefined === input.assert || false === input.assert || true === input.assert);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".assert\"", input.assert);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.json && (false || undefined === input.json || false === input.json || true === input.json);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".json\"", input.json);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.swagger && (false || undefined === input.swagger || true && null !== input.swagger && typeof input.swagger === "object" && assert[4](input.swagger, path + ".swagger", true && exceptionable));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".swagger\"", input.swagger);
+                                    return success;
+                                })(); },
+                                function (input, path, exceptionable) { return true && (function () {
+                                    var success = true && null !== input.include && undefined !== input.include && (Array.isArray(input.include) && (false || input.include.every(function (elem, index) { return (function () {
+                                        var success = true && null !== elem && undefined !== elem && typeof elem === "string";
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".include[\" + index + \"]\"", elem);
+                                        return success;
+                                    })(); })));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".include\"", input.include);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.exclude && (false || undefined === input.exclude || Array.isArray(input.exclude) && (false || input.exclude.every(function (elem, index) { return (function () {
+                                        var success = true && null !== elem && undefined !== elem && typeof elem === "string";
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".exclude[\" + index + \"]\"", elem);
+                                        return success;
+                                    })(); })));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".exclude\"", input.exclude);
+                                    return success;
+                                })(); },
+                                function (input, path, exceptionable) { return true && (function () {
+                                    var success = true && null !== input.allowJs && (false || undefined === input.allowJs || false === input.allowJs || true === input.allowJs);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".allowJs\"", input.allowJs);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.allowSyntheticDefaultImports && (false || undefined === input.allowSyntheticDefaultImports || false === input.allowSyntheticDefaultImports || true === input.allowSyntheticDefaultImports);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".allowSyntheticDefaultImports\"", input.allowSyntheticDefaultImports);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.allowUmdGlobalAccess && (false || undefined === input.allowUmdGlobalAccess || false === input.allowUmdGlobalAccess || true === input.allowUmdGlobalAccess);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".allowUmdGlobalAccess\"", input.allowUmdGlobalAccess);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.allowUnreachableCode && (false || undefined === input.allowUnreachableCode || false === input.allowUnreachableCode || true === input.allowUnreachableCode);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".allowUnreachableCode\"", input.allowUnreachableCode);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.allowUnusedLabels && (false || undefined === input.allowUnusedLabels || false === input.allowUnusedLabels || true === input.allowUnusedLabels);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".allowUnusedLabels\"", input.allowUnusedLabels);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.alwaysStrict && (false || undefined === input.alwaysStrict || false === input.alwaysStrict || true === input.alwaysStrict);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".alwaysStrict\"", input.alwaysStrict);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.baseUrl && (false || undefined === input.baseUrl || typeof input.baseUrl === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".baseUrl\"", input.baseUrl);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.charset && (false || undefined === input.charset || typeof input.charset === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".charset\"", input.charset);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.checkJs && (false || undefined === input.checkJs || false === input.checkJs || true === input.checkJs);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".checkJs\"", input.checkJs);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.declaration && (false || undefined === input.declaration || false === input.declaration || true === input.declaration);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".declaration\"", input.declaration);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.declarationMap && (false || undefined === input.declarationMap || false === input.declarationMap || true === input.declarationMap);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".declarationMap\"", input.declarationMap);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.emitDeclarationOnly && (false || undefined === input.emitDeclarationOnly || false === input.emitDeclarationOnly || true === input.emitDeclarationOnly);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".emitDeclarationOnly\"", input.emitDeclarationOnly);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.declarationDir && (false || undefined === input.declarationDir || typeof input.declarationDir === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".declarationDir\"", input.declarationDir);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.disableSizeLimit && (false || undefined === input.disableSizeLimit || false === input.disableSizeLimit || true === input.disableSizeLimit);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".disableSizeLimit\"", input.disableSizeLimit);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.disableSourceOfProjectReferenceRedirect && (false || undefined === input.disableSourceOfProjectReferenceRedirect || false === input.disableSourceOfProjectReferenceRedirect || true === input.disableSourceOfProjectReferenceRedirect);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".disableSourceOfProjectReferenceRedirect\"", input.disableSourceOfProjectReferenceRedirect);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.disableSolutionSearching && (false || undefined === input.disableSolutionSearching || false === input.disableSolutionSearching || true === input.disableSolutionSearching);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".disableSolutionSearching\"", input.disableSolutionSearching);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.disableReferencedProjectLoad && (false || undefined === input.disableReferencedProjectLoad || false === input.disableReferencedProjectLoad || true === input.disableReferencedProjectLoad);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".disableReferencedProjectLoad\"", input.disableReferencedProjectLoad);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.downlevelIteration && (false || undefined === input.downlevelIteration || false === input.downlevelIteration || true === input.downlevelIteration);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".downlevelIteration\"", input.downlevelIteration);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.emitBOM && (false || undefined === input.emitBOM || false === input.emitBOM || true === input.emitBOM);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".emitBOM\"", input.emitBOM);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.emitDecoratorMetadata && (false || undefined === input.emitDecoratorMetadata || false === input.emitDecoratorMetadata || true === input.emitDecoratorMetadata);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".emitDecoratorMetadata\"", input.emitDecoratorMetadata);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.exactOptionalPropertyTypes && (false || undefined === input.exactOptionalPropertyTypes || false === input.exactOptionalPropertyTypes || true === input.exactOptionalPropertyTypes);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".exactOptionalPropertyTypes\"", input.exactOptionalPropertyTypes);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.experimentalDecorators && (false || undefined === input.experimentalDecorators || false === input.experimentalDecorators || true === input.experimentalDecorators);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".experimentalDecorators\"", input.experimentalDecorators);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.forceConsistentCasingInFileNames && (false || undefined === input.forceConsistentCasingInFileNames || false === input.forceConsistentCasingInFileNames || true === input.forceConsistentCasingInFileNames);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".forceConsistentCasingInFileNames\"", input.forceConsistentCasingInFileNames);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.importHelpers && (false || undefined === input.importHelpers || false === input.importHelpers || true === input.importHelpers);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".importHelpers\"", input.importHelpers);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.importsNotUsedAsValues && (false || undefined === input.importsNotUsedAsValues || 0 === input.importsNotUsedAsValues || 1 === input.importsNotUsedAsValues || 2 === input.importsNotUsedAsValues);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".importsNotUsedAsValues\"", input.importsNotUsedAsValues);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.inlineSourceMap && (false || undefined === input.inlineSourceMap || false === input.inlineSourceMap || true === input.inlineSourceMap);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".inlineSourceMap\"", input.inlineSourceMap);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.inlineSources && (false || undefined === input.inlineSources || false === input.inlineSources || true === input.inlineSources);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".inlineSources\"", input.inlineSources);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.isolatedModules && (false || undefined === input.isolatedModules || false === input.isolatedModules || true === input.isolatedModules);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".isolatedModules\"", input.isolatedModules);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.jsx && (false || undefined === input.jsx || 0 === input.jsx || 1 === input.jsx || 2 === input.jsx || 3 === input.jsx || 4 === input.jsx || 5 === input.jsx);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".jsx\"", input.jsx);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.keyofStringsOnly && (false || undefined === input.keyofStringsOnly || false === input.keyofStringsOnly || true === input.keyofStringsOnly);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".keyofStringsOnly\"", input.keyofStringsOnly);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.lib && (false || undefined === input.lib || Array.isArray(input.lib) && (false || input.lib.every(function (elem, index) { return (function () {
+                                        var success = true && null !== elem && undefined !== elem && typeof elem === "string";
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".lib[\" + index + \"]\"", elem);
+                                        return success;
+                                    })(); })));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".lib\"", input.lib);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.locale && (false || undefined === input.locale || typeof input.locale === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".locale\"", input.locale);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.mapRoot && (false || undefined === input.mapRoot || typeof input.mapRoot === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".mapRoot\"", input.mapRoot);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.maxNodeModuleJsDepth && (false || undefined === input.maxNodeModuleJsDepth || typeof input.maxNodeModuleJsDepth === "number");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".maxNodeModuleJsDepth\"", input.maxNodeModuleJsDepth);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.module && (false || undefined === input.module || 0 === input.module || 1 === input.module || 2 === input.module || 3 === input.module || 4 === input.module || 5 === input.module || 6 === input.module || 7 === input.module || 99 === input.module || 100 === input.module || 199 === input.module);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".module\"", input.module);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.moduleResolution && (false || undefined === input.moduleResolution || 1 === input.moduleResolution || 2 === input.moduleResolution || 3 === input.moduleResolution || 99 === input.moduleResolution);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".moduleResolution\"", input.moduleResolution);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.moduleSuffixes && (false || undefined === input.moduleSuffixes || Array.isArray(input.moduleSuffixes) && (false || input.moduleSuffixes.every(function (elem, index) { return (function () {
+                                        var success = true && null !== elem && undefined !== elem && typeof elem === "string";
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".moduleSuffixes[\" + index + \"]\"", elem);
+                                        return success;
+                                    })(); })));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".moduleSuffixes\"", input.moduleSuffixes);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.moduleDetection && (false || undefined === input.moduleDetection || 1 === input.moduleDetection || 2 === input.moduleDetection || 3 === input.moduleDetection);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".moduleDetection\"", input.moduleDetection);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.newLine && (false || undefined === input.newLine || 0 === input.newLine || 1 === input.newLine);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".newLine\"", input.newLine);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noEmit && (false || undefined === input.noEmit || false === input.noEmit || true === input.noEmit);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noEmit\"", input.noEmit);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noEmitHelpers && (false || undefined === input.noEmitHelpers || false === input.noEmitHelpers || true === input.noEmitHelpers);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noEmitHelpers\"", input.noEmitHelpers);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noEmitOnError && (false || undefined === input.noEmitOnError || false === input.noEmitOnError || true === input.noEmitOnError);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noEmitOnError\"", input.noEmitOnError);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noErrorTruncation && (false || undefined === input.noErrorTruncation || false === input.noErrorTruncation || true === input.noErrorTruncation);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noErrorTruncation\"", input.noErrorTruncation);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noFallthroughCasesInSwitch && (false || undefined === input.noFallthroughCasesInSwitch || false === input.noFallthroughCasesInSwitch || true === input.noFallthroughCasesInSwitch);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noFallthroughCasesInSwitch\"", input.noFallthroughCasesInSwitch);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noImplicitAny && (false || undefined === input.noImplicitAny || false === input.noImplicitAny || true === input.noImplicitAny);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noImplicitAny\"", input.noImplicitAny);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noImplicitReturns && (false || undefined === input.noImplicitReturns || false === input.noImplicitReturns || true === input.noImplicitReturns);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noImplicitReturns\"", input.noImplicitReturns);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noImplicitThis && (false || undefined === input.noImplicitThis || false === input.noImplicitThis || true === input.noImplicitThis);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noImplicitThis\"", input.noImplicitThis);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noStrictGenericChecks && (false || undefined === input.noStrictGenericChecks || false === input.noStrictGenericChecks || true === input.noStrictGenericChecks);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noStrictGenericChecks\"", input.noStrictGenericChecks);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noUnusedLocals && (false || undefined === input.noUnusedLocals || false === input.noUnusedLocals || true === input.noUnusedLocals);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noUnusedLocals\"", input.noUnusedLocals);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noUnusedParameters && (false || undefined === input.noUnusedParameters || false === input.noUnusedParameters || true === input.noUnusedParameters);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noUnusedParameters\"", input.noUnusedParameters);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noImplicitUseStrict && (false || undefined === input.noImplicitUseStrict || false === input.noImplicitUseStrict || true === input.noImplicitUseStrict);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noImplicitUseStrict\"", input.noImplicitUseStrict);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noPropertyAccessFromIndexSignature && (false || undefined === input.noPropertyAccessFromIndexSignature || false === input.noPropertyAccessFromIndexSignature || true === input.noPropertyAccessFromIndexSignature);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noPropertyAccessFromIndexSignature\"", input.noPropertyAccessFromIndexSignature);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.assumeChangesOnlyAffectDirectDependencies && (false || undefined === input.assumeChangesOnlyAffectDirectDependencies || false === input.assumeChangesOnlyAffectDirectDependencies || true === input.assumeChangesOnlyAffectDirectDependencies);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".assumeChangesOnlyAffectDirectDependencies\"", input.assumeChangesOnlyAffectDirectDependencies);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noLib && (false || undefined === input.noLib || false === input.noLib || true === input.noLib);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noLib\"", input.noLib);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noResolve && (false || undefined === input.noResolve || false === input.noResolve || true === input.noResolve);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noResolve\"", input.noResolve);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noUncheckedIndexedAccess && (false || undefined === input.noUncheckedIndexedAccess || false === input.noUncheckedIndexedAccess || true === input.noUncheckedIndexedAccess);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noUncheckedIndexedAccess\"", input.noUncheckedIndexedAccess);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.out && (false || undefined === input.out || typeof input.out === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".out\"", input.out);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.outDir && (false || undefined === input.outDir || typeof input.outDir === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".outDir\"", input.outDir);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.outFile && (false || undefined === input.outFile || typeof input.outFile === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".outFile\"", input.outFile);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.paths && (false || undefined === input.paths || true && null !== input.paths && typeof input.paths === "object" && assert[3](input.paths, path + ".paths", true && exceptionable));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".paths\"", input.paths);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.preserveConstEnums && (false || undefined === input.preserveConstEnums || false === input.preserveConstEnums || true === input.preserveConstEnums);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".preserveConstEnums\"", input.preserveConstEnums);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.noImplicitOverride && (false || undefined === input.noImplicitOverride || false === input.noImplicitOverride || true === input.noImplicitOverride);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".noImplicitOverride\"", input.noImplicitOverride);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.preserveSymlinks && (false || undefined === input.preserveSymlinks || false === input.preserveSymlinks || true === input.preserveSymlinks);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".preserveSymlinks\"", input.preserveSymlinks);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.preserveValueImports && (false || undefined === input.preserveValueImports || false === input.preserveValueImports || true === input.preserveValueImports);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".preserveValueImports\"", input.preserveValueImports);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.project && (false || undefined === input.project || typeof input.project === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".project\"", input.project);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.reactNamespace && (false || undefined === input.reactNamespace || typeof input.reactNamespace === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".reactNamespace\"", input.reactNamespace);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.jsxFactory && (false || undefined === input.jsxFactory || typeof input.jsxFactory === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".jsxFactory\"", input.jsxFactory);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.jsxFragmentFactory && (false || undefined === input.jsxFragmentFactory || typeof input.jsxFragmentFactory === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".jsxFragmentFactory\"", input.jsxFragmentFactory);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.jsxImportSource && (false || undefined === input.jsxImportSource || typeof input.jsxImportSource === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".jsxImportSource\"", input.jsxImportSource);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.composite && (false || undefined === input.composite || false === input.composite || true === input.composite);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".composite\"", input.composite);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.incremental && (false || undefined === input.incremental || false === input.incremental || true === input.incremental);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".incremental\"", input.incremental);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.tsBuildInfoFile && (false || undefined === input.tsBuildInfoFile || typeof input.tsBuildInfoFile === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".tsBuildInfoFile\"", input.tsBuildInfoFile);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.removeComments && (false || undefined === input.removeComments || false === input.removeComments || true === input.removeComments);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".removeComments\"", input.removeComments);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.rootDir && (false || undefined === input.rootDir || typeof input.rootDir === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".rootDir\"", input.rootDir);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.rootDirs && (false || undefined === input.rootDirs || Array.isArray(input.rootDirs) && (false || input.rootDirs.every(function (elem, index) { return (function () {
+                                        var success = true && null !== elem && undefined !== elem && typeof elem === "string";
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".rootDirs[\" + index + \"]\"", elem);
+                                        return success;
+                                    })(); })));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".rootDirs\"", input.rootDirs);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.skipLibCheck && (false || undefined === input.skipLibCheck || false === input.skipLibCheck || true === input.skipLibCheck);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".skipLibCheck\"", input.skipLibCheck);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.skipDefaultLibCheck && (false || undefined === input.skipDefaultLibCheck || false === input.skipDefaultLibCheck || true === input.skipDefaultLibCheck);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".skipDefaultLibCheck\"", input.skipDefaultLibCheck);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.sourceMap && (false || undefined === input.sourceMap || false === input.sourceMap || true === input.sourceMap);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".sourceMap\"", input.sourceMap);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.sourceRoot && (false || undefined === input.sourceRoot || typeof input.sourceRoot === "string");
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".sourceRoot\"", input.sourceRoot);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.strict && (false || undefined === input.strict || false === input.strict || true === input.strict);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".strict\"", input.strict);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.strictFunctionTypes && (false || undefined === input.strictFunctionTypes || false === input.strictFunctionTypes || true === input.strictFunctionTypes);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".strictFunctionTypes\"", input.strictFunctionTypes);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.strictBindCallApply && (false || undefined === input.strictBindCallApply || false === input.strictBindCallApply || true === input.strictBindCallApply);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".strictBindCallApply\"", input.strictBindCallApply);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.strictNullChecks && (false || undefined === input.strictNullChecks || false === input.strictNullChecks || true === input.strictNullChecks);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".strictNullChecks\"", input.strictNullChecks);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.strictPropertyInitialization && (false || undefined === input.strictPropertyInitialization || false === input.strictPropertyInitialization || true === input.strictPropertyInitialization);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".strictPropertyInitialization\"", input.strictPropertyInitialization);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.stripInternal && (false || undefined === input.stripInternal || false === input.stripInternal || true === input.stripInternal);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".stripInternal\"", input.stripInternal);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.suppressExcessPropertyErrors && (false || undefined === input.suppressExcessPropertyErrors || false === input.suppressExcessPropertyErrors || true === input.suppressExcessPropertyErrors);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".suppressExcessPropertyErrors\"", input.suppressExcessPropertyErrors);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.suppressImplicitAnyIndexErrors && (false || undefined === input.suppressImplicitAnyIndexErrors || false === input.suppressImplicitAnyIndexErrors || true === input.suppressImplicitAnyIndexErrors);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".suppressImplicitAnyIndexErrors\"", input.suppressImplicitAnyIndexErrors);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.target && (false || undefined === input.target || 0 === input.target || 1 === input.target || 2 === input.target || 3 === input.target || 4 === input.target || 5 === input.target || 6 === input.target || 7 === input.target || 8 === input.target || 9 === input.target || 99 === input.target || 100 === input.target);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".target\"", input.target);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.traceResolution && (false || undefined === input.traceResolution || false === input.traceResolution || true === input.traceResolution);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".traceResolution\"", input.traceResolution);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.useUnknownInCatchVariables && (false || undefined === input.useUnknownInCatchVariables || false === input.useUnknownInCatchVariables || true === input.useUnknownInCatchVariables);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".useUnknownInCatchVariables\"", input.useUnknownInCatchVariables);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.resolveJsonModule && (false || undefined === input.resolveJsonModule || false === input.resolveJsonModule || true === input.resolveJsonModule);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".resolveJsonModule\"", input.resolveJsonModule);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.types && (false || undefined === input.types || Array.isArray(input.types) && (false || input.types.every(function (elem, index) { return (function () {
+                                        var success = true && null !== elem && undefined !== elem && typeof elem === "string";
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".types[\" + index + \"]\"", elem);
+                                        return success;
+                                    })(); })));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".types\"", input.types);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.typeRoots && (false || undefined === input.typeRoots || Array.isArray(input.typeRoots) && (false || input.typeRoots.every(function (elem, index) { return (function () {
+                                        var success = true && null !== elem && undefined !== elem && typeof elem === "string";
+                                        if (success === false && exceptionable === true)
+                                            throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".typeRoots[\" + index + \"]\"", elem);
+                                        return success;
+                                    })(); })));
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".typeRoots\"", input.typeRoots);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.esModuleInterop && (false || undefined === input.esModuleInterop || false === input.esModuleInterop || true === input.esModuleInterop);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".esModuleInterop\"", input.esModuleInterop);
+                                    return success;
+                                })() && (function () {
+                                    var success = true && null !== input.useDefineForClassFields && (false || undefined === input.useDefineForClassFields || false === input.useDefineForClassFields || true === input.useDefineForClassFields);
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".useDefineForClassFields\"", input.useDefineForClassFields);
+                                    return success;
+                                })(); },
+                                function (input, path, exceptionable) { return true; },
+                                function (input, path, exceptionable) { return true && (function () {
+                                    var success = true && null !== input.output && undefined !== input.output && typeof input.output === "string";
+                                    if (success === false && exceptionable === true)
+                                        throw new typescript_json_1.assert.TypeGuardError("assert", "path + \".output\"", input.output);
+                                    return success;
+                                })(); }
+                            ];
+                            return (function () {
+                                var success = true && null !== input && undefined !== input && (true && null !== input && typeof input === "object" && assert[0](input, path + "", true));
+                                if (success === false && exceptionable === true)
+                                    throw new typescript_json_1.assert.TypeGuardError("assert", "path + \"\"", input);
+                                return success;
+                            })();
+                        })(input); return input; })(nestia_fetcher_1.Primitive.clone(config))];
             }
         });
     }); });