@hello.nrfcloud.com/proto-map 4.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2023-2024, Nordic Semiconductor ASA | nordicsemi.no
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,122 @@
+# `hello.nrfcloud.com/map` Protocols [![npm version](https://img.shields.io/npm/v/@hello.nrfcloud.com/proto-map.svg)](https://www.npmjs.com/package/@hello.nrfcloud.com/proto-map)
+
+[![GitHub Actions](https://github.com/hello-nrfcloud/proto-map/actions/workflows/build-and-publish.yaml/badge.svg)](https://github.com/hello-nrfcloud/proto-map/actions/workflows/build-and-publish.yaml)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+[![Renovate](https://img.shields.io/badge/renovate-enabled-brightgreen.svg)](https://renovatebot.com)
+[![@commitlint/config-conventional](https://img.shields.io/badge/%40commitlint-config--conventional-brightgreen)](https://github.com/conventional-changelog/commitlint/tree/master/@commitlint/config-conventional)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier/)
+[![ESLint: TypeScript](https://img.shields.io/badge/ESLint-TypeScript-blue.svg)](https://github.com/typescript-eslint/typescript-eslint)
+
+Documents the communication protocol between devices, the
+`hello.nrfcloud.com/map` backend and web application.
+
+The [`lwm2m`](./lwm2m/) folder contains the LwM2M objects that devices publish.
+
+LwM2M object definitions are shared between models and can be re-used. Some
+objects provide special behavior (for example object
+[`14201` (Geolocation)](./lwm2m/14201.xml) will place the device's location on
+the map).
+
+Devices publish LwM2M objects using
+[SenML](https://datatracker.ietf.org/doc/html/rfc8428) directly, which needs to
+map to the defined LwM2M objects ([example](./senml/SenMLSchema.spec.ts)).
+
+The SenML payload will be [expanded](./senml/senMLtoLwM2M.spec.ts] to fully
+qualified LwM2M object representations which can then be processed further, e.g.
+stored in a database.
+
+This allows the `hello.nrfcloud.com/map` web application to visualize this data
+in a meaningful way to users without the need for custom implementation.
+
+## LwM2M rules
+
+- `LWM2MVersion` must be `1.1`
+- LwM2M objects are defined in the ID range from `14200` to `15000`
+  (non-inclusively).
+- The URN must have the prefix `urn:oma:lwm2m:x:`.
+- The `ObjectVersion` must be appended if it is not `1.0`, which is the default.
+- All objects must define one `Time` property.
+- Objects must be `Multiple` instance.
+- Objects must be `Optional`.
+- Resources must be `Single` instance. `Multiple` could be useful in some cases,
+  e.g. IP addresses, but until it is really needed, we do not support it.
+- Resources should only be marked as mandatory in case they must be published
+  together (e.g. latitude and longitude). This allows devices to only update the
+  values that have changed.
+- `RangeEnumeration` is only supported for `Float` and `Integer` and must be
+  specified as `<min>..<max>`, where `min` must be smaller than `max` and both
+  must be a number.
+- `Objlnk` resource type is not supported
+
+The conformity to the rules is checked using the script
+[`./lwm2m/check-lwm2m-rules.ts`](./lwm2m/check-lwm2m-rules.ts).
+
+## SenML rules
+
+- The implementation follows the recommendation outline in section 7.4.5. of the
+  [LwM2M v1.1.1 Technical Specification](https://openmobilealliance.org/release/LightweightM2M/V1_1_1-20190617-A/OMA-TS-LightweightM2M_Core-V1_1_1-20190617-A.pdf):
+  `bn` and `n` fields are combined to form the unique identifier for a resource
+  in the form of `/<object ID>/<object instance ID>/<resource ID>/0`. The
+  resource instance ID `0` is always appended, because multiple resource
+  instances are not supported right now.
+- Use the custom property `blv` to specify the object version, `1.0` is the
+  default and should not be specified.
+- Timestamps are to be expressed in the **base time** property `bt` and are
+  mapped to the LwM2M object's timestamp property and must not be send as a
+  property.
+
+## Model transform definitions
+
+Optionally, a set of [JSONata](https://jsonata.org/) expression can be defined
+[per model](./models/) which allows to convert from the data format that is
+published by the devices to the SenML data format used to describe LwM2M objects
+([example mapping](./models/PCA20035+solar/transforms/geolocation.md).
+
+### Model definition rules
+
+- **device models** are identified using a model name, for example
+  `PCA20035+solar`
+- a [`README.md`](./models/PCA20035+solar/README.md) must be provided that
+  describes the model
+- transforms may define transforms that convert the data sent by the device
+  using JSONata for JSON payloads in one or more Markdown files
+  ([Example](./models/PCA20035+solar/transforms/geolocationFromGroundfix.md)):
+  - The `Match Expression` the must evaluate to `true` for the
+    `Transform Expression` to be applied to the input message
+  - an `Input Example` and a `Result Example` must be supplied to validate the
+    expression
+  - The result of the Transform Expression must be SenML according to the rules
+    outlined below.
+
+The conformity to the rules is checked using the script
+[`./models/check-model-rules.ts`](./models/check-model-rules.ts).
+
+## Usage
+
+```bash
+npm i --save-exact @hello.nrfcloud.com/proto-map
+```
+
+## Setup
+
+Install the dependencies:
+
+```bash
+npm ci
+```
+
+Install [xmllint](https://github.com/GNOME/libxml2).
+
+## Run tests
+
+```bash
+npm test
+```
+
+## Update generated code
+
+```bash
+npx tsx generator/lwm2m.ts
+npx tsx generator/models.ts
+npx tsx generator/types.ts
+```

package/dist/generator/addDocBlock.js

@@ -0,0 +1,5 @@
+import ts from "typescript";
+export var addDocBlock = function(comment, node) {
+    ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, "*\n * ".concat(comment.join("\n * "), " \n "), true);
+    return node;
+};

package/dist/generator/generateLwM2MDefinitions.js

@@ -0,0 +1,82 @@
+import ts from "typescript";
+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")),
+        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("ResourceType"))
+    ])), ts.factory.createStringLiteral("./LWM2MObjectInfo.js"));
+    var importLwM2MObjectID = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("LwM2MObjectID"))
+    ])), ts.factory.createStringLiteral("./LwM2MObjectID.js"));
+    var type = ts.factory.createVariableStatement([
+        ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
+    ], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("definitions"), undefined, ts.factory.createTypeReferenceNode("Record", [
+            ts.factory.createTypeReferenceNode("LwM2MObjectID"),
+            ts.factory.createTypeReferenceNode("LWM2MObjectInfo")
+        ]), ts.factory.createObjectLiteralExpression(definitions.map(function(definition) {
+            var _definition_ObjectVersion;
+            var objectDef = ts.factory.createPropertyAssignment(ts.factory.createComputedPropertyName(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("LwM2MObjectID"), generateName(definition))), ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment("ObjectID", ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("LwM2MObjectID"), generateName(definition))),
+                ts.factory.createPropertyAssignment("ObjectVersion", ts.factory.createStringLiteral((_definition_ObjectVersion = definition.ObjectVersion) !== null && _definition_ObjectVersion !== void 0 ? _definition_ObjectVersion : "1.0")),
+                ts.factory.createPropertyAssignment("Name", ts.factory.createStringLiteral(definition.Name)),
+                ts.factory.createPropertyAssignment("Description", ts.factory.createStringLiteral(definition.Description1)),
+                ts.factory.createPropertyAssignment("Resources", ts.factory.createObjectLiteralExpression(definition.Resources.Item.map(function(Resource) {
+                    var range = undefined;
+                    if (Resource.RangeEnumeration.length > 0) {
+                        var maybeRange = parseRangeEnumeration(Resource.RangeEnumeration);
+                        if ("error" in maybeRange) throw maybeRange.error;
+                        range = maybeRange.range;
+                    }
+                    var props = [
+                        ts.factory.createPropertyAssignment("ResourceID", ts.factory.createNumericLiteral(Resource.$.ID)),
+                        ts.factory.createPropertyAssignment("Name", ts.factory.createStringLiteral(Resource.Name)),
+                        ts.factory.createPropertyAssignment("Mandatory", ts.factory.createIdentifier(Resource.Mandatory === "Mandatory" ? "true" : "false")),
+                        ts.factory.createPropertyAssignment("Type", ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ResourceType"), Resource.Type)),
+                        ts.factory.createPropertyAssignment("Description", ts.factory.createStringLiteral(Resource.Description))
+                    ];
+                    if (Resource.RangeEnumeration.length > 0) {
+                        var maybeRange1 = parseRangeEnumeration(Resource.RangeEnumeration);
+                        if ("error" in maybeRange1) throw maybeRange1.error;
+                        var _maybeRange_range = maybeRange1.range, min = _maybeRange_range.min, max = _maybeRange_range.max;
+                        props.push(ts.factory.createPropertyAssignment("RangeEnumeration", ts.factory.createObjectLiteralExpression([
+                            ts.factory.createPropertyAssignment("min", createNumber(min)),
+                            ts.factory.createPropertyAssignment("max", createNumber(max))
+                        ])));
+                    }
+                    if (Resource.Units.length > 0) props.push(ts.factory.createPropertyAssignment("Units", ts.factory.createStringLiteral(Resource.Units)));
+                    var resourceDef = ts.factory.createPropertyAssignment(ts.factory.createNumericLiteral(Resource.$.ID), ts.factory.createObjectLiteralExpression(props));
+                    var docStrings = [
+                        "".concat(Resource.Name, " (").concat(Resource.Type, ")"),
+                        "",
+                        Resource.Description
+                    ];
+                    if (range !== undefined) {
+                        docStrings.push("", "Minimum: ".concat(range.min), "Maximum: ".concat(range.max));
+                    }
+                    addDocBlock(docStrings, resourceDef);
+                    return resourceDef;
+                })))
+            ]));
+            addDocBlock([
+                "".concat(definition.Name, " (").concat(definition.ObjectID, ")"),
+                "",
+                definition.Description1
+            ], objectDef);
+            return objectDef;
+        })))
+    ], ts.NodeFlags.Const));
+    addDocBlock([
+        "Contains the ID of the resource that defines the timestamp for each LwM2M object definition"
+    ], type);
+    return [
+        importLWM2MObjectInfo,
+        importLwM2MObjectID,
+        type
+    ];
+};
+var createNumber = function(n) {
+    return n < 0 ? ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-n)) : ts.factory.createNumericLiteral(n);
+};

