@xube/kit-aws-data-schema 0.0.92 → 0.0.94

package/dist/generated/validators/dataMessage.js

@@ -1,135 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = void 0;
-exports.validate = validate10;
-exports.default = validate10;
-const schema27 = { "$ref": "#/definitions/datamessageJsonSchema", "definitions": { "datamessageJsonSchema": { "type": "object", "properties": { "payload": { "type": "string" }, "account": { "type": "string" }, "device": { "type": "string" }, "component": { "type": "string" }, "timestamp": { "type": "number" } }, "required": ["payload", "account", "device", "component", "timestamp"], "additionalProperties": false } }, "$schema": "http://json-schema.org/draft-07/schema#" };
-const schema28 = { "type": "object", "properties": { "payload": { "type": "string" }, "account": { "type": "string" }, "device": { "type": "string" }, "component": { "type": "string" }, "timestamp": { "type": "number" } }, "required": ["payload", "account", "device", "component", "timestamp"], "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.payload === undefined) {
-        const err0 = { instancePath, schemaPath: "#/definitions/datamessageJsonSchema/required", keyword: "required", params: { missingProperty: "payload" }, message: "must have required property '" + "payload" + "'" };
-        if (vErrors === null) {
-            vErrors = [err0];
-        }
-        else {
-            vErrors.push(err0);
-        }
-        errors++;
-    }
-    if (data.account === undefined) {
-        const err1 = { instancePath, schemaPath: "#/definitions/datamessageJsonSchema/required", keyword: "required", params: { missingProperty: "account" }, message: "must have required property '" + "account" + "'" };
-        if (vErrors === null) {
-            vErrors = [err1];
-        }
-        else {
-            vErrors.push(err1);
-        }
-        errors++;
-    }
-    if (data.device === undefined) {
-        const err2 = { instancePath, schemaPath: "#/definitions/datamessageJsonSchema/required", keyword: "required", params: { missingProperty: "device" }, message: "must have required property '" + "device" + "'" };
-        if (vErrors === null) {
-            vErrors = [err2];
-        }
-        else {
-            vErrors.push(err2);
-        }
-        errors++;
-    }
-    if (data.component === undefined) {
-        const err3 = { instancePath, schemaPath: "#/definitions/datamessageJsonSchema/required", keyword: "required", params: { missingProperty: "component" }, message: "must have required property '" + "component" + "'" };
-        if (vErrors === null) {
-            vErrors = [err3];
-        }
-        else {
-            vErrors.push(err3);
-        }
-        errors++;
-    }
-    if (data.timestamp === undefined) {
-        const err4 = { instancePath, schemaPath: "#/definitions/datamessageJsonSchema/required", keyword: "required", params: { missingProperty: "timestamp" }, message: "must have required property '" + "timestamp" + "'" };
-        if (vErrors === null) {
-            vErrors = [err4];
-        }
-        else {
-            vErrors.push(err4);
-        }
-        errors++;
-    }
-    for (const key0 in data) {
-        if (!(((((key0 === "payload") || (key0 === "account")) || (key0 === "device")) || (key0 === "component")) || (key0 === "timestamp"))) {
-            delete data[key0];
-        }
-    }
-    if (data.payload !== undefined) {
-        if (typeof data.payload !== "string") {
-            const err5 = { instancePath: instancePath + "/payload", schemaPath: "#/definitions/datamessageJsonSchema/properties/payload/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-            if (vErrors === null) {
-                vErrors = [err5];
-            }
-            else {
-                vErrors.push(err5);
-            }
-            errors++;
-        }
-    }
-    if (data.account !== undefined) {
-        if (typeof data.account !== "string") {
-            const err6 = { instancePath: instancePath + "/account", schemaPath: "#/definitions/datamessageJsonSchema/properties/account/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-            if (vErrors === null) {
-                vErrors = [err6];
-            }
-            else {
-                vErrors.push(err6);
-            }
-            errors++;
-        }
-    }
-    if (data.device !== undefined) {
-        if (typeof data.device !== "string") {
-            const err7 = { instancePath: instancePath + "/device", schemaPath: "#/definitions/datamessageJsonSchema/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-            if (vErrors === null) {
-                vErrors = [err7];
-            }
-            else {
-                vErrors.push(err7);
-            }
-            errors++;
-        }
-    }
-    if (data.component !== undefined) {
-        if (typeof data.component !== "string") {
-            const err8 = { instancePath: instancePath + "/component", schemaPath: "#/definitions/datamessageJsonSchema/properties/component/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-            if (vErrors === null) {
-                vErrors = [err8];
-            }
-            else {
-                vErrors.push(err8);
-            }
-            errors++;
-        }
-    }
-    if (data.timestamp !== undefined) {
-        let data4 = data.timestamp;
-        if (!((typeof data4 == "number") && (isFinite(data4)))) {
-            const err9 = { instancePath: instancePath + "/timestamp", schemaPath: "#/definitions/datamessageJsonSchema/properties/timestamp/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-            if (vErrors === null) {
-                vErrors = [err9];
-            }
-            else {
-                vErrors.push(err9);
-            }
-            errors++;
-        }
-    }
-}
-else {
-    const err10 = { instancePath, schemaPath: "#/definitions/datamessageJsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-    if (vErrors === null) {
-        vErrors = [err10];
-    }
-    else {
-        vErrors.push(err10);
-    }
-    errors++;
-} validate10.errors = vErrors; return errors === 0; }

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

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

