@hello.nrfcloud.com/proto-map 16.1.40 → 16.2.0

package/api/DeviceJWT.ts

@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
+import { Context } from './Context.js'
 import { DeviceId, PublicDeviceId } from './DeviceId.js'
 import { Model } from './Devices.js'
-import { Context } from './Context.js'
 
 export const DeviceJWTPayload = Type.Object(
 	{

package/api/Devices.ts

@@ -1,4 +1,5 @@
 import { Type } from '@sinclair/typebox'
+import { models } from '../models/models.js'
 import { Context } from './Context.js'
 import { DeviceId, PublicDeviceId } from './DeviceId.js'
 import {
@@ -7,7 +8,6 @@ import {
 	ObjectVersion,
 	Resources,
 } from './LwM2M.js'
-import { models } from '../models/models.js'
 
 export const LwM2MObjectInstance = Type.Object({
 	ObjectID,

package/api/Email.spec.ts

@@ -1,8 +1,8 @@
-import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import invalidEmails from './test/invalid-emails.json' assert { type: 'json' }
-import { Email } from './Email.js'
+import { describe, it } from 'node:test'
 import { validate } from '../validate.js'
+import { Email } from './Email.js'
+import invalidEmails from './test/invalid-emails.json' assert { type: 'json' }
 
 const v = validate(Email)
 

package/api/IsoDateType.spec.ts

@@ -1,7 +1,7 @@
-import { IsoDateType } from './IsoDateType.js'
-import { describe, test as it } from 'node:test'
 import assert from 'node:assert/strict'
+import { describe, test as it } from 'node:test'
 import { validate } from '../validate.js'
+import { IsoDateType } from './IsoDateType.js'
 
 void describe('isoDateRegExp', () => {
 	void it('should match a date string', () => {

package/api/UserDevices.ts

@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox'
 import { Context } from './Context.js'
 import { DeviceId, PublicDeviceId } from './DeviceId.js'
-import { IsoDateType } from './IsoDateType.js'
 import { Model } from './Devices.js'
+import { IsoDateType } from './IsoDateType.js'
 
 export const UserDevices = Type.Object({
 	'@context': Type.Literal(Context.userDevices.toString()),

package/api/index.ts

@@ -1,11 +1,11 @@
+export * from './APIHealth.js'
 export * from './Context.js'
+export * from './DeviceCredentials.js'
 export * from './DeviceId.js'
-export * from './Devices.js'
-export * from './LwM2M.js'
 export * from './DeviceJWT.js'
-export * from './UserJWT.js'
-export * from './APIHealth.js'
-export * from './DeviceCredentials.js'
+export * from './Devices.js'
 export * from './Email.js'
 export * from './IsoDateType.js'
+export * from './LwM2M.js'
 export * from './UserDevices.js'
+export * from './UserJWT.js'

package/dist/api/DeviceJWT.js

@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox';
+import { Context } from './Context.js';
 import { DeviceId, PublicDeviceId } from './DeviceId.js';
 import { Model } from './Devices.js';
-import { Context } from './Context.js';
 export var DeviceJWTPayload = Type.Object({
     '@context': Type.Literal(Context.deviceJWT.toString()),
     id: PublicDeviceId,

package/dist/api/Devices.js

@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox';
+import { models } from '../models/models.js';
 import { Context } from './Context.js';
 import { DeviceId, PublicDeviceId } from './DeviceId.js';
 import { ObjectID, ObjectInstanceID, ObjectVersion, Resources } from './LwM2M.js';
-import { models } from '../models/models.js';
 export var LwM2MObjectInstance = Type.Object({
     ObjectID: ObjectID,
     ObjectVersion: Type.Optional(ObjectVersion),

package/dist/api/Email.spec.js

@@ -1,10 +1,10 @@
-import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { validate } from '../validate.js';
+import { Email } from './Email.js';
 import invalidEmails from './test/invalid-emails.json' assert {
     type: 'json'
 };
-import { Email } from './Email.js';
-import { validate } from '../validate.js';
 var v = validate(Email);
 void describe('it should validate emails', function() {
     var _loop = function(_i, _iter) {

package/dist/api/IsoDateType.spec.js

@@ -1,7 +1,7 @@
-import { IsoDateType } from './IsoDateType.js';
-import { describe, test as it } from 'node:test';
 import assert from 'node:assert/strict';
+import { describe, test as it } from 'node:test';
 import { validate } from '../validate.js';
+import { IsoDateType } from './IsoDateType.js';
 void describe('isoDateRegExp', function() {
     void it('should match a date string', function() {
         var isoTs = new Date().toISOString();

package/dist/api/UserDevices.js

@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox';
 import { Context } from './Context.js';
 import { DeviceId, PublicDeviceId } from './DeviceId.js';
-import { IsoDateType } from './IsoDateType.js';
 import { Model } from './Devices.js';
+import { IsoDateType } from './IsoDateType.js';
 export var UserDevices = Type.Object({
     '@context': Type.Literal(Context.userDevices.toString()),
     devices: Type.Array(Type.Object({

package/dist/api/index.js

@@ -1,11 +1,11 @@
+export * from './APIHealth.js';
 export * from './Context.js';
+export * from './DeviceCredentials.js';
 export * from './DeviceId.js';
-export * from './Devices.js';
-export * from './LwM2M.js';
 export * from './DeviceJWT.js';
-export * from './UserJWT.js';
-export * from './APIHealth.js';
-export * from './DeviceCredentials.js';
+export * from './Devices.js';
 export * from './Email.js';
 export * from './IsoDateType.js';
+export * from './LwM2M.js';
 export * from './UserDevices.js';
+export * from './UserJWT.js';

package/dist/generator/generateLwM2MDefinitions.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
+import { parseRangeEnumeration } from '../lwm2m/parseRangeEnumeration.js';
 import { addDocBlock } from './addDocBlock.js';
 import { generateName } from './generateType.js';
-import { parseRangeEnumeration } from '../lwm2m/parseRangeEnumeration.js';
 export var generateLwM2MDefinitions = function(definitions) {
     var importLWM2MObjectInfo = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
         ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier("LWM2MObjectInfo")),

package/dist/generator/generateLwM2MDefinitions.spec.js

@@ -1,5 +1,5 @@
-import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
 import { definitions } from '../lwm2m/definitions.js';
 import { LwM2MObjectID } from '../lwm2m/LwM2MObjectID.js';
 import { ResourceType } from '../lwm2m/LWM2MObjectInfo.js';

package/dist/generator/generateModels.js

@@ -1,7 +1,7 @@
+import { parseREADME } from 'markdown/parseREADME.js';
 import ts from 'typescript';
 import { addDocBlock } from './addDocBlock.js';
 import { tokenizeName } from './tokenizeName.js';
-import { parseREADME } from 'markdown/parseREADME.js';
 export var generateModels = function(models) {
     var types = [];
     types.push(addDocBlock([

package/dist/generator/generateType.js

@@ -1,8 +1,8 @@
+import { parseRangeEnumeration } from 'lwm2m/parseRangeEnumeration.js';
 import ts from 'typescript';
-import { addDocBlock } from './addDocBlock.js';
 import { LwM2MType } from '../lwm2m/resourceType.js';
+import { addDocBlock } from './addDocBlock.js';
 import { tokenizeName } from './tokenizeName.js';
-import { parseRangeEnumeration } from 'lwm2m/parseRangeEnumeration.js';
 export var generateType = function(param) {
     var ObjectID = param.ObjectID, ObjectVersion = param.ObjectVersion, Name = param.Name, Description1 = param.Description1, Resources = param.Resources;
     var name = generateName({

package/dist/generator/generateValidator.js

@@ -24,8 +24,8 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 import ts from 'typescript';
-import { generateName } from './generateType.js';
 import { addDocBlock } from './addDocBlock.js';
+import { generateName } from './generateType.js';
 export var generateValidator = function(param) {
     var ObjectID = param.ObjectID, ObjectVersion = param.ObjectVersion, Name = param.Name, Resources = param.Resources;
     // import type { LwM2MObject } from './LwM2MObject.js'

package/dist/generator/generateValidators.js

@@ -24,8 +24,8 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 import ts from 'typescript';
-import { generateName } from './generateType.js';
 import { addDocBlock } from './addDocBlock.js';
+import { generateName } from './generateType.js';
 export var generateValidators = function(objects) {
     // import { LwM2MObjectID } from './LwM2MObjectID.js'
     var importLwM2MObjectID = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([

package/dist/generator/lwm2m.js

@@ -26,14 +26,14 @@ function _unsupported_iterable_to_array(o, minLen) {
 var _path;
 import chalk from 'chalk';
 import { readFile, readdir, writeFile } from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
-import { unwrapNestedArray } from '../lwm2m/unwrapNestedArray.js';
 import xml2js from 'xml2js';
-import { generateLwm2mTimestampResources } from './generateLwm2mTimestampResources.js';
-import { printNode } from './printNode.js';
-import os from 'node:os';
+import { unwrapNestedArray } from '../lwm2m/unwrapNestedArray.js';
 import { generateLwM2MDefinitions } from './generateLwM2MDefinitions.js';
+import { generateLwm2mTimestampResources } from './generateLwm2mTimestampResources.js';
 import { generateName } from './generateType.js';
+import { printNode } from './printNode.js';
 var baseDir = process.cwd();
 var subDir = function() {
     for(var _len = arguments.length, tree = new Array(_len), _key = 0; _key < _len; _key++){

package/dist/generator/tokenizeName.spec.js

@@ -44,9 +44,9 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-import { tokenizeName } from './tokenizeName.js';
-import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { tokenizeName } from './tokenizeName.js';
 void describe('tokenizeName', function() {
     var _loop = function(_i, _iter) {
         var _iter__i = _sliced_to_array(_iter[_i], 2), name = _iter__i[0], expected = _iter__i[1];

package/dist/generator/types.js

@@ -27,16 +27,15 @@ var _path;
 import chalk from 'chalk';
 import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { unwrapNestedArray } from '../lwm2m/unwrapNestedArray.js';
-import xml2js from 'xml2js';
 import ts from 'typescript';
-import { printNode } from './printNode.js';
+import xml2js from 'xml2js';
+import { unwrapNestedArray } from '../lwm2m/unwrapNestedArray.js';
 import os from 'node:os';
-import { generateType } from './generateType.js';
 import { addDocBlock } from './addDocBlock.js';
-import { generateName } from './generateType.js';
+import { generateName, generateType } from './generateType.js';
 import { generateValidator } from './generateValidator.js';
 import { generateValidators } from './generateValidators.js';
+import { printNode } from './printNode.js';
 var baseDir = process.cwd();
 var subDir = function() {
     for(var _len = arguments.length, tree = new Array(_len), _key = 0; _key < _len; _key++){

package/dist/lwm2m/InvalidTimeError.js

@@ -0,0 +1,119 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+export var InvalidTimeError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(InvalidTimeError, Error1);
+    function InvalidTimeError(message) {
+        _class_call_check(this, InvalidTimeError);
+        var _this;
+        _this = _call_super(this, InvalidTimeError, [
+            message
+        ]);
+        _this.name = 'InvalidTimeError';
+        return _this;
+    }
+    return InvalidTimeError;
+}(_wrap_native_super(Error));

package/dist/lwm2m/aws/NoHistoryMeasuresError.js

@@ -0,0 +1,119 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+export var NoHistoryMeasuresError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(NoHistoryMeasuresError, Error1);
+    function NoHistoryMeasuresError(message) {
+        _class_call_check(this, NoHistoryMeasuresError);
+        var _this;
+        _this = _call_super(this, NoHistoryMeasuresError, [
+            message
+        ]);
+        _this.name = 'NoHistoryMeasuresError';
+        return _this;
+    }
+    return NoHistoryMeasuresError;
+}(_wrap_native_super(Error));

package/dist/lwm2m/aws/instanceMeasuresToRecord.js

@@ -0,0 +1,48 @@
+import { MeasureValueType, TimeUnit } from '@aws-sdk/client-timestream-write';
+import { instanceTsAsDate } from 'lwm2m/instanceTs.js';
+import { instanceToMeasures } from './instanceToMeasures.js';
+import { NoHistoryMeasuresError } from './NoHistoryMeasuresError.js';
+export var instanceMeasuresToRecord = function(param) {
+    var ObjectID = param.ObjectID, ObjectInstanceID = param.ObjectInstanceID, ObjectVersion = param.ObjectVersion, Resources = param.Resources;
+    var maybeMeasures = instanceToMeasures({
+        ObjectID: ObjectID,
+        ObjectInstanceID: ObjectInstanceID,
+        ObjectVersion: ObjectVersion,
+        Resources: Resources
+    });
+    if ('error' in maybeMeasures) return maybeMeasures;
+    if (maybeMeasures.measures.length === 0) return {
+        error: new NoHistoryMeasuresError("No measure to be stored in history for object ".concat(ObjectID, "!"))
+    };
+    var instanceTs = instanceTsAsDate({
+        ObjectID: ObjectID,
+        ObjectInstanceID: ObjectInstanceID,
+        Resources: Resources
+    });
+    if (instanceTs === undefined) return {
+        error: new Error("No timestamp found for ".concat(ObjectID, "!"))
+    };
+    return {
+        record: {
+            Dimensions: [
+                {
+                    Name: 'ObjectID',
+                    Value: ObjectID.toString()
+                },
+                {
+                    Name: 'ObjectInstanceID',
+                    Value: (ObjectInstanceID !== null && ObjectInstanceID !== void 0 ? ObjectInstanceID : 0).toString()
+                },
+                {
+                    Name: 'ObjectVersion',
+                    Value: ObjectVersion
+                }
+            ],
+            MeasureName: "".concat(ObjectID, "/").concat(ObjectInstanceID !== null && ObjectInstanceID !== void 0 ? ObjectInstanceID : 0),
+            MeasureValues: maybeMeasures.measures,
+            MeasureValueType: MeasureValueType.MULTI,
+            Time: instanceTs.getTime().toString(),
+            TimeUnit: TimeUnit.MILLISECONDS
+        }
+    };
+};

package/dist/lwm2m/aws/instanceMeasuresToRecord.spec.js

@@ -0,0 +1,39 @@
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+import { InvalidTimeError } from 'lwm2m/InvalidTimeError.js';
+import { LwM2MObjectID } from 'lwm2m/LwM2MObjectID.js';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { instanceMeasuresToRecord } from './instanceMeasuresToRecord.js';
+import { NoHistoryMeasuresError } from './NoHistoryMeasuresError.js';
+void describe('instanceMeasuresToRecord()', function() {
+    void it('should return an error if no measures are found', function() {
+        var res = instanceMeasuresToRecord({
+            ObjectID: LwM2MObjectID.DeviceInformation_14204,
+            Resources: {
+                '0': '352656108602296',
+                '1': '89457387300008502299',
+                '2': 'mfw_nrf9160_1.3.5',
+                '3': 'v1.3.1+thingy91.sol.lp.mmflt',
+                '4': 'thingy91_nrf9160',
+                '99': 1717419305
+            }
+        });
+        assert.equal('error' in res && _instanceof(res.error, NoHistoryMeasuresError), true);
+    });
+    void it('should return an error if the timestamp is invalid', function() {
+        var res = instanceMeasuresToRecord({
+            ObjectID: LwM2MObjectID.Environment_14205,
+            Resources: {
+                '0': 13.8,
+                '99': 1718878270596
+            }
+        });
+        assert.equal('error' in res && _instanceof(res.error, InvalidTimeError), true);
+    });
+});

package/dist/lwm2m/aws/instanceToMeasure.spec.js

@@ -0,0 +1,50 @@
+import { LwM2MObjectID } from 'lwm2m/LwM2MObjectID.js';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { instanceMeasuresToRecord } from './instanceMeasuresToRecord.js';
+void describe('instanceMeasuresToRecord()', function() {
+    void it('should convert LwM2M object instance to Timestream records', function() {
+        var env = {
+            ObjectID: LwM2MObjectID.Environment_14205,
+            ObjectVersion: '1.0',
+            Resources: {
+                0: 21,
+                1: 45,
+                '99': 1717419305
+            }
+        };
+        var maybeRecord = instanceMeasuresToRecord(env);
+        assert.deepEqual('record' in maybeRecord && maybeRecord.record, {
+            Dimensions: [
+                {
+                    Name: 'ObjectID',
+                    Value: LwM2MObjectID.Environment_14205
+                },
+                {
+                    Name: 'ObjectInstanceID',
+                    Value: '0'
+                },
+                {
+                    Name: 'ObjectVersion',
+                    Value: '1.0'
+                }
+            ],
+            MeasureName: '14205/0',
+            MeasureValueType: 'MULTI',
+            MeasureValues: [
+                {
+                    Name: '14205/1.0/0',
+                    Type: 'DOUBLE',
+                    Value: '21'
+                },
+                {
+                    Name: '14205/1.0/1',
+                    Type: 'DOUBLE',
+                    Value: '45'
+                }
+            ],
+            Time: '1717419305000',
+            TimeUnit: 'MILLISECONDS'
+        });
+    });
+});