@keymanapp/common-types 17.0.185-alpha → 17.0.190-alpha

package/build/src/schemas/ldml-keyboard3.schema.validator.mjs

@@ -0,0 +1,3189 @@
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="8811648a-93c4-524f-b22c-ffac1268863b")}catch(e){}}();
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+// obj/schemas/ldml-keyboard3.schema.validator.cjs
+var require_ldml_keyboard3_schema_validator = __commonJS({
+    "obj/schemas/ldml-keyboard3.schema.validator.cjs"(exports, module) {
+        module.exports = validate20;
+        module.exports.default = validate20;
+        var schema22 = { "$schema": "http://json-schema.org/schema#", "additionalProperties": false, "definitions": { "any": { "type": "string" }, "display": { "additionalProperties": false, "properties": { "display": { "type": "string" }, "id": { "type": "string" }, "to": { "type": "string" } }, "required": ["display"], "type": "object" }, "displayOptions": { "additionalProperties": false, "properties": { "baseCharacter": { "type": "string" } }, "type": "object" }, "displays": { "additionalProperties": false, "properties": { "display": { "items": { "$ref": "#/definitions/display" }, "type": "array" }, "displayOptions": { "$ref": "#/definitions/displayOptions" }, "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" } }, "type": "object" }, "flick": { "additionalProperties": false, "properties": { "directions": { "type": "string" }, "to": { "type": "string" } }, "required": ["directions", "to"], "type": "object" }, "flicks": { "additionalProperties": false, "properties": { "flick": { "items": { "$ref": "#/definitions/flick" }, "minItems": 1, "type": "array" }, "id": { "type": "string" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" } }, "required": ["flick", "id"], "type": "object" }, "form": { "additionalProperties": false, "properties": { "id": { "type": "string" }, "scanCodes": { "items": { "$ref": "#/definitions/scanCodes" }, "minItems": 1, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" } }, "required": ["scanCodes"], "type": "object" }, "forms": { "additionalProperties": false, "properties": { "form": { "items": { "$ref": "#/definitions/form" }, "type": "array" }, "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" } }, "type": "object" }, "import": { "additionalProperties": false, "properties": { "base": { "enum": ["cldr"], "type": "string" }, "path": { "type": "string" } }, "required": ["path"], "type": "object" }, "info": { "additionalProperties": false, "properties": { "author": { "type": "string" }, "indicator": { "type": "string" }, "layout": { "type": "string" }, "normalization": { "type": "string" } }, "type": "object" }, "key": { "additionalProperties": false, "properties": { "flicks": { "type": "string" }, "gap": { "enum": ["true"], "type": "string" }, "id": { "type": "string" }, "longPress": { "type": "string" }, "longPressDefault": { "type": "string" }, "multiTap": { "type": "string" }, "stretch": { "enum": ["true"], "type": "string" }, "switch": { "type": "string" }, "to": { "type": "string" }, "transform": { "enum": ["no"], "type": "string" }, "width": { "type": "string" } }, "required": ["id"], "type": "object" }, "keys": { "additionalProperties": false, "properties": { "flicks": { "items": { "$ref": "#/definitions/flicks" }, "type": "array" }, "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "key": { "items": { "$ref": "#/definitions/key" }, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" } }, "type": "object" }, "layer": { "additionalProperties": false, "properties": { "id": { "type": "string" }, "modifier": { "type": "string" }, "row": { "items": { "$ref": "#/definitions/row" }, "minItems": 1, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" } }, "required": ["row"], "type": "object" }, "layers": { "additionalProperties": false, "properties": { "form": { "type": "string" }, "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "layer": { "items": { "$ref": "#/definitions/layer" }, "type": "array" }, "minDeviceWidth": { "type": "string" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" } }, "required": ["form"], "type": "object" }, "locale": { "additionalProperties": false, "properties": { "id": { "type": "string" } }, "required": ["id"], "type": "object" }, "locales": { "additionalProperties": false, "properties": { "locale": { "items": { "$ref": "#/definitions/locale" }, "type": "array" } }, "type": "object" }, "name": { "additionalProperties": false, "properties": { "value": { "type": "string" } }, "required": ["value"], "type": "object" }, "names": { "additionalProperties": false, "properties": { "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "name": { "items": { "$ref": "#/definitions/name" }, "minItems": 1, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" } }, "required": ["name"], "type": "object" }, "reorder": { "additionalProperties": false, "properties": { "before": { "type": "string" }, "from": { "type": "string" }, "order": { "type": "string" }, "preBase": { "type": "string" }, "tertiary": { "type": "string" }, "tertiaryBase": { "type": "string" } }, "required": ["from"], "type": "object" }, "row": { "additionalProperties": false, "properties": { "keys": { "type": "string" } }, "required": ["keys"], "type": "object" }, "scanCodes": { "additionalProperties": false, "properties": { "codes": { "type": "string" } }, "required": ["codes"], "type": "object" }, "set": { "additionalProperties": false, "properties": { "id": { "type": "string" }, "value": { "type": "string" } }, "required": ["id", "value"], "type": "object" }, "settings": { "additionalProperties": false, "properties": { "fallback": { "enum": ["omit"], "type": "string" } }, "type": "object" }, "special": { "$ref": "#/definitions/any" }, "stringVariable": { "additionalProperties": false, "properties": { "id": { "type": "string" }, "value": { "type": "string" } }, "required": ["id", "value"], "type": "object" }, "transform": { "additionalProperties": false, "properties": { "from": { "type": "string" }, "to": { "type": "string" } }, "required": ["from"], "type": "object" }, "transformGroup": { "additionalProperties": false, "properties": { "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "reorder": { "items": { "$ref": "#/definitions/reorder" }, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" }, "transform": { "items": { "$ref": "#/definitions/transform" }, "type": "array" } }, "type": "object" }, "transforms": { "additionalProperties": false, "properties": { "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" }, "transformGroup": { "items": { "$ref": "#/definitions/transformGroup" }, "type": "array" }, "type": { "enum": ["simple", "backspace"], "type": "string" } }, "required": ["type"], "type": "object" }, "unicodeSet": { "additionalProperties": false, "properties": { "id": { "type": "string" }, "value": { "type": "string" } }, "required": ["id", "value"], "type": "object" }, "variables": { "additionalProperties": false, "properties": { "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "set": { "items": { "$ref": "#/definitions/set" }, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" }, "string": { "items": { "$ref": "#/definitions/stringVariable" }, "type": "array" }, "unicodeSet": { "items": { "$ref": "#/definitions/unicodeSet" }, "type": "array" } }, "type": "object" }, "version": { "additionalProperties": false, "properties": { "cldrVersion": { "enum": ["techpreview"], "type": "string" }, "number": { "type": "string" } }, "type": "object" } }, "properties": { "keyboard3": { "additionalProperties": false, "properties": { "conformsTo": { "enum": ["techpreview"], "type": "string" }, "displays": { "$ref": "#/definitions/displays" }, "forms": { "$ref": "#/definitions/forms" }, "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "info": { "$ref": "#/definitions/info" }, "keys": { "$ref": "#/definitions/keys" }, "layers": { "items": { "$ref": "#/definitions/layers" }, "type": "array" }, "locale": { "type": "string" }, "locales": { "$ref": "#/definitions/locales" }, "names": { "$ref": "#/definitions/names" }, "settings": { "$ref": "#/definitions/settings" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" }, "transforms": { "items": { "$ref": "#/definitions/transforms" }, "type": "array" }, "variables": { "$ref": "#/definitions/variables" }, "version": { "$ref": "#/definitions/version" } }, "required": ["names", "locale", "conformsTo"], "type": "object" } }, "required": ["keyboard3"], "title": "techpreview/dtd/ldmlKeyboard3.xsd", "type": "object" };
+        var schema26 = { "additionalProperties": false, "properties": { "base": { "enum": ["cldr"], "type": "string" }, "path": { "type": "string" } }, "required": ["path"], "type": "object" };
+        var schema55 = { "additionalProperties": false, "properties": { "fallback": { "enum": ["omit"], "type": "string" } }, "type": "object" };
+        var schema71 = { "additionalProperties": false, "properties": { "cldrVersion": { "enum": ["techpreview"], "type": "string" }, "number": { "type": "string" } }, "type": "object" };
+        var func4 = Object.prototype.hasOwnProperty;
+        function validate21(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    const _errs1 = errors;
+                    for (const key0 in data) {
+                        if (!(key0 === "display" || key0 === "displayOptions" || key0 === "import" || key0 === "special")) {
+                            validate21.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                            return false;
+                            break;
+                        }
+                    }
+                    if (_errs1 === errors) {
+                        if (data.display !== void 0) {
+                            let data0 = data.display;
+                            const _errs2 = errors;
+                            if (errors === _errs2) {
+                                if (Array.isArray(data0)) {
+                                    var valid1 = true;
+                                    const len0 = data0.length;
+                                    for (let i0 = 0; i0 < len0; i0++) {
+                                        let data1 = data0[i0];
+                                        const _errs4 = errors;
+                                        const _errs5 = errors;
+                                        if (errors === _errs5) {
+                                            if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                                                let missing0;
+                                                if (data1.display === void 0 && (missing0 = "display")) {
+                                                    validate21.errors = [{ instancePath: instancePath + "/display/" + i0, schemaPath: "#/definitions/display/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                                                    return false;
+                                                }
+                                                else {
+                                                    const _errs7 = errors;
+                                                    for (const key1 in data1) {
+                                                        if (!(key1 === "display" || key1 === "id" || key1 === "to")) {
+                                                            validate21.errors = [{ instancePath: instancePath + "/display/" + i0, schemaPath: "#/definitions/display/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                            return false;
+                                                            break;
+                                                        }
+                                                    }
+                                                    if (_errs7 === errors) {
+                                                        if (data1.display !== void 0) {
+                                                            const _errs8 = errors;
+                                                            if (typeof data1.display !== "string") {
+                                                                validate21.errors = [{ instancePath: instancePath + "/display/" + i0 + "/display", schemaPath: "#/definitions/display/properties/display/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                return false;
+                                                            }
+                                                            var valid3 = _errs8 === errors;
+                                                        }
+                                                        else {
+                                                            var valid3 = true;
+                                                        }
+                                                        if (valid3) {
+                                                            if (data1.id !== void 0) {
+                                                                const _errs10 = errors;
+                                                                if (typeof data1.id !== "string") {
+                                                                    validate21.errors = [{ instancePath: instancePath + "/display/" + i0 + "/id", schemaPath: "#/definitions/display/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                var valid3 = _errs10 === errors;
+                                                            }
+                                                            else {
+                                                                var valid3 = true;
+                                                            }
+                                                            if (valid3) {
+                                                                if (data1.to !== void 0) {
+                                                                    const _errs12 = errors;
+                                                                    if (typeof data1.to !== "string") {
+                                                                        validate21.errors = [{ instancePath: instancePath + "/display/" + i0 + "/to", schemaPath: "#/definitions/display/properties/to/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid3 = _errs12 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid3 = true;
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate21.errors = [{ instancePath: instancePath + "/display/" + i0, schemaPath: "#/definitions/display/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid1 = _errs4 === errors;
+                                        if (!valid1) {
+                                            break;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate21.errors = [{ instancePath: instancePath + "/display", schemaPath: "#/properties/display/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs2 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.displayOptions !== void 0) {
+                                let data5 = data.displayOptions;
+                                const _errs14 = errors;
+                                const _errs15 = errors;
+                                if (errors === _errs15) {
+                                    if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                                        const _errs17 = errors;
+                                        for (const key2 in data5) {
+                                            if (!(key2 === "baseCharacter")) {
+                                                validate21.errors = [{ instancePath: instancePath + "/displayOptions", schemaPath: "#/definitions/displayOptions/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                return false;
+                                                break;
+                                            }
+                                        }
+                                        if (_errs17 === errors) {
+                                            if (data5.baseCharacter !== void 0) {
+                                                if (typeof data5.baseCharacter !== "string") {
+                                                    validate21.errors = [{ instancePath: instancePath + "/displayOptions/baseCharacter", schemaPath: "#/definitions/displayOptions/properties/baseCharacter/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                    return false;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate21.errors = [{ instancePath: instancePath + "/displayOptions", schemaPath: "#/definitions/displayOptions/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs14 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.import !== void 0) {
+                                    let data7 = data.import;
+                                    const _errs20 = errors;
+                                    if (errors === _errs20) {
+                                        if (Array.isArray(data7)) {
+                                            var valid6 = true;
+                                            const len1 = data7.length;
+                                            for (let i1 = 0; i1 < len1; i1++) {
+                                                let data8 = data7[i1];
+                                                const _errs22 = errors;
+                                                const _errs23 = errors;
+                                                if (errors === _errs23) {
+                                                    if (data8 && typeof data8 == "object" && !Array.isArray(data8)) {
+                                                        let missing1;
+                                                        if (data8.path === void 0 && (missing1 = "path")) {
+                                                            validate21.errors = [{ instancePath: instancePath + "/import/" + i1, schemaPath: "#/definitions/import/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                            return false;
+                                                        }
+                                                        else {
+                                                            const _errs25 = errors;
+                                                            for (const key3 in data8) {
+                                                                if (!(key3 === "base" || key3 === "path")) {
+                                                                    validate21.errors = [{ instancePath: instancePath + "/import/" + i1, schemaPath: "#/definitions/import/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" }];
+                                                                    return false;
+                                                                    break;
+                                                                }
+                                                            }
+                                                            if (_errs25 === errors) {
+                                                                if (data8.base !== void 0) {
+                                                                    let data9 = data8.base;
+                                                                    const _errs26 = errors;
+                                                                    if (typeof data9 !== "string") {
+                                                                        validate21.errors = [{ instancePath: instancePath + "/import/" + i1 + "/base", schemaPath: "#/definitions/import/properties/base/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    if (!(data9 === "cldr")) {
+                                                                        validate21.errors = [{ instancePath: instancePath + "/import/" + i1 + "/base", schemaPath: "#/definitions/import/properties/base/enum", keyword: "enum", params: { allowedValues: schema26.properties.base.enum }, message: "must be equal to one of the allowed values" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid8 = _errs26 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid8 = true;
+                                                                }
+                                                                if (valid8) {
+                                                                    if (data8.path !== void 0) {
+                                                                        const _errs28 = errors;
+                                                                        if (typeof data8.path !== "string") {
+                                                                            validate21.errors = [{ instancePath: instancePath + "/import/" + i1 + "/path", schemaPath: "#/definitions/import/properties/path/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid8 = _errs28 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid8 = true;
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate21.errors = [{ instancePath: instancePath + "/import/" + i1, schemaPath: "#/definitions/import/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                var valid6 = _errs22 === errors;
+                                                if (!valid6) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate21.errors = [{ instancePath: instancePath + "/import", schemaPath: "#/properties/import/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs20 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.special !== void 0) {
+                                        let data11 = data.special;
+                                        const _errs30 = errors;
+                                        if (errors === _errs30) {
+                                            if (Array.isArray(data11)) {
+                                                var valid9 = true;
+                                                const len2 = data11.length;
+                                                for (let i2 = 0; i2 < len2; i2++) {
+                                                    const _errs32 = errors;
+                                                    if (typeof data11[i2] !== "string") {
+                                                        validate21.errors = [{ instancePath: instancePath + "/special/" + i2, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                    var valid9 = _errs32 === errors;
+                                                    if (!valid9) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate21.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs30 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate21.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate21.errors = vErrors;
+            return errors === 0;
+        }
+        function validate24(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    let missing0;
+                    if (data.scanCodes === void 0 && (missing0 = "scanCodes")) {
+                        validate24.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                        return false;
+                    }
+                    else {
+                        const _errs1 = errors;
+                        for (const key0 in data) {
+                            if (!(key0 === "id" || key0 === "scanCodes" || key0 === "special")) {
+                                validate24.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                                return false;
+                                break;
+                            }
+                        }
+                        if (_errs1 === errors) {
+                            if (data.id !== void 0) {
+                                const _errs2 = errors;
+                                if (typeof data.id !== "string") {
+                                    validate24.errors = [{ instancePath: instancePath + "/id", schemaPath: "#/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                                var valid0 = _errs2 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.scanCodes !== void 0) {
+                                    let data1 = data.scanCodes;
+                                    const _errs4 = errors;
+                                    if (errors === _errs4) {
+                                        if (Array.isArray(data1)) {
+                                            if (data1.length < 1) {
+                                                validate24.errors = [{ instancePath: instancePath + "/scanCodes", schemaPath: "#/properties/scanCodes/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" }];
+                                                return false;
+                                            }
+                                            else {
+                                                var valid1 = true;
+                                                const len0 = data1.length;
+                                                for (let i0 = 0; i0 < len0; i0++) {
+                                                    let data2 = data1[i0];
+                                                    const _errs6 = errors;
+                                                    const _errs7 = errors;
+                                                    if (errors === _errs7) {
+                                                        if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+                                                            let missing1;
+                                                            if (data2.codes === void 0 && (missing1 = "codes")) {
+                                                                validate24.errors = [{ instancePath: instancePath + "/scanCodes/" + i0, schemaPath: "#/definitions/scanCodes/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                                return false;
+                                                            }
+                                                            else {
+                                                                const _errs9 = errors;
+                                                                for (const key1 in data2) {
+                                                                    if (!(key1 === "codes")) {
+                                                                        validate24.errors = [{ instancePath: instancePath + "/scanCodes/" + i0, schemaPath: "#/definitions/scanCodes/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                        return false;
+                                                                        break;
+                                                                    }
+                                                                }
+                                                                if (_errs9 === errors) {
+                                                                    if (data2.codes !== void 0) {
+                                                                        if (typeof data2.codes !== "string") {
+                                                                            validate24.errors = [{ instancePath: instancePath + "/scanCodes/" + i0 + "/codes", schemaPath: "#/definitions/scanCodes/properties/codes/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                        else {
+                                                            validate24.errors = [{ instancePath: instancePath + "/scanCodes/" + i0, schemaPath: "#/definitions/scanCodes/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    var valid1 = _errs6 === errors;
+                                                    if (!valid1) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate24.errors = [{ instancePath: instancePath + "/scanCodes", schemaPath: "#/properties/scanCodes/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs4 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.special !== void 0) {
+                                        let data4 = data.special;
+                                        const _errs12 = errors;
+                                        if (errors === _errs12) {
+                                            if (Array.isArray(data4)) {
+                                                var valid4 = true;
+                                                const len1 = data4.length;
+                                                for (let i1 = 0; i1 < len1; i1++) {
+                                                    const _errs14 = errors;
+                                                    if (typeof data4[i1] !== "string") {
+                                                        validate24.errors = [{ instancePath: instancePath + "/special/" + i1, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                    var valid4 = _errs14 === errors;
+                                                    if (!valid4) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate24.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs12 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate24.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate24.errors = vErrors;
+            return errors === 0;
+        }
+        function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    const _errs1 = errors;
+                    for (const key0 in data) {
+                        if (!(key0 === "form" || key0 === "import" || key0 === "special")) {
+                            validate23.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                            return false;
+                            break;
+                        }
+                    }
+                    if (_errs1 === errors) {
+                        if (data.form !== void 0) {
+                            let data0 = data.form;
+                            const _errs2 = errors;
+                            if (errors === _errs2) {
+                                if (Array.isArray(data0)) {
+                                    var valid1 = true;
+                                    const len0 = data0.length;
+                                    for (let i0 = 0; i0 < len0; i0++) {
+                                        const _errs4 = errors;
+                                        if (!validate24(data0[i0], { instancePath: instancePath + "/form/" + i0, parentData: data0, parentDataProperty: i0, rootData })) {
+                                            vErrors = vErrors === null ? validate24.errors : vErrors.concat(validate24.errors);
+                                            errors = vErrors.length;
+                                        }
+                                        var valid1 = _errs4 === errors;
+                                        if (!valid1) {
+                                            break;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate23.errors = [{ instancePath: instancePath + "/form", schemaPath: "#/properties/form/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs2 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.import !== void 0) {
+                                let data2 = data.import;
+                                const _errs5 = errors;
+                                if (errors === _errs5) {
+                                    if (Array.isArray(data2)) {
+                                        var valid2 = true;
+                                        const len1 = data2.length;
+                                        for (let i1 = 0; i1 < len1; i1++) {
+                                            let data3 = data2[i1];
+                                            const _errs7 = errors;
+                                            const _errs8 = errors;
+                                            if (errors === _errs8) {
+                                                if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+                                                    let missing0;
+                                                    if (data3.path === void 0 && (missing0 = "path")) {
+                                                        validate23.errors = [{ instancePath: instancePath + "/import/" + i1, schemaPath: "#/definitions/import/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                                                        return false;
+                                                    }
+                                                    else {
+                                                        const _errs10 = errors;
+                                                        for (const key1 in data3) {
+                                                            if (!(key1 === "base" || key1 === "path")) {
+                                                                validate23.errors = [{ instancePath: instancePath + "/import/" + i1, schemaPath: "#/definitions/import/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                return false;
+                                                                break;
+                                                            }
+                                                        }
+                                                        if (_errs10 === errors) {
+                                                            if (data3.base !== void 0) {
+                                                                let data4 = data3.base;
+                                                                const _errs11 = errors;
+                                                                if (typeof data4 !== "string") {
+                                                                    validate23.errors = [{ instancePath: instancePath + "/import/" + i1 + "/base", schemaPath: "#/definitions/import/properties/base/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                if (!(data4 === "cldr")) {
+                                                                    validate23.errors = [{ instancePath: instancePath + "/import/" + i1 + "/base", schemaPath: "#/definitions/import/properties/base/enum", keyword: "enum", params: { allowedValues: schema26.properties.base.enum }, message: "must be equal to one of the allowed values" }];
+                                                                    return false;
+                                                                }
+                                                                var valid4 = _errs11 === errors;
+                                                            }
+                                                            else {
+                                                                var valid4 = true;
+                                                            }
+                                                            if (valid4) {
+                                                                if (data3.path !== void 0) {
+                                                                    const _errs13 = errors;
+                                                                    if (typeof data3.path !== "string") {
+                                                                        validate23.errors = [{ instancePath: instancePath + "/import/" + i1 + "/path", schemaPath: "#/definitions/import/properties/path/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid4 = _errs13 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid4 = true;
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                else {
+                                                    validate23.errors = [{ instancePath: instancePath + "/import/" + i1, schemaPath: "#/definitions/import/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                    return false;
+                                                }
+                                            }
+                                            var valid2 = _errs7 === errors;
+                                            if (!valid2) {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate23.errors = [{ instancePath: instancePath + "/import", schemaPath: "#/properties/import/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs5 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.special !== void 0) {
+                                    let data6 = data.special;
+                                    const _errs15 = errors;
+                                    if (errors === _errs15) {
+                                        if (Array.isArray(data6)) {
+                                            var valid5 = true;
+                                            const len2 = data6.length;
+                                            for (let i2 = 0; i2 < len2; i2++) {
+                                                const _errs17 = errors;
+                                                if (typeof data6[i2] !== "string") {
+                                                    validate23.errors = [{ instancePath: instancePath + "/special/" + i2, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                    return false;
+                                                }
+                                                var valid5 = _errs17 === errors;
+                                                if (!valid5) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate23.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs15 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate23.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate23.errors = vErrors;
+            return errors === 0;
+        }
+        var schema41 = { "additionalProperties": false, "properties": { "flicks": { "type": "string" }, "gap": { "enum": ["true"], "type": "string" }, "id": { "type": "string" }, "longPress": { "type": "string" }, "longPressDefault": { "type": "string" }, "multiTap": { "type": "string" }, "stretch": { "enum": ["true"], "type": "string" }, "switch": { "type": "string" }, "to": { "type": "string" }, "transform": { "enum": ["no"], "type": "string" }, "width": { "type": "string" } }, "required": ["id"], "type": "object" };
+        function validate28(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    let missing0;
+                    if (data.flick === void 0 && (missing0 = "flick") || data.id === void 0 && (missing0 = "id")) {
+                        validate28.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                        return false;
+                    }
+                    else {
+                        const _errs1 = errors;
+                        for (const key0 in data) {
+                            if (!(key0 === "flick" || key0 === "id" || key0 === "special")) {
+                                validate28.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                                return false;
+                                break;
+                            }
+                        }
+                        if (_errs1 === errors) {
+                            if (data.flick !== void 0) {
+                                let data0 = data.flick;
+                                const _errs2 = errors;
+                                if (errors === _errs2) {
+                                    if (Array.isArray(data0)) {
+                                        if (data0.length < 1) {
+                                            validate28.errors = [{ instancePath: instancePath + "/flick", schemaPath: "#/properties/flick/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" }];
+                                            return false;
+                                        }
+                                        else {
+                                            var valid1 = true;
+                                            const len0 = data0.length;
+                                            for (let i0 = 0; i0 < len0; i0++) {
+                                                let data1 = data0[i0];
+                                                const _errs4 = errors;
+                                                const _errs5 = errors;
+                                                if (errors === _errs5) {
+                                                    if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                                                        let missing1;
+                                                        if (data1.directions === void 0 && (missing1 = "directions") || data1.to === void 0 && (missing1 = "to")) {
+                                                            validate28.errors = [{ instancePath: instancePath + "/flick/" + i0, schemaPath: "#/definitions/flick/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                            return false;
+                                                        }
+                                                        else {
+                                                            const _errs7 = errors;
+                                                            for (const key1 in data1) {
+                                                                if (!(key1 === "directions" || key1 === "to")) {
+                                                                    validate28.errors = [{ instancePath: instancePath + "/flick/" + i0, schemaPath: "#/definitions/flick/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                    return false;
+                                                                    break;
+                                                                }
+                                                            }
+                                                            if (_errs7 === errors) {
+                                                                if (data1.directions !== void 0) {
+                                                                    const _errs8 = errors;
+                                                                    if (typeof data1.directions !== "string") {
+                                                                        validate28.errors = [{ instancePath: instancePath + "/flick/" + i0 + "/directions", schemaPath: "#/definitions/flick/properties/directions/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid3 = _errs8 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid3 = true;
+                                                                }
+                                                                if (valid3) {
+                                                                    if (data1.to !== void 0) {
+                                                                        const _errs10 = errors;
+                                                                        if (typeof data1.to !== "string") {
+                                                                            validate28.errors = [{ instancePath: instancePath + "/flick/" + i0 + "/to", schemaPath: "#/definitions/flick/properties/to/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid3 = _errs10 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid3 = true;
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate28.errors = [{ instancePath: instancePath + "/flick/" + i0, schemaPath: "#/definitions/flick/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                var valid1 = _errs4 === errors;
+                                                if (!valid1) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate28.errors = [{ instancePath: instancePath + "/flick", schemaPath: "#/properties/flick/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs2 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.id !== void 0) {
+                                    const _errs12 = errors;
+                                    if (typeof data.id !== "string") {
+                                        validate28.errors = [{ instancePath: instancePath + "/id", schemaPath: "#/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                    var valid0 = _errs12 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.special !== void 0) {
+                                        let data5 = data.special;
+                                        const _errs14 = errors;
+                                        if (errors === _errs14) {
+                                            if (Array.isArray(data5)) {
+                                                var valid4 = true;
+                                                const len1 = data5.length;
+                                                for (let i1 = 0; i1 < len1; i1++) {
+                                                    const _errs16 = errors;
+                                                    if (typeof data5[i1] !== "string") {
+                                                        validate28.errors = [{ instancePath: instancePath + "/special/" + i1, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                    var valid4 = _errs16 === errors;
+                                                    if (!valid4) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate28.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs14 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate28.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate28.errors = vErrors;
+            return errors === 0;
+        }
+        function validate27(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    const _errs1 = errors;
+                    for (const key0 in data) {
+                        if (!(key0 === "flicks" || key0 === "import" || key0 === "key" || key0 === "special")) {
+                            validate27.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                            return false;
+                            break;
+                        }
+                    }
+                    if (_errs1 === errors) {
+                        if (data.flicks !== void 0) {
+                            let data0 = data.flicks;
+                            const _errs2 = errors;
+                            if (errors === _errs2) {
+                                if (Array.isArray(data0)) {
+                                    var valid1 = true;
+                                    const len0 = data0.length;
+                                    for (let i0 = 0; i0 < len0; i0++) {
+                                        const _errs4 = errors;
+                                        if (!validate28(data0[i0], { instancePath: instancePath + "/flicks/" + i0, parentData: data0, parentDataProperty: i0, rootData })) {
+                                            vErrors = vErrors === null ? validate28.errors : vErrors.concat(validate28.errors);
+                                            errors = vErrors.length;
+                                        }
+                                        var valid1 = _errs4 === errors;
+                                        if (!valid1) {
+                                            break;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate27.errors = [{ instancePath: instancePath + "/flicks", schemaPath: "#/properties/flicks/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs2 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.import !== void 0) {
+                                let data2 = data.import;
+                                const _errs5 = errors;
+                                if (errors === _errs5) {
+                                    if (Array.isArray(data2)) {
+                                        var valid2 = true;
+                                        const len1 = data2.length;
+                                        for (let i1 = 0; i1 < len1; i1++) {
+                                            let data3 = data2[i1];
+                                            const _errs7 = errors;
+                                            const _errs8 = errors;
+                                            if (errors === _errs8) {
+                                                if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+                                                    let missing0;
+                                                    if (data3.path === void 0 && (missing0 = "path")) {
+                                                        validate27.errors = [{ instancePath: instancePath + "/import/" + i1, schemaPath: "#/definitions/import/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                                                        return false;
+                                                    }
+                                                    else {
+                                                        const _errs10 = errors;
+                                                        for (const key1 in data3) {
+                                                            if (!(key1 === "base" || key1 === "path")) {
+                                                                validate27.errors = [{ instancePath: instancePath + "/import/" + i1, schemaPath: "#/definitions/import/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                return false;
+                                                                break;
+                                                            }
+                                                        }
+                                                        if (_errs10 === errors) {
+                                                            if (data3.base !== void 0) {
+                                                                let data4 = data3.base;
+                                                                const _errs11 = errors;
+                                                                if (typeof data4 !== "string") {
+                                                                    validate27.errors = [{ instancePath: instancePath + "/import/" + i1 + "/base", schemaPath: "#/definitions/import/properties/base/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                if (!(data4 === "cldr")) {
+                                                                    validate27.errors = [{ instancePath: instancePath + "/import/" + i1 + "/base", schemaPath: "#/definitions/import/properties/base/enum", keyword: "enum", params: { allowedValues: schema26.properties.base.enum }, message: "must be equal to one of the allowed values" }];
+                                                                    return false;
+                                                                }
+                                                                var valid4 = _errs11 === errors;
+                                                            }
+                                                            else {
+                                                                var valid4 = true;
+                                                            }
+                                                            if (valid4) {
+                                                                if (data3.path !== void 0) {
+                                                                    const _errs13 = errors;
+                                                                    if (typeof data3.path !== "string") {
+                                                                        validate27.errors = [{ instancePath: instancePath + "/import/" + i1 + "/path", schemaPath: "#/definitions/import/properties/path/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid4 = _errs13 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid4 = true;
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                else {
+                                                    validate27.errors = [{ instancePath: instancePath + "/import/" + i1, schemaPath: "#/definitions/import/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                    return false;
+                                                }
+                                            }
+                                            var valid2 = _errs7 === errors;
+                                            if (!valid2) {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate27.errors = [{ instancePath: instancePath + "/import", schemaPath: "#/properties/import/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs5 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.key !== void 0) {
+                                    let data6 = data.key;
+                                    const _errs15 = errors;
+                                    if (errors === _errs15) {
+                                        if (Array.isArray(data6)) {
+                                            var valid5 = true;
+                                            const len2 = data6.length;
+                                            for (let i2 = 0; i2 < len2; i2++) {
+                                                let data7 = data6[i2];
+                                                const _errs17 = errors;
+                                                const _errs18 = errors;
+                                                if (errors === _errs18) {
+                                                    if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
+                                                        let missing1;
+                                                        if (data7.id === void 0 && (missing1 = "id")) {
+                                                            validate27.errors = [{ instancePath: instancePath + "/key/" + i2, schemaPath: "#/definitions/key/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                            return false;
+                                                        }
+                                                        else {
+                                                            const _errs20 = errors;
+                                                            for (const key2 in data7) {
+                                                                if (!func4.call(schema41.properties, key2)) {
+                                                                    validate27.errors = [{ instancePath: instancePath + "/key/" + i2, schemaPath: "#/definitions/key/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                                    return false;
+                                                                    break;
+                                                                }
+                                                            }
+                                                            if (_errs20 === errors) {
+                                                                if (data7.flicks !== void 0) {
+                                                                    const _errs21 = errors;
+                                                                    if (typeof data7.flicks !== "string") {
+                                                                        validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/flicks", schemaPath: "#/definitions/key/properties/flicks/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid7 = _errs21 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid7 = true;
+                                                                }
+                                                                if (valid7) {
+                                                                    if (data7.gap !== void 0) {
+                                                                        let data9 = data7.gap;
+                                                                        const _errs23 = errors;
+                                                                        if (typeof data9 !== "string") {
+                                                                            validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/gap", schemaPath: "#/definitions/key/properties/gap/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                        if (!(data9 === "true")) {
+                                                                            validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/gap", schemaPath: "#/definitions/key/properties/gap/enum", keyword: "enum", params: { allowedValues: schema41.properties.gap.enum }, message: "must be equal to one of the allowed values" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid7 = _errs23 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid7 = true;
+                                                                    }
+                                                                    if (valid7) {
+                                                                        if (data7.id !== void 0) {
+                                                                            const _errs25 = errors;
+                                                                            if (typeof data7.id !== "string") {
+                                                                                validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/id", schemaPath: "#/definitions/key/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid7 = _errs25 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid7 = true;
+                                                                        }
+                                                                        if (valid7) {
+                                                                            if (data7.longPress !== void 0) {
+                                                                                const _errs27 = errors;
+                                                                                if (typeof data7.longPress !== "string") {
+                                                                                    validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/longPress", schemaPath: "#/definitions/key/properties/longPress/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                                var valid7 = _errs27 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid7 = true;
+                                                                            }
+                                                                            if (valid7) {
+                                                                                if (data7.longPressDefault !== void 0) {
+                                                                                    const _errs29 = errors;
+                                                                                    if (typeof data7.longPressDefault !== "string") {
+                                                                                        validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/longPressDefault", schemaPath: "#/definitions/key/properties/longPressDefault/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    var valid7 = _errs29 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid7 = true;
+                                                                                }
+                                                                                if (valid7) {
+                                                                                    if (data7.multiTap !== void 0) {
+                                                                                        const _errs31 = errors;
+                                                                                        if (typeof data7.multiTap !== "string") {
+                                                                                            validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/multiTap", schemaPath: "#/definitions/key/properties/multiTap/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        var valid7 = _errs31 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid7 = true;
+                                                                                    }
+                                                                                    if (valid7) {
+                                                                                        if (data7.stretch !== void 0) {
+                                                                                            let data14 = data7.stretch;
+                                                                                            const _errs33 = errors;
+                                                                                            if (typeof data14 !== "string") {
+                                                                                                validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/stretch", schemaPath: "#/definitions/key/properties/stretch/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                            if (!(data14 === "true")) {
+                                                                                                validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/stretch", schemaPath: "#/definitions/key/properties/stretch/enum", keyword: "enum", params: { allowedValues: schema41.properties.stretch.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                            var valid7 = _errs33 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid7 = true;
+                                                                                        }
+                                                                                        if (valid7) {
+                                                                                            if (data7.switch !== void 0) {
+                                                                                                const _errs35 = errors;
+                                                                                                if (typeof data7.switch !== "string") {
+                                                                                                    validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/switch", schemaPath: "#/definitions/key/properties/switch/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                                var valid7 = _errs35 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid7 = true;
+                                                                                            }
+                                                                                            if (valid7) {
+                                                                                                if (data7.to !== void 0) {
+                                                                                                    const _errs37 = errors;
+                                                                                                    if (typeof data7.to !== "string") {
+                                                                                                        validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/to", schemaPath: "#/definitions/key/properties/to/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                    var valid7 = _errs37 === errors;
+                                                                                                }
+                                                                                                else {
+                                                                                                    var valid7 = true;
+                                                                                                }
+                                                                                                if (valid7) {
+                                                                                                    if (data7.transform !== void 0) {
+                                                                                                        let data17 = data7.transform;
+                                                                                                        const _errs39 = errors;
+                                                                                                        if (typeof data17 !== "string") {
+                                                                                                            validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/transform", schemaPath: "#/definitions/key/properties/transform/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        if (!(data17 === "no")) {
+                                                                                                            validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/transform", schemaPath: "#/definitions/key/properties/transform/enum", keyword: "enum", params: { allowedValues: schema41.properties.transform.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                        var valid7 = _errs39 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid7 = true;
+                                                                                                    }
+                                                                                                    if (valid7) {
+                                                                                                        if (data7.width !== void 0) {
+                                                                                                            const _errs41 = errors;
+                                                                                                            if (typeof data7.width !== "string") {
+                                                                                                                validate27.errors = [{ instancePath: instancePath + "/key/" + i2 + "/width", schemaPath: "#/definitions/key/properties/width/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                            var valid7 = _errs41 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid7 = true;
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate27.errors = [{ instancePath: instancePath + "/key/" + i2, schemaPath: "#/definitions/key/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                var valid5 = _errs17 === errors;
+                                                if (!valid5) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate27.errors = [{ instancePath: instancePath + "/key", schemaPath: "#/properties/key/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs15 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.special !== void 0) {
+                                        let data19 = data.special;
+                                        const _errs43 = errors;
+                                        if (errors === _errs43) {
+                                            if (Array.isArray(data19)) {
+                                                var valid8 = true;
+                                                const len3 = data19.length;
+                                                for (let i3 = 0; i3 < len3; i3++) {
+                                                    const _errs45 = errors;
+                                                    if (typeof data19[i3] !== "string") {
+                                                        validate27.errors = [{ instancePath: instancePath + "/special/" + i3, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                    var valid8 = _errs45 === errors;
+                                                    if (!valid8) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate27.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs43 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate27.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate27.errors = vErrors;
+            return errors === 0;
+        }
+        function validate32(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    let missing0;
+                    if (data.row === void 0 && (missing0 = "row")) {
+                        validate32.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                        return false;
+                    }
+                    else {
+                        const _errs1 = errors;
+                        for (const key0 in data) {
+                            if (!(key0 === "id" || key0 === "modifier" || key0 === "row" || key0 === "special")) {
+                                validate32.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                                return false;
+                                break;
+                            }
+                        }
+                        if (_errs1 === errors) {
+                            if (data.id !== void 0) {
+                                const _errs2 = errors;
+                                if (typeof data.id !== "string") {
+                                    validate32.errors = [{ instancePath: instancePath + "/id", schemaPath: "#/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                                var valid0 = _errs2 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.modifier !== void 0) {
+                                    const _errs4 = errors;
+                                    if (typeof data.modifier !== "string") {
+                                        validate32.errors = [{ instancePath: instancePath + "/modifier", schemaPath: "#/properties/modifier/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                        return false;
+                                    }
+                                    var valid0 = _errs4 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.row !== void 0) {
+                                        let data2 = data.row;
+                                        const _errs6 = errors;
+                                        if (errors === _errs6) {
+                                            if (Array.isArray(data2)) {
+                                                if (data2.length < 1) {
+                                                    validate32.errors = [{ instancePath: instancePath + "/row", schemaPath: "#/properties/row/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" }];
+                                                    return false;
+                                                }
+                                                else {
+                                                    var valid1 = true;
+                                                    const len0 = data2.length;
+                                                    for (let i0 = 0; i0 < len0; i0++) {
+                                                        let data3 = data2[i0];
+                                                        const _errs8 = errors;
+                                                        const _errs9 = errors;
+                                                        if (errors === _errs9) {
+                                                            if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+                                                                let missing1;
+                                                                if (data3.keys === void 0 && (missing1 = "keys")) {
+                                                                    validate32.errors = [{ instancePath: instancePath + "/row/" + i0, schemaPath: "#/definitions/row/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                                    return false;
+                                                                }
+                                                                else {
+                                                                    const _errs11 = errors;
+                                                                    for (const key1 in data3) {
+                                                                        if (!(key1 === "keys")) {
+                                                                            validate32.errors = [{ instancePath: instancePath + "/row/" + i0, schemaPath: "#/definitions/row/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                            return false;
+                                                                            break;
+                                                                        }
+                                                                    }
+                                                                    if (_errs11 === errors) {
+                                                                        if (data3.keys !== void 0) {
+                                                                            if (typeof data3.keys !== "string") {
+                                                                                validate32.errors = [{ instancePath: instancePath + "/row/" + i0 + "/keys", schemaPath: "#/definitions/row/properties/keys/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                            else {
+                                                                validate32.errors = [{ instancePath: instancePath + "/row/" + i0, schemaPath: "#/definitions/row/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                        var valid1 = _errs8 === errors;
+                                                        if (!valid1) {
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate32.errors = [{ instancePath: instancePath + "/row", schemaPath: "#/properties/row/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs6 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                    if (valid0) {
+                                        if (data.special !== void 0) {
+                                            let data5 = data.special;
+                                            const _errs14 = errors;
+                                            if (errors === _errs14) {
+                                                if (Array.isArray(data5)) {
+                                                    var valid4 = true;
+                                                    const len1 = data5.length;
+                                                    for (let i1 = 0; i1 < len1; i1++) {
+                                                        const _errs16 = errors;
+                                                        if (typeof data5[i1] !== "string") {
+                                                            validate32.errors = [{ instancePath: instancePath + "/special/" + i1, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                            return false;
+                                                        }
+                                                        var valid4 = _errs16 === errors;
+                                                        if (!valid4) {
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                else {
+                                                    validate32.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                    return false;
+                                                }
+                                            }
+                                            var valid0 = _errs14 === errors;
+                                        }
+                                        else {
+                                            var valid0 = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate32.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate32.errors = vErrors;
+            return errors === 0;
+        }
+        function validate31(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    let missing0;
+                    if (data.form === void 0 && (missing0 = "form")) {
+                        validate31.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                        return false;
+                    }
+                    else {
+                        const _errs1 = errors;
+                        for (const key0 in data) {
+                            if (!(key0 === "form" || key0 === "import" || key0 === "layer" || key0 === "minDeviceWidth" || key0 === "special")) {
+                                validate31.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                                return false;
+                                break;
+                            }
+                        }
+                        if (_errs1 === errors) {
+                            if (data.form !== void 0) {
+                                const _errs2 = errors;
+                                if (typeof data.form !== "string") {
+                                    validate31.errors = [{ instancePath: instancePath + "/form", schemaPath: "#/properties/form/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                                var valid0 = _errs2 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.import !== void 0) {
+                                    let data1 = data.import;
+                                    const _errs4 = errors;
+                                    if (errors === _errs4) {
+                                        if (Array.isArray(data1)) {
+                                            var valid1 = true;
+                                            const len0 = data1.length;
+                                            for (let i0 = 0; i0 < len0; i0++) {
+                                                let data2 = data1[i0];
+                                                const _errs6 = errors;
+                                                const _errs7 = errors;
+                                                if (errors === _errs7) {
+                                                    if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+                                                        let missing1;
+                                                        if (data2.path === void 0 && (missing1 = "path")) {
+                                                            validate31.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                            return false;
+                                                        }
+                                                        else {
+                                                            const _errs9 = errors;
+                                                            for (const key1 in data2) {
+                                                                if (!(key1 === "base" || key1 === "path")) {
+                                                                    validate31.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                    return false;
+                                                                    break;
+                                                                }
+                                                            }
+                                                            if (_errs9 === errors) {
+                                                                if (data2.base !== void 0) {
+                                                                    let data3 = data2.base;
+                                                                    const _errs10 = errors;
+                                                                    if (typeof data3 !== "string") {
+                                                                        validate31.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    if (!(data3 === "cldr")) {
+                                                                        validate31.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/enum", keyword: "enum", params: { allowedValues: schema26.properties.base.enum }, message: "must be equal to one of the allowed values" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid3 = _errs10 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid3 = true;
+                                                                }
+                                                                if (valid3) {
+                                                                    if (data2.path !== void 0) {
+                                                                        const _errs12 = errors;
+                                                                        if (typeof data2.path !== "string") {
+                                                                            validate31.errors = [{ instancePath: instancePath + "/import/" + i0 + "/path", schemaPath: "#/definitions/import/properties/path/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid3 = _errs12 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid3 = true;
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate31.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                var valid1 = _errs6 === errors;
+                                                if (!valid1) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate31.errors = [{ instancePath: instancePath + "/import", schemaPath: "#/properties/import/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs4 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.layer !== void 0) {
+                                        let data5 = data.layer;
+                                        const _errs14 = errors;
+                                        if (errors === _errs14) {
+                                            if (Array.isArray(data5)) {
+                                                var valid4 = true;
+                                                const len1 = data5.length;
+                                                for (let i1 = 0; i1 < len1; i1++) {
+                                                    const _errs16 = errors;
+                                                    if (!validate32(data5[i1], { instancePath: instancePath + "/layer/" + i1, parentData: data5, parentDataProperty: i1, rootData })) {
+                                                        vErrors = vErrors === null ? validate32.errors : vErrors.concat(validate32.errors);
+                                                        errors = vErrors.length;
+                                                    }
+                                                    var valid4 = _errs16 === errors;
+                                                    if (!valid4) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate31.errors = [{ instancePath: instancePath + "/layer", schemaPath: "#/properties/layer/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs14 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                    if (valid0) {
+                                        if (data.minDeviceWidth !== void 0) {
+                                            const _errs17 = errors;
+                                            if (typeof data.minDeviceWidth !== "string") {
+                                                validate31.errors = [{ instancePath: instancePath + "/minDeviceWidth", schemaPath: "#/properties/minDeviceWidth/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                return false;
+                                            }
+                                            var valid0 = _errs17 === errors;
+                                        }
+                                        else {
+                                            var valid0 = true;
+                                        }
+                                        if (valid0) {
+                                            if (data.special !== void 0) {
+                                                let data8 = data.special;
+                                                const _errs19 = errors;
+                                                if (errors === _errs19) {
+                                                    if (Array.isArray(data8)) {
+                                                        var valid5 = true;
+                                                        const len2 = data8.length;
+                                                        for (let i2 = 0; i2 < len2; i2++) {
+                                                            const _errs21 = errors;
+                                                            if (typeof data8[i2] !== "string") {
+                                                                validate31.errors = [{ instancePath: instancePath + "/special/" + i2, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                return false;
+                                                            }
+                                                            var valid5 = _errs21 === errors;
+                                                            if (!valid5) {
+                                                                break;
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        validate31.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                        return false;
+                                                    }
+                                                }
+                                                var valid0 = _errs19 === errors;
+                                            }
+                                            else {
+                                                var valid0 = true;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate31.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate31.errors = vErrors;
+            return errors === 0;
+        }
+        function validate35(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    const _errs1 = errors;
+                    for (const key0 in data) {
+                        if (!(key0 === "locale")) {
+                            validate35.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                            return false;
+                            break;
+                        }
+                    }
+                    if (_errs1 === errors) {
+                        if (data.locale !== void 0) {
+                            let data0 = data.locale;
+                            const _errs2 = errors;
+                            if (errors === _errs2) {
+                                if (Array.isArray(data0)) {
+                                    var valid1 = true;
+                                    const len0 = data0.length;
+                                    for (let i0 = 0; i0 < len0; i0++) {
+                                        let data1 = data0[i0];
+                                        const _errs4 = errors;
+                                        const _errs5 = errors;
+                                        if (errors === _errs5) {
+                                            if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                                                let missing0;
+                                                if (data1.id === void 0 && (missing0 = "id")) {
+                                                    validate35.errors = [{ instancePath: instancePath + "/locale/" + i0, schemaPath: "#/definitions/locale/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                                                    return false;
+                                                }
+                                                else {
+                                                    const _errs7 = errors;
+                                                    for (const key1 in data1) {
+                                                        if (!(key1 === "id")) {
+                                                            validate35.errors = [{ instancePath: instancePath + "/locale/" + i0, schemaPath: "#/definitions/locale/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                            return false;
+                                                            break;
+                                                        }
+                                                    }
+                                                    if (_errs7 === errors) {
+                                                        if (data1.id !== void 0) {
+                                                            if (typeof data1.id !== "string") {
+                                                                validate35.errors = [{ instancePath: instancePath + "/locale/" + i0 + "/id", schemaPath: "#/definitions/locale/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate35.errors = [{ instancePath: instancePath + "/locale/" + i0, schemaPath: "#/definitions/locale/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid1 = _errs4 === errors;
+                                        if (!valid1) {
+                                            break;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate35.errors = [{ instancePath: instancePath + "/locale", schemaPath: "#/properties/locale/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate35.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate35.errors = vErrors;
+            return errors === 0;
+        }
+        function validate37(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    let missing0;
+                    if (data.name === void 0 && (missing0 = "name")) {
+                        validate37.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                        return false;
+                    }
+                    else {
+                        const _errs1 = errors;
+                        for (const key0 in data) {
+                            if (!(key0 === "import" || key0 === "name" || key0 === "special")) {
+                                validate37.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                                return false;
+                                break;
+                            }
+                        }
+                        if (_errs1 === errors) {
+                            if (data.import !== void 0) {
+                                let data0 = data.import;
+                                const _errs2 = errors;
+                                if (errors === _errs2) {
+                                    if (Array.isArray(data0)) {
+                                        var valid1 = true;
+                                        const len0 = data0.length;
+                                        for (let i0 = 0; i0 < len0; i0++) {
+                                            let data1 = data0[i0];
+                                            const _errs4 = errors;
+                                            const _errs5 = errors;
+                                            if (errors === _errs5) {
+                                                if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                                                    let missing1;
+                                                    if (data1.path === void 0 && (missing1 = "path")) {
+                                                        validate37.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                        return false;
+                                                    }
+                                                    else {
+                                                        const _errs7 = errors;
+                                                        for (const key1 in data1) {
+                                                            if (!(key1 === "base" || key1 === "path")) {
+                                                                validate37.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                return false;
+                                                                break;
+                                                            }
+                                                        }
+                                                        if (_errs7 === errors) {
+                                                            if (data1.base !== void 0) {
+                                                                let data2 = data1.base;
+                                                                const _errs8 = errors;
+                                                                if (typeof data2 !== "string") {
+                                                                    validate37.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                if (!(data2 === "cldr")) {
+                                                                    validate37.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/enum", keyword: "enum", params: { allowedValues: schema26.properties.base.enum }, message: "must be equal to one of the allowed values" }];
+                                                                    return false;
+                                                                }
+                                                                var valid3 = _errs8 === errors;
+                                                            }
+                                                            else {
+                                                                var valid3 = true;
+                                                            }
+                                                            if (valid3) {
+                                                                if (data1.path !== void 0) {
+                                                                    const _errs10 = errors;
+                                                                    if (typeof data1.path !== "string") {
+                                                                        validate37.errors = [{ instancePath: instancePath + "/import/" + i0 + "/path", schemaPath: "#/definitions/import/properties/path/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid3 = _errs10 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid3 = true;
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                else {
+                                                    validate37.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                    return false;
+                                                }
+                                            }
+                                            var valid1 = _errs4 === errors;
+                                            if (!valid1) {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate37.errors = [{ instancePath: instancePath + "/import", schemaPath: "#/properties/import/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs2 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.name !== void 0) {
+                                    let data4 = data.name;
+                                    const _errs12 = errors;
+                                    if (errors === _errs12) {
+                                        if (Array.isArray(data4)) {
+                                            if (data4.length < 1) {
+                                                validate37.errors = [{ instancePath: instancePath + "/name", schemaPath: "#/properties/name/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" }];
+                                                return false;
+                                            }
+                                            else {
+                                                var valid4 = true;
+                                                const len1 = data4.length;
+                                                for (let i1 = 0; i1 < len1; i1++) {
+                                                    let data5 = data4[i1];
+                                                    const _errs14 = errors;
+                                                    const _errs15 = errors;
+                                                    if (errors === _errs15) {
+                                                        if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                                                            let missing2;
+                                                            if (data5.value === void 0 && (missing2 = "value")) {
+                                                                validate37.errors = [{ instancePath: instancePath + "/name/" + i1, schemaPath: "#/definitions/name/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" }];
+                                                                return false;
+                                                            }
+                                                            else {
+                                                                const _errs17 = errors;
+                                                                for (const key2 in data5) {
+                                                                    if (!(key2 === "value")) {
+                                                                        validate37.errors = [{ instancePath: instancePath + "/name/" + i1, schemaPath: "#/definitions/name/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                                        return false;
+                                                                        break;
+                                                                    }
+                                                                }
+                                                                if (_errs17 === errors) {
+                                                                    if (data5.value !== void 0) {
+                                                                        if (typeof data5.value !== "string") {
+                                                                            validate37.errors = [{ instancePath: instancePath + "/name/" + i1 + "/value", schemaPath: "#/definitions/name/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                        else {
+                                                            validate37.errors = [{ instancePath: instancePath + "/name/" + i1, schemaPath: "#/definitions/name/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    var valid4 = _errs14 === errors;
+                                                    if (!valid4) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate37.errors = [{ instancePath: instancePath + "/name", schemaPath: "#/properties/name/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs12 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.special !== void 0) {
+                                        let data7 = data.special;
+                                        const _errs20 = errors;
+                                        if (errors === _errs20) {
+                                            if (Array.isArray(data7)) {
+                                                var valid7 = true;
+                                                const len2 = data7.length;
+                                                for (let i2 = 0; i2 < len2; i2++) {
+                                                    const _errs22 = errors;
+                                                    if (typeof data7[i2] !== "string") {
+                                                        validate37.errors = [{ instancePath: instancePath + "/special/" + i2, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                    var valid7 = _errs22 === errors;
+                                                    if (!valid7) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate37.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs20 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate37.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate37.errors = vErrors;
+            return errors === 0;
+        }
+        var schema57 = { "additionalProperties": false, "properties": { "import": { "items": { "$ref": "#/definitions/import" }, "type": "array" }, "special": { "items": { "$ref": "#/definitions/special" }, "type": "array" }, "transformGroup": { "items": { "$ref": "#/definitions/transformGroup" }, "type": "array" }, "type": { "enum": ["simple", "backspace"], "type": "string" } }, "required": ["type"], "type": "object" };
+        function validate40(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    const _errs1 = errors;
+                    for (const key0 in data) {
+                        if (!(key0 === "import" || key0 === "reorder" || key0 === "special" || key0 === "transform")) {
+                            validate40.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                            return false;
+                            break;
+                        }
+                    }
+                    if (_errs1 === errors) {
+                        if (data.import !== void 0) {
+                            let data0 = data.import;
+                            const _errs2 = errors;
+                            if (errors === _errs2) {
+                                if (Array.isArray(data0)) {
+                                    var valid1 = true;
+                                    const len0 = data0.length;
+                                    for (let i0 = 0; i0 < len0; i0++) {
+                                        let data1 = data0[i0];
+                                        const _errs4 = errors;
+                                        const _errs5 = errors;
+                                        if (errors === _errs5) {
+                                            if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                                                let missing0;
+                                                if (data1.path === void 0 && (missing0 = "path")) {
+                                                    validate40.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                                                    return false;
+                                                }
+                                                else {
+                                                    const _errs7 = errors;
+                                                    for (const key1 in data1) {
+                                                        if (!(key1 === "base" || key1 === "path")) {
+                                                            validate40.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                            return false;
+                                                            break;
+                                                        }
+                                                    }
+                                                    if (_errs7 === errors) {
+                                                        if (data1.base !== void 0) {
+                                                            let data2 = data1.base;
+                                                            const _errs8 = errors;
+                                                            if (typeof data2 !== "string") {
+                                                                validate40.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                return false;
+                                                            }
+                                                            if (!(data2 === "cldr")) {
+                                                                validate40.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/enum", keyword: "enum", params: { allowedValues: schema26.properties.base.enum }, message: "must be equal to one of the allowed values" }];
+                                                                return false;
+                                                            }
+                                                            var valid3 = _errs8 === errors;
+                                                        }
+                                                        else {
+                                                            var valid3 = true;
+                                                        }
+                                                        if (valid3) {
+                                                            if (data1.path !== void 0) {
+                                                                const _errs10 = errors;
+                                                                if (typeof data1.path !== "string") {
+                                                                    validate40.errors = [{ instancePath: instancePath + "/import/" + i0 + "/path", schemaPath: "#/definitions/import/properties/path/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                var valid3 = _errs10 === errors;
+                                                            }
+                                                            else {
+                                                                var valid3 = true;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate40.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid1 = _errs4 === errors;
+                                        if (!valid1) {
+                                            break;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate40.errors = [{ instancePath: instancePath + "/import", schemaPath: "#/properties/import/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs2 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.reorder !== void 0) {
+                                let data4 = data.reorder;
+                                const _errs12 = errors;
+                                if (errors === _errs12) {
+                                    if (Array.isArray(data4)) {
+                                        var valid4 = true;
+                                        const len1 = data4.length;
+                                        for (let i1 = 0; i1 < len1; i1++) {
+                                            let data5 = data4[i1];
+                                            const _errs14 = errors;
+                                            const _errs15 = errors;
+                                            if (errors === _errs15) {
+                                                if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                                                    let missing1;
+                                                    if (data5.from === void 0 && (missing1 = "from")) {
+                                                        validate40.errors = [{ instancePath: instancePath + "/reorder/" + i1, schemaPath: "#/definitions/reorder/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                        return false;
+                                                    }
+                                                    else {
+                                                        const _errs17 = errors;
+                                                        for (const key2 in data5) {
+                                                            if (!(key2 === "before" || key2 === "from" || key2 === "order" || key2 === "preBase" || key2 === "tertiary" || key2 === "tertiaryBase")) {
+                                                                validate40.errors = [{ instancePath: instancePath + "/reorder/" + i1, schemaPath: "#/definitions/reorder/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                                return false;
+                                                                break;
+                                                            }
+                                                        }
+                                                        if (_errs17 === errors) {
+                                                            if (data5.before !== void 0) {
+                                                                const _errs18 = errors;
+                                                                if (typeof data5.before !== "string") {
+                                                                    validate40.errors = [{ instancePath: instancePath + "/reorder/" + i1 + "/before", schemaPath: "#/definitions/reorder/properties/before/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                var valid6 = _errs18 === errors;
+                                                            }
+                                                            else {
+                                                                var valid6 = true;
+                                                            }
+                                                            if (valid6) {
+                                                                if (data5.from !== void 0) {
+                                                                    const _errs20 = errors;
+                                                                    if (typeof data5.from !== "string") {
+                                                                        validate40.errors = [{ instancePath: instancePath + "/reorder/" + i1 + "/from", schemaPath: "#/definitions/reorder/properties/from/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid6 = _errs20 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid6 = true;
+                                                                }
+                                                                if (valid6) {
+                                                                    if (data5.order !== void 0) {
+                                                                        const _errs22 = errors;
+                                                                        if (typeof data5.order !== "string") {
+                                                                            validate40.errors = [{ instancePath: instancePath + "/reorder/" + i1 + "/order", schemaPath: "#/definitions/reorder/properties/order/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid6 = _errs22 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid6 = true;
+                                                                    }
+                                                                    if (valid6) {
+                                                                        if (data5.preBase !== void 0) {
+                                                                            const _errs24 = errors;
+                                                                            if (typeof data5.preBase !== "string") {
+                                                                                validate40.errors = [{ instancePath: instancePath + "/reorder/" + i1 + "/preBase", schemaPath: "#/definitions/reorder/properties/preBase/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid6 = _errs24 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid6 = true;
+                                                                        }
+                                                                        if (valid6) {
+                                                                            if (data5.tertiary !== void 0) {
+                                                                                const _errs26 = errors;
+                                                                                if (typeof data5.tertiary !== "string") {
+                                                                                    validate40.errors = [{ instancePath: instancePath + "/reorder/" + i1 + "/tertiary", schemaPath: "#/definitions/reorder/properties/tertiary/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                                var valid6 = _errs26 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid6 = true;
+                                                                            }
+                                                                            if (valid6) {
+                                                                                if (data5.tertiaryBase !== void 0) {
+                                                                                    const _errs28 = errors;
+                                                                                    if (typeof data5.tertiaryBase !== "string") {
+                                                                                        validate40.errors = [{ instancePath: instancePath + "/reorder/" + i1 + "/tertiaryBase", schemaPath: "#/definitions/reorder/properties/tertiaryBase/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    var valid6 = _errs28 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid6 = true;
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                else {
+                                                    validate40.errors = [{ instancePath: instancePath + "/reorder/" + i1, schemaPath: "#/definitions/reorder/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                    return false;
+                                                }
+                                            }
+                                            var valid4 = _errs14 === errors;
+                                            if (!valid4) {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate40.errors = [{ instancePath: instancePath + "/reorder", schemaPath: "#/properties/reorder/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs12 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.special !== void 0) {
+                                    let data12 = data.special;
+                                    const _errs30 = errors;
+                                    if (errors === _errs30) {
+                                        if (Array.isArray(data12)) {
+                                            var valid7 = true;
+                                            const len2 = data12.length;
+                                            for (let i2 = 0; i2 < len2; i2++) {
+                                                const _errs32 = errors;
+                                                if (typeof data12[i2] !== "string") {
+                                                    validate40.errors = [{ instancePath: instancePath + "/special/" + i2, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                    return false;
+                                                }
+                                                var valid7 = _errs32 === errors;
+                                                if (!valid7) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate40.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs30 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.transform !== void 0) {
+                                        let data14 = data.transform;
+                                        const _errs35 = errors;
+                                        if (errors === _errs35) {
+                                            if (Array.isArray(data14)) {
+                                                var valid9 = true;
+                                                const len3 = data14.length;
+                                                for (let i3 = 0; i3 < len3; i3++) {
+                                                    let data15 = data14[i3];
+                                                    const _errs37 = errors;
+                                                    const _errs38 = errors;
+                                                    if (errors === _errs38) {
+                                                        if (data15 && typeof data15 == "object" && !Array.isArray(data15)) {
+                                                            let missing2;
+                                                            if (data15.from === void 0 && (missing2 = "from")) {
+                                                                validate40.errors = [{ instancePath: instancePath + "/transform/" + i3, schemaPath: "#/definitions/transform/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" }];
+                                                                return false;
+                                                            }
+                                                            else {
+                                                                const _errs40 = errors;
+                                                                for (const key3 in data15) {
+                                                                    if (!(key3 === "from" || key3 === "to")) {
+                                                                        validate40.errors = [{ instancePath: instancePath + "/transform/" + i3, schemaPath: "#/definitions/transform/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" }];
+                                                                        return false;
+                                                                        break;
+                                                                    }
+                                                                }
+                                                                if (_errs40 === errors) {
+                                                                    if (data15.from !== void 0) {
+                                                                        const _errs41 = errors;
+                                                                        if (typeof data15.from !== "string") {
+                                                                            validate40.errors = [{ instancePath: instancePath + "/transform/" + i3 + "/from", schemaPath: "#/definitions/transform/properties/from/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid11 = _errs41 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid11 = true;
+                                                                    }
+                                                                    if (valid11) {
+                                                                        if (data15.to !== void 0) {
+                                                                            const _errs43 = errors;
+                                                                            if (typeof data15.to !== "string") {
+                                                                                validate40.errors = [{ instancePath: instancePath + "/transform/" + i3 + "/to", schemaPath: "#/definitions/transform/properties/to/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid11 = _errs43 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid11 = true;
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                        else {
+                                                            validate40.errors = [{ instancePath: instancePath + "/transform/" + i3, schemaPath: "#/definitions/transform/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    var valid9 = _errs37 === errors;
+                                                    if (!valid9) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate40.errors = [{ instancePath: instancePath + "/transform", schemaPath: "#/properties/transform/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs35 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate40.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate40.errors = vErrors;
+            return errors === 0;
+        }
+        function validate39(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    let missing0;
+                    if (data.type === void 0 && (missing0 = "type")) {
+                        validate39.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                        return false;
+                    }
+                    else {
+                        const _errs1 = errors;
+                        for (const key0 in data) {
+                            if (!(key0 === "import" || key0 === "special" || key0 === "transformGroup" || key0 === "type")) {
+                                validate39.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                                return false;
+                                break;
+                            }
+                        }
+                        if (_errs1 === errors) {
+                            if (data.import !== void 0) {
+                                let data0 = data.import;
+                                const _errs2 = errors;
+                                if (errors === _errs2) {
+                                    if (Array.isArray(data0)) {
+                                        var valid1 = true;
+                                        const len0 = data0.length;
+                                        for (let i0 = 0; i0 < len0; i0++) {
+                                            let data1 = data0[i0];
+                                            const _errs4 = errors;
+                                            const _errs5 = errors;
+                                            if (errors === _errs5) {
+                                                if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                                                    let missing1;
+                                                    if (data1.path === void 0 && (missing1 = "path")) {
+                                                        validate39.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                        return false;
+                                                    }
+                                                    else {
+                                                        const _errs7 = errors;
+                                                        for (const key1 in data1) {
+                                                            if (!(key1 === "base" || key1 === "path")) {
+                                                                validate39.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                                return false;
+                                                                break;
+                                                            }
+                                                        }
+                                                        if (_errs7 === errors) {
+                                                            if (data1.base !== void 0) {
+                                                                let data2 = data1.base;
+                                                                const _errs8 = errors;
+                                                                if (typeof data2 !== "string") {
+                                                                    validate39.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                if (!(data2 === "cldr")) {
+                                                                    validate39.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/enum", keyword: "enum", params: { allowedValues: schema26.properties.base.enum }, message: "must be equal to one of the allowed values" }];
+                                                                    return false;
+                                                                }
+                                                                var valid3 = _errs8 === errors;
+                                                            }
+                                                            else {
+                                                                var valid3 = true;
+                                                            }
+                                                            if (valid3) {
+                                                                if (data1.path !== void 0) {
+                                                                    const _errs10 = errors;
+                                                                    if (typeof data1.path !== "string") {
+                                                                        validate39.errors = [{ instancePath: instancePath + "/import/" + i0 + "/path", schemaPath: "#/definitions/import/properties/path/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid3 = _errs10 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid3 = true;
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                else {
+                                                    validate39.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                    return false;
+                                                }
+                                            }
+                                            var valid1 = _errs4 === errors;
+                                            if (!valid1) {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate39.errors = [{ instancePath: instancePath + "/import", schemaPath: "#/properties/import/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs2 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.special !== void 0) {
+                                    let data4 = data.special;
+                                    const _errs12 = errors;
+                                    if (errors === _errs12) {
+                                        if (Array.isArray(data4)) {
+                                            var valid4 = true;
+                                            const len1 = data4.length;
+                                            for (let i1 = 0; i1 < len1; i1++) {
+                                                const _errs14 = errors;
+                                                if (typeof data4[i1] !== "string") {
+                                                    validate39.errors = [{ instancePath: instancePath + "/special/" + i1, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                    return false;
+                                                }
+                                                var valid4 = _errs14 === errors;
+                                                if (!valid4) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate39.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs12 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.transformGroup !== void 0) {
+                                        let data6 = data.transformGroup;
+                                        const _errs17 = errors;
+                                        if (errors === _errs17) {
+                                            if (Array.isArray(data6)) {
+                                                var valid6 = true;
+                                                const len2 = data6.length;
+                                                for (let i2 = 0; i2 < len2; i2++) {
+                                                    const _errs19 = errors;
+                                                    if (!validate40(data6[i2], { instancePath: instancePath + "/transformGroup/" + i2, parentData: data6, parentDataProperty: i2, rootData })) {
+                                                        vErrors = vErrors === null ? validate40.errors : vErrors.concat(validate40.errors);
+                                                        errors = vErrors.length;
+                                                    }
+                                                    var valid6 = _errs19 === errors;
+                                                    if (!valid6) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate39.errors = [{ instancePath: instancePath + "/transformGroup", schemaPath: "#/properties/transformGroup/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs17 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                    if (valid0) {
+                                        if (data.type !== void 0) {
+                                            let data8 = data.type;
+                                            const _errs20 = errors;
+                                            if (typeof data8 !== "string") {
+                                                validate39.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                return false;
+                                            }
+                                            if (!(data8 === "simple" || data8 === "backspace")) {
+                                                validate39.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/enum", keyword: "enum", params: { allowedValues: schema57.properties.type.enum }, message: "must be equal to one of the allowed values" }];
+                                                return false;
+                                            }
+                                            var valid0 = _errs20 === errors;
+                                        }
+                                        else {
+                                            var valid0 = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate39.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate39.errors = vErrors;
+            return errors === 0;
+        }
+        function validate43(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    const _errs1 = errors;
+                    for (const key0 in data) {
+                        if (!(key0 === "import" || key0 === "set" || key0 === "special" || key0 === "string" || key0 === "unicodeSet")) {
+                            validate43.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                            return false;
+                            break;
+                        }
+                    }
+                    if (_errs1 === errors) {
+                        if (data.import !== void 0) {
+                            let data0 = data.import;
+                            const _errs2 = errors;
+                            if (errors === _errs2) {
+                                if (Array.isArray(data0)) {
+                                    var valid1 = true;
+                                    const len0 = data0.length;
+                                    for (let i0 = 0; i0 < len0; i0++) {
+                                        let data1 = data0[i0];
+                                        const _errs4 = errors;
+                                        const _errs5 = errors;
+                                        if (errors === _errs5) {
+                                            if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                                                let missing0;
+                                                if (data1.path === void 0 && (missing0 = "path")) {
+                                                    validate43.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                                                    return false;
+                                                }
+                                                else {
+                                                    const _errs7 = errors;
+                                                    for (const key1 in data1) {
+                                                        if (!(key1 === "base" || key1 === "path")) {
+                                                            validate43.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                            return false;
+                                                            break;
+                                                        }
+                                                    }
+                                                    if (_errs7 === errors) {
+                                                        if (data1.base !== void 0) {
+                                                            let data2 = data1.base;
+                                                            const _errs8 = errors;
+                                                            if (typeof data2 !== "string") {
+                                                                validate43.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                return false;
+                                                            }
+                                                            if (!(data2 === "cldr")) {
+                                                                validate43.errors = [{ instancePath: instancePath + "/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/enum", keyword: "enum", params: { allowedValues: schema26.properties.base.enum }, message: "must be equal to one of the allowed values" }];
+                                                                return false;
+                                                            }
+                                                            var valid3 = _errs8 === errors;
+                                                        }
+                                                        else {
+                                                            var valid3 = true;
+                                                        }
+                                                        if (valid3) {
+                                                            if (data1.path !== void 0) {
+                                                                const _errs10 = errors;
+                                                                if (typeof data1.path !== "string") {
+                                                                    validate43.errors = [{ instancePath: instancePath + "/import/" + i0 + "/path", schemaPath: "#/definitions/import/properties/path/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                var valid3 = _errs10 === errors;
+                                                            }
+                                                            else {
+                                                                var valid3 = true;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate43.errors = [{ instancePath: instancePath + "/import/" + i0, schemaPath: "#/definitions/import/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid1 = _errs4 === errors;
+                                        if (!valid1) {
+                                            break;
+                                        }
+                                    }
+                                }
+                                else {
+                                    validate43.errors = [{ instancePath: instancePath + "/import", schemaPath: "#/properties/import/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs2 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        if (valid0) {
+                            if (data.set !== void 0) {
+                                let data4 = data.set;
+                                const _errs12 = errors;
+                                if (errors === _errs12) {
+                                    if (Array.isArray(data4)) {
+                                        var valid4 = true;
+                                        const len1 = data4.length;
+                                        for (let i1 = 0; i1 < len1; i1++) {
+                                            let data5 = data4[i1];
+                                            const _errs14 = errors;
+                                            const _errs15 = errors;
+                                            if (errors === _errs15) {
+                                                if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                                                    let missing1;
+                                                    if (data5.id === void 0 && (missing1 = "id") || data5.value === void 0 && (missing1 = "value")) {
+                                                        validate43.errors = [{ instancePath: instancePath + "/set/" + i1, schemaPath: "#/definitions/set/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                                        return false;
+                                                    }
+                                                    else {
+                                                        const _errs17 = errors;
+                                                        for (const key2 in data5) {
+                                                            if (!(key2 === "id" || key2 === "value")) {
+                                                                validate43.errors = [{ instancePath: instancePath + "/set/" + i1, schemaPath: "#/definitions/set/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                                return false;
+                                                                break;
+                                                            }
+                                                        }
+                                                        if (_errs17 === errors) {
+                                                            if (data5.id !== void 0) {
+                                                                const _errs18 = errors;
+                                                                if (typeof data5.id !== "string") {
+                                                                    validate43.errors = [{ instancePath: instancePath + "/set/" + i1 + "/id", schemaPath: "#/definitions/set/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                    return false;
+                                                                }
+                                                                var valid6 = _errs18 === errors;
+                                                            }
+                                                            else {
+                                                                var valid6 = true;
+                                                            }
+                                                            if (valid6) {
+                                                                if (data5.value !== void 0) {
+                                                                    const _errs20 = errors;
+                                                                    if (typeof data5.value !== "string") {
+                                                                        validate43.errors = [{ instancePath: instancePath + "/set/" + i1 + "/value", schemaPath: "#/definitions/set/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                        return false;
+                                                                    }
+                                                                    var valid6 = _errs20 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid6 = true;
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                else {
+                                                    validate43.errors = [{ instancePath: instancePath + "/set/" + i1, schemaPath: "#/definitions/set/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                    return false;
+                                                }
+                                            }
+                                            var valid4 = _errs14 === errors;
+                                            if (!valid4) {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate43.errors = [{ instancePath: instancePath + "/set", schemaPath: "#/properties/set/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                        return false;
+                                    }
+                                }
+                                var valid0 = _errs12 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            if (valid0) {
+                                if (data.special !== void 0) {
+                                    let data8 = data.special;
+                                    const _errs22 = errors;
+                                    if (errors === _errs22) {
+                                        if (Array.isArray(data8)) {
+                                            var valid7 = true;
+                                            const len2 = data8.length;
+                                            for (let i2 = 0; i2 < len2; i2++) {
+                                                const _errs24 = errors;
+                                                if (typeof data8[i2] !== "string") {
+                                                    validate43.errors = [{ instancePath: instancePath + "/special/" + i2, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                    return false;
+                                                }
+                                                var valid7 = _errs24 === errors;
+                                                if (!valid7) {
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            validate43.errors = [{ instancePath: instancePath + "/special", schemaPath: "#/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                            return false;
+                                        }
+                                    }
+                                    var valid0 = _errs22 === errors;
+                                }
+                                else {
+                                    var valid0 = true;
+                                }
+                                if (valid0) {
+                                    if (data.string !== void 0) {
+                                        let data10 = data.string;
+                                        const _errs27 = errors;
+                                        if (errors === _errs27) {
+                                            if (Array.isArray(data10)) {
+                                                var valid9 = true;
+                                                const len3 = data10.length;
+                                                for (let i3 = 0; i3 < len3; i3++) {
+                                                    let data11 = data10[i3];
+                                                    const _errs29 = errors;
+                                                    const _errs30 = errors;
+                                                    if (errors === _errs30) {
+                                                        if (data11 && typeof data11 == "object" && !Array.isArray(data11)) {
+                                                            let missing2;
+                                                            if (data11.id === void 0 && (missing2 = "id") || data11.value === void 0 && (missing2 = "value")) {
+                                                                validate43.errors = [{ instancePath: instancePath + "/string/" + i3, schemaPath: "#/definitions/stringVariable/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" }];
+                                                                return false;
+                                                            }
+                                                            else {
+                                                                const _errs32 = errors;
+                                                                for (const key3 in data11) {
+                                                                    if (!(key3 === "id" || key3 === "value")) {
+                                                                        validate43.errors = [{ instancePath: instancePath + "/string/" + i3, schemaPath: "#/definitions/stringVariable/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" }];
+                                                                        return false;
+                                                                        break;
+                                                                    }
+                                                                }
+                                                                if (_errs32 === errors) {
+                                                                    if (data11.id !== void 0) {
+                                                                        const _errs33 = errors;
+                                                                        if (typeof data11.id !== "string") {
+                                                                            validate43.errors = [{ instancePath: instancePath + "/string/" + i3 + "/id", schemaPath: "#/definitions/stringVariable/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                            return false;
+                                                                        }
+                                                                        var valid11 = _errs33 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid11 = true;
+                                                                    }
+                                                                    if (valid11) {
+                                                                        if (data11.value !== void 0) {
+                                                                            const _errs35 = errors;
+                                                                            if (typeof data11.value !== "string") {
+                                                                                validate43.errors = [{ instancePath: instancePath + "/string/" + i3 + "/value", schemaPath: "#/definitions/stringVariable/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid11 = _errs35 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid11 = true;
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                        else {
+                                                            validate43.errors = [{ instancePath: instancePath + "/string/" + i3, schemaPath: "#/definitions/stringVariable/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                            return false;
+                                                        }
+                                                    }
+                                                    var valid9 = _errs29 === errors;
+                                                    if (!valid9) {
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                validate43.errors = [{ instancePath: instancePath + "/string", schemaPath: "#/properties/string/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                return false;
+                                            }
+                                        }
+                                        var valid0 = _errs27 === errors;
+                                    }
+                                    else {
+                                        var valid0 = true;
+                                    }
+                                    if (valid0) {
+                                        if (data.unicodeSet !== void 0) {
+                                            let data14 = data.unicodeSet;
+                                            const _errs37 = errors;
+                                            if (errors === _errs37) {
+                                                if (Array.isArray(data14)) {
+                                                    var valid12 = true;
+                                                    const len4 = data14.length;
+                                                    for (let i4 = 0; i4 < len4; i4++) {
+                                                        let data15 = data14[i4];
+                                                        const _errs39 = errors;
+                                                        const _errs40 = errors;
+                                                        if (errors === _errs40) {
+                                                            if (data15 && typeof data15 == "object" && !Array.isArray(data15)) {
+                                                                let missing3;
+                                                                if (data15.id === void 0 && (missing3 = "id") || data15.value === void 0 && (missing3 = "value")) {
+                                                                    validate43.errors = [{ instancePath: instancePath + "/unicodeSet/" + i4, schemaPath: "#/definitions/unicodeSet/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" }];
+                                                                    return false;
+                                                                }
+                                                                else {
+                                                                    const _errs42 = errors;
+                                                                    for (const key4 in data15) {
+                                                                        if (!(key4 === "id" || key4 === "value")) {
+                                                                            validate43.errors = [{ instancePath: instancePath + "/unicodeSet/" + i4, schemaPath: "#/definitions/unicodeSet/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key4 }, message: "must NOT have additional properties" }];
+                                                                            return false;
+                                                                            break;
+                                                                        }
+                                                                    }
+                                                                    if (_errs42 === errors) {
+                                                                        if (data15.id !== void 0) {
+                                                                            const _errs43 = errors;
+                                                                            if (typeof data15.id !== "string") {
+                                                                                validate43.errors = [{ instancePath: instancePath + "/unicodeSet/" + i4 + "/id", schemaPath: "#/definitions/unicodeSet/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                return false;
+                                                                            }
+                                                                            var valid14 = _errs43 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid14 = true;
+                                                                        }
+                                                                        if (valid14) {
+                                                                            if (data15.value !== void 0) {
+                                                                                const _errs45 = errors;
+                                                                                if (typeof data15.value !== "string") {
+                                                                                    validate43.errors = [{ instancePath: instancePath + "/unicodeSet/" + i4 + "/value", schemaPath: "#/definitions/unicodeSet/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                                var valid14 = _errs45 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid14 = true;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                            else {
+                                                                validate43.errors = [{ instancePath: instancePath + "/unicodeSet/" + i4, schemaPath: "#/definitions/unicodeSet/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                return false;
+                                                            }
+                                                        }
+                                                        var valid12 = _errs39 === errors;
+                                                        if (!valid12) {
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                else {
+                                                    validate43.errors = [{ instancePath: instancePath + "/unicodeSet", schemaPath: "#/properties/unicodeSet/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                    return false;
+                                                }
+                                            }
+                                            var valid0 = _errs37 === errors;
+                                        }
+                                        else {
+                                            var valid0 = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate43.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate43.errors = vErrors;
+            return errors === 0;
+        }
+        function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+            let vErrors = null;
+            let errors = 0;
+            if (errors === 0) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                    let missing0;
+                    if (data.keyboard3 === void 0 && (missing0 = "keyboard3")) {
+                        validate20.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+                        return false;
+                    }
+                    else {
+                        const _errs1 = errors;
+                        for (const key0 in data) {
+                            if (!(key0 === "keyboard3")) {
+                                validate20.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                                return false;
+                                break;
+                            }
+                        }
+                        if (_errs1 === errors) {
+                            if (data.keyboard3 !== void 0) {
+                                let data0 = data.keyboard3;
+                                const _errs2 = errors;
+                                if (errors === _errs2) {
+                                    if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+                                        let missing1;
+                                        if (data0.names === void 0 && (missing1 = "names") || data0.locale === void 0 && (missing1 = "locale") || data0.conformsTo === void 0 && (missing1 = "conformsTo")) {
+                                            validate20.errors = [{ instancePath: instancePath + "/keyboard3", schemaPath: "#/properties/keyboard3/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                                            return false;
+                                        }
+                                        else {
+                                            const _errs4 = errors;
+                                            for (const key1 in data0) {
+                                                if (!func4.call(schema22.properties.keyboard3.properties, key1)) {
+                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3", schemaPath: "#/properties/keyboard3/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                                                    return false;
+                                                    break;
+                                                }
+                                            }
+                                            if (_errs4 === errors) {
+                                                if (data0.conformsTo !== void 0) {
+                                                    let data1 = data0.conformsTo;
+                                                    const _errs5 = errors;
+                                                    if (typeof data1 !== "string") {
+                                                        validate20.errors = [{ instancePath: instancePath + "/keyboard3/conformsTo", schemaPath: "#/properties/keyboard3/properties/conformsTo/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                    if (!(data1 === "techpreview")) {
+                                                        validate20.errors = [{ instancePath: instancePath + "/keyboard3/conformsTo", schemaPath: "#/properties/keyboard3/properties/conformsTo/enum", keyword: "enum", params: { allowedValues: schema22.properties.keyboard3.properties.conformsTo.enum }, message: "must be equal to one of the allowed values" }];
+                                                        return false;
+                                                    }
+                                                    var valid1 = _errs5 === errors;
+                                                }
+                                                else {
+                                                    var valid1 = true;
+                                                }
+                                                if (valid1) {
+                                                    if (data0.displays !== void 0) {
+                                                        const _errs7 = errors;
+                                                        if (!validate21(data0.displays, { instancePath: instancePath + "/keyboard3/displays", parentData: data0, parentDataProperty: "displays", rootData })) {
+                                                            vErrors = vErrors === null ? validate21.errors : vErrors.concat(validate21.errors);
+                                                            errors = vErrors.length;
+                                                        }
+                                                        var valid1 = _errs7 === errors;
+                                                    }
+                                                    else {
+                                                        var valid1 = true;
+                                                    }
+                                                    if (valid1) {
+                                                        if (data0.forms !== void 0) {
+                                                            const _errs8 = errors;
+                                                            if (!validate23(data0.forms, { instancePath: instancePath + "/keyboard3/forms", parentData: data0, parentDataProperty: "forms", rootData })) {
+                                                                vErrors = vErrors === null ? validate23.errors : vErrors.concat(validate23.errors);
+                                                                errors = vErrors.length;
+                                                            }
+                                                            var valid1 = _errs8 === errors;
+                                                        }
+                                                        else {
+                                                            var valid1 = true;
+                                                        }
+                                                        if (valid1) {
+                                                            if (data0.import !== void 0) {
+                                                                let data4 = data0.import;
+                                                                const _errs9 = errors;
+                                                                if (errors === _errs9) {
+                                                                    if (Array.isArray(data4)) {
+                                                                        var valid2 = true;
+                                                                        const len0 = data4.length;
+                                                                        for (let i0 = 0; i0 < len0; i0++) {
+                                                                            let data5 = data4[i0];
+                                                                            const _errs11 = errors;
+                                                                            const _errs12 = errors;
+                                                                            if (errors === _errs12) {
+                                                                                if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                                                                                    let missing2;
+                                                                                    if (data5.path === void 0 && (missing2 = "path")) {
+                                                                                        validate20.errors = [{ instancePath: instancePath + "/keyboard3/import/" + i0, schemaPath: "#/definitions/import/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    else {
+                                                                                        const _errs14 = errors;
+                                                                                        for (const key2 in data5) {
+                                                                                            if (!(key2 === "base" || key2 === "path")) {
+                                                                                                validate20.errors = [{ instancePath: instancePath + "/keyboard3/import/" + i0, schemaPath: "#/definitions/import/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" }];
+                                                                                                return false;
+                                                                                                break;
+                                                                                            }
+                                                                                        }
+                                                                                        if (_errs14 === errors) {
+                                                                                            if (data5.base !== void 0) {
+                                                                                                let data6 = data5.base;
+                                                                                                const _errs15 = errors;
+                                                                                                if (typeof data6 !== "string") {
+                                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                                if (!(data6 === "cldr")) {
+                                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/import/" + i0 + "/base", schemaPath: "#/definitions/import/properties/base/enum", keyword: "enum", params: { allowedValues: schema26.properties.base.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                                var valid4 = _errs15 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid4 = true;
+                                                                                            }
+                                                                                            if (valid4) {
+                                                                                                if (data5.path !== void 0) {
+                                                                                                    const _errs17 = errors;
+                                                                                                    if (typeof data5.path !== "string") {
+                                                                                                        validate20.errors = [{ instancePath: instancePath + "/keyboard3/import/" + i0 + "/path", schemaPath: "#/definitions/import/properties/path/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                    var valid4 = _errs17 === errors;
+                                                                                                }
+                                                                                                else {
+                                                                                                    var valid4 = true;
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/import/" + i0, schemaPath: "#/definitions/import/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                            var valid2 = _errs11 === errors;
+                                                                            if (!valid2) {
+                                                                                break;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    else {
+                                                                        validate20.errors = [{ instancePath: instancePath + "/keyboard3/import", schemaPath: "#/properties/keyboard3/properties/import/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                                        return false;
+                                                                    }
+                                                                }
+                                                                var valid1 = _errs9 === errors;
+                                                            }
+                                                            else {
+                                                                var valid1 = true;
+                                                            }
+                                                            if (valid1) {
+                                                                if (data0.info !== void 0) {
+                                                                    let data8 = data0.info;
+                                                                    const _errs19 = errors;
+                                                                    const _errs20 = errors;
+                                                                    if (errors === _errs20) {
+                                                                        if (data8 && typeof data8 == "object" && !Array.isArray(data8)) {
+                                                                            const _errs22 = errors;
+                                                                            for (const key3 in data8) {
+                                                                                if (!(key3 === "author" || key3 === "indicator" || key3 === "layout" || key3 === "normalization")) {
+                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/info", schemaPath: "#/definitions/info/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" }];
+                                                                                    return false;
+                                                                                    break;
+                                                                                }
+                                                                            }
+                                                                            if (_errs22 === errors) {
+                                                                                if (data8.author !== void 0) {
+                                                                                    const _errs23 = errors;
+                                                                                    if (typeof data8.author !== "string") {
+                                                                                        validate20.errors = [{ instancePath: instancePath + "/keyboard3/info/author", schemaPath: "#/definitions/info/properties/author/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                        return false;
+                                                                                    }
+                                                                                    var valid6 = _errs23 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid6 = true;
+                                                                                }
+                                                                                if (valid6) {
+                                                                                    if (data8.indicator !== void 0) {
+                                                                                        const _errs25 = errors;
+                                                                                        if (typeof data8.indicator !== "string") {
+                                                                                            validate20.errors = [{ instancePath: instancePath + "/keyboard3/info/indicator", schemaPath: "#/definitions/info/properties/indicator/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                            return false;
+                                                                                        }
+                                                                                        var valid6 = _errs25 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid6 = true;
+                                                                                    }
+                                                                                    if (valid6) {
+                                                                                        if (data8.layout !== void 0) {
+                                                                                            const _errs27 = errors;
+                                                                                            if (typeof data8.layout !== "string") {
+                                                                                                validate20.errors = [{ instancePath: instancePath + "/keyboard3/info/layout", schemaPath: "#/definitions/info/properties/layout/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                return false;
+                                                                                            }
+                                                                                            var valid6 = _errs27 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid6 = true;
+                                                                                        }
+                                                                                        if (valid6) {
+                                                                                            if (data8.normalization !== void 0) {
+                                                                                                const _errs29 = errors;
+                                                                                                if (typeof data8.normalization !== "string") {
+                                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/info/normalization", schemaPath: "#/definitions/info/properties/normalization/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                                var valid6 = _errs29 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid6 = true;
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        else {
+                                                                            validate20.errors = [{ instancePath: instancePath + "/keyboard3/info", schemaPath: "#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                            return false;
+                                                                        }
+                                                                    }
+                                                                    var valid1 = _errs19 === errors;
+                                                                }
+                                                                else {
+                                                                    var valid1 = true;
+                                                                }
+                                                                if (valid1) {
+                                                                    if (data0.keys !== void 0) {
+                                                                        const _errs31 = errors;
+                                                                        if (!validate27(data0.keys, { instancePath: instancePath + "/keyboard3/keys", parentData: data0, parentDataProperty: "keys", rootData })) {
+                                                                            vErrors = vErrors === null ? validate27.errors : vErrors.concat(validate27.errors);
+                                                                            errors = vErrors.length;
+                                                                        }
+                                                                        var valid1 = _errs31 === errors;
+                                                                    }
+                                                                    else {
+                                                                        var valid1 = true;
+                                                                    }
+                                                                    if (valid1) {
+                                                                        if (data0.layers !== void 0) {
+                                                                            let data14 = data0.layers;
+                                                                            const _errs32 = errors;
+                                                                            if (errors === _errs32) {
+                                                                                if (Array.isArray(data14)) {
+                                                                                    var valid7 = true;
+                                                                                    const len1 = data14.length;
+                                                                                    for (let i1 = 0; i1 < len1; i1++) {
+                                                                                        const _errs34 = errors;
+                                                                                        if (!validate31(data14[i1], { instancePath: instancePath + "/keyboard3/layers/" + i1, parentData: data14, parentDataProperty: i1, rootData })) {
+                                                                                            vErrors = vErrors === null ? validate31.errors : vErrors.concat(validate31.errors);
+                                                                                            errors = vErrors.length;
+                                                                                        }
+                                                                                        var valid7 = _errs34 === errors;
+                                                                                        if (!valid7) {
+                                                                                            break;
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/layers", schemaPath: "#/properties/keyboard3/properties/layers/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                                                    return false;
+                                                                                }
+                                                                            }
+                                                                            var valid1 = _errs32 === errors;
+                                                                        }
+                                                                        else {
+                                                                            var valid1 = true;
+                                                                        }
+                                                                        if (valid1) {
+                                                                            if (data0.locale !== void 0) {
+                                                                                const _errs35 = errors;
+                                                                                if (typeof data0.locale !== "string") {
+                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/locale", schemaPath: "#/properties/keyboard3/properties/locale/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                    return false;
+                                                                                }
+                                                                                var valid1 = _errs35 === errors;
+                                                                            }
+                                                                            else {
+                                                                                var valid1 = true;
+                                                                            }
+                                                                            if (valid1) {
+                                                                                if (data0.locales !== void 0) {
+                                                                                    const _errs37 = errors;
+                                                                                    if (!validate35(data0.locales, { instancePath: instancePath + "/keyboard3/locales", parentData: data0, parentDataProperty: "locales", rootData })) {
+                                                                                        vErrors = vErrors === null ? validate35.errors : vErrors.concat(validate35.errors);
+                                                                                        errors = vErrors.length;
+                                                                                    }
+                                                                                    var valid1 = _errs37 === errors;
+                                                                                }
+                                                                                else {
+                                                                                    var valid1 = true;
+                                                                                }
+                                                                                if (valid1) {
+                                                                                    if (data0.names !== void 0) {
+                                                                                        const _errs38 = errors;
+                                                                                        if (!validate37(data0.names, { instancePath: instancePath + "/keyboard3/names", parentData: data0, parentDataProperty: "names", rootData })) {
+                                                                                            vErrors = vErrors === null ? validate37.errors : vErrors.concat(validate37.errors);
+                                                                                            errors = vErrors.length;
+                                                                                        }
+                                                                                        var valid1 = _errs38 === errors;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid1 = true;
+                                                                                    }
+                                                                                    if (valid1) {
+                                                                                        if (data0.settings !== void 0) {
+                                                                                            let data19 = data0.settings;
+                                                                                            const _errs39 = errors;
+                                                                                            const _errs40 = errors;
+                                                                                            if (errors === _errs40) {
+                                                                                                if (data19 && typeof data19 == "object" && !Array.isArray(data19)) {
+                                                                                                    const _errs42 = errors;
+                                                                                                    for (const key4 in data19) {
+                                                                                                        if (!(key4 === "fallback")) {
+                                                                                                            validate20.errors = [{ instancePath: instancePath + "/keyboard3/settings", schemaPath: "#/definitions/settings/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key4 }, message: "must NOT have additional properties" }];
+                                                                                                            return false;
+                                                                                                            break;
+                                                                                                        }
+                                                                                                    }
+                                                                                                    if (_errs42 === errors) {
+                                                                                                        if (data19.fallback !== void 0) {
+                                                                                                            let data20 = data19.fallback;
+                                                                                                            if (typeof data20 !== "string") {
+                                                                                                                validate20.errors = [{ instancePath: instancePath + "/keyboard3/settings/fallback", schemaPath: "#/definitions/settings/properties/fallback/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                            if (!(data20 === "omit")) {
+                                                                                                                validate20.errors = [{ instancePath: instancePath + "/keyboard3/settings/fallback", schemaPath: "#/definitions/settings/properties/fallback/enum", keyword: "enum", params: { allowedValues: schema55.properties.fallback.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                                else {
+                                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/settings", schemaPath: "#/definitions/settings/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                    return false;
+                                                                                                }
+                                                                                            }
+                                                                                            var valid1 = _errs39 === errors;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid1 = true;
+                                                                                        }
+                                                                                        if (valid1) {
+                                                                                            if (data0.special !== void 0) {
+                                                                                                let data21 = data0.special;
+                                                                                                const _errs45 = errors;
+                                                                                                if (errors === _errs45) {
+                                                                                                    if (Array.isArray(data21)) {
+                                                                                                        var valid10 = true;
+                                                                                                        const len2 = data21.length;
+                                                                                                        for (let i2 = 0; i2 < len2; i2++) {
+                                                                                                            const _errs47 = errors;
+                                                                                                            if (typeof data21[i2] !== "string") {
+                                                                                                                validate20.errors = [{ instancePath: instancePath + "/keyboard3/special/" + i2, schemaPath: "#/definitions/special/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                return false;
+                                                                                                            }
+                                                                                                            var valid10 = _errs47 === errors;
+                                                                                                            if (!valid10) {
+                                                                                                                break;
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        validate20.errors = [{ instancePath: instancePath + "/keyboard3/special", schemaPath: "#/properties/keyboard3/properties/special/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                                                                        return false;
+                                                                                                    }
+                                                                                                }
+                                                                                                var valid1 = _errs45 === errors;
+                                                                                            }
+                                                                                            else {
+                                                                                                var valid1 = true;
+                                                                                            }
+                                                                                            if (valid1) {
+                                                                                                if (data0.transforms !== void 0) {
+                                                                                                    let data23 = data0.transforms;
+                                                                                                    const _errs50 = errors;
+                                                                                                    if (errors === _errs50) {
+                                                                                                        if (Array.isArray(data23)) {
+                                                                                                            var valid12 = true;
+                                                                                                            const len3 = data23.length;
+                                                                                                            for (let i3 = 0; i3 < len3; i3++) {
+                                                                                                                const _errs52 = errors;
+                                                                                                                if (!validate39(data23[i3], { instancePath: instancePath + "/keyboard3/transforms/" + i3, parentData: data23, parentDataProperty: i3, rootData })) {
+                                                                                                                    vErrors = vErrors === null ? validate39.errors : vErrors.concat(validate39.errors);
+                                                                                                                    errors = vErrors.length;
+                                                                                                                }
+                                                                                                                var valid12 = _errs52 === errors;
+                                                                                                                if (!valid12) {
+                                                                                                                    break;
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            validate20.errors = [{ instancePath: instancePath + "/keyboard3/transforms", schemaPath: "#/properties/keyboard3/properties/transforms/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                                                                                                            return false;
+                                                                                                        }
+                                                                                                    }
+                                                                                                    var valid1 = _errs50 === errors;
+                                                                                                }
+                                                                                                else {
+                                                                                                    var valid1 = true;
+                                                                                                }
+                                                                                                if (valid1) {
+                                                                                                    if (data0.variables !== void 0) {
+                                                                                                        const _errs53 = errors;
+                                                                                                        if (!validate43(data0.variables, { instancePath: instancePath + "/keyboard3/variables", parentData: data0, parentDataProperty: "variables", rootData })) {
+                                                                                                            vErrors = vErrors === null ? validate43.errors : vErrors.concat(validate43.errors);
+                                                                                                            errors = vErrors.length;
+                                                                                                        }
+                                                                                                        var valid1 = _errs53 === errors;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        var valid1 = true;
+                                                                                                    }
+                                                                                                    if (valid1) {
+                                                                                                        if (data0.version !== void 0) {
+                                                                                                            let data26 = data0.version;
+                                                                                                            const _errs54 = errors;
+                                                                                                            const _errs55 = errors;
+                                                                                                            if (errors === _errs55) {
+                                                                                                                if (data26 && typeof data26 == "object" && !Array.isArray(data26)) {
+                                                                                                                    const _errs57 = errors;
+                                                                                                                    for (const key5 in data26) {
+                                                                                                                        if (!(key5 === "cldrVersion" || key5 === "number")) {
+                                                                                                                            validate20.errors = [{ instancePath: instancePath + "/keyboard3/version", schemaPath: "#/definitions/version/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key5 }, message: "must NOT have additional properties" }];
+                                                                                                                            return false;
+                                                                                                                            break;
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                    if (_errs57 === errors) {
+                                                                                                                        if (data26.cldrVersion !== void 0) {
+                                                                                                                            let data27 = data26.cldrVersion;
+                                                                                                                            const _errs58 = errors;
+                                                                                                                            if (typeof data27 !== "string") {
+                                                                                                                                validate20.errors = [{ instancePath: instancePath + "/keyboard3/version/cldrVersion", schemaPath: "#/definitions/version/properties/cldrVersion/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                return false;
+                                                                                                                            }
+                                                                                                                            if (!(data27 === "techpreview")) {
+                                                                                                                                validate20.errors = [{ instancePath: instancePath + "/keyboard3/version/cldrVersion", schemaPath: "#/definitions/version/properties/cldrVersion/enum", keyword: "enum", params: { allowedValues: schema71.properties.cldrVersion.enum }, message: "must be equal to one of the allowed values" }];
+                                                                                                                                return false;
+                                                                                                                            }
+                                                                                                                            var valid14 = _errs58 === errors;
+                                                                                                                        }
+                                                                                                                        else {
+                                                                                                                            var valid14 = true;
+                                                                                                                        }
+                                                                                                                        if (valid14) {
+                                                                                                                            if (data26.number !== void 0) {
+                                                                                                                                const _errs60 = errors;
+                                                                                                                                if (typeof data26.number !== "string") {
+                                                                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/version/number", schemaPath: "#/definitions/version/properties/number/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                                                                                                    return false;
+                                                                                                                                }
+                                                                                                                                var valid14 = _errs60 === errors;
+                                                                                                                            }
+                                                                                                                            else {
+                                                                                                                                var valid14 = true;
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    validate20.errors = [{ instancePath: instancePath + "/keyboard3/version", schemaPath: "#/definitions/version/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                                                                                    return false;
+                                                                                                                }
+                                                                                                            }
+                                                                                                            var valid1 = _errs54 === errors;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            var valid1 = true;
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        validate20.errors = [{ instancePath: instancePath + "/keyboard3", schemaPath: "#/properties/keyboard3/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                        return false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    validate20.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                    return false;
+                }
+            }
+            validate20.errors = vErrors;
+            return errors === 0;
+        }
+    }
+});
+export default require_ldml_keyboard3_schema_validator();
+//# debugId=8811648a-93c4-524f-b22c-ffac1268863b
+//# sourceMappingURL=ldml-keyboard3.schema.validator.mjs.map