@hello.nrfcloud.com/proto-map 5.6.2 → 6.0.0

package/dist/generator/lwm2m.js

@@ -24,15 +24,15 @@ 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);
 }
 var _path;
-import chalk from "chalk";
-import { readFile, readdir, writeFile } from "node:fs/promises";
-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 { generateLwM2MDefinitions } from "./generateLwM2MDefinitions.js";
+import chalk from 'chalk';
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+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 { generateLwM2MDefinitions } from './generateLwM2MDefinitions.js';
 var baseDir = process.cwd();
 var subDir = function() {
     for(var _len = arguments.length, tree = new Array(_len), _key = 0; _key < _len; _key++){
@@ -42,16 +42,16 @@ var subDir = function() {
         baseDir
     ].concat(_to_consumable_array(tree)));
 };
-console.log(chalk.gray("LwM2M"));
+console.log(chalk.gray('LwM2M'));
 // Load definitions
 var definitions = [];
 var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
 try {
-    for(var _iterator = (await readdir(subDir("lwm2m"))).filter(function(s) {
-        return s.endsWith(".xml");
+    for(var _iterator = (await readdir(subDir('lwm2m'))).filter(function(s) {
+        return s.endsWith('.xml');
     })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
         var objectDefinitionFile = _step.value;
-        var definition = unwrapNestedArray(await xml2js.parseStringPromise(await readFile(subDir("lwm2m", objectDefinitionFile), "utf-8"))).LWM2M.Object;
+        var definition = unwrapNestedArray(await xml2js.parseStringPromise(await readFile(subDir('lwm2m', objectDefinitionFile), 'utf-8'))).LWM2M.Object;
         definitions.push(definition);
     }
 } catch (err) {
@@ -68,7 +68,7 @@ try {
         }
     }
 }
-console.log(chalk.gray("", "\xb7"), chalk.gray("timestamp resources map"));
+console.log(chalk.gray('', '·'), chalk.gray('timestamp resources map'));
 var timestampResources = {};
 var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
 try {
@@ -78,10 +78,10 @@ try {
         var ObjectID = parseInt(definition1.ObjectID, 10);
         var ResourceId = parseInt((_definition_Resources_Item_find = definition1.Resources.Item.find(function(param) {
             var Type = param.Type;
-            return Type === "Time";
+            return Type === 'Time';
         })) === null || _definition_Resources_Item_find === void 0 ? void 0 : _definition_Resources_Item_find.$.ID, 10);
         timestampResources[ObjectID] = ResourceId;
-        console.log("  ", chalk.gray("\xb7"), "".concat(chalk.white(ObjectID)).concat(chalk.gray(".")).concat(chalk.white(ResourceId)));
+        console.log('  ', chalk.gray('·'), "".concat(chalk.white(ObjectID)).concat(chalk.gray('.')).concat(chalk.white(ResourceId)));
     }
 } catch (err) {
     _didIteratorError1 = true;
@@ -97,10 +97,10 @@ try {
         }
     }
 }
-var timestampResourcesFile = subDir("lwm2m", "timestampResources.ts");
-console.log(chalk.green("Writing"), chalk.blue(timestampResourcesFile.replace(baseDir, "")));
-await writeFile(timestampResourcesFile, generateLwm2mTimestampResources(timestampResources).map(printNode).join(os.EOL), "utf-8");
-console.log(chalk.gray("", "\xb7"), chalk.gray("static object information"));
-var definitionsFile = subDir("lwm2m", "definitions.ts");
-console.log(chalk.green("Writing"), chalk.blue(definitionsFile.replace(baseDir, "")));
-await writeFile(definitionsFile, generateLwM2MDefinitions(definitions).map(printNode).join(os.EOL), "utf-8");
+var timestampResourcesFile = subDir('lwm2m', 'timestampResources.ts');
+console.log(chalk.green('Writing'), chalk.blue(timestampResourcesFile.replace(baseDir, '')));
+await writeFile(timestampResourcesFile, generateLwm2mTimestampResources(timestampResources).map(printNode).join(os.EOL), 'utf-8');
+console.log(chalk.gray('', '·'), chalk.gray('static object information'));
+var definitionsFile = subDir('lwm2m', 'definitions.ts');
+console.log(chalk.green('Writing'), chalk.blue(definitionsFile.replace(baseDir, '')));
+await writeFile(definitionsFile, generateLwM2MDefinitions(definitions).map(printNode).join(os.EOL), 'utf-8');

package/dist/generator/models.js

@@ -150,16 +150,12 @@ function _ts_generator(thisArg, body) {
     }
 }
 var _path;