package/dist/generator/generateLwM2MDefinitions.spec.js

@@ -0,0 +1,91 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { definitions } from "../lwm2m/definitions.js";
+import { LwM2MObjectID } from "../lwm2m/LwM2MObjectID.js";
+import { ResourceType } from "../lwm2m/LWM2MObjectInfo.js";
+void describe("generateLwM2MDefinitions()", function() {
+    void it("should have generated definitions from the XML files", function() {
+        assert.deepEqual(definitions[LwM2MObjectID.Geolocation_14201], {
+            ObjectID: 14201,
+            ObjectVersion: "1.0",
+            Name: "Geolocation",
+            Description: "Describes the geo location of a device",
+            Resources: {
+                0: {
+                    ResourceID: 0,
+                    Name: "Latitude",
+                    Mandatory: true,
+                    Type: ResourceType.Float,
+                    Description: "The decimal notation of latitude in degrees, e.g. -43.5723 [World Geodetic System 1984].",
+                    Units: "\xb0",
+                    RangeEnumeration: {
+                        max: 90,
+                        min: -90
+                    }
+                },
+                1: {
+                    ResourceID: 1,
+                    Name: "Longitude",
+                    Mandatory: true,
+                    Type: ResourceType.Float,
+                    Description: "The decimal notation of longitude in degrees, e.g. 153.21760 [World Geodetic System 1984].",
+                    Units: "\xb0",
+                    RangeEnumeration: {
+                        max: 180,
+                        min: -180
+                    }
+                },
+                2: {
+                    ResourceID: 2,
+                    Name: "Altitude",
+                    Mandatory: false,
+                    Type: ResourceType.Float,
+                    Description: "The decimal notation of altitude in meters above sea level.",
+                    Units: "m"
+                },
+                3: {
+                    ResourceID: 3,
+                    Name: "Radius",
+                    Mandatory: false,
+                    Type: ResourceType.Float,
+                    Description: "The value in this resource indicates the radius of a circular area in meters. The circular area is used to describe uncertainty about a point for coordinates in a two-dimensional coordinate reference systems (CRS). The center point of a circular area is specified by using the Latitude and the Longitude Resources.",
+                    Units: "m"
+                },
+                4: {
+                    ResourceID: 4,
+                    Name: "Speed",
+                    Mandatory: false,
+                    Type: ResourceType.Float,
+                    Description: "Speed is the time rate of change in position.",
+                    Units: "m/s"
+                },
+                5: {
+                    ResourceID: 5,
+                    Name: "Heading",
+                    Mandatory: false,
+                    Type: ResourceType.Float,
+                    Description: "The angle of movement in degrees.",
+                    Units: "\xb0",
+                    RangeEnumeration: {
+                        min: 0,
+                        max: 360
+                    }
+                },
+                6: {
+                    ResourceID: 6,
+                    Name: "Source",
+                    Mandatory: true,
+                    Type: ResourceType.String,
+                    Description: "The source of the geo location, e.g. GNSS, SCELL, MCELL, WIFI."
+                },
+                99: {
+                    ResourceID: 99,
+                    Name: "Timestamp",
+                    Mandatory: true,
+                    Type: ResourceType.Time,
+                    Description: "The timestamp of when the location measurement was performed."
+                }
+            }
+        });
+    });
+});

