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

package/README.md

@@ -65,28 +65,12 @@ The conformity to the rules is checked using the script
   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).

package/dist/generator/generateModels.js

@@ -1,59 +1,9 @@
-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([
@@ -68,11 +18,6 @@ export var generateModels = function(models) {
         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([
@@ -100,17 +45,6 @@ export var generateModels = function(models) {
             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)),
@@ -121,22 +55,3 @@ export var generateModels = function(models) {
     ], 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/models.js

@@ -154,12 +154,8 @@ 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';
 var baseDir = process.cwd();
 var subDir = function() {
     for(var _len = arguments.length, tree = new Array(_len), _key = 0; _key < _len; _key++){
@@ -170,78 +166,6 @@ var subDir = function() {
     ].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() {
     var _ref = _async_to_generator(function(f) {
         var _tmp;
@@ -279,17 +203,11 @@ var models = await Promise.all((await Promise.all((await readdir(subDir('models'
                     _tmp = {
                         id: model.name
                     };
-                    return [
-                        4,
-                        loadModelTransforms(model.name)
-                    ];
-                case 1:
-                    _tmp.transforms = _state.sent();
                     return [
                         4,
                         readFile(path.join(subDir('models'), model.name, 'README.md'), 'utf-8')
                     ];
-                case 2:
+                case 1:
                     return [
                         2,
                         (_tmp.readmeMarkdown = _state.sent(), _tmp)

package/dist/markdown/getCodeBlock.js

@@ -1,43 +1,17 @@
 import { remark } from 'remark';
 export var parseMarkdown2 = remark();
-var isCodeBlock = function(lang) {
-    return function(child) {
-        return child.type === 'code' && child.lang === lang;
-    };
-};
-var isHeadingWithTitle = function(title) {
-    return function(child) {
-        var _child_children_;
-        return child.type === 'heading' && ((_child_children_ = child.children[0]) === null || _child_children_ === void 0 ? void 0 : _child_children_.type) === 'text' && child.children[0].value === title;
-    };
-};
 var isHeading = function(child) {
     return child.type === 'heading';
 };
 var isParagraph = function(child) {
     return child.type === 'paragraph';
 };
-var codeBlockWithHeading = function(children) {
-    return function(lang, title) {
-        var block = children.find(function(child, index, array) {
-            if (!isCodeBlock(lang)(child)) return false;
-            var prevChild = array[index - 1];
-            if (prevChild === undefined) return false;
-            return isHeadingWithTitle(title)(prevChild);
-        });
-        if (block === undefined) throw new Error("Could not find ".concat(lang, ' codeblock with title "').concat(title, '"!'));
-        return block.value;
-    };
-};
 var headingWithLevel = function(children, level) {
     return children.filter(isHeading).find(function(param) {
         var depth = param.depth;
         return depth === level;
     });
 };
-export var getCodeBlock = function(markdown) {
-    return codeBlockWithHeading(remark().parse(markdown).children);
-};
 export var getHeading = function(markdown, level) {
     return headingWithLevel(remark().parse(markdown).children, level);
 };

package/dist/models/check-model-rules.js

@@ -1,15 +1,8 @@
 import chalk from 'chalk';
-import jsonata from 'jsonata';
 import assert from 'node:assert/strict';
 import { readFile, readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { FrontMatter, ModelIDRegExp } from './types.js';
-import { senMLtoLwM2M } from '../senml/senMLtoLwM2M.js';
-import { getCodeBlock } from '../markdown/getCodeBlock.js';
-import { getFrontMatter } from '../markdown/getFrontMatter.js';
-import { validateSenML } from '../senml/validateSenML.js';
-import { isRegisteredLwM2MObject } from '../lwm2m/isRegisteredLwM2MObject.js';
-import { hasValue } from '../senml/hasValue.js';
+import { ModelIDRegExp } from './types.js';
 import { parseREADME } from 'markdown/parseREADME.js';
 console.log(chalk.gray('Models rules check'));
 console.log('');
@@ -37,89 +30,6 @@ try {
             throw new Error("README is not valid for ".concat(model, "!"));
         }
         console.log(chalk.green('✔'), chalk.gray("README.md is valid"));
-        // Validate jsonata expressions
-        var hasTransforms = false;
-        var transformsFolder = path.join(modelDir, 'transforms');
-        try {
-            await stat(transformsFolder);
-            hasTransforms = true;
-            console.log(' ', chalk.gray('Transforms:'));
-        } catch (e) {
-            console.log(' ', chalk.gray('No transforms found.'));
-        }
-        if (hasTransforms) {
-            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-            try {
-                for(var _iterator1 = (await readdir(transformsFolder)).filter(function(f) {
-                    return f.endsWith('.md');
-                })[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                    var transform = _step1.value;
-                    console.log(' ', chalk.white('·'), chalk.white.bold(transform));
-                    var markdown = await readFile(path.join(modelDir, 'transforms', transform), 'utf-8');
-                    // Validate front-matter
-                    var type = getFrontMatter(markdown, FrontMatter).type;
-                    console.log(' ', chalk.green('✔'), chalk.gray("Type ".concat(type, " is valid")));
-                    var findBlock = getCodeBlock(markdown);
-                    var matchExpression = findBlock('jsonata', 'Match Expression');
-                    var transformExpression = findBlock('jsonata', 'Transform Expression');
-                    var inputExample = JSON.parse(findBlock('json', 'Input Example'));
-                    var resultExample = JSON.parse(findBlock('json', 'Result Example'));
-                    var selectResult = await jsonata(matchExpression).evaluate(inputExample);
-                    if (selectResult !== true) {
-                        throw new Error("The select expression did not evaluate to true with the given example.");
-                    }
-                    console.log(' ', chalk.green('✔'), chalk.gray('Select expression evaluated to true for the example input'));
-                    var transformResult = await jsonata(// For testing purposes this function call result is hardcoded
-                    transformExpression.replace('$millis()', '1699999999999')).evaluate(inputExample);
-                    var maybeValidSenML = validateSenML(transformResult.filter(hasValue));
-                    if ('errors' in maybeValidSenML) {
-                        console.error(maybeValidSenML.errors);
-                        throw new Error('The JSONata expression must produce valid SenML');
-                    }
-                    assert.deepEqual(maybeValidSenML.value, resultExample);
-                    console.log(' ', chalk.green('✔'), chalk.gray('Transformation result is valid SenML'));
-                    assert.deepEqual(maybeValidSenML.value, resultExample);
-                    console.log(' ', chalk.green('✔'), chalk.gray('The transformation result matches the example'));
-                    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
-                    try {
-                        // Validate
-                        for(var _iterator2 = senMLtoLwM2M(maybeValidSenML.value)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
-                            var object = _step2.value;
-                            if (!isRegisteredLwM2MObject(object, console.error)) {
-                                throw new Error('The LwM2M object must follow LwM2M schema definition');
-                            }
-                            console.log(' ', chalk.green('✔'), chalk.gray('SenML object is valid LwM2M'));
-                        }
-                    } catch (err) {
-                        _didIteratorError2 = true;
-                        _iteratorError2 = err;
-                    } finally{
-                        try {
-                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                                _iterator2.return();
-                            }
-                        } finally{
-                            if (_didIteratorError2) {
-                                throw _iteratorError2;
-                            }
-                        }
-                    }
-                }
-            } catch (err) {
-                _didIteratorError1 = true;
-                _iteratorError1 = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                        _iterator1.return();
-                    }
-                } finally{
-                    if (_didIteratorError1) {
-                        throw _iteratorError1;
-                    }
-                }
-            }
-        }
     }
 } catch (err) {
     _didIteratorError = true;

package/dist/models/models.js

@@ -1,4 +1,6 @@
-function _define_property(obj, key, value) {
+/**
+ * The Model IDs defined in this repo.
+ */ function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -11,127 +13,16 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-import { TransformType } from "./types.js";
 export var ModelID;
 (function(ModelID) {
-    ModelID["PCA20035_solar"] = "PCA20035+solar";
-    ModelID["Asset_tracker_v2_AWS"] = "asset_tracker_v2+AWS";
     ModelID["Kartverket_vasstandsdata"] = "kartverket-vasstandsdata";
 })(ModelID || (ModelID = {}));
-var _obj;
 /**
  * The models defined for hello.nrfcloud.com
- */ export var models = (_obj = {}, _define_property(_obj, "PCA20035+solar", {
-    "id": "PCA20035+solar",
-    "transforms": [
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'AIR_QUAL'",
-            "transform": "[\n    {\"bn\": \"14205/0/\", \"n\": \"10\", \"v\": $number(data), \"bt\": ts }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'BATTERY'",
-            "transform": "[\n    {\"bn\": \"14202/0/\", \"n\": \"0\", \"v\": $number(data), \"bt\": ts }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'BUTTON'",
-            "transform": "[\n    {\"bn\": \"14220/0/\", \"n\": \"0\", \"v\": $number(data), \"bt\": ts }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'DEVICE' and $exists(data.deviceInfo)",
-            "transform": "[\n    {\"bn\": \"14204/0/\", \"n\": \"0\", \"vs\": data.deviceInfo.imei, \"bt\": ts },\n    {\"n\": \"1\", \"vs\": data.deviceInfo.iccid },\n    {\"n\": \"2\", \"vs\": data.deviceInfo.modemFirmware },\n    {\"n\": \"3\", \"vs\": data.deviceInfo.appVersion },\n    {\"n\": \"4\", \"vs\": data.deviceInfo.board },\n    {\"n\": \"5\", \"vs\": data.deviceInfo.bat }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'SOLAR'",
-            "transform": "[\n    {\"bn\": \"14210/0/\", \"n\": \"0\", \"v\": $number(data), \"bt\": ts }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'GROUND_FIX' and $exists(data.lat) and $exists(data.lon) and $exists(data.uncertainty) and $exists(data.fulfilledWith)",
-            "transform": "[\n    {\"bn\": \"14201/1/\", \"n\": \"0\", \"v\": data.lat, \"bt\": $millis() },\n    {\"n\": \"1\", \"v\": data.lon },\n    {\"n\": \"3\", \"v\": data.uncertainty },\n    {\"n\": \"6\", \"vs\": data.fulfilledWith }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'GNSS'",
-            "transform": "[\n    {\"bn\": \"14201/0/\", \"n\": \"0\", \"v\": data.lat, \"bt\": ts },\n    {\"n\": \"1\", \"v\": data.lng },\n    {\"n\": \"2\", \"v\": data.alt },\n    {\"n\": \"3\", \"v\": data.acc },\n    {\"n\": \"4\", \"v\": data.spd },\n    {\"n\": \"5\", \"v\": data.hdg },\n    {\"n\": \"6\", \"vs\": \"GNSS\" }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'HUMID'",
-            "transform": "[\n    {\"bn\": \"14205/0/\", \"n\": \"1\", \"v\": $number(data), \"bt\": ts }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'DEVICE' and $exists(data.networkInfo)",
-            "transform": "[\n    {\"bn\": \"14203/0/\", \"n\": \"0\", \"vs\": data.networkInfo.networkMode, \"bt\": ts },\n    {\"n\": \"1\", \"v\": data.networkInfo.currentBand },\n    {\"n\": \"2\", \"v\": data.networkInfo.rsrp },\n    {\"n\": \"3\", \"v\": data.networkInfo.areaCode },\n    {\"n\": \"4\", \"v\": data.networkInfo.cellID },\n    {\"n\": \"5\", \"v\": data.networkInfo.mccmnc },\n    {\"n\": \"6\", \"vs\": data.networkInfo.ipAddress },\n    {\"n\": \"11\", \"v\": data.networkInfo.eest }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'AIR_PRESS'",
-            "transform": "[\n    {\"bn\": \"14205/0/\", \"n\": \"2\", \"v\": $number(data)*10, \"bt\": ts }\n]"
-        },
-        {
-            "type": TransformType.Messages,
-            "match": "appId = 'TEMP'",
-            "transform": "[\n    {\"bn\": \"14205/0/\", \"n\": \"0\", \"v\": $number(data), \"bt\": ts }\n]"
-        }
-    ],
-    "about": {
-        "title": "Thingy:91 with Solar Shield",
-        "description": "The Nordic Thingy:91 Solar Shield is a plug-and-play prototyping platform. Powerfoyle solar cell is mounted onto the Thingy to quickly get started exploring the endless possibilities with solar powered IoT applications and to develop products with eternal life or even battery-free products.\u200B\nThe Thingy:91 runs the asset_tracker_v2 application and sends messages to nRF Cloud using MQTT."
-    }
-}), _define_property(_obj, "asset_tracker_v2+AWS", {
-    "id": "asset_tracker_v2+AWS",
-    "transforms": [
-        {
-            "type": TransformType.Shadow,
-            "match": "$exists(state.reported.gnss)",
-            "transform": "[\n    {\"bn\": \"14201/0/\", \"n\": \"0\", \"v\": state.reported.gnss.v.lat, \"bt\": state.reported.gnss.ts },\n    {\"n\": \"1\", \"v\": state.reported.gnss.v.lng },\n    {\"n\": \"2\", \"v\": state.reported.gnss.v.alt },\n    {\"n\": \"3\", \"v\": state.reported.gnss.v.acc },\n    {\"n\": \"4\", \"v\": state.reported.gnss.v.spd },\n    {\"n\": \"5\", \"v\": state.reported.gnss.v.hdg },\n    {\"n\": \"6\", \"vs\": \"GNSS\" }\n]"
-        },
-        {
-            "type": TransformType.Shadow,
-            "match": "$exists(state.reported.bat)",
-            "transform": "[\n    {\"bn\": \"14202/0/\", \"n\": \"1\", \"v\": state.reported.bat.v/1000, \"bt\": state.reported.bat.ts }\n]"
-        },
-        {
-            "type": TransformType.Shadow,
-            "match": "$exists(state.reported.dev)",
-            "transform": "[\n    {\"bn\": \"14204/0/\", \"n\": \"0\", \"vs\": state.reported.dev.v.imei, \"bt\": state.reported.dev.ts },\n    {\"n\": \"1\", \"vs\": state.reported.dev.v.iccid },\n    {\"n\": \"2\", \"vs\": state.reported.dev.v.modV },\n    {\"n\": \"3\", \"vs\": state.reported.dev.v.appV },\n    {\"n\": \"4\", \"vs\": state.reported.dev.v.brdV }\n]"
-        },
-        {
-            "type": TransformType.Shadow,
-            "match": "$exists(state.reported.env)",
-            "transform": "[\n    {\"bn\": \"14205/0/\", \"n\": \"0\", \"v\": state.reported.env.v.temp, \"bt\": state.reported.env.ts },\n    {\"n\": \"1\", \"v\": state.reported.env.v.hum },\n    {\"n\": \"2\", \"v\": state.reported.env.v.atmp },\n    {\"n\": \"10\", \"v\": state.reported.env.v.bsec_iaq }\n]"
-        },
-        {
-            "type": TransformType.Shadow,
-            "match": "$exists(state.reported.fg)",
-            "transform": "[\n    {\"bn\": \"14202/0/\", \"n\": \"0\", \"v\": state.reported.fg.v.SoC, \"bt\": state.reported.fg.ts },\n    {\"n\": \"1\", \"v\": state.reported.fg.v.V/1000 },\n    {\"n\": \"2\", \"v\": state.reported.fg.v.I },\n    {\"n\": \"3\", \"v\": state.reported.fg.v.T = null ? null : state.reported.fg.v.T/10 },\n    {\"n\": \"4\", \"v\": state.reported.fg.v.TTF },\n    {\"n\": \"5\", \"v\": state.reported.fg.v.TTE }\n]"
-        },
-        {
-            "type": TransformType.Shadow,
-            "match": "$exists(state.reported.roam)",
-            "transform": "[\n    {\"bn\": \"14203/0/\", \"n\": \"0\", \"vs\": state.reported.roam.v.nw, \"bt\": state.reported.roam.ts },\n    {\"n\": \"1\", \"v\": state.reported.roam.v.band },\n    {\"bn\": \"14203/0/\", \"n\": \"2\", \"v\": state.reported.roam.v.rsrp, \"bt\": state.reported.roam.ts },\n    {\"n\": \"3\", \"v\": state.reported.roam.v.area },\n    {\"n\": \"4\", \"v\": state.reported.roam.v.cell },\n    {\"n\": \"5\", \"v\": state.reported.roam.v.mccmnc },\n    {\"n\": \"6\", \"vs\": state.reported.roam.v.ip },\n    {\"bn\": \"14203/0/\", \"n\": \"11\", \"v\": state.reported.roam.v.eest, \"bt\": state.reported.roam.ts }\n]"
-        },
-        {
-            "type": TransformType.Shadow,
-            "match": "$exists(state.reported.sol)",
-            "transform": "[\n    {\"bn\": \"14210/0/\", \"n\": \"0\", \"v\": state.reported.sol.v.gain, \"bt\": state.reported.sol.ts },\n    {\"n\": \"1\", \"v\": state.reported.sol.v.bat }\n]"
-        }
-    ],
-    "about": {
-        "title": "asset_tracker_v2 on AWS",
-        "description": "This implements the conversion for the asset_tracker_v2 message protocol when connected to AWS IoT."
-    }
-}), _define_property(_obj, "kartverket-vasstandsdata", {
+ */ export var models = _define_property({}, "kartverket-vasstandsdata", {
     "id": "kartverket-vasstandsdata",
-    "transforms": [],
     "about": {
         "title": "Kartverket Vasstandsdata",
         "description": "A simulated device reporting the current sea level as provided by the Kartverket's (Norwegian Mapping Authority) API for vasstandsdata (API for water level data).\nReports sea water level using the Object 14230.\nThe data is licensed by the Norwegian Mapping Authority\u2019s under the Creative Commons Attribution 4.0 International (CC BY 4.0) license."
     }
-}), _obj);
+});

package/dist/models/types.js

@@ -1,13 +1 @@
-import { Type } from '@sinclair/typebox';
 export var ModelIDRegExp = /^[A-Za-z0-9+_-]+$/;
-export var TransformType;
-(function(TransformType) {
-    TransformType["Shadow"] = "shadow";
-    TransformType["Messages"] = "messages";
-})(TransformType || (TransformType = {}));
-export var FrontMatter = Type.Object({
-    type: Type.Union([
-        Type.Literal('shadow'),
-        Type.Literal('messages')
-    ])
-});

package/models/README.md

@@ -4,7 +4,3 @@ Models are defined in the subdirectories of this folder.
 
 A model definition consists of a `README.md` that provides a human-friendly
 description of the model.
-
-Optionally, if the device does not send senML directly,
-[transforms can be defined](../README.md#model-transform-definitions) that
-convert the payload sent by the model to senML.