@xube/kit-aws-data-schema 0.0.73

package/dist/generated/validators/readingV1.js

@@ -0,0 +1,216 @@
+"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", "component", "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", "component", "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.component === undefined) {
+        const err1 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/required", keyword: "required", params: { missingProperty: "component" }, message: "must have required property '" + "component" + "'" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    if (data.s === undefined) {
+        const err2 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/required", keyword: "required", params: { missingProperty: "s" }, message: "must have required property '" + "s" + "'" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+    if (data.type === undefined) {
+        const err3 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property '" + "type" + "'" };
+        if (vErrors === null) {
+            vErrors = [err3];
+        }
+        else {
+            vErrors.push(err3);
+        }
+        errors++;
+    }
+    if (data.id === undefined) {
+        const err4 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/required", keyword: "required", params: { missingProperty: "id" }, message: "must have required property '" + "id" + "'" };
+        if (vErrors === null) {
+            vErrors = [err4];
+        }
+        else {
+            vErrors.push(err4);
+        }
+        errors++;
+    }
+    if (data.data !== undefined) {
+        let data0 = data.data;
+        const _errs4 = errors;
+        let valid2 = false;
+        const _errs5 = errors;
+        if (typeof data0 !== "string") {
+            const err5 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf/0/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err5];
+            }
+            else {
+                vErrors.push(err5);
+            }
+            errors++;
+        }
+        var _valid0 = _errs5 === errors;
+        valid2 = valid2 || _valid0;
+        if (!valid2) {
+            const _errs7 = errors;
+            if (!((typeof data0 == "number") && (isFinite(data0)))) {
+                const err6 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf/1/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                    vErrors = [err6];
+                }
+                else {
+                    vErrors.push(err6);
+                }
+                errors++;
+            }
+            var _valid0 = _errs7 === errors;
+            valid2 = valid2 || _valid0;
+            if (!valid2) {
+                const _errs9 = errors;
+                if (typeof data0 !== "boolean") {
+                    const err7 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf/2/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                    if (vErrors === null) {
+                        vErrors = [err7];
+                    }
+                    else {
+                        vErrors.push(err7);
+                    }
+                    errors++;
+                }
+                var _valid0 = _errs9 === errors;
+                valid2 = valid2 || _valid0;
+                if (!valid2) {
+                    const _errs11 = errors;
+                    if (data0 && typeof data0 == "object" && !Array.isArray(data0)) { }
+                    else {
+                        const err8 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf/3/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                        if (vErrors === null) {
+                            vErrors = [err8];
+                        }
+                        else {
+                            vErrors.push(err8);
+                        }
+                        errors++;
+                    }
+                    var _valid0 = _errs11 === errors;
+                    valid2 = valid2 || _valid0;
+                }
+            }
+        }
+        if (!valid2) {
+            const err9 = { instancePath: instancePath + "/data", schemaPath: "#/definitions/readingv1JsonSchema/properties/data/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+            if (vErrors === null) {
+                vErrors = [err9];
+            }
+            else {
+                vErrors.push(err9);
+            }
+            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 err10 = { instancePath: instancePath + "/component", schemaPath: "#/definitions/readingv1JsonSchema/properties/component/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err10];
+            }
+            else {
+                vErrors.push(err10);
+            }
+            errors++;
+        }
+    }
+    if (data.s !== undefined) {
+        let data2 = data.s;
+        if (!((typeof data2 == "number") && (isFinite(data2)))) {
+            const err11 = { instancePath: instancePath + "/s", schemaPath: "#/definitions/readingv1JsonSchema/properties/s/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err11];
+            }
+            else {
+                vErrors.push(err11);
+            }
+            errors++;
+        }
+    }
+    if (data.us !== undefined) {
+        let data3 = data.us;
+        if (!((typeof data3 == "number") && (isFinite(data3)))) {
+            const err12 = { instancePath: instancePath + "/us", schemaPath: "#/definitions/readingv1JsonSchema/properties/us/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+            if (vErrors === null) {
+                vErrors = [err12];
+            }
+            else {
+                vErrors.push(err12);
+            }
+            errors++;
+        }
+    }
+    if (data.type !== undefined) {
+        if (typeof data.type !== "string") {
+            const err13 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/readingv1JsonSchema/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err13];
+            }
+            else {
+                vErrors.push(err13);
+            }
+            errors++;
+        }
+    }
+    if (data.id !== undefined) {
+        if (typeof data.id !== "string") {
+            const err14 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/readingv1JsonSchema/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+                vErrors = [err14];
+            }
+            else {
+                vErrors.push(err14);
+            }
+            errors++;
+        }
+    }
+}
+else {
+    const err15 = { instancePath, schemaPath: "#/definitions/readingv1JsonSchema/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+        vErrors = [err15];
+    }
+    else {
+        vErrors.push(err15);
+    }
+    errors++;
+} validate10.errors = vErrors; return errors === 0; }

