@xube/kit-aws-data-schema 0.0.73

package/dist/generated/validators/aggregateMetadata.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = void 0;
+exports.validate = validate10;
+exports.default = validate10;
+const schema27 = { "$ref": "#/definitions/aggregatemetadataJsonSchema", "definitions": { "aggregatemetadataJsonSchema": { "type": "object", "properties": { "v": { "type": "number" } }, "required": ["v"], "additionalProperties": false } }, "$schema": "http://json-schema.org/draft-07/schema#" };
+const schema28 = { "type": "object", "properties": { "v": { "type": "number" } }, "required": ["v"], "additionalProperties": false };
+function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.v === undefined) {
+        const err0 = { instancePath, schemaPath: "#/definitions/aggregatemetadataJsonSchema/required", keyword: "required", params: { missingProperty: "v" }, message: "must have required property '" + "v" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!(key0 === "v")) {
+            const err1 = { instancePath, schemaPath: "#/definitions/aggregatemetadataJsonSchema/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err1];
+            }
+            else {
+                vErrors.push(err1);
+            }
+            errors++;
+        }
+    }
+    if (data.v !== undefined) {
+        let data0 = data.v;
+        if (!((typeof data0 == "number") && (isFinite(data0)))) {
+            const err2 = { instancePath: instancePath + "/v", schemaPath: "#/definitions/aggregatemetadataJsonSchema/properties/v/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err2];
+            }
+            else {
+                vErrors.push(err2);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err3 = { instancePath, schemaPath: "#/definitions/aggregatemetadataJsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err3];
+    }
+    else {
+        vErrors.push(err3);
+    }
+    errors++;
+} validate10.errors = vErrors; return errors === 0; }

package/dist/generated/validators/aggregateMetadataTypes.d.ts

@@ -0,0 +1,13 @@
+export function validate(data: any, { instancePath, parentData, parentDataProperty, rootData }?: {
+    instancePath?: string | undefined;
+    parentData: any;
+    parentDataProperty: any;
+    rootData?: any;
+}): boolean;
+export default validate10;
+declare function validate10(data: any, { instancePath, parentData, parentDataProperty, rootData }?: {
+    instancePath?: string | undefined;
+    parentData: any;
+    parentDataProperty: any;
+    rootData?: any;
+}): boolean;

package/dist/generated/validators/aggregateMetadataTypes.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = void 0;
+exports.validate = validate10;
+exports.default = validate10;
+const schema27 = { "$ref": "#/definitions/aggregatemetadatatypesJsonSchema", "definitions": { "aggregatemetadatatypesJsonSchema": { "type": "object", "properties": { "v": { "type": "number", "const": 1 }, "s": { "type": "number" }, "m": { "type": "array", "items": { "type": "object", "properties": { "m": { "type": "object", "properties": { "s": { "type": "number" }, "us": { "type": "number" } }, "required": ["s", "us"], "additionalProperties": false }, "s": { "type": "number" } }, "required": ["m"], "additionalProperties": false } } }, "required": ["v", "s", "m"], "additionalProperties": false } }, "$schema": "http://json-schema.org/draft-07/schema#" };
+const schema28 = { "type": "object", "properties": { "v": { "type": "number", "const": 1 }, "s": { "type": "number" }, "m": { "type": "array", "items": { "type": "object", "properties": { "m": { "type": "object", "properties": { "s": { "type": "number" }, "us": { "type": "number" } }, "required": ["s", "us"], "additionalProperties": false }, "s": { "type": "number" } }, "required": ["m"], "additionalProperties": false } } }, "required": ["v", "s", "m"], "additionalProperties": false };
+function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.v === undefined) {
+        const err0 = { instancePath, schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/required", keyword: "required", params: { missingProperty: "v" }, message: "must have required property '" + "v" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.s === undefined) {
+        const err1 = { instancePath, schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    if (data.m === undefined) {
+        const err2 = { instancePath, schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/required", keyword: "required", params: { missingProperty: "m" }, message: "must have required property '" + "m" + "'" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!(((key0 === "v") || (key0 === "s")) || (key0 === "m"))) {
+            const err3 = { instancePath, schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err3];
+            }
+            else {
+                vErrors.push(err3);
+            }
+            errors++;
+        }
+    }
+    if (data.v !== undefined) {
+        let data0 = data.v;
+        if (!((typeof data0 == "number") && (isFinite(data0)))) {
+            const err4 = { instancePath: instancePath + "/v", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/v/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err4];
+            }
+            else {
+                vErrors.push(err4);
+            }
+            errors++;
+        }
+        if (1 !== data0) {
+            const err5 = { instancePath: instancePath + "/v", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/v/const", keyword: "const", params: { allowedValue: 1 }, message: "must be equal to constant" };
+            if (vErrors === null) {
+                vErrors = [err5];
+            }
+            else {
+                vErrors.push(err5);
+            }
+            errors++;
+        }
+    }
+    if (data.s !== undefined) {
+        let data1 = data.s;
+        if (!((typeof data1 == "number") && (isFinite(data1)))) {
+            const err6 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err6];
+            }
+            else {
+                vErrors.push(err6);
+            }
+            errors++;
+        }
+    }
+    if (data.m !== undefined) {
+        let data2 = data.m;
+        if (Array.isArray(data2)) {
+            const len0 = data2.length;
+            for (let i0 = 0; i0 < len0; i0++) {
+                let data3 = data2[i0];
+                if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+                    if (data3.m === undefined) {
+                        const err7 = { instancePath: instancePath + "/m/" + i0, schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/required", keyword: "required", params: { missingProperty: "m" }, message: "must have required property '" + "m" + "'" };
+                        if (vErrors === null) {
+                            vErrors = [err7];
+                        }
+                        else {
+                            vErrors.push(err7);
+                        }
+                        errors++;
+                    }
+                    for (const key1 in data3) {
+                        if (!((key1 === "m") || (key1 === "s"))) {
+                            const err8 = { instancePath: instancePath + "/m/" + i0, schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                            if (vErrors === null) {
+                                vErrors = [err8];
+                            }
+                            else {
+                                vErrors.push(err8);
+                            }
+                            errors++;
+                        }
+                    }
+                    if (data3.m !== undefined) {
+                        let data4 = data3.m;
+                        if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
+                            if (data4.s === undefined) {
+                                const err9 = { instancePath: instancePath + "/m/" + i0 + "/m", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/properties/m/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
+                                if (vErrors === null) {
+                                    vErrors = [err9];
+                                }
+                                else {
+                                    vErrors.push(err9);
+                                }
+                                errors++;
+                            }
+                            if (data4.us === undefined) {
+                                const err10 = { instancePath: instancePath + "/m/" + i0 + "/m", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/properties/m/required", keyword: "required", params: { missingProperty: "us" }, message: "must have required property '" + "us" + "'" };
+                                if (vErrors === null) {
+                                    vErrors = [err10];
+                                }
+                                else {
+                                    vErrors.push(err10);
+                                }
+                                errors++;
+                            }
+                            for (const key2 in data4) {
+                                if (!((key2 === "s") || (key2 === "us"))) {
+                                    const err11 = { instancePath: instancePath + "/m/" + i0 + "/m", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/properties/m/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                                    if (vErrors === null) {
+                                        vErrors = [err11];
+                                    }
+                                    else {
+                                        vErrors.push(err11);
+                                    }
+                                    errors++;
+                                }
+                            }
+                            if (data4.s !== undefined) {
+                                let data5 = data4.s;
+                                if (!((typeof data5 == "number") && (isFinite(data5)))) {
+                                    const err12 = { instancePath: instancePath + "/m/" + i0 + "/m/s", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/properties/m/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                    if (vErrors === null) {
+                                        vErrors = [err12];
+                                    }
+                                    else {
+                                        vErrors.push(err12);
+                                    }
+                                    errors++;
+                                }
+                            }
+                            if (data4.us !== undefined) {
+                                let data6 = data4.us;
+                                if (!((typeof data6 == "number") && (isFinite(data6)))) {
+                                    const err13 = { instancePath: instancePath + "/m/" + i0 + "/m/us", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/properties/m/properties/us/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                    if (vErrors === null) {
+                                        vErrors = [err13];
+                                    }
+                                    else {
+                                        vErrors.push(err13);
+                                    }
+                                    errors++;
+                                }
+                            }
+                        }
+                        else {
+                            const err14 = { instancePath: instancePath + "/m/" + i0 + "/m", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/properties/m/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                            if (vErrors === null) {
+                                vErrors = [err14];
+                            }
+                            else {
+                                vErrors.push(err14);
+                            }
+                            errors++;
+                        }
+                    }
+                    if (data3.s !== undefined) {
+                        let data7 = data3.s;
+                        if (!((typeof data7 == "number") && (isFinite(data7)))) {
+                            const err15 = { instancePath: instancePath + "/m/" + i0 + "/s", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                            if (vErrors === null) {
+                                vErrors = [err15];
+                            }
+                            else {
+                                vErrors.push(err15);
+                            }
+                            errors++;
+                        }
+                    }
+                }
+                else {
+                    const err16 = { instancePath: instancePath + "/m/" + i0, schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/items/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                    if (vErrors === null) {
+                        vErrors = [err16];
+                    }
+                    else {
+                        vErrors.push(err16);
+                    }
+                    errors++;
+                }
+            }
+        }
+        else {
+            const err17 = { instancePath: instancePath + "/m", schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/properties/m/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err17];
+            }
+            else {
+                vErrors.push(err17);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err18 = { instancePath, schemaPath: "#/definitions/aggregatemetadatatypesJsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err18];
+    }
+    else {
+        vErrors.push(err18);
+    }
+    errors++;
+} validate10.errors = vErrors; return errors === 0; }

package/dist/generated/validators/aggregateMetadataV1.d.ts

@@ -0,0 +1,13 @@
+export function validate(data: any, { instancePath, parentData, parentDataProperty, rootData }?: {
+    instancePath?: string | undefined;
+    parentData: any;
+    parentDataProperty: any;
+    rootData?: any;
+}): boolean;
+export default validate10;
+declare function validate10(data: any, { instancePath, parentData, parentDataProperty, rootData }?: {
+    instancePath?: string | undefined;
+    parentData: any;
+    parentDataProperty: any;
+    rootData?: any;
+}): boolean;

package/dist/generated/validators/aggregateMetadataV1.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = void 0;
+exports.validate = validate10;
+exports.default = validate10;
+const schema27 = { "$ref": "#/definitions/aggregatemetadatav1JsonSchema", "definitions": { "aggregatemetadatav1JsonSchema": { "type": "object", "properties": { "v": { "type": "number", "const": 1 }, "s": { "type": "number" }, "m": { "type": "array", "items": { "type": "object", "properties": { "m": { "type": "object", "properties": { "s": { "type": "number" }, "us": { "type": "number" } }, "required": ["s", "us"], "additionalProperties": false }, "s": { "type": "number" } }, "required": ["m"], "additionalProperties": false } } }, "required": ["v", "s", "m"], "additionalProperties": false } }, "$schema": "http://json-schema.org/draft-07/schema#" };
+const schema28 = { "type": "object", "properties": { "v": { "type": "number", "const": 1 }, "s": { "type": "number" }, "m": { "type": "array", "items": { "type": "object", "properties": { "m": { "type": "object", "properties": { "s": { "type": "number" }, "us": { "type": "number" } }, "required": ["s", "us"], "additionalProperties": false }, "s": { "type": "number" } }, "required": ["m"], "additionalProperties": false } } }, "required": ["v", "s", "m"], "additionalProperties": false };
+function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.v === undefined) {
+        const err0 = { instancePath, schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/required", keyword: "required", params: { missingProperty: "v" }, message: "must have required property '" + "v" + "'" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (data.s === undefined) {
+        const err1 = { instancePath, schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    if (data.m === undefined) {
+        const err2 = { instancePath, schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/required", keyword: "required", params: { missingProperty: "m" }, message: "must have required property '" + "m" + "'" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    for (const key0 in data) {
+        if (!(((key0 === "v") || (key0 === "s")) || (key0 === "m"))) {
+            const err3 = { instancePath, schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err3];
+            }
+            else {
+                vErrors.push(err3);
+            }
+            errors++;
+        }
+    }
+    if (data.v !== undefined) {
+        let data0 = data.v;
+        if (!((typeof data0 == "number") && (isFinite(data0)))) {
+            const err4 = { instancePath: instancePath + "/v", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/v/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err4];
+            }
+            else {
+                vErrors.push(err4);
+            }
+            errors++;
+        }
+        if (1 !== data0) {
+            const err5 = { instancePath: instancePath + "/v", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/v/const", keyword: "const", params: { allowedValue: 1 }, message: "must be equal to constant" };
+            if (vErrors === null) {
+                vErrors = [err5];
+            }
+            else {
+                vErrors.push(err5);
+            }
+            errors++;
+        }
+    }
+    if (data.s !== undefined) {
+        let data1 = data.s;
+        if (!((typeof data1 == "number") && (isFinite(data1)))) {
+            const err6 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err6];
+            }
+            else {
+                vErrors.push(err6);
+            }
+            errors++;
+        }
+    }
+    if (data.m !== undefined) {
+        let data2 = data.m;
+        if (Array.isArray(data2)) {
+            const len0 = data2.length;
+            for (let i0 = 0; i0 < len0; i0++) {
+                let data3 = data2[i0];
+                if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+                    if (data3.m === undefined) {
+                        const err7 = { instancePath: instancePath + "/m/" + i0, schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/required", keyword: "required", params: { missingProperty: "m" }, message: "must have required property '" + "m" + "'" };
+                        if (vErrors === null) {
+                            vErrors = [err7];
+                        }
+                        else {
+                            vErrors.push(err7);
+                        }
+                        errors++;
+                    }
+                    for (const key1 in data3) {
+                        if (!((key1 === "m") || (key1 === "s"))) {
+                            const err8 = { instancePath: instancePath + "/m/" + i0, schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                            if (vErrors === null) {
+                                vErrors = [err8];
+                            }
+                            else {
+                                vErrors.push(err8);
+                            }
+                            errors++;
+                        }
+                    }
+                    if (data3.m !== undefined) {
+                        let data4 = data3.m;
+                        if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
+                            if (data4.s === undefined) {
+                                const err9 = { instancePath: instancePath + "/m/" + i0 + "/m", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/properties/m/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
+                                if (vErrors === null) {
+                                    vErrors = [err9];
+                                }
+                                else {
+                                    vErrors.push(err9);
+                                }
+                                errors++;
+                            }
+                            if (data4.us === undefined) {
+                                const err10 = { instancePath: instancePath + "/m/" + i0 + "/m", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/properties/m/required", keyword: "required", params: { missingProperty: "us" }, message: "must have required property '" + "us" + "'" };
+                                if (vErrors === null) {
+                                    vErrors = [err10];
+                                }
+                                else {
+                                    vErrors.push(err10);
+                                }
+                                errors++;
+                            }
+                            for (const key2 in data4) {
+                                if (!((key2 === "s") || (key2 === "us"))) {
+                                    const err11 = { instancePath: instancePath + "/m/" + i0 + "/m", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/properties/m/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                                    if (vErrors === null) {
+                                        vErrors = [err11];
+                                    }
+                                    else {
+                                        vErrors.push(err11);
+                                    }
+                                    errors++;
+                                }
+                            }
+                            if (data4.s !== undefined) {
+                                let data5 = data4.s;
+                                if (!((typeof data5 == "number") && (isFinite(data5)))) {
+                                    const err12 = { instancePath: instancePath + "/m/" + i0 + "/m/s", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/properties/m/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                    if (vErrors === null) {
+                                        vErrors = [err12];
+                                    }
+                                    else {
+                                        vErrors.push(err12);
+                                    }
+                                    errors++;
+                                }
+                            }
+                            if (data4.us !== undefined) {
+                                let data6 = data4.us;
+                                if (!((typeof data6 == "number") && (isFinite(data6)))) {
+                                    const err13 = { instancePath: instancePath + "/m/" + i0 + "/m/us", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/properties/m/properties/us/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                    if (vErrors === null) {
+                                        vErrors = [err13];
+                                    }
+                                    else {
+                                        vErrors.push(err13);
+                                    }
+                                    errors++;
+                                }
+                            }
+                        }
+                        else {
+                            const err14 = { instancePath: instancePath + "/m/" + i0 + "/m", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/properties/m/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                            if (vErrors === null) {
+                                vErrors = [err14];
+                            }
+                            else {
+                                vErrors.push(err14);
+                            }
+                            errors++;
+                        }
+                    }
+                    if (data3.s !== undefined) {
+                        let data7 = data3.s;
+                        if (!((typeof data7 == "number") && (isFinite(data7)))) {
+                            const err15 = { instancePath: instancePath + "/m/" + i0 + "/s", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                            if (vErrors === null) {
+                                vErrors = [err15];
+                            }
+                            else {
+                                vErrors.push(err15);
+                            }
+                            errors++;
+                        }
+                    }
+                }
+                else {
+                    const err16 = { instancePath: instancePath + "/m/" + i0, schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/items/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                    if (vErrors === null) {
+                        vErrors = [err16];
+                    }
+                    else {
+                        vErrors.push(err16);
+                    }
+                    errors++;
+                }
+            }
+        }
+        else {
+            const err17 = { instancePath: instancePath + "/m", schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/properties/m/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err17];
+            }
+            else {
+                vErrors.push(err17);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err18 = { instancePath, schemaPath: "#/definitions/aggregatemetadatav1JsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err18];
+    }
+    else {
+        vErrors.push(err18);
+    }
+    errors++;
+} validate10.errors = vErrors; return errors === 0; }

package/dist/generated/validators/dataMessage.d.ts

@@ -0,0 +1,13 @@
+export function validate(data: any, { instancePath, parentData, parentDataProperty, rootData }?: {
+    instancePath?: string | undefined;
+    parentData: any;
+    parentDataProperty: any;
+    rootData?: any;
+}): boolean;
+export default validate10;
+declare function validate10(data: any, { instancePath, parentData, parentDataProperty, rootData }?: {
+    instancePath?: string | undefined;
+    parentData: any;
+    parentDataProperty: any;
+    rootData?: any;
+}): boolean;