@xube/kit-aws-data-schema 0.2.8 → 0.2.13

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const DATA_TYPE = "data";
 export declare const DATA_TABLE_NAME_ENV_VAR = "DATA_TABLE_NAME";
+export declare const READING_VERSION_IDENTIFIER = "v";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,SAAS,CAAC;AAEhC,eAAO,MAAM,uBAAuB,oBAAoB,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,SAAS,CAAC;AAEhC,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AAEzD,eAAO,MAAM,0BAA0B,MAAM,CAAC"}

package/dist/constants.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATA_TABLE_NAME_ENV_VAR = exports.DATA_TYPE = void 0;
+exports.READING_VERSION_IDENTIFIER = exports.DATA_TABLE_NAME_ENV_VAR = exports.DATA_TYPE = void 0;
 exports.DATA_TYPE = "data";
 exports.DATA_TABLE_NAME_ENV_VAR = "DATA_TABLE_NAME";
+exports.READING_VERSION_IDENTIFIER = "v";

package/dist/decode/aggregate.d.ts

@@ -1,118 +1,34 @@
 import { z } from "zod";
 export declare const AggregateMetadataSchema: z.ZodObject<{
     v: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    v: number;
-}, {
-    v: number;
-}>;
+}, z.core.$strip>;
 export type AggregateMetadata = z.infer<typeof AggregateMetadataSchema>;
 export declare const isAggregateMetadata: (obj: unknown) => obj is AggregateMetadata;
 export declare const AggregateMetaDataV1Version: number;
-export declare const AggregateMetadataV1Schema: z.ZodObject<z.objectUtil.extendShape<{
-    v: z.ZodNumber;
-}, {
+export declare const AggregateMetadataV1Schema: z.ZodObject<{
     v: z.ZodLiteral<number>;
     s: z.ZodNumber;
     m: z.ZodArray<z.ZodObject<{
         m: z.ZodObject<{
             s: z.ZodNumber;
             us: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            s: number;
-            us: number;
-        }, {
-            s: number;
-            us: number;
-        }>;
+        }, z.core.$strip>;
         s: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }, {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }>, "many">;
-}>, "strip", z.ZodTypeAny, {
-    s: number;
-    m: {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }[];
-    v: number;
-}, {
-    s: number;
-    m: {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }[];
-    v: number;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type AggregateMetadataV1 = z.infer<typeof AggregateMetadataV1Schema>;
 export declare const isAggregateMetadataV1: (obj: unknown) => obj is AggregateMetadataV1;
-export declare const AggregateMetadataSchemas: z.ZodObject<z.objectUtil.extendShape<{
-    v: z.ZodNumber;
-}, {
+export declare const AggregateMetadataSchemas: z.ZodObject<{
     v: z.ZodLiteral<number>;
     s: z.ZodNumber;
     m: z.ZodArray<z.ZodObject<{
         m: z.ZodObject<{
             s: z.ZodNumber;
             us: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            s: number;
-            us: number;
-        }, {
-            s: number;
-            us: number;
-        }>;
+        }, z.core.$strip>;
         s: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }, {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }>, "many">;
-}>, "strip", z.ZodTypeAny, {
-    s: number;
-    m: {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }[];
-    v: number;
-}, {
-    s: number;
-    m: {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }[];
-    v: number;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type AggregateMetadataTypes = z.infer<typeof AggregateMetadataSchemas>;
 export declare const isAggregateMetadataTypes: (obj: unknown) => obj is AggregateMetadataTypes;
 //# sourceMappingURL=aggregate.d.ts.map

package/dist/decode/aggregate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../src/decode/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,eAAO,MAAM,uBAAuB;;;;;;EAGlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,QAAS,OAAO,KAAG,GAAG,IAAI,iBACR,CAAC;AAEnD,eAAO,MAAM,0BAA0B,EAAE,MAAU,CAAA;AACnD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInC,CAAC;AACJ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,eAAO,MAAM,qBAAqB,QAAS,OAAO,KAAG,GAAG,IAAI,mBACV,CAAC;AAEnD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACV,CAAC;AAE5B,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC9E,eAAO,MAAM,wBAAwB,QAAS,OAAO,KAAG,GAAG,IAAI,sBACf,CAAC"}
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../src/decode/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,eAAO,MAAM,uBAAuB;;iBAGlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,QAAS,OAAO,KAAG,GAAG,IAAI,iBACR,CAAC;AAEnD,eAAO,MAAM,0BAA0B,EAAE,MAAU,CAAA;AACnD,eAAO,MAAM,yBAAyB;;;;;;;;;;iBAInC,CAAC;AACJ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,eAAO,MAAM,qBAAqB,QAAS,OAAO,KAAG,GAAG,IAAI,mBACV,CAAC;AAEnD,eAAO,MAAM,wBAAwB;;;;;;;;;;iBACV,CAAC;AAE5B,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC9E,eAAO,MAAM,wBAAwB,QAAS,OAAO,KAAG,GAAG,IAAI,sBACf,CAAC"}

package/dist/decode/reading.d.ts

@@ -1,108 +1,87 @@
 import { z } from "zod";
-export declare const ReadingDataTypesSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
+export declare const READING_VERSION_1 = 1;
+export declare const READING_VERSION_2 = 2;
+export declare const DEFAULT_READING_VERSION = 1;
+export declare const ReadingDataTypesSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
 export declare const DeviceReadingMetadataV1Schema: z.ZodObject<{
     s: z.ZodNumber;
     us: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    s: number;
-    us: number;
-}, {
-    s: number;
-    us: number;
-}>;
+}, z.core.$strip>;
 export type DeviceReadingMetadataV1 = z.infer<typeof DeviceReadingMetadataV1Schema>;
 export declare const isDeviceReadingMetadataV1: (item: unknown) => item is DeviceReadingMetadataV1;
 export declare const DeviceReadingV1Schema: z.ZodObject<{
     m: z.ZodObject<{
         s: z.ZodNumber;
         us: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        s: number;
-        us: number;
-    }, {
-        s: number;
-        us: number;
-    }>;
+    }, z.core.$strip>;
     s: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    m: {
-        s: number;
-        us: number;
-    };
-    s?: number | undefined;
-}, {
-    m: {
-        s: number;
-        us: number;
-    };
-    s?: number | undefined;
-}>;
+}, z.core.$strip>;
 export type DeviceReadingV1 = z.infer<typeof DeviceReadingV1Schema>;
 export declare const isDeviceReadingV1: (item: unknown) => item is DeviceReadingV1;
 export declare const DeviceReadingSchemas: z.ZodObject<{
     m: z.ZodObject<{
         s: z.ZodNumber;
         us: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        s: number;
-        us: number;
-    }, {
-        s: number;
-        us: number;
-    }>;
+    }, z.core.$strip>;
     s: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    m: {
-        s: number;
-        us: number;
-    };
-    s?: number | undefined;
-}, {
-    m: {
-        s: number;
-        us: number;
-    };
-    s?: number | undefined;
-}>;
+}, z.core.$strip>;
 export type DeviceReadingTypes = z.infer<typeof DeviceReadingSchemas>;
 export declare const isDeviceReadingTypes: (item: unknown) => item is DeviceReadingTypes;
 export declare const ReadingMetadataV1Schema: z.ZodObject<{
     s: z.ZodNumber;
     us: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    s: number;
-    us: number;
-}, {
-    s: number;
-    us: number;
-}>;
+}, z.core.$strip>;
 export type ReadingMetadataV1 = z.infer<typeof ReadingMetadataV1Schema>;
 export declare const isReadingMetadataV1: (item: unknown) => item is ReadingMetadataV1;