package/dist/generated/validators/deviceReadingMetadataV1.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = void 0;
-exports.validate = validate10;
-exports.default = validate10;
-const schema27 = { "$ref": "#/definitions/devicereadingmetadatav1JsonSchema", "definitions": { "devicereadingmetadatav1JsonSchema": { "type": "object", "properties": { "s": { "type": "number" }, "us": { "type": "number" } }, "required": ["s", "us"], "additionalProperties": false } }, "$schema": "http://json-schema.org/draft-07/schema#" };
-const schema28 = { "type": "object", "properties": { "s": { "type": "number" }, "us": { "type": "number" } }, "required": ["s", "us"], "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.s === undefined) {
-        const err0 = { instancePath, schemaPath: "#/definitions/devicereadingmetadatav1JsonSchema/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
-        if (vErrors === null) {
-            vErrors = [err0];
-        }
-        else {
-            vErrors.push(err0);
-        }
-        errors++;
-    }
-    if (data.us === undefined) {
-        const err1 = { instancePath, schemaPath: "#/definitions/devicereadingmetadatav1JsonSchema/required", keyword: "required", params: { missingProperty: "us" }, message: "must have required property '" + "us" + "'" };
-        if (vErrors === null) {
-            vErrors = [err1];
-        }
-        else {
-            vErrors.push(err1);
-        }
-        errors++;
-    }
-    for (const key0 in data) {
-        if (!((key0 === "s") || (key0 === "us"))) {
-            delete data[key0];
-        }
-    }
-    if (data.s !== undefined) {
-        let data0 = data.s;
-        if (!((typeof data0 == "number") && (isFinite(data0)))) {
-            const err2 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/devicereadingmetadatav1JsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-            if (vErrors === null) {
-                vErrors = [err2];
-            }
-            else {
-                vErrors.push(err2);
-            }
-            errors++;
-        }
-    }
-    if (data.us !== undefined) {
-        let data1 = data.us;
-        if (!((typeof data1 == "number") && (isFinite(data1)))) {
-            const err3 = { instancePath: instancePath + "/us", schemaPath: "#/definitions/devicereadingmetadatav1JsonSchema/properties/us/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-            if (vErrors === null) {
-                vErrors = [err3];
-            }
-            else {
-                vErrors.push(err3);
-            }
-            errors++;
-        }
-    }
-}
-else {
-    const err4 = { instancePath, schemaPath: "#/definitions/devicereadingmetadatav1JsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-    if (vErrors === null) {
-        vErrors = [err4];
-    }
-    else {
-        vErrors.push(err4);
-    }
-    errors++;
-} validate10.errors = vErrors; return errors === 0; }

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

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

