npm - tenable-universal-layout - Versions diffs - 0.0.1-security → 7.20.13 - Mend

tenable-universal-layout 0.0.1-security → 7.20.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of tenable-universal-layout might be problematic. Click here for more details.

Files changed (967) hide show

package/dist/libs/validators/generatedValidators/validateServerProperties.js ADDED Viewed

@@ -0,0 +1,1443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverPropertiesSchema = void 0;
+exports.serverPropertiesSchema = validate10;
+const schema11 = { "$id": "serverPropertiesSchema", "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "required": ["license", "analytics"], "definitions": { "App": { "type": "object", "required": ["displayName", "enabled", "link"], "properties": { "displayName": { "type": "string" }, "enabled": { "type": "boolean" }, "expirationDate": { "type": "number" }, "link": { "type": "string" } } } }, "properties": { "license": { "type": "object", "required": ["apps"], "properties": { "type": { "type": "string" }, "apps": { "type": "object", "properties": { "ad": { "$ref": "#/definitions/App" }, "aiv": { "$ref": "#/definitions/App" }, "cnapp": { "$ref": "#/definitions/App" }, "cns": { "$ref": "#/definitions/App" }, "ec": { "$ref": "#/definitions/App" }, "lumin": { "$ref": "#/definitions/App" }, "pci": { "$ref": "#/definitions/App" }, "tio": { "$ref": "#/definitions/App" }, "was": { "$ref": "#/definitions/App" }, "asm": { "$ref": "#/definitions/App" }, "apa": { "$ref": "#/definitions/App" }, "workspace": { "$ref": "#/definitions/App" }, "one": { "$ref": "#/definitions/App" }, "tpc": { "$ref": "#/definitions/App" }, "tpcSc": { "$ref": "#/definitions/App" }, "tpcConsec": { "$ref": "#/definitions/App" }, "reports": { "$ref": "#/definitions/App" } } } } }, "analytics": { "type": "object", "required": ["enabled", "key", "siteId"], "properties": { "enabled": { "type": "boolean" }, "key": { "type": "string" }, "siteId": { "type": "string" } } } } };
+const schema12 = { "type": "object", "required": ["displayName", "enabled", "link"], "properties": { "displayName": { "type": "string" }, "enabled": { "type": "boolean" }, "expirationDate": { "type": "number" }, "link": { "type": "string" } } };
+function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { /*# sourceURL="serverPropertiesSchema" */ ; let vErrors = null; let errors = 0; if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if (((data.license === undefined) && (missing0 = "license")) || ((data.analytics === undefined) && (missing0 = "analytics"))) {
+            validate10.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            if (data.license !== undefined) {
+                let data0 = data.license;
+                const _errs1 = errors;
+                if (errors === _errs1) {
+                    if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+                        let missing1;
+                        if ((data0.apps === undefined) && (missing1 = "apps")) {
+                            validate10.errors = [{ instancePath: instancePath + "/license", schemaPath: "#/properties/license/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                            return false;
+                        }
+                        else {
+                            if (data0.type !== undefined) {
+                                const _errs3 = errors;
+                                if (typeof data0.type !== "string") {
+                                    validate10.errors = [{ instancePath: instancePath + "/license/type", schemaPath: "#/properties/license/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                                var valid1 = _errs3 === errors;
+                            }
+                            else {
+                                var valid1 = true;
+                            }
+                            if (valid1) {
+                                if (data0.apps !== undefined) {
+                                    let data2 = data0.apps;
+                                    const _errs5 = errors;
+                                    if (errors === _errs5) {
+                                        if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+                                            if (data2.ad !== undefined) {
+                                                let data3 = data2.ad;
+                                                const _errs7 = errors;
+                                                const _errs8 = errors;
+                                                if (errors === _errs8) {
+                                                    if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+                                                        let missing2;
+                                                        if ((((data3.displayName === undefined) && (missing2 = "displayName")) || ((data3.enabled === undefined) && (missing2 = "enabled"))) || ((data3.link === undefined) && (missing2 = "link"))) {
+                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/ad", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" }];
+                                                            return false;
+                                                        }
+                                                        else {
+                                                            if (data3.displayName !== undefined) {
+                                                                const _errs10 = errors;
+                                                                if (typeof data3.displayName !== "string") {
+                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/ad/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                var valid4 = _errs10 === errors;
+                                                            }
+                                                            else {
+                                                                var valid4 = true;
+                                                            }
+                                                            if (valid4) {
+                                                                if (data3.enabled !== undefined) {
+                                                                    const _errs12 = errors;
+                                                                    if (typeof data3.enabled !== "boolean") {
+                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/ad/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid4 = _errs12 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid4 = true;
+                                                                }
+                                                                if (valid4) {
+                                                                    if (data3.expirationDate !== undefined) {
+                                                                        let data6 = data3.expirationDate;
+                                                                        const _errs14 = errors;
+                                                                        if (!((typeof data6 == "number") && (isFinite(data6)))) {
+                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/ad/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid4 = _errs14 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid4 = true;
+                                                                    }
+                                                                    if (valid4) {
+                                                                        if (data3.link !== undefined) {
+                                                                            const _errs16 = errors;
+                                                                            if (typeof data3.link !== "string") {
+                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/ad/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid4 = _errs16 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid4 = true;
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/ad", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                var valid2 = _errs7 === errors;
+                                            }
+                                            else {
+                                                var valid2 = true;
+                                            }
+                                            if (valid2) {
+                                                if (data2.aiv !== undefined) {
+                                                    let data8 = data2.aiv;
+                                                    const _errs18 = errors;
+                                                    const _errs19 = errors;
+                                                    if (errors === _errs19) {
+                                                        if (data8 && typeof data8 == "object" && !Array.isArray(data8)) {
+                                                            let missing3;
+                                                            if ((((data8.displayName === undefined) && (missing3 = "displayName")) || ((data8.enabled === undefined) && (missing3 = "enabled"))) || ((data8.link === undefined) && (missing3 = "link"))) {
+                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/aiv", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" }];
+                                                                return false;
+                                                            }
+                                                            else {
+                                                                if (data8.displayName !== undefined) {
+                                                                    const _errs21 = errors;
+                                                                    if (typeof data8.displayName !== "string") {
+                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/aiv/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid6 = _errs21 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid6 = true;
+                                                                }
+                                                                if (valid6) {
+                                                                    if (data8.enabled !== undefined) {
+                                                                        const _errs23 = errors;
+                                                                        if (typeof data8.enabled !== "boolean") {
+                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/aiv/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid6 = _errs23 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid6 = true;
+                                                                    }
+                                                                    if (valid6) {
+                                                                        if (data8.expirationDate !== undefined) {
+                                                                            let data11 = data8.expirationDate;
+                                                                            const _errs25 = errors;
+                                                                            if (!((typeof data11 == "number") && (isFinite(data11)))) {
+                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/aiv/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid6 = _errs25 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid6 = true;
+                                                                        }
+                                                                        if (valid6) {
+                                                                            if (data8.link !== undefined) {
+                                                                                const _errs27 = errors;
+                                                                                if (typeof data8.link !== "string") {
+                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/aiv/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                                var valid6 = _errs27 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid6 = true;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                        else {
+                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/aiv", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    var valid2 = _errs18 === errors;
+                                                }
+                                                else {
+                                                    var valid2 = true;
+                                                }
+                                                if (valid2) {
+                                                    if (data2.cnapp !== undefined) {
+                                                        let data13 = data2.cnapp;
+                                                        const _errs29 = errors;
+                                                        const _errs30 = errors;
+                                                        if (errors === _errs30) {
+                                                            if (data13 && typeof data13 == "object" && !Array.isArray(data13)) {
+                                                                let missing4;
+                                                                if ((((data13.displayName === undefined) && (missing4 = "displayName")) || ((data13.enabled === undefined) && (missing4 = "enabled"))) || ((data13.link === undefined) && (missing4 = "link"))) {
+                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/cnapp", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing4 }, message: "must have required property '" + missing4 + "'" }];
+                                                                    return false;
+                                                                }
+                                                                else {
+                                                                    if (data13.displayName !== undefined) {
+                                                                        const _errs32 = errors;
+                                                                        if (typeof data13.displayName !== "string") {
+                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/cnapp/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid8 = _errs32 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid8 = true;
+                                                                    }
+                                                                    if (valid8) {
+                                                                        if (data13.enabled !== undefined) {
+                                                                            const _errs34 = errors;
+                                                                            if (typeof data13.enabled !== "boolean") {
+                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/cnapp/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid8 = _errs34 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid8 = true;
+                                                                        }
+                                                                        if (valid8) {
+                                                                            if (data13.expirationDate !== undefined) {
+                                                                                let data16 = data13.expirationDate;
+                                                                                const _errs36 = errors;
+                                                                                if (!((typeof data16 == "number") && (isFinite(data16)))) {
+                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/cnapp/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                    return false;
+                                                                                }
+                                                                                var valid8 = _errs36 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid8 = true;
+                                                                            }
+                                                                            if (valid8) {
+                                                                                if (data13.link !== undefined) {
+                                                                                    const _errs38 = errors;
+                                                                                    if (typeof data13.link !== "string") {
+                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/cnapp/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    var valid8 = _errs38 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid8 = true;
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                            else {
+                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/cnapp", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                        var valid2 = _errs29 === errors;
+                                                    }
+                                                    else {
+                                                        var valid2 = true;
+                                                    }
+                                                    if (valid2) {
+                                                        if (data2.cns !== undefined) {
+                                                            let data18 = data2.cns;
+                                                            const _errs40 = errors;
+                                                            const _errs41 = errors;
+                                                            if (errors === _errs41) {
+                                                                if (data18 && typeof data18 == "object" && !Array.isArray(data18)) {
+                                                                    let missing5;
+                                                                    if ((((data18.displayName === undefined) && (missing5 = "displayName")) || ((data18.enabled === undefined) && (missing5 = "enabled"))) || ((data18.link === undefined) && (missing5 = "link"))) {
+                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/cns", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing5 }, message: "must have required property '" + missing5 + "'" }];
+                                                                        return false;
+                                                                    }
+                                                                    else {
+                                                                        if (data18.displayName !== undefined) {
+                                                                            const _errs43 = errors;
+                                                                            if (typeof data18.displayName !== "string") {
+                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/cns/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid10 = _errs43 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid10 = true;
+                                                                        }
+                                                                        if (valid10) {
+                                                                            if (data18.enabled !== undefined) {
+                                                                                const _errs45 = errors;
+                                                                                if (typeof data18.enabled !== "boolean") {
+                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/cns/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                    return false;
+                                                                                }
+                                                                                var valid10 = _errs45 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid10 = true;
+                                                                            }
+                                                                            if (valid10) {
+                                                                                if (data18.expirationDate !== undefined) {
+                                                                                    let data21 = data18.expirationDate;
+                                                                                    const _errs47 = errors;
+                                                                                    if (!((typeof data21 == "number") && (isFinite(data21)))) {
+                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/cns/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    var valid10 = _errs47 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid10 = true;
+                                                                                }
+                                                                                if (valid10) {
+                                                                                    if (data18.link !== undefined) {
+                                                                                        const _errs49 = errors;
+                                                                                        if (typeof data18.link !== "string") {
+                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/cns/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        var valid10 = _errs49 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid10 = true;
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                                else {
+                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/cns", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                    return false;
+                                                                }
+                                                            }
+                                                            var valid2 = _errs40 === errors;
+                                                        }
+                                                        else {
+                                                            var valid2 = true;
+                                                        }
+                                                        if (valid2) {
+                                                            if (data2.ec !== undefined) {
+                                                                let data23 = data2.ec;
+                                                                const _errs51 = errors;
+                                                                const _errs52 = errors;
+                                                                if (errors === _errs52) {
+                                                                    if (data23 && typeof data23 == "object" && !Array.isArray(data23)) {
+                                                                        let missing6;
+                                                                        if ((((data23.displayName === undefined) && (missing6 = "displayName")) || ((data23.enabled === undefined) && (missing6 = "enabled"))) || ((data23.link === undefined) && (missing6 = "link"))) {
+                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/ec", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing6 }, message: "must have required property '" + missing6 + "'" }];
+                                                                            return false;
+                                                                        }
+                                                                        else {
+                                                                            if (data23.displayName !== undefined) {
+                                                                                const _errs54 = errors;
+                                                                                if (typeof data23.displayName !== "string") {
+                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/ec/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                                var valid12 = _errs54 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid12 = true;
+                                                                            }
+                                                                            if (valid12) {
+                                                                                if (data23.enabled !== undefined) {
+                                                                                    const _errs56 = errors;
+                                                                                    if (typeof data23.enabled !== "boolean") {
+                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/ec/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    var valid12 = _errs56 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid12 = true;
+                                                                                }
+                                                                                if (valid12) {
+                                                                                    if (data23.expirationDate !== undefined) {
+                                                                                        let data26 = data23.expirationDate;
+                                                                                        const _errs58 = errors;
+                                                                                        if (!((typeof data26 == "number") && (isFinite(data26)))) {
+                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/ec/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        var valid12 = _errs58 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid12 = true;
+                                                                                    }
+                                                                                    if (valid12) {
+                                                                                        if (data23.link !== undefined) {
+                                                                                            const _errs60 = errors;
+                                                                                            if (typeof data23.link !== "string") {
+                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/ec/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                            var valid12 = _errs60 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid12 = true;
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    else {
+                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/ec", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                        return false;
+                                                                    }
+                                                                }
+                                                                var valid2 = _errs51 === errors;
+                                                            }
+                                                            else {
+                                                                var valid2 = true;
+                                                            }
+                                                            if (valid2) {
+                                                                if (data2.lumin !== undefined) {
+                                                                    let data28 = data2.lumin;
+                                                                    const _errs62 = errors;
+                                                                    const _errs63 = errors;
+                                                                    if (errors === _errs63) {
+                                                                        if (data28 && typeof data28 == "object" && !Array.isArray(data28)) {
+                                                                            let missing7;
+                                                                            if ((((data28.displayName === undefined) && (missing7 = "displayName")) || ((data28.enabled === undefined) && (missing7 = "enabled"))) || ((data28.link === undefined) && (missing7 = "link"))) {
+                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/lumin", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing7 }, message: "must have required property '" + missing7 + "'" }];
+                                                                                return false;
+                                                                            }
+                                                                            else {
+                                                                                if (data28.displayName !== undefined) {
+                                                                                    const _errs65 = errors;
+                                                                                    if (typeof data28.displayName !== "string") {
+                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/lumin/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    var valid14 = _errs65 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid14 = true;
+                                                                                }
+                                                                                if (valid14) {
+                                                                                    if (data28.enabled !== undefined) {
+                                                                                        const _errs67 = errors;
+                                                                                        if (typeof data28.enabled !== "boolean") {
+                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/lumin/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        var valid14 = _errs67 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid14 = true;
+                                                                                    }
+                                                                                    if (valid14) {
+                                                                                        if (data28.expirationDate !== undefined) {
+                                                                                            let data31 = data28.expirationDate;
+                                                                                            const _errs69 = errors;
+                                                                                            if (!((typeof data31 == "number") && (isFinite(data31)))) {
+                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/lumin/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                            var valid14 = _errs69 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid14 = true;
+                                                                                        }
+                                                                                        if (valid14) {
+                                                                                            if (data28.link !== undefined) {
+                                                                                                const _errs71 = errors;
+                                                                                                if (typeof data28.link !== "string") {
+                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/lumin/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                                var valid14 = _errs71 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid14 = true;
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        else {
+                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/lumin", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                    var valid2 = _errs62 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid2 = true;
+                                                                }
+                                                                if (valid2) {
+                                                                    if (data2.pci !== undefined) {
+                                                                        let data33 = data2.pci;
+                                                                        const _errs73 = errors;
+                                                                        const _errs74 = errors;
+                                                                        if (errors === _errs74) {
+                                                                            if (data33 && typeof data33 == "object" && !Array.isArray(data33)) {
+                                                                                let missing8;
+                                                                                if ((((data33.displayName === undefined) && (missing8 = "displayName")) || ((data33.enabled === undefined) && (missing8 = "enabled"))) || ((data33.link === undefined) && (missing8 = "link"))) {
+                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/pci", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing8 }, message: "must have required property '" + missing8 + "'" }];
+                                                                                    return false;
+                                                                                }
+                                                                                else {
+                                                                                    if (data33.displayName !== undefined) {
+                                                                                        const _errs76 = errors;
+                                                                                        if (typeof data33.displayName !== "string") {
+                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/pci/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        var valid16 = _errs76 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid16 = true;
+                                                                                    }
+                                                                                    if (valid16) {
+                                                                                        if (data33.enabled !== undefined) {
+                                                                                            const _errs78 = errors;
+                                                                                            if (typeof data33.enabled !== "boolean") {
+                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/pci/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                            var valid16 = _errs78 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid16 = true;
+                                                                                        }
+                                                                                        if (valid16) {
+                                                                                            if (data33.expirationDate !== undefined) {
+                                                                                                let data36 = data33.expirationDate;
+                                                                                                const _errs80 = errors;
+                                                                                                if (!((typeof data36 == "number") && (isFinite(data36)))) {
+                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/pci/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                                var valid16 = _errs80 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid16 = true;
+                                                                                            }
+                                                                                            if (valid16) {
+                                                                                                if (data33.link !== undefined) {
+                                                                                                    const _errs82 = errors;
+                                                                                                    if (typeof data33.link !== "string") {
+                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/pci/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                    var valid16 = _errs82 === errors;
+                                                                                                }
+                                                                                                else {
+                                                                                                    var valid16 = true;
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                            else {
+                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/pci", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                return false;
+                                                                            }
+                                                                        }
+                                                                        var valid2 = _errs73 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid2 = true;
+                                                                    }
+                                                                    if (valid2) {
+                                                                        if (data2.tio !== undefined) {
+                                                                            let data38 = data2.tio;
+                                                                            const _errs84 = errors;
+                                                                            const _errs85 = errors;
+                                                                            if (errors === _errs85) {
+                                                                                if (data38 && typeof data38 == "object" && !Array.isArray(data38)) {
+                                                                                    let missing9;
+                                                                                    if ((((data38.displayName === undefined) && (missing9 = "displayName")) || ((data38.enabled === undefined) && (missing9 = "enabled"))) || ((data38.link === undefined) && (missing9 = "link"))) {
+                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/tio", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing9 }, message: "must have required property '" + missing9 + "'" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    else {
+                                                                                        if (data38.displayName !== undefined) {
+                                                                                            const _errs87 = errors;
+                                                                                            if (typeof data38.displayName !== "string") {
+                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/tio/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                            var valid18 = _errs87 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid18 = true;
+                                                                                        }
+                                                                                        if (valid18) {
+                                                                                            if (data38.enabled !== undefined) {
+                                                                                                const _errs89 = errors;
+                                                                                                if (typeof data38.enabled !== "boolean") {
+                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/tio/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                                var valid18 = _errs89 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid18 = true;
+                                                                                            }
+                                                                                            if (valid18) {
+                                                                                                if (data38.expirationDate !== undefined) {
+                                                                                                    let data41 = data38.expirationDate;
+                                                                                                    const _errs91 = errors;
+                                                                                                    if (!((typeof data41 == "number") && (isFinite(data41)))) {
+                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/tio/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                    var valid18 = _errs91 === errors;
+                                                                                                }
+                                                                                                else {
+                                                                                                    var valid18 = true;
+                                                                                                }
+                                                                                                if (valid18) {
+                                                                                                    if (data38.link !== undefined) {
+                                                                                                        const _errs93 = errors;
+                                                                                                        if (typeof data38.link !== "string") {
+                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/tio/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        var valid18 = _errs93 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid18 = true;
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/tio", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                            var valid2 = _errs84 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid2 = true;
+                                                                        }
+                                                                        if (valid2) {
+                                                                            if (data2.was !== undefined) {
+                                                                                let data43 = data2.was;
+                                                                                const _errs95 = errors;
+                                                                                const _errs96 = errors;
+                                                                                if (errors === _errs96) {
+                                                                                    if (data43 && typeof data43 == "object" && !Array.isArray(data43)) {
+                                                                                        let missing10;
+                                                                                        if ((((data43.displayName === undefined) && (missing10 = "displayName")) || ((data43.enabled === undefined) && (missing10 = "enabled"))) || ((data43.link === undefined) && (missing10 = "link"))) {
+                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/was", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing10 }, message: "must have required property '" + missing10 + "'" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        else {
+                                                                                            if (data43.displayName !== undefined) {
+                                                                                                const _errs98 = errors;
+                                                                                                if (typeof data43.displayName !== "string") {
+                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/was/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                                var valid20 = _errs98 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid20 = true;
+                                                                                            }
+                                                                                            if (valid20) {
+                                                                                                if (data43.enabled !== undefined) {
+                                                                                                    const _errs100 = errors;
+                                                                                                    if (typeof data43.enabled !== "boolean") {
+                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/was/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                    var valid20 = _errs100 === errors;
+                                                                                                }
+                                                                                                else {
+                                                                                                    var valid20 = true;
+                                                                                                }
+                                                                                                if (valid20) {
+                                                                                                    if (data43.expirationDate !== undefined) {
+                                                                                                        let data46 = data43.expirationDate;
+                                                                                                        const _errs102 = errors;
+                                                                                                        if (!((typeof data46 == "number") && (isFinite(data46)))) {
+                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/was/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        var valid20 = _errs102 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid20 = true;
+                                                                                                    }
+                                                                                                    if (valid20) {
+                                                                                                        if (data43.link !== undefined) {
+                                                                                                            const _errs104 = errors;
+                                                                                                            if (typeof data43.link !== "string") {
+                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/was/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                            var valid20 = _errs104 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid20 = true;
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                    else {
+                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/was", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                }
+                                                                                var valid2 = _errs95 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid2 = true;
+                                                                            }
+                                                                            if (valid2) {
+                                                                                if (data2.asm !== undefined) {
+                                                                                    let data48 = data2.asm;
+                                                                                    const _errs106 = errors;
+                                                                                    const _errs107 = errors;
+                                                                                    if (errors === _errs107) {
+                                                                                        if (data48 && typeof data48 == "object" && !Array.isArray(data48)) {
+                                                                                            let missing11;
+                                                                                            if ((((data48.displayName === undefined) && (missing11 = "displayName")) || ((data48.enabled === undefined) && (missing11 = "enabled"))) || ((data48.link === undefined) && (missing11 = "link"))) {
+                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/asm", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing11 }, message: "must have required property '" + missing11 + "'" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                            else {
+                                                                                                if (data48.displayName !== undefined) {
+                                                                                                    const _errs109 = errors;
+                                                                                                    if (typeof data48.displayName !== "string") {
+                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/asm/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                    var valid22 = _errs109 === errors;
+                                                                                                }
+                                                                                                else {
+                                                                                                    var valid22 = true;
+                                                                                                }
+                                                                                                if (valid22) {
+                                                                                                    if (data48.enabled !== undefined) {
+                                                                                                        const _errs111 = errors;
+                                                                                                        if (typeof data48.enabled !== "boolean") {
+                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/asm/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        var valid22 = _errs111 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid22 = true;
+                                                                                                    }
+                                                                                                    if (valid22) {
+                                                                                                        if (data48.expirationDate !== undefined) {
+                                                                                                            let data51 = data48.expirationDate;
+                                                                                                            const _errs113 = errors;
+                                                                                                            if (!((typeof data51 == "number") && (isFinite(data51)))) {
+                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/asm/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                            var valid22 = _errs113 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid22 = true;
+                                                                                                        }
+                                                                                                        if (valid22) {
+                                                                                                            if (data48.link !== undefined) {
+                                                                                                                const _errs115 = errors;
+                                                                                                                if (typeof data48.link !== "string") {
+                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/asm/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                    return false;
+                                                                                                                }
+                                                                                                                var valid22 = _errs115 === errors;
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                var valid22 = true;
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                        else {
+                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/asm", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                    }
+                                                                                    var valid2 = _errs106 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid2 = true;
+                                                                                }
+                                                                                if (valid2) {
+                                                                                    if (data2.apa !== undefined) {
+                                                                                        let data53 = data2.apa;
+                                                                                        const _errs117 = errors;
+                                                                                        const _errs118 = errors;
+                                                                                        if (errors === _errs118) {
+                                                                                            if (data53 && typeof data53 == "object" && !Array.isArray(data53)) {
+                                                                                                let missing12;
+                                                                                                if ((((data53.displayName === undefined) && (missing12 = "displayName")) || ((data53.enabled === undefined) && (missing12 = "enabled"))) || ((data53.link === undefined) && (missing12 = "link"))) {
+                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/apa", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing12 }, message: "must have required property '" + missing12 + "'" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                                else {
+                                                                                                    if (data53.displayName !== undefined) {
+                                                                                                        const _errs120 = errors;
+                                                                                                        if (typeof data53.displayName !== "string") {
+                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/apa/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        var valid24 = _errs120 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid24 = true;
+                                                                                                    }
+                                                                                                    if (valid24) {
+                                                                                                        if (data53.enabled !== undefined) {
+                                                                                                            const _errs122 = errors;
+                                                                                                            if (typeof data53.enabled !== "boolean") {
+                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/apa/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                            var valid24 = _errs122 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid24 = true;
+                                                                                                        }
+                                                                                                        if (valid24) {
+                                                                                                            if (data53.expirationDate !== undefined) {
+                                                                                                                let data56 = data53.expirationDate;
+                                                                                                                const _errs124 = errors;
+                                                                                                                if (!((typeof data56 == "number") && (isFinite(data56)))) {
+                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/apa/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                                    return false;
+                                                                                                                }
+                                                                                                                var valid24 = _errs124 === errors;
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                var valid24 = true;
+                                                                                                            }
+                                                                                                            if (valid24) {
+                                                                                                                if (data53.link !== undefined) {
+                                                                                                                    const _errs126 = errors;
+                                                                                                                    if (typeof data53.link !== "string") {
+                                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/apa/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                    var valid24 = _errs126 === errors;
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    var valid24 = true;
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                            else {
+                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/apa", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                        }
+                                                                                        var valid2 = _errs117 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid2 = true;
+                                                                                    }
+                                                                                    if (valid2) {
+                                                                                        if (data2.workspace !== undefined) {
+                                                                                            let data58 = data2.workspace;
+                                                                                            const _errs128 = errors;
+                                                                                            const _errs129 = errors;
+                                                                                            if (errors === _errs129) {
+                                                                                                if (data58 && typeof data58 == "object" && !Array.isArray(data58)) {
+                                                                                                    let missing13;
+                                                                                                    if ((((data58.displayName === undefined) && (missing13 = "displayName")) || ((data58.enabled === undefined) && (missing13 = "enabled"))) || ((data58.link === undefined) && (missing13 = "link"))) {
+                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/workspace", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing13 }, message: "must have required property '" + missing13 + "'" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        if (data58.displayName !== undefined) {
+                                                                                                            const _errs131 = errors;
+                                                                                                            if (typeof data58.displayName !== "string") {
+                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/workspace/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                            var valid26 = _errs131 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid26 = true;
+                                                                                                        }
+                                                                                                        if (valid26) {
+                                                                                                            if (data58.enabled !== undefined) {
+                                                                                                                const _errs133 = errors;
+                                                                                                                if (typeof data58.enabled !== "boolean") {
+                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/workspace/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                                    return false;
+                                                                                                                }
+                                                                                                                var valid26 = _errs133 === errors;
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                var valid26 = true;
+                                                                                                            }
+                                                                                                            if (valid26) {
+                                                                                                                if (data58.expirationDate !== undefined) {
+                                                                                                                    let data61 = data58.expirationDate;
+                                                                                                                    const _errs135 = errors;
+                                                                                                                    if (!((typeof data61 == "number") && (isFinite(data61)))) {
+                                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/workspace/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                    var valid26 = _errs135 === errors;
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    var valid26 = true;
+                                                                                                                }
+                                                                                                                if (valid26) {
+                                                                                                                    if (data58.link !== undefined) {
+                                                                                                                        const _errs137 = errors;
+                                                                                                                        if (typeof data58.link !== "string") {
+                                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/workspace/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                            return false;
+                                                                                                                        }
+                                                                                                                        var valid26 = _errs137 === errors;
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        var valid26 = true;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                                else {
+                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/workspace", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                            }
+                                                                                            var valid2 = _errs128 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid2 = true;
+                                                                                        }
+                                                                                        if (valid2) {
+                                                                                            if (data2.one !== undefined) {
+                                                                                                let data63 = data2.one;
+                                                                                                const _errs139 = errors;
+                                                                                                const _errs140 = errors;
+                                                                                                if (errors === _errs140) {
+                                                                                                    if (data63 && typeof data63 == "object" && !Array.isArray(data63)) {
+                                                                                                        let missing14;
+                                                                                                        if ((((data63.displayName === undefined) && (missing14 = "displayName")) || ((data63.enabled === undefined) && (missing14 = "enabled"))) || ((data63.link === undefined) && (missing14 = "link"))) {
+                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/one", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing14 }, message: "must have required property '" + missing14 + "'" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            if (data63.displayName !== undefined) {
+                                                                                                                const _errs142 = errors;
+                                                                                                                if (typeof data63.displayName !== "string") {
+                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/one/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                    return false;
+                                                                                                                }
+                                                                                                                var valid28 = _errs142 === errors;
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                var valid28 = true;
+                                                                                                            }
+                                                                                                            if (valid28) {
+                                                                                                                if (data63.enabled !== undefined) {
+                                                                                                                    const _errs144 = errors;
+                                                                                                                    if (typeof data63.enabled !== "boolean") {
+                                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/one/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                    var valid28 = _errs144 === errors;
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    var valid28 = true;
+                                                                                                                }
+                                                                                                                if (valid28) {
+                                                                                                                    if (data63.expirationDate !== undefined) {
+                                                                                                                        let data66 = data63.expirationDate;
+                                                                                                                        const _errs146 = errors;
+                                                                                                                        if (!((typeof data66 == "number") && (isFinite(data66)))) {
+                                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/one/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                                            return false;
+                                                                                                                        }
+                                                                                                                        var valid28 = _errs146 === errors;
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        var valid28 = true;
+                                                                                                                    }
+                                                                                                                    if (valid28) {
+                                                                                                                        if (data63.link !== undefined) {
+                                                                                                                            const _errs148 = errors;
+                                                                                                                            if (typeof data63.link !== "string") {
+                                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/one/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                return false;
+                                                                                                                            }
+                                                                                                                            var valid28 = _errs148 === errors;
+                                                                                                                        }
+                                                                                                                        else {
+                                                                                                                            var valid28 = true;
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/one", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                }
+                                                                                                var valid2 = _errs139 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid2 = true;
+                                                                                            }
+                                                                                            if (valid2) {
+                                                                                                if (data2.tpc !== undefined) {
+                                                                                                    let data68 = data2.tpc;
+                                                                                                    const _errs150 = errors;
+                                                                                                    const _errs151 = errors;
+                                                                                                    if (errors === _errs151) {
+                                                                                                        if (data68 && typeof data68 == "object" && !Array.isArray(data68)) {
+                                                                                                            let missing15;
+                                                                                                            if ((((data68.displayName === undefined) && (missing15 = "displayName")) || ((data68.enabled === undefined) && (missing15 = "enabled"))) || ((data68.link === undefined) && (missing15 = "link"))) {
+                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/tpc", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing15 }, message: "must have required property '" + missing15 + "'" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                if (data68.displayName !== undefined) {
+                                                                                                                    const _errs153 = errors;
+                                                                                                                    if (typeof data68.displayName !== "string") {
+                                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/tpc/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                    var valid30 = _errs153 === errors;
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    var valid30 = true;
+                                                                                                                }
+                                                                                                                if (valid30) {
+                                                                                                                    if (data68.enabled !== undefined) {
+                                                                                                                        const _errs155 = errors;
+                                                                                                                        if (typeof data68.enabled !== "boolean") {
+                                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/tpc/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                                            return false;
+                                                                                                                        }
+                                                                                                                        var valid30 = _errs155 === errors;
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        var valid30 = true;
+                                                                                                                    }
+                                                                                                                    if (valid30) {
+                                                                                                                        if (data68.expirationDate !== undefined) {
+                                                                                                                            let data71 = data68.expirationDate;
+                                                                                                                            const _errs157 = errors;
+                                                                                                                            if (!((typeof data71 == "number") && (isFinite(data71)))) {
+                                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/tpc/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                                                return false;
+                                                                                                                            }
+                                                                                                                            var valid30 = _errs157 === errors;
+                                                                                                                        }
+                                                                                                                        else {
+                                                                                                                            var valid30 = true;
+                                                                                                                        }
+                                                                                                                        if (valid30) {
+                                                                                                                            if (data68.link !== undefined) {
+                                                                                                                                const _errs159 = errors;
+                                                                                                                                if (typeof data68.link !== "string") {
+                                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/tpc/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                    return false;
+                                                                                                                                }
+                                                                                                                                var valid30 = _errs159 === errors;
+                                                                                                                            }
+                                                                                                                            else {
+                                                                                                                                var valid30 = true;
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/tpc", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                    }
+                                                                                                    var valid2 = _errs150 === errors;
+                                                                                                }
+                                                                                                else {
+                                                                                                    var valid2 = true;
+                                                                                                }
+                                                                                                if (valid2) {
+                                                                                                    if (data2.tpcSc !== undefined) {
+                                                                                                        let data73 = data2.tpcSc;
+                                                                                                        const _errs161 = errors;
+                                                                                                        const _errs162 = errors;
+                                                                                                        if (errors === _errs162) {
+                                                                                                            if (data73 && typeof data73 == "object" && !Array.isArray(data73)) {
+                                                                                                                let missing16;
+                                                                                                                if ((((data73.displayName === undefined) && (missing16 = "displayName")) || ((data73.enabled === undefined) && (missing16 = "enabled"))) || ((data73.link === undefined) && (missing16 = "link"))) {
+                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcSc", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing16 }, message: "must have required property '" + missing16 + "'" }];
+                                                                                                                    return false;
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    if (data73.displayName !== undefined) {
+                                                                                                                        const _errs164 = errors;
+                                                                                                                        if (typeof data73.displayName !== "string") {
+                                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcSc/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                            return false;
+                                                                                                                        }
+                                                                                                                        var valid32 = _errs164 === errors;
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        var valid32 = true;
+                                                                                                                    }
+                                                                                                                    if (valid32) {
+                                                                                                                        if (data73.enabled !== undefined) {
+                                                                                                                            const _errs166 = errors;
+                                                                                                                            if (typeof data73.enabled !== "boolean") {
+                                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcSc/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                                                return false;
+                                                                                                                            }
+                                                                                                                            var valid32 = _errs166 === errors;
+                                                                                                                        }
+                                                                                                                        else {
+                                                                                                                            var valid32 = true;
+                                                                                                                        }
+                                                                                                                        if (valid32) {
+                                                                                                                            if (data73.expirationDate !== undefined) {
+                                                                                                                                let data76 = data73.expirationDate;
+                                                                                                                                const _errs168 = errors;
+                                                                                                                                if (!((typeof data76 == "number") && (isFinite(data76)))) {
+                                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcSc/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                                                    return false;
+                                                                                                                                }
+                                                                                                                                var valid32 = _errs168 === errors;
+                                                                                                                            }
+                                                                                                                            else {
+                                                                                                                                var valid32 = true;
+                                                                                                                            }
+                                                                                                                            if (valid32) {
+                                                                                                                                if (data73.link !== undefined) {
+                                                                                                                                    const _errs170 = errors;
+                                                                                                                                    if (typeof data73.link !== "string") {
+                                                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcSc/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                        return false;
+                                                                                                                                    }
+                                                                                                                                    var valid32 = _errs170 === errors;
+                                                                                                                                }
+                                                                                                                                else {
+                                                                                                                                    var valid32 = true;
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcSc", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                        }
+                                                                                                        var valid2 = _errs161 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid2 = true;
+                                                                                                    }
+                                                                                                    if (valid2) {
+                                                                                                        if (data2.tpcConsec !== undefined) {
+                                                                                                            let data78 = data2.tpcConsec;
+                                                                                                            const _errs172 = errors;
+                                                                                                            const _errs173 = errors;
+                                                                                                            if (errors === _errs173) {
+                                                                                                                if (data78 && typeof data78 == "object" && !Array.isArray(data78)) {
+                                                                                                                    let missing17;
+                                                                                                                    if ((((data78.displayName === undefined) && (missing17 = "displayName")) || ((data78.enabled === undefined) && (missing17 = "enabled"))) || ((data78.link === undefined) && (missing17 = "link"))) {
+                                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcConsec", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing17 }, message: "must have required property '" + missing17 + "'" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        if (data78.displayName !== undefined) {
+                                                                                                                            const _errs175 = errors;
+                                                                                                                            if (typeof data78.displayName !== "string") {
+                                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcConsec/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                return false;
+                                                                                                                            }
+                                                                                                                            var valid34 = _errs175 === errors;
+                                                                                                                        }
+                                                                                                                        else {
+                                                                                                                            var valid34 = true;
+                                                                                                                        }
+                                                                                                                        if (valid34) {
+                                                                                                                            if (data78.enabled !== undefined) {
+                                                                                                                                const _errs177 = errors;
+                                                                                                                                if (typeof data78.enabled !== "boolean") {
+                                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcConsec/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                                                    return false;
+                                                                                                                                }
+                                                                                                                                var valid34 = _errs177 === errors;
+                                                                                                                            }
+                                                                                                                            else {
+                                                                                                                                var valid34 = true;
+                                                                                                                            }
+                                                                                                                            if (valid34) {
+                                                                                                                                if (data78.expirationDate !== undefined) {
+                                                                                                                                    let data81 = data78.expirationDate;
+                                                                                                                                    const _errs179 = errors;
+                                                                                                                                    if (!((typeof data81 == "number") && (isFinite(data81)))) {
+                                                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcConsec/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                                                        return false;
+                                                                                                                                    }
+                                                                                                                                    var valid34 = _errs179 === errors;
+                                                                                                                                }
+                                                                                                                                else {
+                                                                                                                                    var valid34 = true;
+                                                                                                                                }
+                                                                                                                                if (valid34) {
+                                                                                                                                    if (data78.link !== undefined) {
+                                                                                                                                        const _errs181 = errors;
+                                                                                                                                        if (typeof data78.link !== "string") {
+                                                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcConsec/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                            return false;
+                                                                                                                                        }
+                                                                                                                                        var valid34 = _errs181 === errors;
+                                                                                                                                    }
+                                                                                                                                    else {
+                                                                                                                                        var valid34 = true;
+                                                                                                                                    }
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/tpcConsec", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                                    return false;
+                                                                                                                }
+                                                                                                            }
+                                                                                                            var valid2 = _errs172 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid2 = true;
+                                                                                                        }
+                                                                                                        if (valid2) {
+                                                                                                            if (data2.reports !== undefined) {
+                                                                                                                let data83 = data2.reports;
+                                                                                                                const _errs183 = errors;
+                                                                                                                const _errs184 = errors;
+                                                                                                                if (errors === _errs184) {
+                                                                                                                    if (data83 && typeof data83 == "object" && !Array.isArray(data83)) {
+                                                                                                                        let missing18;
+                                                                                                                        if ((((data83.displayName === undefined) && (missing18 = "displayName")) || ((data83.enabled === undefined) && (missing18 = "enabled"))) || ((data83.link === undefined) && (missing18 = "link"))) {
+                                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/reports", schemaPath: "#/definitions/App/required", keyword: "required", params: { missingProperty: missing18 }, message: "must have required property '" + missing18 + "'" }];
+                                                                                                                            return false;
+                                                                                                                        }
+                                                                                                                        else {
+                                                                                                                            if (data83.displayName !== undefined) {
+                                                                                                                                const _errs186 = errors;
+                                                                                                                                if (typeof data83.displayName !== "string") {
+                                                                                                                                    validate10.errors = [{ instancePath: instancePath + "/license/apps/reports/displayName", schemaPath: "#/definitions/App/properties/displayName/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                    return false;
+                                                                                                                                }
+                                                                                                                                var valid36 = _errs186 === errors;
+                                                                                                                            }
+                                                                                                                            else {
+                                                                                                                                var valid36 = true;
+                                                                                                                            }
+                                                                                                                            if (valid36) {
+                                                                                                                                if (data83.enabled !== undefined) {
+                                                                                                                                    const _errs188 = errors;
+                                                                                                                                    if (typeof data83.enabled !== "boolean") {
+                                                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/reports/enabled", schemaPath: "#/definitions/App/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                                                                                                                        return false;
+                                                                                                                                    }
+                                                                                                                                    var valid36 = _errs188 === errors;
+                                                                                                                                }
+                                                                                                                                else {
+                                                                                                                                    var valid36 = true;
+                                                                                                                                }
+                                                                                                                                if (valid36) {
+                                                                                                                                    if (data83.expirationDate !== undefined) {
+                                                                                                                                        let data86 = data83.expirationDate;
+                                                                                                                                        const _errs190 = errors;
+                                                                                                                                        if (!((typeof data86 == "number") && (isFinite(data86)))) {
+                                                                                                                                            validate10.errors = [{ instancePath: instancePath + "/license/apps/reports/expirationDate", schemaPath: "#/definitions/App/properties/expirationDate/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                                                                                            return false;
+                                                                                                                                        }
+                                                                                                                                        var valid36 = _errs190 === errors;
+                                                                                                                                    }
+                                                                                                                                    else {
+                                                                                                                                        var valid36 = true;
+                                                                                                                                    }
+                                                                                                                                    if (valid36) {
+                                                                                                                                        if (data83.link !== undefined) {
+                                                                                                                                            const _errs192 = errors;
+                                                                                                                                            if (typeof data83.link !== "string") {
+                                                                                                                                                validate10.errors = [{ instancePath: instancePath + "/license/apps/reports/link", schemaPath: "#/definitions/App/properties/link/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                                return false;
+                                                                                                                                            }
+                                                                                                                                            var valid36 = _errs192 === errors;
+                                                                                                                                        }
+                                                                                                                                        else {
+                                                                                                                                            var valid36 = true;
+                                                                                                                                        }
+                                                                                                                                    }
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        validate10.errors = [{ instancePath: instancePath + "/license/apps/reports", schemaPath: "#/definitions/App/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                                        return false;
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                var valid2 = _errs183 === errors;
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                var valid2 = true;
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate10.errors = [{ instancePath: instancePath + "/license/apps", schemaPath: "#/properties/license/properties/apps/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid1 = _errs5 === errors;
+                                }
+                                else {
+                                    var valid1 = true;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        validate10.errors = [{ instancePath: instancePath + "/license", schemaPath: "#/properties/license/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                        return false;
+                    }
+                }
+                var valid0 = _errs1 === errors;
+            }
+            else {
+                var valid0 = true;
+            }
+            if (valid0) {
+                if (data.analytics !== undefined) {
+                    let data88 = data.analytics;
+                    const _errs194 = errors;
+                    if (errors === _errs194) {
+                        if (data88 && typeof data88 == "object" && !Array.isArray(data88)) {
+                            let missing19;
+                            if ((((data88.enabled === undefined) && (missing19 = "enabled")) || ((data88.key === undefined) && (missing19 = "key"))) || ((data88.siteId === undefined) && (missing19 = "siteId"))) {
+                                validate10.errors = [{ instancePath: instancePath + "/analytics", schemaPath: "#/properties/analytics/required", keyword: "required", params: { missingProperty: missing19 }, message: "must have required property '" + missing19 + "'" }];
+                                return false;
+                            }
+                            else {
+                                if (data88.enabled !== undefined) {
+                                    const _errs196 = errors;
+                                    if (typeof data88.enabled !== "boolean") {
+                                        validate10.errors = [{ instancePath: instancePath + "/analytics/enabled", schemaPath: "#/properties/analytics/properties/enabled/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                        return false;
+                                    }
+                                    var valid37 = _errs196 === errors;
+                                }
+                                else {
+                                    var valid37 = true;
+                                }
+                                if (valid37) {
+                                    if (data88.key !== undefined) {
+                                        const _errs198 = errors;
+                                        if (typeof data88.key !== "string") {
+                                            validate10.errors = [{ instancePath: instancePath + "/analytics/key", schemaPath: "#/properties/analytics/properties/key/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                            return false;
+                                        }
+                                        var valid37 = _errs198 === errors;
+                                    }
+                                    else {
+                                        var valid37 = true;
+                                    }
+                                    if (valid37) {
+                                        if (data88.siteId !== undefined) {
+                                            const _errs200 = errors;
+                                            if (typeof data88.siteId !== "string") {
+                                                validate10.errors = [{ instancePath: instancePath + "/analytics/siteId", schemaPath: "#/properties/analytics/properties/siteId/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                return false;
+                                            }
+                                            var valid37 = _errs200 === errors;
+                                        }
+                                        else {
+                                            var valid37 = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            validate10.errors = [{ instancePath: instancePath + "/analytics", schemaPath: "#/properties/analytics/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                            return false;
+                        }
+                    }
+                    var valid0 = _errs194 === errors;
+                }
+                else {
+                    var valid0 = true;
+                }
+            }
+        }
+    }
+    else {
+        validate10.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate10.errors = vErrors; return errors === 0; }
+//# sourceMappingURL=validateServerProperties.js.map