@xube/kit-aws-data-schema 0.0.73

package/dist/generated/validators/dataMessage.js

@@ -0,0 +1,142 @@
+"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"))) {
+            const err5 = { instancePath, schemaPath: "#/definitions/datamessageJsonSchema/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err5];
+            }
+            else {
+                vErrors.push(err5);
+            }
+            errors++;
+        }
+    }
+    if (data.payload !== undefined) {
+        if (typeof data.payload !== "string") {
+            const err6 = { instancePath: instancePath + "/payload", schemaPath: "#/definitions/datamessageJsonSchema/properties/payload/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err6];
+            }
+            else {
+                vErrors.push(err6);
+            }
+            errors++;
+        }
+    }
+    if (data.account !== undefined) {
+        if (typeof data.account !== "string") {
+            const err7 = { instancePath: instancePath + "/account", schemaPath: "#/definitions/datamessageJsonSchema/properties/account/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err7];
+            }
+            else {
+                vErrors.push(err7);
+            }
+            errors++;
+        }
+    }
+    if (data.device !== undefined) {
+        if (typeof data.device !== "string") {
+            const err8 = { instancePath: instancePath + "/device", schemaPath: "#/definitions/datamessageJsonSchema/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err8];
+            }
+            else {
+                vErrors.push(err8);
+            }
+            errors++;
+        }
+    }
+    if (data.component !== undefined) {
+        if (typeof data.component !== "string") {
+            const err9 = { instancePath: instancePath + "/component", schemaPath: "#/definitions/datamessageJsonSchema/properties/component/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err9];
+            }
+            else {
+                vErrors.push(err9);
+            }
+            errors++;
+        }
+    }
+    if (data.timestamp !== undefined) {
+        let data4 = data.timestamp;
+        if (!((typeof data4 == "number") && (isFinite(data4)))) {
+            const err10 = { instancePath: instancePath + "/timestamp", schemaPath: "#/definitions/datamessageJsonSchema/properties/timestamp/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err10];
+            }
+            else {
+                vErrors.push(err10);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err11 = { instancePath, schemaPath: "#/definitions/datamessageJsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err11];
+    }
+    else {
+        vErrors.push(err11);
+    }
+    errors++;
+} validate10.errors = vErrors; return errors === 0; }

package/dist/generated/validators/deviceReadingMetadataV1.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/deviceReadingMetadataV1.js

@@ -0,0 +1,77 @@
+"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"))) {
+            const err2 = { instancePath, schemaPath: "#/definitions/devicereadingmetadatav1JsonSchema/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err2];
+            }
+            else {
+                vErrors.push(err2);
+            }
+            errors++;
+        }
+    }
+    if (data.s !== undefined) {
+        let data0 = data.s;
+        if (!((typeof data0 == "number") && (isFinite(data0)))) {
+            const err3 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/devicereadingmetadatav1JsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err3];
+            }
+            else {
+                vErrors.push(err3);
+            }
+            errors++;
+        }
+    }
+    if (data.us !== undefined) {
+        let data1 = data.us;
+        if (!((typeof data1 == "number") && (isFinite(data1)))) {
+            const err4 = { instancePath: instancePath + "/us", schemaPath: "#/definitions/devicereadingmetadatav1JsonSchema/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, schemaPath: "#/definitions/devicereadingmetadatav1JsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err5];
+    }
+    else {
+        vErrors.push(err5);
+    }
+    errors++;
+} validate10.errors = vErrors; return errors === 0; }

package/dist/generated/validators/deviceReadingV1.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/deviceReadingV1.js

@@ -0,0 +1,127 @@
+"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"))) {
+            const err1 = { instancePath, schemaPath: "#/definitions/devicereadingv1JsonSchema/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err1];
+            }
+            else {
+                vErrors.push(err1);
+            }
+            errors++;
+        }
+    }
+    if (data.m !== undefined) {
+        let data0 = data.m;
+        if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+            if (data0.s === undefined) {
+                const err2 = { instancePath: instancePath + "/m", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/m/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err2];
+                }
+                else {
+                    vErrors.push(err2);
+                }
+                errors++;
+            }
+            if (data0.us === undefined) {
+                const err3 = { instancePath: instancePath + "/m", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/m/required", keyword: "required", params: { missingProperty: "us" }, message: "must have required property '" + "us" + "'" };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+            for (const key1 in data0) {
+                if (!((key1 === "s") || (key1 === "us"))) {
+                    const err4 = { instancePath: instancePath + "/m", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/m/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                        vErrors = [err4];
+                    }
+                    else {
+                        vErrors.push(err4);
+                    }
+                    errors++;
+                }
+            }
+            if (data0.s !== undefined) {
+                let data1 = data0.s;
+                if (!((typeof data1 == "number") && (isFinite(data1)))) {
+                    const err5 = { 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 = [err5];
+                    }
+                    else {
+                        vErrors.push(err5);
+                    }
+                    errors++;
+                }
+            }
+            if (data0.us !== undefined) {
+                let data2 = data0.us;
+                if (!((typeof data2 == "number") && (isFinite(data2)))) {
+                    const err6 = { 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 = [err6];
+                    }
+                    else {
+                        vErrors.push(err6);
+                    }
+                    errors++;
+                }
+            }
+        }
+        else {
+            const err7 = { instancePath: instancePath + "/m", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/m/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+                vErrors = [err7];
+            }
+            else {
+                vErrors.push(err7);
+            }
+            errors++;
+        }
+    }
+    if (data.s !== undefined) {
+        let data3 = data.s;
+        if (!((typeof data3 == "number") && (isFinite(data3)))) {
+            const err8 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/devicereadingv1JsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err8];
+            }
+            else {
+                vErrors.push(err8);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err9 = { instancePath, schemaPath: "#/definitions/devicereadingv1JsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err9];
+    }
+    else {
+        vErrors.push(err9);
+    }
+    errors++;
+} validate10.errors = vErrors; return errors === 0; }

package/dist/generated/validators/readingMetadataV1.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/readingMetadataV1.js

@@ -0,0 +1,77 @@
+"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"))) {
+            const err2 = { instancePath, schemaPath: "#/definitions/readingmetadatav1JsonSchema/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+                vErrors = [err2];
+            }
+            else {
+                vErrors.push(err2);
+            }
+            errors++;
+        }
+    }
+    if (data.s !== undefined) {
+        let data0 = data.s;
+        if (!((typeof data0 == "number") && (isFinite(data0)))) {
+            const err3 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/readingmetadatav1JsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err3];
+            }
+            else {
+                vErrors.push(err3);
+            }
+            errors++;
+        }
+    }
+    if (data.us !== undefined) {
+        let data1 = data.us;
+        if (!((typeof data1 == "number") && (isFinite(data1)))) {
+            const err4 = { instancePath: instancePath + "/us", schemaPath: "#/definitions/readingmetadatav1JsonSchema/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, schemaPath: "#/definitions/readingmetadatav1JsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err5];
+    }
+    else {
+        vErrors.push(err5);
+    }
+    errors++;
+} validate10.errors = vErrors; return errors === 0; }

package/dist/generated/validators/readingV1.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;