package/dist/generated/validators/deviceReadingV1.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = void 0;
-exports.validate = validate10;
-exports.default = validate10;
-const schema27 = { "$ref": "#/definitions/devicereadingv1JsonSchema", "definitions": { "devicereadingv1JsonSchema": { "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 } }, "$schema": "http://json-schema.org/draft-07/schema#" };
-const schema28 = { "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 };
-function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; if (data && typeof data == "object" && !Array.isArray(data)) {
-    if (data.m === undefined) {
-        const err0 = { instancePath, schemaPath: "#/definitions/devicereadingv1JsonSchema/required", keyword: "required", params: { missingProperty: "m" }, message: "must have required property '" + "m" + "'" };
-        if (vErrors === null) {
-            vErrors = [err0];
-        }
-        else {
-            vErrors.push(err0);
-        }
-        errors++;
-    }
-    for (const key0 in data) {
-        if (!((key0 === "m") || (key0 === "s"))) {
-            delete data[key0];
-        }
-    }
-    if (data.m !== undefined) {
-        let data0 = data.m;
-        if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
-            if (data0.s === undefined) {
-                const err1 = { instancePath: instancePath + "/m", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/m/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
-                if (vErrors === null) {
-                    vErrors = [err1];
-                }
-                else {
-                    vErrors.push(err1);
-                }
-                errors++;
-            }
-            if (data0.us === undefined) {
-                const err2 = { instancePath: instancePath + "/m", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/m/required", keyword: "required", params: { missingProperty: "us" }, message: "must have required property '" + "us" + "'" };
-                if (vErrors === null) {
-                    vErrors = [err2];
-                }
-                else {
-                    vErrors.push(err2);
-                }
-                errors++;
-            }
-            for (const key1 in data0) {
-                if (!((key1 === "s") || (key1 === "us"))) {
-                    delete data0[key1];
-                }
-            }
-            if (data0.s !== undefined) {
-                let data1 = data0.s;
-                if (!((typeof data1 == "number") && (isFinite(data1)))) {
-                    const err3 = { instancePath: instancePath + "/m/s", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/m/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                    if (vErrors === null) {
-                        vErrors = [err3];
-                    }
-                    else {
-                        vErrors.push(err3);
-                    }
-                    errors++;
-                }
-            }
-            if (data0.us !== undefined) {
-                let data2 = data0.us;
-                if (!((typeof data2 == "number") && (isFinite(data2)))) {
-                    const err4 = { instancePath: instancePath + "/m/us", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/m/properties/us/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                    if (vErrors === null) {
-                        vErrors = [err4];
-                    }
-                    else {
-                        vErrors.push(err4);
-                    }
-                    errors++;
-                }
-            }
-        }
-        else {
-            const err5 = { instancePath: instancePath + "/m", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/m/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-            if (vErrors === null) {
-                vErrors = [err5];
-            }
-            else {
-                vErrors.push(err5);
-            }
-            errors++;
-        }
-    }
-    if (data.s !== undefined) {
-        let data3 = data.s;
-        if (!((typeof data3 == "number") && (isFinite(data3)))) {
-            const err6 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-            if (vErrors === null) {
-                vErrors = [err6];
-            }
-            else {
-                vErrors.push(err6);
-            }
-            errors++;
-        }
-    }
-}
-else {
-    const err7 = { instancePath, schemaPath: "#/definitions/devicereadingv1JsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-    if (vErrors === null) {
-        vErrors = [err7];
-    }
-    else {
-        vErrors.push(err7);
-    }
-    errors++;
-} validate10.errors = vErrors; return errors === 0; }

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

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

package/dist/generated/validators/readingMetadataV1.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = void 0;
-exports.validate = validate10;
-exports.default = validate10;
-const schema27 = { "$ref": "#/definitions/readingmetadatav1JsonSchema", "definitions": { "readingmetadatav1JsonSchema": { "type": "object", "properties": { "s": { "type": "number" }, "us": { "type": "number" } }, "required": ["s", "us"], "additionalProperties": false } }, "$schema": "http://json-schema.org/draft-07/schema#" };
-const schema28 = { "type": "object", "properties": { "s": { "type": "number" }, "us": { "type": "number" } }, "required": ["s", "us"], "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.s === undefined) {
-        const err0 = { instancePath, schemaPath: "#/definitions/readingmetadatav1JsonSchema/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
-        if (vErrors === null) {
-            vErrors = [err0];
-        }
-        else {
-            vErrors.push(err0);
-        }
-        errors++;
-    }
-    if (data.us === undefined) {
-        const err1 = { instancePath, schemaPath: "#/definitions/readingmetadatav1JsonSchema/required", keyword: "required", params: { missingProperty: "us" }, message: "must have required property '" + "us" + "'" };
-        if (vErrors === null) {
-            vErrors = [err1];
-        }
-        else {
-            vErrors.push(err1);
-        }
-        errors++;
-    }
-    for (const key0 in data) {
-        if (!((key0 === "s") || (key0 === "us"))) {
-            delete data[key0];
-        }
-    }
-    if (data.s !== undefined) {
-        let data0 = data.s;
-        if (!((typeof data0 == "number") && (isFinite(data0)))) {
-            const err2 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/readingmetadatav1JsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-            if (vErrors === null) {
-                vErrors = [err2];
-            }
-            else {
-                vErrors.push(err2);
-            }
-            errors++;
-        }
-    }
-    if (data.us !== undefined) {
-        let data1 = data.us;
-        if (!((typeof data1 == "number") && (isFinite(data1)))) {
-            const err3 = { instancePath: instancePath + "/us", schemaPath: "#/definitions/readingmetadatav1JsonSchema/properties/us/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-            if (vErrors === null) {
-                vErrors = [err3];
-            }
-            else {
-                vErrors.push(err3);
-            }
-            errors++;
-        }
-    }
-}
-else {
-    const err4 = { instancePath, schemaPath: "#/definitions/readingmetadatav1JsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-    if (vErrors === null) {
-        vErrors = [err4];
-    }
-    else {
-        vErrors.push(err4);
-    }
-    errors++;
-} validate10.errors = vErrors; return errors === 0; }

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

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

package/dist/generated/validators/readingV1.js

@@ -1,215 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = void 0;
-exports.validate = validate10;
-exports.default = validate10;
-const schema27 = { "$ref": "#/definitions/readingv1JsonSchema", "definitions": { "readingv1JsonSchema": { "type": "object", "properties": { "data": { "anyOf": [{ "type": "string" }, { "type": "number" }, { "type": "boolean" }, { "type": "object", "properties": {}, "additionalProperties": true }] }, "component": { "type": "string" }, "s": { "type": "number" }, "us": { "type": "number" }, "type": { "type": "string" }, "id": { "type": "string" } }, "required": ["data", "s", "type", "id"], "additionalProperties": true } }, "$schema": "http://json-schema.org/draft-07/schema#" };
-const schema28 = { "type": "object", "properties": { "data": { "anyOf": [{ "type": "string" }, { "type": "number" }, { "type": "boolean" }, { "type": "object", "properties": {}, "additionalProperties": true }] }, "component": { "type": "string" }, "s": { "type": "number" }, "us": { "type": "number" }, "type": { "type": "string" }, "id": { "type": "string" } }, "required": ["data", "s", "type", "id"], "additionalProperties": true };
-function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; if (data && typeof data == "object" && !Array.isArray(data)) {
-    if (data.data === undefined) {
-        const err0 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/required", keyword: "required", params: { missingProperty: "data" }, message: "must have required property '" + "data" + "'" };
-        if (vErrors === null) {
-            vErrors = [err0];
-        }
-        else {
-            vErrors.push(err0);
-        }
-        errors++;
-    }
-    if (data.s === undefined) {
-        const err1 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
-        if (vErrors === null) {
-            vErrors = [err1];
-        }
-        else {
-            vErrors.push(err1);
-        }
-        errors++;
-    }
-    if (data.type === undefined) {
-        const err2 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property '" + "type" + "'" };
-        if (vErrors === null) {
-            vErrors = [err2];
-        }
-        else {
-            vErrors.push(err2);
-        }
-        errors++;
-    }
-    if (data.id === undefined) {
-        const err3 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/required", keyword: "required", params: { missingProperty: "id" }, message: "must have required property '" + "id" + "'" };
-        if (vErrors === null) {
-            vErrors = [err3];
-        }
-        else {
-            vErrors.push(err3);
-        }
-        errors++;
-    }
-    for (const key0 in data) {
-        if (!((((((key0 === "data") || (key0 === "component")) || (key0 === "s")) || (key0 === "us")) || (key0 === "type")) || (key0 === "id"))) {
-            delete data[key0];
-        }
-    }
-    if (data.data !== undefined) {
-        let data0 = data.data;
-        const _errs4 = errors;
-        let valid2 = false;
-        const _errs5 = errors;
-        if (typeof data0 !== "string") {
-            const err4 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf/0/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-            if (vErrors === null) {
-                vErrors = [err4];
-            }
-            else {
-                vErrors.push(err4);
-            }
-            errors++;
-        }
-        var _valid0 = _errs5 === errors;
-        valid2 = valid2 || _valid0;
-        if (!valid2) {
-            const _errs7 = errors;
-            if (!((typeof data0 == "number") && (isFinite(data0)))) {
-                const err5 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf/1/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                if (vErrors === null) {
-                    vErrors = [err5];
-                }
-                else {
-                    vErrors.push(err5);
-                }
-                errors++;
-            }
-            var _valid0 = _errs7 === errors;
-            valid2 = valid2 || _valid0;
-            if (!valid2) {
-                const _errs9 = errors;
-                if (typeof data0 !== "boolean") {
-                    const err6 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf/2/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
-                    if (vErrors === null) {
-                        vErrors = [err6];
-                    }
-                    else {
-                        vErrors.push(err6);
-                    }
-                    errors++;
-                }
-                var _valid0 = _errs9 === errors;
-                valid2 = valid2 || _valid0;
-                if (!valid2) {
-                    const _errs11 = errors;
-                    if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
-                        for (const key1 in data0) {
-                            delete data0[key1];
-                        }
-                    }
-                    else {
-                        const err7 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf/3/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                        if (vErrors === null) {
-                            vErrors = [err7];
-                        }
-                        else {
-                            vErrors.push(err7);
-                        }
-                        errors++;
-                    }
-                    var _valid0 = _errs11 === errors;
-                    valid2 = valid2 || _valid0;
-                }
-            }
-        }
-        if (!valid2) {
-            const err8 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
-            if (vErrors === null) {
-                vErrors = [err8];
-            }
-            else {
-                vErrors.push(err8);
-            }
-            errors++;
-        }
-        else {
-            errors = _errs4;
-            if (vErrors !== null) {
-                if (_errs4) {
-                    vErrors.length = _errs4;
-                }
-                else {
-                    vErrors = null;
-                }
-            }
-        }
-    }
-    if (data.component !== undefined) {
-        if (typeof data.component !== "string") {
-            const err9 = { instancePath: instancePath + "/component", schemaPath: "#/definitions/readingv1JsonSchema/properties/component/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-            if (vErrors === null) {
-                vErrors = [err9];
-            }
-            else {
-                vErrors.push(err9);
-            }
-            errors++;
-        }
-    }
-    if (data.s !== undefined) {
-        let data2 = data.s;
-        if (!((typeof data2 == "number") && (isFinite(data2)))) {
-            const err10 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/readingv1JsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-            if (vErrors === null) {
-                vErrors = [err10];
-            }
-            else {
-                vErrors.push(err10);
-            }
-            errors++;
-        }
-    }
-    if (data.us !== undefined) {
-        let data3 = data.us;
-        if (!((typeof data3 == "number") && (isFinite(data3)))) {
-            const err11 = { instancePath: instancePath + "/us", schemaPath: "#/definitions/readingv1JsonSchema/properties/us/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-            if (vErrors === null) {
-                vErrors = [err11];
-            }
-            else {
-                vErrors.push(err11);
-            }
-            errors++;
-        }
-    }
-    if (data.type !== undefined) {
-        if (typeof data.type !== "string") {
-            const err12 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/readingv1JsonSchema/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-            if (vErrors === null) {
-                vErrors = [err12];
-            }
-            else {
-                vErrors.push(err12);
-            }
-            errors++;
-        }
-    }
-    if (data.id !== undefined) {
-        if (typeof data.id !== "string") {
-            const err13 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/readingv1JsonSchema/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-            if (vErrors === null) {
-                vErrors = [err13];
-            }
-            else {
-                vErrors.push(err13);
-            }
-            errors++;
-        }
-    }
-}
-else {
-    const err14 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-    if (vErrors === null) {
-        vErrors = [err14];
-    }
-    else {
-        vErrors.push(err14);
-    }
-    errors++;
-} validate10.errors = vErrors; return errors === 0; }

package/dist/generator.d.ts

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