-import chalk from "chalk";
-import { readFile, readdir, stat, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { getCodeBlock } from "../markdown/getCodeBlock.js";
-import { getFrontMatter } from "../markdown/getFrontMatter.js";
-import { generateModels } from "./generateModels.js";
-import { printNode } from "./printNode.js";
-import { FrontMatter } from "../models/types.js";
-import { isDir } from "./isDir.js";
+import chalk from 'chalk';
+import { readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateModels } from './generateModels.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++){
@@ -169,80 +165,8 @@ var subDir = function() {
         baseDir
     ].concat(_to_consumable_array(tree)));
 };
-console.log(chalk.gray("Models"));
-var loadModelTransforms = function() {
-    var _ref = _async_to_generator(function(model) {
-        var transformersDir, _;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    transformersDir = subDir("models", model, "transforms");
-                    return [
-                        4,
-                        isDir(transformersDir)
-                    ];
-                case 1:
-                    if (!_state.sent()) return [
-                        2,
-                        []
-                    ];
-                    _ = Promise.all;
-                    return [
-                        4,
-                        readdir(transformersDir)
-                    ];
-                case 2:
-                    return [
-                        2,
-                        _.apply(Promise, [
-                            _state.sent()
-                        ]).then(function(entries) {
-                            return entries.filter(function(e) {
-                                return e.endsWith(".md");
-                            });
-                        }).then(function() {
-                            var _ref = _async_to_generator(function(expressions) {
-                                return _ts_generator(this, function(_state) {
-                                    return [
-                                        2,
-                                        Promise.all(expressions.map(function() {
-                                            var _ref = _async_to_generator(function(expression) {
-                                                return _ts_generator(this, function(_state) {
-                                                    return [
-                                                        2,
-                                                        readFile(subDir("models", model, "transforms", expression), "utf-8")
-                                                    ];
-                                                });
-                                            });
-                                            return function(expression) {
-                                                return _ref.apply(this, arguments);
-                                            };
-                                        }()))
-                                    ];
-                                });
-                            });
-                            return function(expressions) {
-                                return _ref.apply(this, arguments);
-                            };
-                        }()).then(function(transforms) {
-                            return transforms.map(function(markdown) {
-                                var findBlock = getCodeBlock(markdown);
-                                return {
-                                    type: getFrontMatter(markdown, FrontMatter).type,
-                                    match: findBlock("jsonata", "Match Expression"),
-                                    transform: findBlock("jsonata", "Transform Expression")
-                                };
-                            });
-                        })
-                    ];
-            }
-        });
-    });
-    return function loadModelTransforms(model) {
-        return _ref.apply(this, arguments);
-    };
-}();
-var models = await Promise.all((await Promise.all((await readdir(subDir("models"))).map(function() {
+console.log(chalk.gray('Models'));
+var models = await Promise.all((await Promise.all((await readdir(subDir('models'))).map(function() {
     var _ref = _async_to_generator(function(f) {
         var _tmp;
         return _ts_generator(this, function(_state) {
@@ -253,7 +177,7 @@ var models = await Promise.all((await Promise.all((await readdir(subDir("models"
                     };
                     return [
                         4,
-                        stat(subDir("models", f))
+                        stat(subDir('models', f))
                     ];
                 case 1:
                     return [
@@ -275,21 +199,15 @@ var models = await Promise.all((await Promise.all((await readdir(subDir("models"
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    console.log(chalk.gray("\xb7"), chalk.white(model.name));
+                    console.log(chalk.gray('·'), chalk.white(model.name));
                     _tmp = {
                         id: model.name
                     };
                     return [
                         4,
-                        loadModelTransforms(model.name)
+                        readFile(path.join(subDir('models'), model.name, 'README.md'), 'utf-8')
                     ];
                 case 1:
-                    _tmp.transforms = _state.sent();
-                    return [
-                        4,
-                        readFile(path.join(subDir("models"), model.name, "README.md"), "utf-8")
-                    ];
-                case 2:
                     return [
                         2,
                         (_tmp.readmeMarkdown = _state.sent(), _tmp)
@@ -301,6 +219,6 @@ var models = await Promise.all((await Promise.all((await readdir(subDir("models"
         return _ref.apply(this, arguments);
     };
 }()));
-var modelsFile = subDir("models", "models.ts");
-console.log(chalk.green("Writing"), chalk.blue(modelsFile.replace(baseDir, "")));
-await writeFile(modelsFile, generateModels(models).map(printNode).join(os.EOL), "utf-8");
+var modelsFile = subDir('models', 'models.ts');
+console.log(chalk.green('Writing'), chalk.blue(modelsFile.replace(baseDir, '')));
+await writeFile(modelsFile, generateModels(models).map(printNode).join(os.EOL), 'utf-8');

package/dist/generator/printNode.js

@@ -1,5 +1,5 @@
-import ts from "typescript";
-var resultFile = ts.createSourceFile("stub.ts", "", ts.ScriptTarget.Latest, /*setParentNodes*/ false, ts.ScriptKind.TS);
+import ts from 'typescript';
+var resultFile = ts.createSourceFile("stub.ts", '', ts.ScriptTarget.Latest, /*setParentNodes*/ false, ts.ScriptKind.TS);
 var printer = ts.createPrinter({
     newLine: ts.NewLineKind.LineFeed
 });

package/dist/generator/tokenizeName.js

@@ -1,5 +1,5 @@
 export var tokenizeName = function(name) {
-    return name.split(" ").map(function(s) {
+    return name.split(' ').map(function(s) {
         return "".concat(s.slice(0, 1).toUpperCase()).concat(s.slice(1));
-    }).join(" ").replaceAll(" ", "").replaceAll("&", "and").replace(/^(\d)(.+)/, "n$1$2").replaceAll(/[^a-z0-9]/gi, "_").replaceAll(/_{2,}/g, "_").replaceAll(/_+$/g, "").trim();
+    }).join(' ').replaceAll(' ', '').replaceAll('&', 'and').replace(/^(\d)(.+)/, 'n$1$2').replaceAll(/[^a-z0-9]/gi, '_').replaceAll(/_{2,}/g, '_').replaceAll(/_+$/g, '').trim();
 };

package/dist/generator/tokenizeName.spec.js

@@ -44,10 +44,10 @@ 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";
-void describe("tokenizeName", function() {
+import { tokenizeName } from './tokenizeName.js';
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+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];
         void it("should replaced ".concat(name, " to ").concat(expected), function() {
@@ -57,42 +57,42 @@ void describe("tokenizeName", function() {
     for(var _i = 0, _iter = [
         // Uppercase words
         [
-            "Battery and Power",
-            "BatteryAndPower"
+            'Battery and Power',
+            'BatteryAndPower'
         ],
         [
-            "LwM2M Server",
-            "LwM2MServer"
+            'LwM2M Server',
+            'LwM2MServer'
         ],
         // Dash -> underline
         [
-            "LTE-MTC Band Config",
-            "LTE_MTCBandConfig"
+            'LTE-MTC Band Config',
+            'LTE_MTCBandConfig'
         ],
         // Number at the Beginning, prefix with n
         [
-            "5GNR Connectivity",
-            "n5GNRConnectivity"
+            '5GNR Connectivity',
+            'n5GNRConnectivity'
         ],
         // Slash -> underline
         [
-            "On/Off Switch",
-            "On_OffSwitch"
+            'On/Off Switch',
+            'On_OffSwitch'
         ],
         // Dot -> underline
         [
-            "LwM2M v1.1 Test Object",
-            "LwM2MV1_1TestObject"
+            'LwM2M v1.1 Test Object',
+            'LwM2MV1_1TestObject'
         ],
         // & -> and
         [
-            "AT&T Connectivity Extension",
-            "ATandTConnectivityExtension"
+            'AT&T Connectivity Extension',
+            'ATandTConnectivityExtension'
         ],
         // Remove whitespace
         [
-            " Server ",
-            "Server"
+            ' Server ',
+            'Server'
         ]
     ]; _i < _iter.length; _i++)_loop(_i, _iter);
 });

package/dist/generator/types.js

@@ -24,19 +24,19 @@ 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);
 }
 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 os from "node:os";
-import { generateType } from "./generateType.js";
-import { addDocBlock } from "./addDocBlock.js";
-import { generateName } from "./generateType.js";
-import { generateValidator } from "./generateValidator.js";
-import { generateValidators } from "./generateValidators.js";
+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 os from 'node:os';
+import { generateType } from './generateType.js';
+import { addDocBlock } from './addDocBlock.js';
+import { generateName } from './generateType.js';
+import { generateValidator } from './generateValidator.js';
+import { generateValidators } from './generateValidators.js';
 var baseDir = process.cwd();
 var subDir = function() {
     for(var _len = arguments.length, tree = new Array(_len), _key = 0; _key < _len; _key++){
@@ -48,14 +48,14 @@ var subDir = function() {
 };
 var idMembers = [];
 var objects = [];
-console.log(chalk.gray("Creating TypeBox definition for LwM2M objects"));
+console.log(chalk.gray('Creating TypeBox definition for LwM2M objects'));
 var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
 try {
-    for(var _iterator = (await readdir(subDir("lwm2m"))).filter(function(s) {
-        return s.endsWith(".xml");
+    for(var _iterator = (await readdir(subDir('lwm2m'))).filter(function(s) {
+        return s.endsWith('.xml');
     })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
         var objectDefinitionFile = _step.value;
-        var definition = unwrapNestedArray(await xml2js.parseStringPromise(await readFile(subDir("lwm2m", objectDefinitionFile), "utf-8"))).LWM2M.Object;
+        var definition = unwrapNestedArray(await xml2js.parseStringPromise(await readFile(subDir('lwm2m', objectDefinitionFile), 'utf-8'))).LWM2M.Object;
         var ObjectID = parseInt(definition.ObjectID, 10);
         var member = ts.factory.createEnumMember(generateName(definition), ts.factory.createNumericLiteral(ObjectID));
         addDocBlock([
@@ -65,18 +65,18 @@ try {
         ], member);
         idMembers.push(member);
         try {
-            await mkdir(subDir("lwm2m", "object"));
+            await mkdir(subDir('lwm2m', "object"));
         } catch (e) {
         // pass
         }
         // Type
-        var typeFile = subDir("lwm2m", "object", "".concat(ObjectID, ".d.ts"));
-        console.log(chalk.green("Writing"), chalk.blue(typeFile.replace(baseDir, "")));
-        await writeFile(typeFile, generateType(definition).map(printNode).join(os.EOL), "utf-8");
+        var typeFile = subDir('lwm2m', "object", "".concat(ObjectID, ".d.ts"));
+        console.log(chalk.green('Writing'), chalk.blue(typeFile.replace(baseDir, '')));
+        await writeFile(typeFile, generateType(definition).map(printNode).join(os.EOL), 'utf-8');
         // Validator
-        var validatorFile = subDir("lwm2m", "object", "validate".concat(ObjectID, ".ts"));
-        console.log(chalk.green("Writing"), chalk.blue(validatorFile.replace(baseDir, "")));
-        await writeFile(validatorFile, generateValidator(definition).map(printNode).join(os.EOL), "utf-8");
+        var validatorFile = subDir('lwm2m', "object", "validate".concat(ObjectID, ".ts"));
+        console.log(chalk.green('Writing'), chalk.blue(validatorFile.replace(baseDir, '')));
+        await writeFile(validatorFile, generateValidator(definition).map(printNode).join(os.EOL), 'utf-8');
         objects.push(definition);
     }
 } catch (err) {
@@ -93,36 +93,36 @@ try {
         }
     }
 }
-var validatorsFile = subDir("lwm2m", "validators.ts");
-console.log(chalk.green("Writing"), chalk.blue(validatorsFile.replace(baseDir, "")));
-await writeFile(validatorsFile, generateValidators(objects).map(printNode).join(os.EOL), "utf-8");
-var idFile = subDir("lwm2m", "LwM2MObjectID.ts");
-console.log(chalk.green("Writing"), chalk.blue(idFile.replace(baseDir, "")));
+var validatorsFile = subDir('lwm2m', "validators.ts");
+console.log(chalk.green('Writing'), chalk.blue(validatorsFile.replace(baseDir, '')));
+await writeFile(validatorsFile, generateValidators(objects).map(printNode).join(os.EOL), 'utf-8');
+var idFile = subDir('lwm2m', "LwM2MObjectID.ts");
+console.log(chalk.green('Writing'), chalk.blue(idFile.replace(baseDir, '')));
 var enumNode = ts.factory.createEnumDeclaration([
     ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
-], ts.factory.createIdentifier("LwM2MObjectID"), idMembers);
+], ts.factory.createIdentifier('LwM2MObjectID'), idMembers);
 addDocBlock([
-    "The LwM2M Object IDs defined in this repo."
+    'The LwM2M Object IDs defined in this repo.'
 ], enumNode);
 var objectIdArray = ts.factory.createVariableStatement([
     ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
 ], ts.factory.createVariableDeclarationList([
     ts.factory.createVariableDeclaration(ts.factory.createIdentifier("LwM2MObjectIDs"), undefined, undefined, ts.factory.createArrayLiteralExpression(objects.map(function(definition) {
         // const id = ts.factory.createNumericLiteral(ObjectID)
-        var id = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("LwM2MObjectID"), ts.factory.createIdentifier(generateName(definition)));
+        var id = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('LwM2MObjectID'), ts.factory.createIdentifier(generateName(definition)));
         ts.addSyntheticLeadingComment(id, ts.SyntaxKind.SingleLineCommentTrivia, " ".concat(definition.Name, " (").concat(definition.ObjectID, ")"), true);
         return id;
     })))
 ], ts.NodeFlags.Const));
 addDocBlock([
-    "The LwM2M Object IDs defined in this repo."
+    'The LwM2M Object IDs defined in this repo.'
 ], objectIdArray);
 await writeFile(idFile, [
     enumNode,
     objectIdArray
-].map(printNode).join(os.EOL), "utf-8");
-var objectsFile = subDir("lwm2m", "objects.ts");
-console.log(chalk.green("Writing"), chalk.blue(objectsFile.replace(baseDir, "")));
+].map(printNode).join(os.EOL), 'utf-8');
+var objectsFile = subDir('lwm2m', "objects.ts");
+console.log(chalk.green('Writing'), chalk.blue(objectsFile.replace(baseDir, '')));
 await writeFile(objectsFile, objects.map(function(param) {
     var ObjectID = param.ObjectID, Name = param.Name;
     var name = generateName({
@@ -137,4 +137,4 @@ await writeFile(objectsFile, objects.map(function(param) {
             ts.factory.createExportSpecifier(false, undefined, ts.factory.createIdentifier("validate".concat(ObjectID)))
         ]), ts.factory.createStringLiteral("./object/validate".concat(ObjectID, ".js")))
     ];
-}).flat().map(printNode).join(os.EOL), "utf-8");
+}).flat().map(printNode).join(os.EOL), 'utf-8');

package/dist/lwm2m/LWM2MObjectDefinition.js

@@ -1,45 +1,45 @@
-import { Type } from "@sinclair/typebox";
+import { Type } from '@sinclair/typebox';
 var ResourceType = Type.Union([
-    Type.Literal("String"),
-    Type.Literal("Integer"),
-    Type.Literal("Float"),
-    Type.Literal("Boolean"),
-    Type.Literal("Opaque"),
-    Type.Literal("Time")
+    Type.Literal('String'),
+    Type.Literal('Integer'),
+    Type.Literal('Float'),
+    Type.Literal('Boolean'),
+    Type.Literal('Opaque'),
+    Type.Literal('Time')
 ]);
 export var RangeEnumerationRegExp = RegExp("^(?<min>-?[0-9]+(?:\\.[0-9]+)?)\\.\\.(?<max>-?[0-9]+(?:\\.[0-9]+)?)$");
 var RangeEnumeration = Type.RegExp(RangeEnumerationRegExp, {
-    title: "RangeEnumeration"
+    title: 'RangeEnumeration'
 });
 export var LWM2MObjectDefinition = Type.Object({
     Name: Type.String({
         minLength: 1,
         examples: [
-            "Location"
+            'Location'
         ]
     }),
     Description1: Type.String({
         minLength: 1,
         examples: [
-            "This LwM2M Object provides a range of location telemetry related information which can be queried by the LwM2M Server."
+            'This LwM2M Object provides a range of location telemetry related information which can be queried by the LwM2M Server.'
         ]
     }),
     ObjectID: Type.RegExp(/^14[0-9]{3}$/),
     ObjectURN: Type.RegExp(/^urn:oma:lwm2m:x:14[0-9]{3}$/),
-    LWM2MVersion: Type.Literal("1.1", {
-        title: "LwM2M version",
-        description: "Defaults to 1.1"
+    LWM2MVersion: Type.Literal('1.1', {
+        title: 'LwM2M version',
+        description: 'Defaults to 1.1'
     }),
     ObjectVersion: Type.Optional(Type.String({
         minLength: 1,
         examples: [
-            "1.1"
+            '1.1'
         ],
-        title: "ObjectVersion",
-        description: "Defaults to 1.0"
+        title: 'ObjectVersion',
+        description: 'Defaults to 1.0'
     })),
-    MultipleInstances: Type.Literal("Multiple"),
-    Mandatory: Type.Literal("Optional"),
+    MultipleInstances: Type.Literal('Multiple'),
+    Mandatory: Type.Literal('Optional'),
     Resources: Type.Record(Type.Integer({
         minimum: 0,
         maximum: 65534
@@ -47,42 +47,42 @@ export var LWM2MObjectDefinition = Type.Object({
         Name: Type.String({
             minLength: 1,
             examples: [
-                "Latitude"
+                'Latitude'
             ]
         }),
-        Operations: Type.Literal("R", {
-            description: "Only read-properties are supported"
+        Operations: Type.Literal('R', {
+            description: 'Only read-properties are supported'
         }),
-        MultipleInstances: Type.Literal("Single"),
+        MultipleInstances: Type.Literal('Single'),
         Mandatory: Type.Union([
-            Type.Literal("Optional"),
-            Type.Literal("Mandatory")
+            Type.Literal('Optional'),
+            Type.Literal('Mandatory')
         ]),
         Type: ResourceType,
         RangeEnumeration: Type.Union([
             Type.String({
                 maxLength: 0,
-                title: "an empty string"
+                title: 'an empty string'
             }),
             RangeEnumeration
         ]),
         Units: Type.String({
             examples: [
-                "lat"
+                'lat'
             ],
-            title: "Units"
+            title: 'Units'
         }),
         Description: Type.String({
             minLength: 1,
             examples: [
-                "The decimal notation of latitude, e.g. -43.5723 [World Geodetic System 1984]."
+                'The decimal notation of latitude, e.g. -43.5723 [World Geodetic System 1984].'
             ]
         })
     }), {
         minProperties: 1,
-        description: "Defines the object resources as a map"
+        description: 'Defines the object resources as a map'
     }),
     Description2: Type.String()
 }, {
-    description: "LwM2M Object definitions with additional limitations applied to suit the hello.nrfcloud.com/map use-case"
+    description: 'LwM2M Object definitions with additional limitations applied to suit the hello.nrfcloud.com/map use-case'
 });