kuzzle-device-manager 2.0.0-rc21 → 2.0.0-rc22

package/lib/core-classes/MeasureService.js

@@ -8,7 +8,6 @@ const kuzzle_1 = require("kuzzle");
 const lodash_1 = __importDefault(require("lodash"));
 const InternalCollection_1 = require("../InternalCollection");
 const models_1 = require("../models");
-const types_1 = require("../types");
 class MeasureService {
     constructor(plugin, batchController, assetService, measuresRegister) {
         this.config = plugin.config;
@@ -33,14 +32,11 @@ class MeasureService {
      * @param deviceModel Model of the device
      * @param decodedPayloads `decodedPayload`
      * @param payloadUuids Payload Uuids that generated the measurements
-     * @param {object} options
-     * @param options.provisionDevice If true and a `decodedPayload`
-     * reference a nonexisting device, create this device
+     * @param options.provisionDevice If true and a `decodedPayload` reference a nonexisting device, create this device
      * @param options.refresh Wait for ES indexation
      */
-    async processDecodedPayload(deviceModel, decodedPayloads, payloadUuids, options) {
-        const references = Object.keys(decodedPayloads);
-        const devices = await this.getDevices(deviceModel, references, options);
+    async processDecodedPayload(deviceModel, decodedPayload, payloadUuids, options) {
+        const devices = await this.getDevices(deviceModel, decodedPayload.references, options);
         for (const device of devices) {
             let asset = null;
             if (device._source.assetId) {
@@ -52,7 +48,13 @@ class MeasureService {
                     this.app.log.error(`[${device._source.engineId}] Cannot find asset "${device._source.assetId}" linked to device "${device._id}".`);
                 }
             }
-            const measures = this.buildMeasures(device, asset, decodedPayloads[device._source.reference], payloadUuids);
+            const measurements = decodedPayload.getMeasurements(device._source.reference);
+            if (!measurements) {
+                this.app.log.warn(`Cannot find measurements for device "${device._source.reference}"`);
+                continue;
+            }
+            const measures = this.buildMeasures(device, asset, measurements, payloadUuids);
+            device.updateMetadata(decodedPayload.getMetadata(device._source.reference));
             /**
              * Event before starting to process new measures.
              *
@@ -63,14 +65,14 @@ class MeasureService {
                 await this.app.trigger(`engine:${device._source.engineId}:device-manager:measures:process:before`, { asset, device, measures });
             }
             device.updateMeasures(updatedMeasures);
-            await this.sdk.document.update(this.config.adminIndex, InternalCollection_1.InternalCollection.DEVICES, device._id, { measures: device._source.measures });
+            await this.sdk.document.update(this.config.adminIndex, InternalCollection_1.InternalCollection.DEVICES, device._id, device._source);
             if (device._source.engineId) {
-                await this.sdk.document.update(device._source.engineId, InternalCollection_1.InternalCollection.DEVICES, device._id, { measures: device._source.measures });
+                await this.sdk.document.update(device._source.engineId, InternalCollection_1.InternalCollection.DEVICES, device._id, device._source);
                 // @todo replace by batch.mCreate when available
                 await this.sdk.document.mCreate(device._source.engineId, InternalCollection_1.InternalCollection.MEASURES, updatedMeasures.map(measure => ({ body: measure })), { strict: true });
                 if (asset) {
                     asset.updateMeasures(updatedMeasures);
-                    await this.sdk.document.update(device._source.engineId, InternalCollection_1.InternalCollection.ASSETS, asset._id, { measures: asset._source.measures });
+                    await this.sdk.document.update(device._source.engineId, InternalCollection_1.InternalCollection.ASSETS, asset._id, asset._source);
                 }
             }
             /**
@@ -94,17 +96,19 @@ class MeasureService {
                 continue;
             }
             const deviceMeasureName = measurement.deviceMeasureName || measurement.type;
-            const assetMeasureName = asset === null ? undefined : this.findAssetMeasureName(device, asset, deviceMeasureName);
+            const assetMeasureName = asset === null
+                ? undefined
+                : this.findAssetMeasureName(device, asset, deviceMeasureName);
             const measureContent = {
                 assetMeasureName,
                 deviceMeasureName,
                 measuredAt: measurement.measuredAt,
                 origin: {
-                    assetId: asset ? asset._id : undefined,
+                    assetId: asset?._id,
                     deviceModel: device._source.model,
                     id: device._id,
                     payloadUuids,
-                    type: types_1.OriginType.DEVICE,
+                    type: 'device',
                 },
                 type: measurement.type,
                 unit: this.measuresRegister.get(measurement.type).unit,
@@ -114,8 +118,11 @@ class MeasureService {
         }
         return measures;
     }
+    /**
+     * Get devices or create missing ones (when auto-provisionning is enabled)
+     */
     async getDevices(deviceModel, references, { refresh }) {
-        let devices = [];
+        const devices = [];
         // @todo replace with batch.mGet when available
         const { successes, errors } = await this.sdk.document.mGet(this.config.adminIndex, InternalCollection_1.InternalCollection.DEVICES, references.map(reference => models_1.Device.id(deviceModel, reference)));
         for (const { _source, _id } of successes) {
@@ -172,7 +179,7 @@ class MeasureService {
     async registerByAsset(engineId, assetId, jsonMeasurements, kuid, { refresh, strict } = {}) {
         const invalidMeasurements = [];
         const validMeasures = [];
-        const asset = await this.assetService.getAsset(engineId, assetId);
+        const asset = await this.assetService.get(engineId, assetId);
         if (!asset) {
             throw new kuzzle_1.NotFoundError(`Asset ${assetId} does not exist`);
         }
@@ -184,11 +191,11 @@ class MeasureService {
                 validMeasures.push({
                     assetMeasureName,
                     deviceMeasureName: null,
-                    measuredAt: measurement.measuredAt ? measurement.measuredAt : Date.now(),
+                    measuredAt: measurement.measuredAt || Date.now(),
                     origin: {
                         assetId,
                         id: kuid,
-                        type: types_1.OriginType.USER,
+                        type: 'user',
                     },
                     type: measurement.type,
                     unit: this.measuresRegister.get(measurement.type).unit,
@@ -235,8 +242,12 @@ class MeasureService {
     }
     findAssetMeasureName(device, asset, deviceMeasureName) {
         const deviceLink = asset._source.deviceLinks.find(link => link.deviceId === device._id);
+        // TOSEE Convert to assert ?
+        if (!deviceLink) {
+            throw new kuzzle_1.PluginImplementationError(`The device "${device._id}" is not linked to the asset "${asset._id}"`);
+        }
         const measureLink = deviceLink.measureNamesLinks.find(nameLink => nameLink.deviceMeasureName === deviceMeasureName);
-        return measureLink.assetMeasureName;
+        return measureLink ? measureLink.assetMeasureName : undefined;
     }
 }
 exports.MeasureService = MeasureService;

package/lib/core-classes/PayloadService.d.ts

@@ -2,16 +2,14 @@ import { BatchController, KuzzleRequest } from 'kuzzle';
 import { DeviceManagerPlugin } from '../DeviceManagerPlugin';
 import { Decoder } from './Decoder';
 import { MeasureService } from './MeasureService';
-import { MeasuresRegister } from './registers/MeasuresRegister';
 export declare class PayloadService {
     private config;
     private context;
     private batch;
-    private measuresRegister;
     private measureService;
     private get sdk();
     private get app();
-    constructor(plugin: DeviceManagerPlugin, batchController: BatchController, measuresRegister: MeasuresRegister, measureService: MeasureService);
+    constructor(plugin: DeviceManagerPlugin, batchController: BatchController, measureService: MeasureService);
     /**
      * Process a payload by validating and decode it with the `decoder` associated
      * with the device model. It :
@@ -23,4 +21,10 @@ export declare class PayloadService {
     }): Promise<void | {
         valid: boolean;
     }>;
+    /**
+     * Method used to save the payload and catch + log the error if any.
+     *
+     * This method never returns a rejected promise.
+     */
+    private savePayload;
 }

package/lib/core-classes/PayloadService.js

@@ -3,11 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PayloadService = void 0;
 const uuid_1 = require("uuid");
 class PayloadService {
-    constructor(plugin, batchController, measuresRegister, measureService) {
+    constructor(plugin, batchController, measureService) {
         this.config = plugin.config;
         this.context = plugin.context;
         this.measureService = measureService;
-        this.measuresRegister = measuresRegister;
         this.batch = batchController;
     }
     get sdk() {
@@ -37,16 +36,24 @@ class PayloadService {
             throw error;
         }
         finally {
-            await this.batch.create(this.config.adminIndex, 'payloads', {
-                deviceModel: decoder.deviceModel,
-                payload,
-                uuid,
-                valid,
-            }, uuid);
+            await this.savePayload(decoder.deviceModel, uuid, valid, payload);
         }
         const decodedPayload = await decoder.decode(payload, request);
         return this.measureService.processDecodedPayload(decoder.deviceModel, decodedPayload, [uuid], { refresh });
     }
+    /**
+     * Method used to save the payload and catch + log the error if any.
+     *
+     * This method never returns a rejected promise.
+     */
+    async savePayload(deviceModel, uuid, valid, payload) {
+        try {
+            await this.batch.create(this.config.adminIndex, 'payloads', { deviceModel, payload, uuid, valid }, uuid);
+        }
+        catch (error) {
+            this.app.log.error(`Cannot save the payload from "${deviceModel}": ${error}`);
+        }
+    }
 }
 exports.PayloadService = PayloadService;
 //# sourceMappingURL=PayloadService.js.map

package/lib/core-classes/registers/DecodersRegister.d.ts

@@ -1,14 +1,20 @@
 import { ControllerDefinition, PluginContext } from 'kuzzle';
+import { MeasuresRegister } from './MeasuresRegister';
 import { DecoderContent } from '../../types';
 import { Decoder } from '../Decoder';
 import { PayloadService } from '../PayloadService';
 export declare class DecodersRegister {
+    private measuresRegister;
     private context;
+    /**
+     * Map<deviceModel, Decoder>
+     */
     private _decoders;
     private get sdk();
-    getByDeviceModel(deviceModel: string): Decoder;
     get decoders(): Decoder[];
+    constructor(measuresRegister: MeasuresRegister);
     init(context: PluginContext): void;
+    get(deviceModel: string): Decoder;
     list(): DecoderContent[];
     /**
      * Registers a new decoder for a device model.

package/lib/core-classes/registers/DecodersRegister.js

@@ -3,21 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DecodersRegister = void 0;
 const kuzzle_1 = require("kuzzle");
 class DecodersRegister {
-    constructor() {
+    constructor(measuresRegister) {
+        /**
+         * Map<deviceModel, Decoder>
+         */
         this._decoders = new Map();
+        this.measuresRegister = measuresRegister;
     }
     get sdk() {
         return this.context.accessors.sdk;
     }
-    getByDeviceModel(deviceModel) {
-        return this._decoders.get(deviceModel);
-    }
     get decoders() {
         return Array.from(this._decoders.values());
     }
     init(context) {
         this.context = context;
     }
+    get(deviceModel) {
+        if (!this._decoders.has(deviceModel)) {
+            throw new kuzzle_1.BadRequestError(`Cannot find decoder for "${deviceModel}"`);
+        }
+        return this._decoders.get(deviceModel);
+    }
     list() {
         const decoders = this.decoders.map(decoder => decoder.serialize());
         return decoders;
@@ -35,7 +42,18 @@ class DecodersRegister {
      * @returns Corresponding API action requestPayload
      */
     register(decoder) {
+        if (!decoder.deviceModel) {
+            decoder.deviceModel = decoder.constructor.name.replace('Decoder', '');
+        }
         decoder.action = decoder.action || kuzzle_1.Inflector.kebabCase(decoder.deviceModel);
+        if (decoder.measures.length === 0) {
+            throw new kuzzle_1.PluginImplementationError(`Decoder "${decoder.deviceModel}" did not declare any measures in the "decoder.measures" property.`);
+        }
+        for (const measureDeclaration of decoder.measures) {
+            if (!this.measuresRegister.has(measureDeclaration.type)) {
+                throw new kuzzle_1.PluginImplementationError(`Decoder "${decoder.deviceModel}" cannot register unknown measure type "${measureDeclaration.type}"`);
+            }
+        }
         if (this._decoders.has(decoder.deviceModel)) {
             throw new kuzzle_1.PluginImplementationError(`Decoder for device model "${decoder.deviceModel}" already registered`);
         }

package/lib/measures/BatteryMeasure.d.ts

@@ -1,7 +1,5 @@
 import { Measurement, MeasureDefinition } from '../types';
-export interface BatteryMeasurement extends Measurement {
-    values: {
-        battery: number;
-    };
-}
+export declare type BatteryMeasurement = Measurement<{
+    battery: number;
+}>;
 export declare const batteryMeasure: MeasureDefinition;

package/lib/measures/HumidityMeasure.d.ts

@@ -1,7 +1,5 @@
 import { Measurement, MeasureDefinition } from '../types';
-export interface HumidityMeasurement extends Measurement {
-    values: {
-        humidity: number;
-    };
-}
+export declare type HumidityMeasurement = Measurement<{
+    humidity: number;
+}>;
 export declare const humidityMeasure: MeasureDefinition;

package/lib/measures/MovementMeasure.d.ts

@@ -1,7 +1,5 @@
 import { Measurement, MeasureDefinition } from '../types';
-export interface MovementMeasurement extends Measurement {
-    values: {
-        movement: boolean;
-    };
-}
+export declare type MovementMeasurement = Measurement<{
+    movement: boolean;
+}>;
 export declare const movementMeasure: MeasureDefinition;

package/lib/measures/PositionMeasure.d.ts

@@ -1,12 +1,10 @@
 import { Measurement, MeasureDefinition } from '../types';
-export interface PositionMeasurement extends Measurement {
-    values: {
-        position: {
-            lat: number;
-            lon: number;
-        };
-        altitude?: number;
-        accuracy?: number;
+export declare type PositionMeasurement = Measurement<{
+    position: {
+        lat: number;
+        lon: number;
     };
-}
+    altitude?: number;
+    accuracy?: number;
+}>;
 export declare const positionMeasure: MeasureDefinition;

package/lib/measures/TemperatureMeasure.d.ts

@@ -1,7 +1,5 @@
-import { Measurement, MeasureDefinition } from '../types';
-export interface TemperatureMeasurement extends Measurement {
-    values: {
-        temperature: number;
-    };
-}
+import { MeasureDefinition, Measurement } from '../types';
+export declare type TemperatureMeasurement = Measurement<{
+    temperature: number;
+}>;
 export declare const temperatureMeasure: MeasureDefinition;

package/lib/models/BaseAsset.js

@@ -8,6 +8,9 @@ class BaseAsset {
         if (!Array.isArray(this._source.measures)) {
             this._source.measures = [];
         }
+        if (!Array.isArray(this._source.deviceLinks)) {
+            this._source.deviceLinks = [];
+        }
     }
     static id(type, model, reference) {
         return `${type}-${model}-${reference}`;
@@ -18,7 +21,7 @@ class BaseAsset {
     unlinkDevice(device) {
         // TOSEE : Iterate over all or assert there is
         // only one link and remove first match?
-        const linkToKeep = this._source.deviceLinks.filter((deviceLink) => deviceLink.deviceId !== device._id);
+        const linkToKeep = this._source.deviceLinks.filter(link => link.deviceId !== device._id);
         this._source.deviceLinks = linkToKeep;
     }
     /**

package/lib/models/Device.d.ts

@@ -1,3 +1,4 @@
+import { JSONObject } from 'kuzzle-sdk';
 import { LinkRequest } from '../types/Request';
 import { DeviceContent, MeasureContent } from '../types';
 export declare class Device {
@@ -17,4 +18,5 @@ export declare class Device {
      * Only keep the latest measures
      */
     updateMeasures(newMeasures: MeasureContent[]): void;
+    updateMetadata(metadata: JSONObject): void;
 }

package/lib/models/Device.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = void 0;
+const lodash_1 = __importDefault(require("lodash"));
 class Device {
     constructor(content, _id) {
         this._id = _id || Device.id(content.model, content.reference);
@@ -43,6 +47,9 @@ class Device {
             }
         }
     }
+    updateMetadata(metadata) {
+        this._source.metadata = lodash_1.default.merge(this._source.metadata, metadata);
+    }
 }
 exports.Device = Device;
 //# sourceMappingURL=Device.js.map

package/lib/types/DecodedPayload.d.ts

@@ -1,33 +1,46 @@
+import { JSONObject } from 'kuzzle';
+import { Decoder } from '../core-classes/Decoder';
 import { Measurement } from './measures/MeasureContent';
 /**
- * Record containing decoded measurements for each device.
- *
- * Record<deviceReference, Measurement[]>
- *
- * @example
- * const decodedPayload: DecodedPayload = {
- *   'BZH42AZF': [
- *     {
- *       deviceMeasureName: 'battery',
- *       measuredAt: 1655379939496,
- *       type: 'battery',
- *       values: { battery: 32 },
- *     },
- *   ],
- *   'IS7L8HK': [
- *     {
- *       deviceMeasureName: 'internal_temperature',
- *       measuredAt: 1655379939496,
- *       type: 'temperature',
- *       values: { temperature: -3 },
- *     },
- *     {
- *       deviceMeasureName: 'external_temperature',
- *       measuredAt: 1655379939496,
- *       type: 'temperature',
- *       values: { temperature: 39 },
- *     },
- *   ],
- * };
+ * Class containing the decoded measures.
  */
-export declare type DecodedPayload = Record<string, Measurement[]>;
+export declare class DecodedPayload<TDecoder extends Decoder = Decoder> {
+    decoder: TDecoder;
+    /**
+     * Measurements per device.
+     *
+     * Record<deviceReference, Measurement[]>
+     */
+    private measurementsByDevice;
+    /**
+     * Metadata per device.
+     */
+    private metadataByDevice;
+    constructor(decoder: TDecoder);
+    get references(): string[];
+    /**
+     * Add a new measure into the decoded payload
+     *
+     * @param deviceReference Device reference
+     * @param measureName Name of the decoded measure
+     * @param measurement Measurement object
+     */
+    addMeasurement<TMeasurement extends Measurement = Measurement>(deviceReference: string, measureName: TDecoder['measures'][number]['name'], measurement: TMeasurement): void;
+    /**
+     * Add metadata values for a Device.
+     *
+     * Metadata should have been declared on the plugin to be used.
+     *
+     * @param deviceReference Device reference
+     * @param metadata Object containing metadata values
+     */
+    addMetadata(deviceReference: string, metadata: JSONObject): void;
+    /**
+     * Gets the measurements decoded for a device
+     */
+    getMeasurements(deviceReference: string): Measurement[];
+    /**
+     * Get the metadata for a device
+     */
+    getMetadata(deviceReference: string): JSONObject;
+}

package/lib/types/DecodedPayload.js

@@ -1,4 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// @todo we should have an intermediary object
+exports.DecodedPayload = void 0;
+const kuzzle_1 = require("kuzzle");
+/**
+ * Class containing the decoded measures.
+ */
+class DecodedPayload {
+    constructor(decoder) {
+        /**
+         * Measurements per device.
+         *
+         * Record<deviceReference, Measurement[]>
+         */
+        this.measurementsByDevice = {};
+        /**
+         * Metadata per device.
+         */
+        this.metadataByDevice = {};
+        this.decoder = decoder;
+    }
+    get references() {
+        return Object.keys(this.measurementsByDevice);
+    }
+    /**
+     * Add a new measure into the decoded payload
+     *
+     * @param deviceReference Device reference
+     * @param measureName Name of the decoded measure
+     * @param measurement Measurement object
+     */
+    addMeasurement(deviceReference, measureName, measurement) {
+        if (!this.decoder.measureNames.includes(measureName)) {
+            throw new kuzzle_1.PluginImplementationError(`Decoder "${this.decoder.deviceModel}" has no measure named "${measureName}"`);
+        }
+        if (!this.measurementsByDevice[deviceReference]) {
+            this.measurementsByDevice[deviceReference] = [];
+        }
+        measurement.deviceMeasureName = measureName;
+        this.measurementsByDevice[deviceReference].push(measurement);
+    }
+    /**
+     * Add metadata values for a Device.
+     *
+     * Metadata should have been declared on the plugin to be used.
+     *
+     * @param deviceReference Device reference
+     * @param metadata Object containing metadata values
+     */
+    addMetadata(deviceReference, metadata) {
+        if (!this.metadataByDevice[deviceReference]) {
+            this.metadataByDevice[deviceReference] = {};
+        }
+        this.metadataByDevice[deviceReference] = {
+            ...this.metadataByDevice[deviceReference],
+            ...metadata,
+        };
+    }
+    /**
+     * Gets the measurements decoded for a device
+     */
+    getMeasurements(deviceReference) {
+        return this.measurementsByDevice[deviceReference];
+    }
+    /**
+     * Get the metadata for a device
+     */
+    getMetadata(deviceReference) {
+        return this.metadataByDevice[deviceReference];
+    }
+}
+exports.DecodedPayload = DecodedPayload;
 //# sourceMappingURL=DecodedPayload.js.map

package/lib/types/DecoderContent.d.ts

@@ -1,5 +1,5 @@
 import { DecoderMeasures } from '../core-classes/Decoder';
 export interface DecoderContent {
     deviceModel: string;
-    decoderMeasures: DecoderMeasures;
+    measures: DecoderMeasures;
 }

package/lib/types/index.d.ts

@@ -5,3 +5,5 @@ export * from './measures/MeasureDefinition';
 export * from './DecoderContent';
 export * from './DecodedPayload';
 export * from './DeviceManagerConfiguration';
+export * from './MetadataContent';
+export * from './AssetCategoryContent';

package/lib/types/index.js

@@ -21,4 +21,6 @@ __exportStar(require("./measures/MeasureDefinition"), exports);
 __exportStar(require("./DecoderContent"), exports);
 __exportStar(require("./DecodedPayload"), exports);
 __exportStar(require("./DeviceManagerConfiguration"), exports);
+__exportStar(require("./MetadataContent"), exports);
+__exportStar(require("./AssetCategoryContent"), exports);
 //# sourceMappingURL=index.js.map

package/lib/types/measures/MeasureContent.d.ts

@@ -5,8 +5,10 @@ import { MeasureUnit } from './MeasureDefinition';
  *
  * This interface should be extended and the `values` property specialized
  * to declare new measurement type.
+ *
+ * @todo cannot use type when iterating on measure of the pipe event
  */
-export interface Measurement {
+export interface Measurement<TMeasurementValues extends JSONObject = JSONObject> {
     /**
      * Type of the measure. (e.g. "temperature")
      * The type name is also the name of the sub-property to look at
@@ -18,7 +20,7 @@ export interface Measurement {
      *
      * This should be specialized by child interfaces.
      */
-    values: JSONObject;
+    values: TMeasurementValues;
     /**
      * Micro Timestamp of the measurement time.
      */
@@ -27,19 +29,21 @@ export interface Measurement {
      * Name given by the decoder to the measure.
      *
      * By default, it's the type of the measure
+     * @todo device.name
      */
     deviceMeasureName?: string;
 }
-export interface AssetMeasurement extends Measurement {
+export interface AssetMeasurement<TMeasurementValues extends JSONObject = JSONObject> extends Measurement<TMeasurementValues> {
     /**
      * Name given by the `deviceLink` of the linked asset.
+     * @todo asset.name
      */
     assetMeasureName: string;
 }
 /**
  * Represent the full content of a measure document.
  */
-export interface MeasureContent extends KDocumentContent, AssetMeasurement {
+export interface MeasureContent<TMeasurementValues extends JSONObject = JSONObject> extends KDocumentContent, AssetMeasurement<TMeasurementValues> {
     /**
      * Measurement self-description.
      */
@@ -51,7 +55,7 @@ export interface MeasureContent extends KDocumentContent, AssetMeasurement {
         /**
          * From what the measure has been pushed.
          */
-        type: OriginType;
+        type: 'user' | 'device';
         /**
          * Payload uuid that was used to create this measure.
          */
@@ -72,10 +76,3 @@ export interface MeasureContent extends KDocumentContent, AssetMeasurement {
         assetId?: string;
     };
 }
-/**
- * From where the measure has been pushed
- */
-export declare enum OriginType {
-    USER = "user",
-    DEVICE = "device"
-}

package/lib/types/measures/MeasureContent.js

@@ -1,12 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OriginType = void 0;
-/**
- * From where the measure has been pushed
- */
-var OriginType;
-(function (OriginType) {
-    OriginType["USER"] = "user";
-    OriginType["DEVICE"] = "device";
-})(OriginType = exports.OriginType || (exports.OriginType = {}));
 //# sourceMappingURL=MeasureContent.js.map

package/lib/types/measures/MeasureDefinition.d.ts

@@ -20,7 +20,7 @@ export interface MeasureUnit {
  *
  * @example
  * {
- *   measurementMappings: { temperature: { type: 'float' } },
+ *   valuesMappings: { temperature: { type: 'float' } },
  *   unit: {
  *     name: 'Degree',
  *     sign: '°',