package/dist/generator.d.ts

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

package/dist/generator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kit_generator_1 = require("@xube/kit-generator");
+const aggregate_1 = require("./decode/aggregate");
+const reading_1 = require("./decode/reading");
+const message_1 = require("./message/message");
+const generatedFilePaths = [
+    ...(0, kit_generator_1.generateTypeSchemaFiles)("aggregateMetadata", aggregate_1.AggregateMetadataSchema, __dirname),
+    ...(0, kit_generator_1.generateTypeSchemaFiles)("aggregateMetadataV1", aggregate_1.AggregateMetadataV1Schema, __dirname),
+    ...(0, kit_generator_1.generateTypeSchemaFiles)("aggregateMetadataTypes", aggregate_1.AggregateMetadataSchemas, __dirname),
+    ...(0, kit_generator_1.generateTypeSchemaFiles)("deviceReadingMetadataV1", reading_1.DeviceReadingMetadataV1Schema, __dirname),
+    ...(0, kit_generator_1.generateTypeSchemaFiles)("deviceReadingV1", reading_1.DeviceReadingV1Schema, __dirname),
+    ...(0, kit_generator_1.generateTypeSchemaFiles)("readingV1", reading_1.ReadingV1Schema, __dirname),
+    ...(0, kit_generator_1.generateTypeSchemaFiles)("readingMetadataV1", reading_1.ReadingMetadataV1Schema, __dirname),
+    ...(0, kit_generator_1.generateTypeSchemaFiles)("dataMessage", message_1.DataMessageSchema, __dirname)
+];
+(0, kit_generator_1.generateExportIndex)(generatedFilePaths, __dirname);

package/dist/get/get-data-by-date-range.d.ts