package/dist/generator/generateLwm2mTimestampResources.js

@@ -0,0 +1,69 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    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 ts from "typescript";
+import { addDocBlock } from "./addDocBlock.js";
+export var generateLwm2mTimestampResources = function(timestampResources) {
+    var type = ts.factory.createVariableStatement([
+        ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
+    ], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("timestampResources"), undefined, ts.factory.createTypeReferenceNode("Readonly", [
+            ts.factory.createTypeReferenceNode("Record", [
+                ts.factory.createTypeReferenceNode("number"),
+                ts.factory.createTypeReferenceNode("number")
+            ])
+        ]), ts.factory.createObjectLiteralExpression(Object.entries(timestampResources).map(function(param) {
+            var _param = _sliced_to_array(param, 2), k = _param[0], v = _param[1];
+            return ts.factory.createPropertyAssignment(k, ts.factory.createNumericLiteral(v));
+        })))
+    ], ts.NodeFlags.Const));
+    addDocBlock([
+        "Contains the ID of the resource that defines the timestamp for each LwM2M object definition"
+    ], type);
+    return [
+        type
+    ];
+};

package/dist/generator/generateModels.js

@@ -0,0 +1,142 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    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 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(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+        ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier("Transform")),
+        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("TransformType"))
+    ])), ts.factory.createStringLiteral("./types.js")));
+    types.push(addDocBlock([
+        "The Model IDs defined in this repo."
+    ], ts.factory.createEnumDeclaration([
+        ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
+    ], ts.factory.createIdentifier("ModelID"), models.map(function(param) {
+        var id = param.id;
+        return ts.factory.createEnumMember(tokenizeName(id), ts.factory.createStringLiteral(id));
+    }))));
+    types.push(ts.factory.createTypeAliasDeclaration([
+        ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
+    ], ts.factory.createIdentifier("Model"), undefined, ts.factory.createTypeLiteralNode([
+        addDocBlock([
+            "The Model ID"
+        ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("id"), undefined, ts.factory.createTypeReferenceNode("ModelID"))),
+        addDocBlock([
+            "The transforms defined for this model."
+        ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("transforms"), undefined, ts.factory.createTypeReferenceNode("Array", [
+            ts.factory.createTypeReferenceNode("Transform")
+        ]))),
+        addDocBlock([
+            "Description of the Model from the README.md"
+        ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("about"), undefined, ts.factory.createTypeLiteralNode([
+            addDocBlock([
+                "The text of the H1 headline"
+            ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("title"), undefined, ts.factory.createTypeReferenceNode("string"))),
+            addDocBlock([
+                "The text of the paragraphs following the H1 headline"
+            ], ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral("description"), undefined, ts.factory.createTypeReferenceNode("string")))
+        ])))
+    ])));
+    types.push(addDocBlock([
+        "The models defined for hello.nrfcloud.com"
+    ], ts.factory.createVariableStatement([
+        ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
+    ], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier("models"), undefined, ts.factory.createTypeReferenceNode("Readonly", [
+            ts.factory.createTypeReferenceNode("Record", [
+                ts.factory.createTypeReferenceNode("ModelID", []),
+                ts.factory.createTypeReferenceNode("Model", [])
+            ])
+        ]), ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression(models.map(function(model) {
+            var readme = parseREADME(model.readmeMarkdown);
+            return ts.factory.createPropertyAssignment(ts.factory.createComputedPropertyName(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ModelID"), ts.factory.createIdentifier(tokenizeName(model.id)))), // The model object
+            ts.factory.createObjectLiteralExpression([
+                // id
+                ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("id"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ModelID"), ts.factory.createIdentifier(tokenizeName(model.id)))),
+                // transforms
+                ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("transforms"), ts.factory.createArrayLiteralExpression(model.transforms.map(function(transform) {
+                    return ts.factory.createObjectLiteralExpression([
+                        // type
+                        ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("type"), transform.type === "messages" ? ts.factory.createIdentifier("TransformType.Messages") : ts.factory.createIdentifier("TransformType.Shadow")),
+                        // match
+                        ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("match"), createAssignment(transform.match)),
+                        // transform
+                        ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("transform"), createAssignment(transform.transform))
+                    ]);
+                }))),
+                // About
+                ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("about"), ts.factory.createObjectLiteralExpression([
+                    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("title"), ts.factory.createStringLiteral(readme.heading)),
+                    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral("description"), ts.factory.createStringLiteral(readme.description.join("\n")))
+                ]))
+            ]));
+        })), ts.factory.createTypeReferenceNode("const")))
+    ], ts.NodeFlags.Const))));
+    return types;
+};
+var createAssignment = function(v) {
+    if (v === null) return ts.factory.createNull();
+    if (typeof v === "string") {
+        return ts.factory.createStringLiteral(v);
+    }
+    if (Array.isArray(v)) {
+        return ts.factory.createArrayLiteralExpression(v.map(function(el) {
+            return createAssignment(el);
+        }));
+    }
+    if (typeof v === "object") return ts.factory.createObjectLiteralExpression(Object.entries(v).map(function(param) {
+        var _param = _sliced_to_array(param, 2), k = _param[0], _$v = _param[1];
+        return ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(k), createAssignment(_$v));
+    }));
+    return addDocBlock([
+        "Could not convert node",
+        JSON.stringify(v)
+    ], ts.factory.createNull());
+};