-export declare const ReadingV1Schema: z.ZodObject<z.objectUtil.extendShape<{
-    data: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
+export declare const ReadingV2MetadataSchema: z.ZodObject<{
+    v: z.ZodLiteral<2>;
+    tm: z.ZodNumber;
+    bo: z.ZodOptional<z.ZodBoolean>;
+    so: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ReadingV2Metadata = z.infer<typeof ReadingV2MetadataSchema>;
+export declare const isReadingV2Metadata: (item: unknown) => item is ReadingV2Metadata;
+export declare const ReadingSchema: z.ZodObject<{
+    v: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    id: z.ZodString;
     component: z.ZodOptional<z.ZodString>;
-}, {
+    type: z.ZodString;
     s: z.ZodNumber;
     us: z.ZodOptional<z.ZodNumber>;
-    type: z.ZodString;
+    data: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
+    bo: z.ZodOptional<z.ZodBoolean>;
+    so: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type Reading = z.infer<typeof ReadingSchema>;
+export declare const isReading: (item: unknown) => item is Reading;
+export declare const isReadingV1: (item: unknown) => item is Reading & {
+    v: typeof READING_VERSION_1;
+};
+export declare const isReadingV2: (item: unknown) => item is Reading & {
+    v: typeof READING_VERSION_2;
+};
+export declare const ReadingV1Schema: z.ZodObject<{
+    v: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
     id: z.ZodString;
-}>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
-    data: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
     component: z.ZodOptional<z.ZodString>;
-}, {
+    type: z.ZodString;
     s: z.ZodNumber;
     us: z.ZodOptional<z.ZodNumber>;
-    type: z.ZodString;
+    data: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
+    bo: z.ZodOptional<z.ZodBoolean>;
+    so: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type ReadingV1 = Reading;
+export declare const ReadingV2Schema: z.ZodObject<{
+    v: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
     id: z.ZodString;
-}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
-    data: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
     component: z.ZodOptional<z.ZodString>;
-}, {
+    type: z.ZodString;
     s: z.ZodNumber;
     us: z.ZodOptional<z.ZodNumber>;
-    type: z.ZodString;
-    id: z.ZodString;
-}>, z.ZodTypeAny, "passthrough">>;
-export type ReadingV1 = z.infer<typeof ReadingV1Schema>;
-export declare const isReadingV1: (item: unknown) => item is ReadingV1;
+    data: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
+    bo: z.ZodOptional<z.ZodBoolean>;
+    so: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type ReadingV2 = Reading;
 //# sourceMappingURL=reading.d.ts.map

package/dist/decode/reading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reading.d.ts","sourceRoot":"","sources":["../../src/decode/reading.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB,6MAAyB,CAAC;AAE7D,eAAO,MAAM,6BAA6B;;;;;;;;;EAGxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,eAAO,MAAM,yBAAyB,SAAU,OAAO,KAAG,IAAI,IAAI,uBACX,CAAC;AAExD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,eAAO,MAAM,iBAAiB,SAAU,OAAO,KAAG,IAAI,IAAI,eACX,CAAC;AAEhD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAAwB,CAAC;AAC1D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACtE,eAAO,MAAM,oBAAoB,SAAU,OAAO,KAAG,IAAI,IAAI,kBACf,CAAC;AAE/C,eAAO,MAAM,uBAAuB;;;;;;;;;EAAgC,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,SAAU,OAAO,KAAG,IAAI,IAAI,iBACX,CAAC;AAElD,eAAO,MAAM,eAAe;;;;OA9B6B,EAAG,SAAS;QAEnE,EAAG,WAAW,CAAC,EAAE,SAAS;UAAY,EAAG,SAAS;QAEpD,EAAC,SAAS;;;;;SAJkD,SAAS;UAEhE,WAAW,GAAG,SAAS;YAAe,SAAS;UAEnD,SAAS;;;;;SAJkD,SAAS;UAEhE,WAAW,GAAG,SAAS;YAAe,SAAS;UAEnD,SAAS;iCAgCM,CAAC;AACjB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,eAAO,MAAM,WAAW,SAAU,OAAO,KAAG,IAAI,IAAI,SACX,CAAC"}
+{"version":3,"file":"reading.d.ts","sourceRoot":"","sources":["../../src/decode/reading.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC,eAAO,MAAM,uBAAuB,IAAoB,CAAC;AAEzD,eAAO,MAAM,sBAAsB,+FAAyB,CAAC;AAE7D,eAAO,MAAM,6BAA6B;;;iBAGxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,eAAO,MAAM,yBAAyB,SAC9B,OAAO,KACZ,IAAI,IAAI,uBAC4C,CAAC;AAExD,eAAO,MAAM,qBAAqB;;;;;;iBAGhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,eAAO,MAAM,iBAAiB,SAAU,OAAO,KAAG,IAAI,IAAI,eACX,CAAC;AAEhD,eAAO,MAAM,oBAAoB;;;;;;iBAAwB,CAAC;AAC1D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACtE,eAAO,MAAM,oBAAoB,SACzB,OAAO,KACZ,IAAI,IAAI,kBAAkE,CAAC;AAE9E,eAAO,MAAM,uBAAuB;;;iBAAgC,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,SAAU,OAAO,KAAG,IAAI,IAAI,iBACX,CAAC;AAElD,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,SACxB,OAAO,KACZ,IAAI,IAAI,iBACsC,CAAC;AAElD,eAAO,MAAM,aAAa;;;;;;;;;;iBAYxB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,eAAO,MAAM,SAAS,SAAU,OAAO,KAAG,IAAI,IAAI,OACX,CAAC;AAExC,eAAO,MAAM,WAAW,SAChB,OAAO,KACZ,IAAI,IAAI,OAAO,GAAG;IAAE,CAAC,EAAE,OAAO,iBAAiB,CAAA;CAGjD,CAAC;AAEF,eAAO,MAAM,WAAW,SAChB,OAAO,KACZ,IAAI,IAAI,OAAO,GAAG;IAAE,CAAC,EAAE,OAAO,iBAAiB,CAAA;CAGjD,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;iBAAgB,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC;AAChC,eAAO,MAAM,eAAe;;;;;;;;;;iBAAgB,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC"}

package/dist/decode/reading.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReadingV1 = exports.ReadingV1Schema = exports.isReadingMetadataV1 = exports.ReadingMetadataV1Schema = exports.isDeviceReadingTypes = exports.DeviceReadingSchemas = exports.isDeviceReadingV1 = exports.DeviceReadingV1Schema = exports.isDeviceReadingMetadataV1 = exports.DeviceReadingMetadataV1Schema = exports.ReadingDataTypesSchema = void 0;
+exports.ReadingV2Schema = exports.ReadingV1Schema = exports.isReadingV2 = exports.isReadingV1 = exports.isReading = exports.ReadingSchema = exports.isReadingV2Metadata = exports.ReadingV2MetadataSchema = exports.isReadingMetadataV1 = exports.ReadingMetadataV1Schema = exports.isDeviceReadingTypes = exports.DeviceReadingSchemas = exports.isDeviceReadingV1 = exports.DeviceReadingV1Schema = exports.isDeviceReadingMetadataV1 = exports.DeviceReadingMetadataV1Schema = exports.ReadingDataTypesSchema = exports.DEFAULT_READING_VERSION = exports.READING_VERSION_2 = exports.READING_VERSION_1 = void 0;
 const zod_1 = require("zod");
 const kit_schema_1 = require("@xube/kit-schema");
+const constants_1 = require("../constants");
+exports.READING_VERSION_1 = 1;
+exports.READING_VERSION_2 = 2;
+exports.DEFAULT_READING_VERSION = exports.READING_VERSION_1;
 exports.ReadingDataTypesSchema = kit_schema_1.GenericDataTypesSchema;
 exports.DeviceReadingMetadataV1Schema = zod_1.z.object({
     s: zod_1.z.number(), //Seconds,
@@ -22,12 +26,38 @@ exports.isDeviceReadingTypes = isDeviceReadingTypes;
 exports.ReadingMetadataV1Schema = exports.DeviceReadingMetadataV1Schema;
 const isReadingMetadataV1 = (item) => exports.ReadingMetadataV1Schema.safeParse(item).success;
 exports.isReadingMetadataV1 = isReadingMetadataV1;
-exports.ReadingV1Schema = zod_1.z
-    .object({
-    data: exports.ReadingDataTypesSchema,
+exports.ReadingV2MetadataSchema = zod_1.z.object({
+    [constants_1.READING_VERSION_IDENTIFIER]: zod_1.z.literal(exports.READING_VERSION_2),
+    tm: zod_1.z.number().refine((tm) => tm > 0, { message: "tm must be positive" }),
+    bo: zod_1.z.boolean().optional(),
+    so: zod_1.z.boolean().optional(),
+});
+const isReadingV2Metadata = (item) => exports.ReadingV2MetadataSchema.safeParse(item).success;
+exports.isReadingV2Metadata = isReadingV2Metadata;
+exports.ReadingSchema = zod_1.z.looseObject({
+    [constants_1.READING_VERSION_IDENTIFIER]: zod_1.z
+        .union([zod_1.z.literal(exports.READING_VERSION_1), zod_1.z.literal(exports.READING_VERSION_2)])
+        .default(exports.DEFAULT_READING_VERSION),
+    id: zod_1.z.string(),
     component: zod_1.z.string().optional(),
-})
-    .merge(kit_schema_1.BaseDataSchema)
-    .passthrough();
-const isReadingV1 = (item) => exports.ReadingV1Schema.safeParse(item).success;
+    type: zod_1.z.string(),
+    s: zod_1.z.number(),
+    us: zod_1.z.number().optional(),
+    data: exports.ReadingDataTypesSchema,
+    bo: zod_1.z.boolean().optional(),
+    so: zod_1.z.boolean().optional(),
+});
+const isReading = (item) => exports.ReadingSchema.safeParse(item).success;
+exports.isReading = isReading;
+const isReadingV1 = (item) => {
+    const result = exports.ReadingSchema.safeParse(item);
+    return result.success && result.data.v === exports.READING_VERSION_1;
+};
 exports.isReadingV1 = isReadingV1;
+const isReadingV2 = (item) => {
+    const result = exports.ReadingSchema.safeParse(item);
+    return result.success && result.data.v === exports.READING_VERSION_2;
+};
+exports.isReadingV2 = isReadingV2;
+exports.ReadingV1Schema = exports.ReadingSchema;
+exports.ReadingV2Schema = exports.ReadingSchema;

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

@@ -2,58 +2,20 @@ 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">;
+        components: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
     dateRange: z.ZodObject<{
         start: z.ZodString;
         end: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        start: string;
-        end: string;
-    }, {
-        start: string;
-        end: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    devices: {
-        id: string;
-        components: string[];
-    }[];
-    dateRange: {
-        start: string;
-        end: string;
-    };
-}, {
-    devices: {
-        id: string;
-        components: string[];
-    }[];
-    dateRange: {
-        start: string;
-        end: string;
-    };
-}>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type GetDataByDateRangeRequest = z.infer<typeof GetDataByDateRangeRequestSchema>;
 export declare const isGetDataByDateRangeRequest: (object: unknown) => object is GetDataByDateRangeRequest;
 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;
-}>;
+    readings: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
+}, z.core.$strip>;
 export type ComponentDataEntryResponse = z.infer<typeof ComponentDataEntryResponseSchema>;
 export declare const DeviceDataEntryResponseSchema: z.ZodObject<{
     id: z.ZodString;
@@ -62,52 +24,10 @@ export declare const DeviceDataEntryResponseSchema: z.ZodObject<{
         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;
-    }[];
-}>;
+            readings: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type DeviceDataEntryResponse = z.infer<typeof DeviceDataEntryResponseSchema>;
 export declare const GetDataByDateRangeResponseSchema: z.ZodObject<{
     devices: z.ZodArray<z.ZodObject<{
@@ -117,76 +37,10 @@ export declare const GetDataByDateRangeResponseSchema: z.ZodObject<{
             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;
-        }[];
-    }[];
-}>;
+                readings: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type GetDataByDateRangeResponse = z.infer<typeof GetDataByDateRangeResponseSchema>;
 //# sourceMappingURL=get-data-by-date-range.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"get-data-by-date-range.d.ts","sourceRoot":"","sources":["../../src/get/get-data-by-date-range.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AACF,eAAO,MAAM,2BAA2B,WAC9B,OAAO,KACd,MAAM,IAAI,yBAGZ,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;EAI3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AACF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}
+{"version":3,"file":"get-data-by-date-range.d.ts","sourceRoot":"","sources":["../../src/get/get-data-by-date-range.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,+BAA+B;;;;;;;;;iBAY1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AACF,eAAO,MAAM,2BAA2B,WAC9B,OAAO,KACd,MAAM,IAAI,yBAGZ,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;iBAI3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AACF,eAAO,MAAM,6BAA6B;;;;;;;;;;iBAQxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;iBAE3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetDataByDateRangeResponseSchema = exports.DeviceDataEntryResponseSchema = exports.ComponentDataEntryResponseSchema = exports.isGetDataByDateRangeRequest = exports.GetDataByDateRangeRequestSchema = void 0;
+const kit_schema_1 = require("@xube/kit-schema");
 const zod_1 = require("zod");
 exports.GetDataByDateRangeRequestSchema = zod_1.z.object({
     devices: zod_1.z.array(zod_1.z.object({
@@ -21,7 +22,7 @@ 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({}),
+    readings: kit_schema_1.GenericDataTypesSchema,
 });
 exports.DeviceDataEntryResponseSchema = zod_1.z.object({
     id: zod_1.z.string(),

package/dist/message/message.d.ts

@@ -6,21 +6,7 @@ export declare const DataMessageSchema: z.ZodObject<{
     component: z.ZodOptional<z.ZodString>;
     request: z.ZodOptional<z.ZodString>;
     timestamp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    payload: string;
-    account: string;
-    device: string;
-    timestamp: number;
-    component?: string | undefined;
-    request?: string | undefined;
-}, {
-    payload: string;
-    account: string;
-    device: string;
-    timestamp: number;
-    component?: string | undefined;
-    request?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type DataMessage = z.infer<typeof DataMessageSchema>;
 export declare const isDataMessage: (item: unknown) => item is DataMessage;
 //# sourceMappingURL=message.d.ts.map

package/dist/message/message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/message/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EAO5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,eAAO,MAAM,aAAa,SAAU,OAAO,KAAG,IAAI,IAAI,WACX,CAAC"}
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/message/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,eAAO,MAAM,aAAa,SAAU,OAAO,KAAG,IAAI,IAAI,WACX,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xube/kit-aws-data-schema",
-  "version": "0.2.8",
+  "version": "0.2.13",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -18,15 +18,15 @@
   },
   "homepage": "https://github.com/XubeLtd/dev-kit#readme",
   "devDependencies": {
-    "@xube/kit-build": "^0.2.8"
+    "@xube/kit-build": "^0.2.13"
   },
   "dependencies": {
-    "@xube/kit-aws-schema": "^0.2.8",
-    "@xube/kit-constants": "^0.2.8",
-    "@xube/kit-generator": "^0.2.8",
-    "@xube/kit-log": "^0.2.8",
-    "@xube/kit-schema": "^0.2.8",
-    "zod": "^3.23.8",
-    "zod-validation-error": "^2.0.0"
+    "@xube/kit-aws-schema": "^0.2.13",
+    "@xube/kit-constants": "^0.2.13",
+    "@xube/kit-generator": "^0.2.13",
+    "@xube/kit-log": "^0.2.13",
+    "@xube/kit-schema": "^0.2.13",
+    "zod": "^4.4.3",
+    "zod-validation-error": "^5.0.0"
   }
 }

package/src/constants.ts

@@ -1,3 +1,5 @@
 export const DATA_TYPE = "data";
 
-export const DATA_TABLE_NAME_ENV_VAR = "DATA_TABLE_NAME";
+export const DATA_TABLE_NAME_ENV_VAR = "DATA_TABLE_NAME";
+
+export const READING_VERSION_IDENTIFIER = "v";

package/src/decode/reading.test.ts

@@ -0,0 +1,231 @@
+import {
+  DEFAULT_READING_VERSION,
+  READING_VERSION_1,
+  READING_VERSION_2,
+  Reading,
+  ReadingSchema,
+  ReadingV2Metadata,
+  ReadingV2MetadataSchema,
+  isReading,
+  isReadingV1,
+  isReadingV2,
+  isReadingV2Metadata,
+} from "./reading";
+
+const baseV1 = {
+  v: READING_VERSION_1,
+  id: "dev1",
+  component: "componentA",
+  type: "data",
+  s: 1697578841,
+  us: 214981,
+  data: "S,+000.30,+001.74,M,00,33",
+};
+
+const baseV2 = {
+  v: READING_VERSION_2,
+  id: "dev1",
+  component: "componentA",
+  type: "data",
+  s: 1780859506,
+  us: 366000,
+  data: "AQIDBA==",
+};
+
+describe("ReadingSchema (unified storage shape)", () => {
+  describe("v1 rows", () => {
+    it("parses a v1 row with neither bo nor so", () => {
+      const parsed = ReadingSchema.parse(baseV1) as Reading;
+      expect(parsed.v).toBe(READING_VERSION_1);
+      expect(parsed.s).toBe(baseV1.s);
+      expect(parsed.us).toBe(baseV1.us);
+      expect(parsed.bo).toBeUndefined();
+      expect(parsed.so).toBeUndefined();
+    });
+
+    it("parses a v1 row with only bo", () => {
+      const parsed = ReadingSchema.parse({ ...baseV1, bo: true }) as Reading;
+      expect(parsed.v).toBe(READING_VERSION_1);
+      expect(parsed.bo).toBe(true);
+      expect(parsed.so).toBeUndefined();
+    });
+
+    it("parses a v1 row with only so", () => {
+      const parsed = ReadingSchema.parse({ ...baseV1, so: false }) as Reading;
+      expect(parsed.v).toBe(READING_VERSION_1);
+      expect(parsed.bo).toBeUndefined();
+      expect(parsed.so).toBe(false);
+    });
+
+    it("parses a v1 row with both bo and so", () => {
+      const parsed = ReadingSchema.parse({
+        ...baseV1,
+        bo: false,
+        so: true,
+      }) as Reading;
+      expect(parsed.v).toBe(READING_VERSION_1);
+      expect(parsed.bo).toBe(false);
+      expect(parsed.so).toBe(true);
+    });
+  });
+
+  describe("v2 rows", () => {
+    it("parses a v2 row with neither bo nor so", () => {
+      const parsed = ReadingSchema.parse(baseV2) as Reading;
+      expect(parsed.v).toBe(READING_VERSION_2);
+      expect(parsed.s).toBe(baseV2.s);
+      expect(parsed.us).toBe(baseV2.us);
+      expect(parsed.bo).toBeUndefined();
+      expect(parsed.so).toBeUndefined();
+    });
+
+    it("parses a v2 row with only bo", () => {
+      const parsed = ReadingSchema.parse({ ...baseV2, bo: true }) as Reading;
+      expect(parsed.v).toBe(READING_VERSION_2);
+      expect(parsed.bo).toBe(true);
+      expect(parsed.so).toBeUndefined();
+    });
+
+    it("parses a v2 row with only so", () => {
+      const parsed = ReadingSchema.parse({ ...baseV2, so: false }) as Reading;
+      expect(parsed.v).toBe(READING_VERSION_2);
+      expect(parsed.bo).toBeUndefined();
+      expect(parsed.so).toBe(false);
+    });
+
+    it("parses a v2 row with both bo and so", () => {
+      const parsed = ReadingSchema.parse({
+        ...baseV2,
+        bo: false,
+        so: true,
+      }) as Reading;
+      expect(parsed.v).toBe(READING_VERSION_2);
+      expect(parsed.bo).toBe(false);
+      expect(parsed.so).toBe(true);
+    });
+  });
+
+  describe("legacy + default behaviour", () => {
+    it("parses a legacy row (no v field) and defaults to v1", () => {
+      const { v: _omit, ...legacy } = baseV1;
+      const parsed = ReadingSchema.parse(legacy) as Reading;
+      expect(parsed.v).toBe(DEFAULT_READING_VERSION);
+      expect(parsed.v).toBe(READING_VERSION_1);
+    });
+
+    it("preserves passthrough fields (looseObject)", () => {
+      const parsed = ReadingSchema.parse({
+        ...baseV1,
+        extra: "passthrough",
+      }) as Reading & { extra: string };
+      expect(parsed.extra).toBe("passthrough");
+    });
+
+    it("rejects an unknown v value", () => {
+      expect(ReadingSchema.safeParse({ ...baseV1, v: 99 }).success).toBe(false);
+    });
+
+    it("rejects a row missing required core fields", () => {
+      const { id: _id, ...withoutId } = baseV1;
+      expect(ReadingSchema.safeParse(withoutId).success).toBe(false);
+    });
+
+    it.each([
+      ["null", null],
+      ["undefined", undefined],
+      ["string", "not-an-object"],
+      ["number", 42],
+      ["boolean", true],
+      ["array", [1, 2, 3]],
+    ])("rejects %s input without crashing", (_label, input) => {
+      expect(ReadingSchema.safeParse(input).success).toBe(false);
+    });
+  });
+});
+
+describe("type-narrowing predicates", () => {
+  const v1Both = { ...baseV1, bo: true, so: true };
+  const v2Both = { ...baseV2, bo: true, so: true };
+
+  it("isReading accepts any valid reading", () => {
+    expect(isReading(baseV1)).toBe(true);
+    expect(isReading(v1Both)).toBe(true);
+    expect(isReading(baseV2)).toBe(true);
+    expect(isReading(v2Both)).toBe(true);
+    expect(isReading({ foo: "bar" })).toBe(false);
+    expect(isReading(null)).toBe(false);
+  });
+
+  it("isReadingV1 narrows to v=1 only", () => {
+    expect(isReadingV1(baseV1)).toBe(true);
+    expect(isReadingV1(v1Both)).toBe(true);
+    expect(isReadingV1(baseV2)).toBe(false);
+    expect(isReadingV1(v2Both)).toBe(false);
+  });
+
+  it("isReadingV2 narrows to v=2 only", () => {
+    expect(isReadingV2(baseV2)).toBe(true);
+    expect(isReadingV2(v2Both)).toBe(true);
+    expect(isReadingV2(baseV1)).toBe(false);
+    expect(isReadingV2(v1Both)).toBe(false);
+  });
+});
+
+describe("ReadingV2MetadataSchema (wire-format header)", () => {
+  const minimal: ReadingV2Metadata = {
+    v: READING_VERSION_2,
+    tm: 1780859506366,
+  };
+
+  it("accepts minimal v2 metadata (no bo, no so)", () => {
+    expect(ReadingV2MetadataSchema.safeParse(minimal).success).toBe(true);
+  });
+
+  it("accepts v2 metadata with only bo", () => {
+    expect(
+      ReadingV2MetadataSchema.safeParse({ ...minimal, bo: true }).success,
+    ).toBe(true);
+  });
+
+  it("accepts v2 metadata with only so", () => {
+    expect(
+      ReadingV2MetadataSchema.safeParse({ ...minimal, so: false }).success,
+    ).toBe(true);
+  });
+
+  it("accepts v2 metadata with both bo and so", () => {
+    expect(
+      ReadingV2MetadataSchema.safeParse({
+        ...minimal,
+        bo: false,
+        so: true,
+      }).success,
+    ).toBe(true);
+  });
+
+  it("rejects v2 metadata with tm = 0 or negative", () => {
+    expect(ReadingV2MetadataSchema.safeParse({ ...minimal, tm: 0 }).success).toBe(
+      false,
+    );
+    expect(
+      ReadingV2MetadataSchema.safeParse({ ...minimal, tm: -1 }).success,
+    ).toBe(false);
+  });
+
+  it("rejects v2 metadata missing tm", () => {
+    const { tm: _tm, ...noTm } = minimal;
+    expect(ReadingV2MetadataSchema.safeParse(noTm).success).toBe(false);
+  });
+
+  it("isReadingV2Metadata matches the schema", () => {
+    expect(isReadingV2Metadata(minimal)).toBe(true);
+    expect(isReadingV2Metadata({ ...minimal, bo: true, so: false })).toBe(true);
+    expect(isReadingV2Metadata({ v: 1, tm: 1 })).toBe(false);
+  });
+});
+
+describe("DEFAULT_READING_VERSION", () => {
+  it("currently equals READING_VERSION_1", () => {
+    expect(DEFAULT_READING_VERSION).toBe(READING_VERSION_1);
+  });
+});

package/src/decode/reading.ts

@@ -1,5 +1,11 @@
 import { z } from "zod";
-import { BaseDataSchema, GenericDataTypesSchema } from "@xube/kit-schema";
+import { GenericDataTypesSchema } from "@xube/kit-schema";
+import { READING_VERSION_IDENTIFIER } from "../constants";
+
+export const READING_VERSION_1 = 1;
+export const READING_VERSION_2 = 2;
+
+export const DEFAULT_READING_VERSION = READING_VERSION_1;
 
 export const ReadingDataTypesSchema = GenericDataTypesSchema;
 
@@ -7,8 +13,12 @@ export const DeviceReadingMetadataV1Schema = z.object({
   s: z.number(), //Seconds,
   us: z.number(), //Microseconds
 });
-export type DeviceReadingMetadataV1 = z.infer<typeof DeviceReadingMetadataV1Schema>;
-export const isDeviceReadingMetadataV1 = (item: unknown): item is DeviceReadingMetadataV1 =>
+export type DeviceReadingMetadataV1 = z.infer<
+  typeof DeviceReadingMetadataV1Schema
+>;
+export const isDeviceReadingMetadataV1 = (
+  item: unknown,
+): item is DeviceReadingMetadataV1 =>
   DeviceReadingMetadataV1Schema.safeParse(item).success;
 
 export const DeviceReadingV1Schema = z.object({
@@ -21,21 +31,59 @@ export const isDeviceReadingV1 = (item: unknown): item is DeviceReadingV1 =>
 
 export const DeviceReadingSchemas = DeviceReadingV1Schema;
 export type DeviceReadingTypes = z.infer<typeof DeviceReadingSchemas>;
-export const isDeviceReadingTypes = (item: unknown): item is DeviceReadingTypes =>
-  DeviceReadingSchemas.safeParse(item).success;
+export const isDeviceReadingTypes = (
+  item: unknown,
+): item is DeviceReadingTypes => DeviceReadingSchemas.safeParse(item).success;
 
 export const ReadingMetadataV1Schema = DeviceReadingMetadataV1Schema;
 export type ReadingMetadataV1 = z.infer<typeof ReadingMetadataV1Schema>;
 export const isReadingMetadataV1 = (item: unknown): item is ReadingMetadataV1 =>
   ReadingMetadataV1Schema.safeParse(item).success;
 
-export const ReadingV1Schema = z
-  .object({
-    data: ReadingDataTypesSchema,
-    component: z.string().optional(),
-  })
-  .merge(BaseDataSchema)
-  .passthrough();
-export type ReadingV1 = z.infer<typeof ReadingV1Schema>;
-export const isReadingV1 = (item: unknown): item is ReadingV1 =>
-  ReadingV1Schema.safeParse(item).success;
+export const ReadingV2MetadataSchema = z.object({
+  [READING_VERSION_IDENTIFIER]: z.literal(READING_VERSION_2),
+  tm: z.number().refine((tm) => tm > 0, { message: "tm must be positive" }),
+  bo: z.boolean().optional(),
+  so: z.boolean().optional(),
+});
+export type ReadingV2Metadata = z.infer<typeof ReadingV2MetadataSchema>;
+export const isReadingV2Metadata = (
+  item: unknown,
+): item is ReadingV2Metadata =>
+  ReadingV2MetadataSchema.safeParse(item).success;
+
+export const ReadingSchema = z.looseObject({
+  [READING_VERSION_IDENTIFIER]: z
+    .union([z.literal(READING_VERSION_1), z.literal(READING_VERSION_2)])
+    .default(DEFAULT_READING_VERSION),
+  id: z.string(),
+  component: z.string().optional(),
+  type: z.string(),
+  s: z.number(),
+  us: z.number().optional(),
+  data: ReadingDataTypesSchema,
+  bo: z.boolean().optional(),
+  so: z.boolean().optional(),
+});
+export type Reading = z.infer<typeof ReadingSchema>;
+export const isReading = (item: unknown): item is Reading =>
+  ReadingSchema.safeParse(item).success;
+
+export const isReadingV1 = (
+  item: unknown,
+): item is Reading & { v: typeof READING_VERSION_1 } => {
+  const result = ReadingSchema.safeParse(item);
+  return result.success && result.data.v === READING_VERSION_1;
+};
+
+export const isReadingV2 = (
+  item: unknown,
+): item is Reading & { v: typeof READING_VERSION_2 } => {
+  const result = ReadingSchema.safeParse(item);
+  return result.success && result.data.v === READING_VERSION_2;
+};
+
+export const ReadingV1Schema = ReadingSchema;
+export type ReadingV1 = Reading;
+export const ReadingV2Schema = ReadingSchema;
+export type ReadingV2 = Reading;

package/src/get/get-data-by-date-range.ts

@@ -1,4 +1,5 @@
 import { XubeLog } from "@xube/kit-log";
+import { GenericDataTypesSchema } from "@xube/kit-schema";
 import { z } from "zod";
 import { fromZodError } from "zod-validation-error";
 
@@ -28,7 +29,7 @@ export const isGetDataByDateRangeRequest = (
 export const ComponentDataEntryResponseSchema = z.object({
   seconds: z.number(),
   microseconds: z.number().optional(),
-  readings: z.object({}),
+  readings: GenericDataTypesSchema,
 });
 export type ComponentDataEntryResponse = z.infer<
   typeof ComponentDataEntryResponseSchema