@@ -0,0 +1,204 @@
+import { z } from "zod";
+export declare const GetDataByDateRangeRequestSchema: z.ZodObject<{
+    devices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        components: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        components: string[];
+    }, {
+        id: string;
+        components: string[];
+    }>, "many">;
+    dateRange: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+    }, {
+        start: string;
+        end: string;
+    }>;
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    devices: {
+        id: string;
+        components: string[];
+    }[];
+    dateRange: {
+        start: string;
+        end: string;
+    };
+    email: string;
+}, {
+    devices: {
+        id: string;
+        components: string[];
+    }[];
+    dateRange: {
+        start: string;
+        end: string;
+    };
+    email: string;
+}>;
+export type GetDataByDateRangeRequest = z.infer<typeof GetDataByDateRangeRequestSchema>;
+export declare const isGetDataByDateRangeRequest: (object: unknown) => object is {
+    devices: {
+        id: string;
+        components: string[];
+    }[];
+    dateRange: {
+        start: string;
+        end: string;
+    };
+    email: string;
+};
+export declare const ComponentDataEntryResponseSchema: z.ZodObject<{
+    seconds: z.ZodNumber;
+    microseconds: z.ZodOptional<z.ZodNumber>;
+    readings: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    seconds: number;
+    readings: {};
+    microseconds?: number | undefined;
+}, {
+    seconds: number;
+    readings: {};
+    microseconds?: number | undefined;
+}>;
+export type ComponentDataEntryResponse = z.infer<typeof ComponentDataEntryResponseSchema>;
+export declare const DeviceDataEntryResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    components: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        data: z.ZodArray<z.ZodObject<{
+            seconds: z.ZodNumber;
+            microseconds: z.ZodOptional<z.ZodNumber>;
+            readings: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        }, "strip", z.ZodTypeAny, {
+            seconds: number;
+            readings: {};
+            microseconds?: number | undefined;
+        }, {
+            seconds: number;
+            readings: {};
+            microseconds?: number | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            seconds: number;
+            readings: {};
+            microseconds?: number | undefined;
+        }[];
+        id: string;
+    }, {
+        data: {
+            seconds: number;
+            readings: {};
+            microseconds?: number | undefined;
+        }[];
+        id: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    components: {
+        data: {
+            seconds: number;
+            readings: {};
+            microseconds?: number | undefined;
+        }[];
+        id: string;
+    }[];
+}, {
+    id: string;
+    components: {
+        data: {
+            seconds: number;
+            readings: {};
+            microseconds?: number | undefined;
+        }[];
+        id: string;
+    }[];
+}>;
+export type DeviceDataEntryResponse = z.infer<typeof DeviceDataEntryResponseSchema>;
+export declare const GetDataByDateRangeResponseSchema: z.ZodObject<{
+    devices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        components: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            data: z.ZodArray<z.ZodObject<{
+                seconds: z.ZodNumber;
+                microseconds: z.ZodOptional<z.ZodNumber>;
+                readings: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+            }, "strip", z.ZodTypeAny, {
+                seconds: number;
+                readings: {};
+                microseconds?: number | undefined;
+            }, {
+                seconds: number;
+                readings: {};
+                microseconds?: number | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            data: {
+                seconds: number;
+                readings: {};
+                microseconds?: number | undefined;
+            }[];
+            id: string;
+        }, {
+            data: {
+                seconds: number;
+                readings: {};
+                microseconds?: number | undefined;
+            }[];
+            id: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        components: {
+            data: {
+                seconds: number;
+                readings: {};
+                microseconds?: number | undefined;
+            }[];
+            id: string;
+        }[];
+    }, {
+        id: string;
+        components: {
+            data: {
+                seconds: number;
+                readings: {};
+                microseconds?: number | undefined;
+            }[];
+            id: string;
+        }[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    devices: {
+        id: string;
+        components: {
+            data: {
+                seconds: number;
+                readings: {};
+                microseconds?: number | undefined;
+            }[];
+            id: string;
+        }[];
+    }[];
+}, {
+    devices: {
+        id: string;
+        components: {
+            data: {
+                seconds: number;
+                readings: {};
+                microseconds?: number | undefined;
+            }[];
+            id: string;
+        }[];
+    }[];
+}>;
+export type GetDataByDateRangeResponse = z.infer<typeof GetDataByDateRangeResponseSchema>;

package/dist/get/get-data-by-date-range.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetDataByDateRangeResponseSchema = exports.DeviceDataEntryResponseSchema = exports.ComponentDataEntryResponseSchema = exports.isGetDataByDateRangeRequest = exports.GetDataByDateRangeRequestSchema = void 0;
+const zod_1 = require("zod");
+exports.GetDataByDateRangeRequestSchema = zod_1.z.object({
+    devices: zod_1.z.array(zod_1.z.object({
+        id: zod_1.z.string(),
+        components: zod_1.z.array(zod_1.z.string()),
+    })),
+    dateRange: zod_1.z.object({
+        start: zod_1.z.string().datetime(),
+        end: zod_1.z.string().datetime(),
+    }),
+    email: zod_1.z.string().email(),
+});
+const isGetDataByDateRangeRequest = (object) => {
+    return exports.GetDataByDateRangeRequestSchema.passthrough().safeParse(object)
+        .success;
+};
+exports.isGetDataByDateRangeRequest = isGetDataByDateRangeRequest;
+exports.ComponentDataEntryResponseSchema = zod_1.z.object({
+    seconds: zod_1.z.number(),
+    microseconds: zod_1.z.number().optional(),
+    readings: zod_1.z.object({}),
+});
+exports.DeviceDataEntryResponseSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    components: zod_1.z.array(zod_1.z.object({
+        id: zod_1.z.string(),
+        data: zod_1.z.array(exports.ComponentDataEntryResponseSchema),
+    })),
+});
+exports.GetDataByDateRangeResponseSchema = zod_1.z.object({
+    devices: zod_1.z.array(exports.DeviceDataEntryResponseSchema),
+});

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./constants";
+export * from "./decode/aggregate";
+export * from "./decode/reading";
+export * from "./get/get-data-by-date-range";
+export * from "./generated/index";
+export * from "./key/get";
+export * from "./message/message";

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./decode/aggregate"), exports);
+__exportStar(require("./decode/reading"), exports);
+__exportStar(require("./get/get-data-by-date-range"), exports);
+__exportStar(require("./generated/index"), exports);
+__exportStar(require("./key/get"), exports);
+__exportStar(require("./message/message"), exports);

package/dist/key/get.d.ts

@@ -0,0 +1,2 @@
+export declare const getDataPartitionKey: (id: string) => string;
+export declare const getDataSortKey: (componentId: string, seconds: number | string, microseconds?: number | string) => string;

package/dist/key/get.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDataSortKey = exports.getDataPartitionKey = void 0;
+const getDataPartitionKey = (id) => {
+    return `DEVICE#${id}`;
+};
+exports.getDataPartitionKey = getDataPartitionKey;
+const getDataSortKey = (componentId, seconds, microseconds) => {
+    return `${componentId}#${seconds}.${microseconds ?? 0}`;
+};
+exports.getDataSortKey = getDataSortKey;