package/dist/generator/generateType.js

@@ -0,0 +1,90 @@
+import ts from "typescript";
+import { addDocBlock } from "./addDocBlock.js";
+import { LwM2MType } from "../lwm2m/resourceType.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({
+        Name: Name,
+        ObjectID: ObjectID
+    });
+    var importLwM2MObject = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(true, undefined, ts.factory.createNamedImports([
+        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("LwM2MObject"))
+    ])), ts.factory.createStringLiteral("../LwM2MObject.js"));
+    var importLwM2MObjectID = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("LwM2MObjectID"))
+    ])), ts.factory.createStringLiteral("../LwM2MObjectID.js"));
+    // Generate the type
+    var exportType = ts.factory.createTypeAliasDeclaration([
+        ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
+    ], ts.factory.createIdentifier(name), undefined, ts.factory.createTypeReferenceNode("LwM2MObject", [
+        ts.factory.createTypeLiteralNode([
+            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("ObjectID"), undefined, ts.factory.createTypeReferenceNode("LwM2MObjectID.".concat(name), undefined)),
+            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("ObjectVersion"), undefined, ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(ObjectVersion !== null && ObjectVersion !== void 0 ? ObjectVersion : "1.0"))),
+            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("Resources"), undefined, ts.factory.createTypeLiteralNode(byImportance(Resources.Item).map(function(resource) {
+                var res = ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("".concat(resource.$.ID)), resource.Mandatory === "Mandatory" ? undefined : ts.factory.createToken(ts.SyntaxKind.QuestionToken), typeScriptResourceType(resource.Type));
+                addDocBlock([
+                    "".concat(resource.Name).concat(resource.Units.length > 0 ? " (".concat(resource.Units, ")") : ""),
+                    "",
+                    resource.Description
+                ], res);
+                if (resource.RangeEnumeration.length > 0) {
+                    var maybeRange = parseRangeEnumeration(resource.RangeEnumeration);
+                    if ("error" in maybeRange) throw maybeRange.error;
+                    addDocBlock([
+                        "Minimum: ".concat(maybeRange.range.min),
+                        "Maximum: ".concat(maybeRange.range.max)
+                    ], res);
+                }
+                return res;
+            })))
+        ])
+    ]));
+    addDocBlock([
+        "".concat(Name, " (").concat(ObjectID, ")"),
+        "",
+        Description1
+    ], exportType);
+    return [
+        importLwM2MObject,
+        importLwM2MObjectID,
+        exportType
+    ];
+};
+export var generateName = function(param) {
+    var Name = param.Name, ObjectID = param.ObjectID;
+    return "".concat(tokenizeName(Name), "_").concat(ObjectID);
+};
+var typeScriptResourceType = function(type) {
+    switch(type){
+        case LwM2MType.Float:
+        case LwM2MType.Integer:
+        case LwM2MType.UnsignedInteger:
+            return ts.factory.createTypeReferenceNode("number");
+        case LwM2MType.Boolean:
+            return ts.factory.createTypeReferenceNode("boolean");
+        case LwM2MType.String:
+        case LwM2MType.Opaque:
+        case LwM2MType.Corelnk:
+        case LwM2MType.Objlnk:
+            return ts.factory.createTypeReferenceNode("string");
+        case LwM2MType.Time:
+            return ts.factory.createTypeReferenceNode("Date");
+        default:
+            throw new Error("Unexpected resource type: ".concat(type));
+    }
+};
+var byImportance = function(resources) {
+    return resources// sort by id
+    .sort(function(param, param1) {
+        var _param_$ = param.$, id1 = _param_$.ID, _param_$1 = param1.$, id2 = _param_$1.ID;
+        return parseInt(id1, 10) - parseInt(id2, 10);
+    })// sort mandatory up
+    .sort(function(param, param1) {
+        var m1 = param.Mandatory, m2 = param1.Mandatory;
+        if (m1 === "Mandatory" && m2 === "Mandatory") return 0;
+        if (m1 === "Mandatory") return -1;
+        return 1;
+    });
+};