package/dist/message/message.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const DataMessageSchema: z.ZodObject<{
+    payload: z.ZodString;
+    account: z.ZodString;
+    device: z.ZodString;
+    component: z.ZodString;
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    component: string;
+    payload: string;
+    account: string;
+    device: string;
+    timestamp: number;
+}, {
+    component: string;
+    payload: string;
+    account: string;
+    device: string;
+    timestamp: number;
+}>;

package/dist/message/message.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataMessageSchema = void 0;
+const zod_1 = require("zod");
+exports.DataMessageSchema = zod_1.z.object({
+    payload: zod_1.z.string(),
+    account: zod_1.z.string(),
+    device: zod_1.z.string(),
+    component: zod_1.z.string(),
+    timestamp: zod_1.z.number(),
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@xube/kit-aws-data-schema",
+  "version": "0.0.73",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "generate": "npx ts-node src/generator.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/XubeLtd/dev-kit.git"
+  },
+  "author": "Xube Pty Ltd",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/XubeLtd/dev-kit/issues"
+  },
+  "homepage": "https://github.com/XubeLtd/dev-kit#readme",
+  "devDependencies": {
+    "@types/node": "^20.4.7",
+    "@xube/kit-build": "^0.0.73",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@xube/kit-aws-schema": "^0.0.73",
+    "@xube/kit-constants": "^0.0.73",
+    "@xube/kit-generator": "^0.0.73",
+    "@xube/kit-log": "^0.0.73",
+    "@xube/kit-schema": "^0.0.73",
+    "zod": "^3.22.4"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,3 @@
+export const DATA_TYPE = "data";
+
+export const DATA_TABLE_NAME_ENV_VAR = "DATA_TABLE_NAME";

package/src/decode/aggregate.ts

@@ -0,0 +1,18 @@
+import {z} from "zod";
+import { DeviceReadingV1Schema } from "./reading";
+
+export const AggregateMetadataSchema = z.object({
+    v: z.number(), //Aggregate Metadata Schema Version
+    // vr: z.number(), //Reading Metadata Schema Version
+});
+
+export const AggregateMetaDataV1Version: number = 1
+export const AggregateMetadataV1Schema = AggregateMetadataSchema.merge(z.object({
+  v: z.literal(AggregateMetaDataV1Version),
+  s: z.number(), //Size??
+  m: z.array(DeviceReadingV1Schema), //Reading Metadata Array
+}));
+
+export const AggregateMetadataSchemas = //z.union([
+  AggregateMetadataV1Schema;
+//]);

package/src/decode/reading.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { BaseDataSchema, GenericDataTypesSchema } from "@xube/kit-schema";
+
+export const ReadingDataTypesSchema = GenericDataTypesSchema;
+
+export const DeviceReadingMetadataV1Schema = z.object({
+  s: z.number(), //Seconds,
+  us: z.number(), //Microseconds
+});
+export const DeviceReadingV1Schema = z.object({
+  m: DeviceReadingMetadataV1Schema,
+  s: z.number().optional(), //Size
+});
+export const DeviceReadingSchemas = DeviceReadingV1Schema;
+
+export const ReadingMetadataV1Schema = DeviceReadingMetadataV1Schema;
+export const ReadingV1Schema = z
+  .object({
+    data: ReadingDataTypesSchema,
+    component: z.string(),
+  })
+  .merge(BaseDataSchema)
+  .passthrough();

package/src/generated/index.ts

@@ -0,0 +1,16 @@
+export {validate as validateAggregateMetadata} from './validators/aggregateMetadata'
+export * from './types/aggregateMetadata'
+export {validate as validateAggregateMetadataV1} from './validators/aggregateMetadataV1'
+export * from './types/aggregateMetadataV1'
+export {validate as validateAggregateMetadataTypes} from './validators/aggregateMetadataTypes'
+export * from './types/aggregateMetadataTypes'
+export {validate as validateDeviceReadingMetadataV1} from './validators/deviceReadingMetadataV1'
+export * from './types/deviceReadingMetadataV1'
+export {validate as validateDeviceReadingV1} from './validators/deviceReadingV1'
+export * from './types/deviceReadingV1'
+export {validate as validateReadingV1} from './validators/readingV1'
+export * from './types/readingV1'
+export {validate as validateReadingMetadataV1} from './validators/readingMetadataV1'
+export * from './types/readingMetadataV1'
+export {validate as validateDataMessage} from './validators/dataMessage'
+export * from './types/dataMessage'