kuzzle-device-manager-types 2.0.0-rc35 → 2.0.0

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-export * from './lib/core/DeviceManagerPlugin';
-export * from './lib/core/DeviceManagerConfiguration';
-export * from './lib/modules/asset';
-export * from './lib/modules/device';
-export * from './lib/modules/measure';
-export * from './lib/modules/decoder';
-export * from './lib/modules/shared';
-export * from './lib/modules/model';
+export * from './lib/core/exports';
+export * from './lib/modules/asset/exports';
+export * from './lib/modules/device/exports';
+export * from './lib/modules/measure/exports';
+export * from './lib/modules/decoder/exports';
+export * from './lib/modules/shared/exports';
+export * from './lib/modules/model/exports';

package/dist/lib/core/DeviceManagerEngine.d.ts

@@ -20,9 +20,10 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
         collections: any[];
     }>;
     onDelete(index: string): Promise<{
-        collections: string[];
+        collections: InternalCollection[];
     }>;
     createAssetsCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    createAssetsHistoryCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
     private getDigitalTwinMappings;
     createDevicesCollection(engineId: string): Promise<InternalCollection>;
     createMeasuresCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;

package/dist/lib/core/DeviceManagerPlugin.d.ts

@@ -1,8 +1,8 @@
 import { Plugin, PluginContext, JSONObject } from "kuzzle";
 import { MeasureDefinition } from "../modules/measure";
 import { AssetModelDefinition, DeviceModelDefinition } from "../modules/model";
+import { KuzzleRole } from "../modules/shared";
 import { DeviceManagerConfiguration } from "./DeviceManagerConfiguration";
-import { KuzzleRole } from "lib/modules/shared/types/KuzzleRole";
 export declare class DeviceManagerPlugin extends Plugin {
     config: DeviceManagerConfiguration;
     roles: KuzzleRole[];
@@ -24,7 +24,7 @@ export declare class DeviceManagerPlugin extends Plugin {
          *
          * @param engineGroup Engine group name
          * @param model Name of the asset model
-         * @param definition.measuresNames Array describing measures names and types
+         * @param definition.measures Array describing measures names and types
          * @param definition.metadataMappings Metadata mappings definition
          * @param definition.defaultMetadata Default metadata values
          *
@@ -32,9 +32,9 @@ export declare class DeviceManagerPlugin extends Plugin {
          * ```
          * deviceManager.models.registerAsset(
          *   "logistic",
-         *   "container",
+         *   "Container",
          *   {
-         *     measuresNames: [
+         *     measures: [
          *       { name: "temperatureExt", type: "temperature" },
          *       { name: "temperatureInt", type: "temperature" },
          *       { name: "position", type: "position" },

package/dist/lib/core/InternalCollection.d.ts

@@ -1,5 +1,6 @@
 export declare enum InternalCollection {
     ASSETS = "assets",
+    ASSETS_HISTORY = "assets-history",
     DEVICES = "devices",
     MEASURES = "measures",
     MODELS = "models",

package/dist/lib/core/exports.d.ts

@@ -0,0 +1,2 @@
+export * from "./DeviceManagerConfiguration";
+export * from "./DeviceManagerPlugin";

package/dist/lib/core/registers/ModelsRegister.d.ts

@@ -1,5 +1,6 @@
 import { JSONObject } from "kuzzle";
-import { MeasureDefinition } from "lib/modules/measure";
+import { NamedMeasures } from "../../modules/decoder";
+import { MeasureDefinition } from "../../modules/measure";
 import { DeviceManagerPlugin } from "../DeviceManagerPlugin";
 export declare class ModelsRegister {
     private config;
@@ -10,8 +11,8 @@ export declare class ModelsRegister {
     private get sdk();
     init(plugin: DeviceManagerPlugin): void;
     loadModels(): Promise<void>;
-    registerAsset(engineGroup: string, model: string, metadataMappings: JSONObject, measures: Record<string, string>, defaultMetadata?: JSONObject): void;
-    registerDevice(model: string, measures: Record<string, string>, metadataMappings?: JSONObject, defaultMetadata?: JSONObject): void;
+    registerAsset(engineGroup: string, model: string, measures: NamedMeasures, metadataMappings?: JSONObject, defaultMetadata?: JSONObject): void;
+    registerDevice(model: string, measures: NamedMeasures, metadataMappings?: JSONObject, defaultMetadata?: JSONObject): void;
     registerMeasure(type: string, measureDefinition: MeasureDefinition): void;
     private load;
 }

package/dist/lib/modules/asset/AssetHistoryService.d.ts

@@ -0,0 +1,11 @@
+import { KDocument } from "kuzzle";
+import { DeviceManagerPlugin } from "../../core";
+import { AssetHistoryEvent } from "./types/AssetHistoryContent";
+import { AssetContent } from "./types/AssetContent";
+export declare class AssetHistoryService {
+    private context;
+    private config;
+    private get sdk();
+    constructor(plugin: DeviceManagerPlugin);
+    add<TAssetHistoryEvent extends AssetHistoryEvent>(engineId: string, event: TAssetHistoryEvent, asset: KDocument<AssetContent>): Promise<void>;
+}

package/dist/lib/modules/asset/AssetModule.d.ts

@@ -1,6 +1,7 @@
 import { Module } from "../shared/Module";
 export declare class AssetModule extends Module {
     private assetService;
+    private assetHistoryService;
     private assetController;
     init(): Promise<void>;
 }

package/dist/lib/modules/asset/AssetService.d.ts

@@ -1,14 +1,17 @@
-import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle";
+import { JSONObject, KDocument, KHit, SearchResult, User } from "kuzzle";
 import { MeasureContent } from "../measure/";
 import { Metadata } from "../shared";
 import { DeviceManagerPlugin } from "../../core";
 import { AssetContent } from "./types/AssetContent";
+import { AssetHistoryService } from "./AssetHistoryService";
 export declare class AssetService {
     private context;
     private config;
+    private assetHistoryService;
     private get sdk();
     private get app();
-    constructor(plugin: DeviceManagerPlugin);
+    private get impersonatedSdk();
+    constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService);
     /**
      * Returns measures history for an asset
      *
@@ -24,13 +27,16 @@ export declare class AssetService {
         endAt?: string;
     }): Promise<KDocument<MeasureContent>[]>;
     get(engineId: string, assetId: string): Promise<KDocument<AssetContent>>;
-    update(engineId: string, assetId: string, metadata: Metadata, { refresh }: {
+    /**
+     * Updates an asset metadata
+     */
+    update(user: User, engineId: string, assetId: string, metadata: Metadata, { refresh }: {
         refresh: any;
     }): Promise<KDocument<AssetContent>>;
-    create(engineId: string, model: string, reference: string, metadata: JSONObject, { refresh }: {
+    create(user: User, engineId: string, model: string, reference: string, metadata: JSONObject, { refresh }: {
         refresh: any;
     }): Promise<KDocument<AssetContent>>;
-    delete(engineId: string, assetId: string, { refresh, strict }: {
+    delete(user: User, engineId: string, assetId: string, { refresh, strict }: {
         refresh: any;
         strict: boolean;
     }): Promise<void>;

package/dist/lib/modules/asset/collections/assetsHistoryMappings.d.ts

@@ -0,0 +1,63 @@
+export declare const assetsHistoryMappings: {
+    dynamic: string;
+    properties: {
+        event: {
+            properties: {
+                name: {
+                    type: string;
+                };
+                measure: {
+                    properties: {
+                        names: {
+                            type: string;
+                        };
+                    };
+                };
+                metadata: {
+                    properties: {
+                        names: {
+                            type: string;
+                        };
+                    };
+                };
+                link: {
+                    properties: {
+                        deviceId: {
+                            type: string;
+                        };
+                    };
+                };
+                unlink: {
+                    properties: {
+                        deviceId: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+        };
+        id: {
+            type: string;
+        };
+        asset: {
+            properties: {
+                _kuzzle_info: {
+                    properties: {
+                        author: {
+                            type: string;
+                        };
+                        createdAt: {
+                            type: string;
+                        };
+                        updatedAt: {
+                            type: string;
+                        };
+                        updater: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

package/dist/lib/modules/asset/collections/assetsMappings.d.ts

@@ -28,9 +28,15 @@ export declare const assetsMappings: {
                 _id: {
                     type: string;
                 };
-                measures: {
-                    dynamic: string;
-                    properties: {};
+                measureNames: {
+                    properties: {
+                        asset: {
+                            type: string;
+                        };
+                        device: {
+                            type: string;
+                        };
+                    };
                 };
             };
         };

package/dist/lib/modules/asset/exports.d.ts

@@ -0,0 +1,6 @@
+export * from "./types/AssetContent";
+export * from "./types/AssetHistoryContent";
+export * from "./types/AssetEvents";
+export * from "./types/AssetApi";
+export * from "./roles/RoleAssetsAdmin";
+export * from "./roles/RoleAssetsReader";

package/dist/lib/modules/asset/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./collections/assetsMappings";
+export * from "./collections/assetsHistoryMappings";
 export * from "./types/AssetContent";
+export * from "./types/AssetHistoryContent";
 export * from "./types/AssetEvents";
 export * from "./types/AssetApi";
 export * from "./model/AssetSerializer";

package/dist/lib/modules/asset/roles/RoleAssetsReader.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleRole } from "lib/modules/shared/types/KuzzleRole";
+import { KuzzleRole } from "../../shared/types/KuzzleRole";
 /**
  * This role only gives a read-only access to assets and their models.
  *

package/dist/lib/modules/asset/types/AssetContent.d.ts

@@ -13,17 +13,20 @@ export interface AssetContent<TMeasures extends JSONObject = any, TMetadata exte
          */
         _id: string;
         /**
-         * Names lookup table for measures
+         * Names of the linked measures
          *
-         * Record<deviceName, assetName>
+         * Array<{ asset: string, device: string }>
          *
          * @example
          *
-         * {
-         *   "temperature": "externalTemperature",
-         * }
+         * [
+         *   { asset: "externalTemperature", device: "temperature" }
+         * ]
          */
-        measures: Record<string, string>;
+        measureNames: Array<{
+            asset: string;
+            device: string;
+        }>;
     }>;
 }
 /**

package/dist/lib/modules/asset/types/AssetEvents.d.ts

@@ -1,6 +1,7 @@
 import { KDocument } from "kuzzle";
 import { Metadata } from "../../../modules/shared";
 import { AssetContent } from "./AssetContent";
+import { AssetHistoryEvent } from "./AssetHistoryContent";
 export type EventAssetUpdateBefore = {
     name: "device-manager:asset:update:before";
     args: [{
@@ -15,3 +16,15 @@ export type EventAssetUpdateAfter = {
         metadata: Metadata;
     }];
 };
+/**
+ * @internal
+ */
+export type AskAssetHistoryAdd<TAssetHistoryEvent extends AssetHistoryEvent> = {
+    name: "ask:device-manager:asset:history:add";
+    payload: {
+        engineId: string;
+        event: TAssetHistoryEvent;
+        asset: KDocument<AssetContent>;
+    };
+    result: void;
+};

package/dist/lib/modules/asset/types/AssetHistoryContent.d.ts

@@ -0,0 +1,50 @@
+import { JSONObject, KDocumentContent } from "kuzzle";
+import { Metadata } from "../../shared";
+import { AssetContent } from "./AssetContent";
+export type AssetHistoryEventMeasure = {
+    name: "measure";
+    measure: {
+        names: string[];
+    };
+};
+export type AssetHistoryEventMetadata = {
+    name: "metadata";
+    metadata: {
+        names: string[];
+    };
+};
+export type AssetHistoryEventLink = {
+    name: "link";
+    link: {
+        deviceId: string;
+    };
+};
+export type AssetHistoryEventUnlink = {
+    name: "unlink";
+    unlink: {
+        deviceId: string;
+    };
+};
+export type AssetHistoryEvent = AssetHistoryEventMeasure | AssetHistoryEventMetadata | AssetHistoryEventLink | AssetHistoryEventUnlink;
+/**
+ * Asset History document content
+ */
+export interface AssetHistoryContent<TAssetHistoryEvent extends AssetHistoryEvent = any, TMeasures extends JSONObject = any, TMetadata extends Metadata = any> extends KDocumentContent {
+    /**
+     * Name of the event who caused the historization
+     *
+     *  - `measure` a new measure has been received
+     *  - `metadata` the asset metadata has been updated
+     *  - `link` a device has been linked or unlinked to the asset
+     *  - `unlink` a device has been unlinked from the asset
+     */
+    event: TAssetHistoryEvent;
+    /**
+     * ID of the historized asset
+     */
+    id: string;
+    /**
+     * Asset content after the event
+     */
+    asset: AssetContent<TMeasures, TMetadata>;
+}

package/dist/lib/modules/decoder/exports.d.ts

@@ -0,0 +1,6 @@
+export * from "./types/DecoderApi";
+export * from "./types/DecoderContent";
+export * from "./DecodedPayload";
+export * from "./Decoder";
+export * from "./roles/RolePayloadsAll";
+export * from "./roles/RoleDecodersAdmin";

package/dist/lib/modules/device/DeviceService.d.ts

@@ -1,12 +1,14 @@
-import { JSONObject, KDocument, KHit, Plugin, SearchResult } from "kuzzle";
+import { JSONObject, KDocument, KHit, Plugin, SearchResult, User } from "kuzzle";
 import { AssetContent } from "./../asset";
 import { Metadata } from "../shared";
 import { DeviceContent } from "./types/DeviceContent";
+import { ApiDeviceLinkAssetRequest } from "./exports";
 export declare class DeviceService {
     private config;
     private context;
     private get sdk();
     private get app();
+    private get impersonatedSdk();
     constructor(plugin: Plugin);
     /**
      * Create a new device.
@@ -15,15 +17,15 @@ export declare class DeviceService {
      * method since in this case "engineId" is not really an engine ID but still
      * required as an argument (in part to check the tenant rights)
      */
-    create(model: string, reference: string, metadata: JSONObject, { engineId, refresh, }?: {
+    create(user: User, model: string, reference: string, metadata: JSONObject, { engineId, refresh, }?: {
         engineId?: string;
         refresh?: any;
     }): Promise<KDocument<DeviceContent>>;
     get(index: string, deviceId: string): Promise<KDocument<DeviceContent>>;
-    update(engineId: string, deviceId: string, metadata: Metadata, { refresh }: {
+    update(user: User, engineId: string, deviceId: string, metadata: Metadata, { refresh }: {
         refresh: any;
     }): Promise<KDocument<DeviceContent>>;
-    delete(engineId: string, deviceId: string, { refresh }: {
+    delete(user: User, engineId: string, deviceId: string, { refresh }: {
         refresh: any;
     }): Promise<void>;
     search(engineId: string, searchBody: JSONObject, { from, size, scroll, lang, }: {
@@ -40,7 +42,7 @@ export declare class DeviceService {
      * @param options.refresh Wait for ES indexation
      * @param options.strict If true, throw if an operation isn't possible
      */
-    attachEngine(engineId: string, deviceId: string, { refresh }?: {
+    attachEngine(user: User, engineId: string, deviceId: string, { refresh }?: {
         refresh?: any;
     }): Promise<KDocument<DeviceContent>>;
     /**
@@ -49,25 +51,30 @@ export declare class DeviceService {
      * @param deviceId Device id
      * @param options.refresh Wait for ES indexation
      */
-    detachEngine(deviceId: string, { refresh }?: {
+    detachEngine(user: User, deviceId: string, { refresh }?: {
         refresh?: any;
     }): Promise<KDocument<DeviceContent>>;
     /**
      * Link a device to an asset.
      */
-    linkAsset(engineId: string, deviceId: string, assetId: string, measuresNames: Record<string, string>, { refresh }?: {
+    linkAsset(user: User, engineId: string, deviceId: string, assetId: string, measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"], { refresh }?: {
         refresh?: any;
     }): Promise<{
         asset: KDocument<AssetContent>;
         device: KDocument<DeviceContent>;
     }>;
+    /**
+     * Checks if the asset does not already have a linked device using one of the
+     * requested measure names.
+     */
+    private checkAssetMeasureNamesAvailability;
     /**
      * Unlink a device of an asset
      *
      * @param deviceId Id of the device
      * @param options.refresh Wait for ES indexation
      */
-    unlinkAsset(deviceId: string, { refresh }?: {
+    unlinkAsset(user: User, deviceId: string, { refresh }?: {
         refresh?: any;
     }): Promise<{
         asset: KDocument<AssetContent>;

package/dist/lib/modules/device/exports.d.ts

@@ -0,0 +1,6 @@
+export * from "./types/DeviceContent";
+export * from "./types/DeviceApi";
+export * from "./types/DeviceEvents";
+export * from "./roles/RoleDevicesAdmin";
+export * from "./roles/RoleDevicesPlatformAdmin";
+export * from "./roles/RoleDevicesReader";

package/dist/lib/modules/device/types/DeviceApi.d.ts

@@ -72,19 +72,22 @@ export interface ApiDeviceLinkAssetRequest extends DevicesControllerRequest {
     _id: string;
     refresh?: string;
     assetId: string;
-    body: {
+    body?: {
         /**
-         * Names lookup table for measures
+         * Names of the linked measures
          *
-         * Record<deviceName, assetName>
+         * Array<{ asset: string, device: string }>
          *
          * @example
          *
-         * {
-         *   "temperature": "externalTemperature",
-         * }
+         * [
+         *   { asset: "externalTemperature", device: "temperature" }
+         * ]
          */
-        measureNames: Record<string, string>;
+        measureNames: Array<{
+            asset: string;
+            device: string;
+        }>;
     };
 }
 export type ApiDeviceLinkAssetResult = {

package/dist/lib/modules/device/types/DeviceEvents.d.ts

@@ -1,4 +1,4 @@
-import { KDocument } from "kuzzle";
+import { KDocument, User } from "kuzzle";
 import { Metadata } from "../../../modules/shared";
 import { DeviceContent } from "./DeviceContent";
 export type EventDeviceUpdateBefore = {
@@ -15,3 +15,14 @@ export type EventDeviceUpdateAfter = {
         metadata: Metadata;
     }];
 };
+/**
+ * @internal
+ */
+export type AskDeviceUnlinkAsset = {
+    name: "ask:device-manager:device:unlink-asset";
+    payload: {
+        deviceId: string;
+        user: User;
+    };
+    result: void;
+};

package/dist/lib/modules/measure/MeasureModule.d.ts

@@ -1,6 +1,5 @@
 import { Module } from "../shared/Module";
 export declare class MeasureModule extends Module {
     private measureService;
-    private measureController;
     init(): Promise<void>;
 }

package/dist/lib/modules/measure/MeasureService.d.ts

@@ -1,10 +1,8 @@
 import { JSONObject, KDocument } from "kuzzle";
 import { DeviceManagerPlugin } from "../../core";
 import { DeviceContent } from "./../device";
-import { AssetContent } from "../asset";
 import { Metadata } from "../shared";
 import { DecodedMeasurement } from "./types/MeasureContent";
-import { ApiMeasurePushRequest } from "./types/MeasureApi";
 export declare class MeasureService {
     private config;
     private context;
@@ -27,24 +25,13 @@ export declare class MeasureService {
      *  - trigger events to trigger business rules
      */
     ingest(device: KDocument<DeviceContent>, measurements: DecodedMeasurement<JSONObject>[], metadata: Metadata, payloadUuids: string[]): Promise<void>;
-    /**
-     * Updates embedded measures in a digital twin
-     */
-    private updateEmbeddedMeasures;
+    private compareMetadata;
+    private updateDeviceMeasures;
+    private updateAssetMeasures;
     /**
      * Build the measures documents to save
      */
     private buildMeasures;
-    /**
-     * Register new measures from a device, updates :
-     * - linked asset
-     * - engine measures
-     *
-     * The `measuredAt` of the measures will be set automatically if not setted
-     */
-    registerByAsset(engineId: string, assetId: string, measureInfo: ApiMeasurePushRequest["body"]["measure"], kuid: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<KDocument<AssetContent>>;
     private tryGetLinkedAsset;
     /**
      * Retrieve the measure name for the asset

package/dist/lib/modules/measure/collections/measuresMappings.d.ts

@@ -1,19 +1,9 @@
 export declare const measuresMappings: {
     dynamic: string;
     properties: {
-        /**
-         * Type of the measure. (e.g. "temperature")
-         * The type name is also the name of the sub-property to look at
-         * in the "values" object to get the measure main value.
-         */
         type: {
             type: string;
         };
-        /**
-         * Property containing the actual measurement.
-         *
-         * This should be specialized by child interfaces.
-         */
         values: {
             properties: {};
         };
@@ -47,20 +37,12 @@ export declare const measuresMappings: {
          */
         origin: {
             properties: {
-                /**
-                 * From what the measure has been pushed. Can be:
-                 * - 'asset'
-                 * - 'device'
-                 */
                 type: {
                     type: string;
                 };
                 measureName: {
                     type: string;
                 };
-                /**
-                 * Array of payloads uuids that were used to create this measure.
-                 */
                 payloadUuids: {
                     type: string;
                 };
@@ -70,11 +52,6 @@ export declare const measuresMappings: {
                 reference: {
                     type: string;
                 };
-                /**
-                 * ID of the origin. Can be:
-                 * - device id if origin type is `device`
-                 * - user id if origin type is `asset`
-                 */
                 _id: {
                     type: string;
                 };

package/dist/lib/modules/measure/exports.d.ts

@@ -0,0 +1,6 @@
+export * from "./types/MeasureEvents";
+export * from "./types/MeasureContent";
+export * from "./types/MeasureDefinition";
+export * from "./measures";
+export * from "./roles/RoleMeasuresAdmin";
+export * from "./roles/RoleMeasuresReader";

package/dist/lib/modules/measure/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./collections/measuresMappings";
-export * from "./types/MeasureApi";
 export * from "./types/MeasureEvents";
 export * from "./types/MeasureContent";
 export * from "./types/MeasureDefinition";

package/dist/lib/modules/measure/roles/RoleMeasuresAdmin.d.ts

@@ -1,15 +1,10 @@
-import { KuzzleRole } from "lib/modules/shared/types/KuzzleRole";
+import { KuzzleRole } from "../../shared/types/KuzzleRole";
 /**
- * This role allows to push measures and manage their models.
+ * This role allows to manage measure models.
  *
  * It's a tenant role.
  *
  * @example
-    "device-manager/measures": {
-      actions: {
-        "*": true,
-      },
-    },
     "device-manager/models": {
       actions: {
         deleteMeasure: true,

package/dist/lib/modules/measure/roles/RoleMeasuresReader.d.ts

@@ -1,4 +1,4 @@
-import { KuzzleRole } from "lib/modules/shared/types/KuzzleRole";
+import { KuzzleRole } from "../../shared/types/KuzzleRole";
 /**
  * This role allows to list measure models.
  *

package/dist/lib/modules/measure/types/MeasureContent.d.ts

@@ -1,6 +1,50 @@
 import { JSONObject, KDocumentContent } from "kuzzle";
 import { Metadata } from "../../../modules/shared";
 import { AssetMeasureContext } from "../../../modules/asset";
+export type MeasureOriginDevice = {
+    /**
+     * Origin of the measure
+     */
+    type: "device";
+    /**
+     * Name of the measure in the device
+     */
+    measureName: string;
+    /**
+     * Payload uuids that were used to create this measure.
+     */
+    payloadUuids: Array<string>;
+    /**
+     * Model of the device
+     *
+     * @example "AbeewayTemp"
+     */
+    deviceModel: string;
+    /**
+     * Reference of the device
+     */
+    reference: string;
+    /**
+     * Device ID
+     */
+    _id: string;
+};
+export type MeasureOriginComputed = {
+    type: "computed";
+    /**
+     * String that identify the rule used to compute the measure
+     */
+    _id: string;
+    /**
+     * Name of the measure
+     */
+    measureName: string;
+    /**
+     * Payload uuids that were used to create this measure for traceability.
+     */
+    payloadUuids: Array<string>;
+};
+export type MeasureOrigin = MeasureOriginDevice | MeasureOriginComputed;
 /**
  * Represents the content of a measure document.
  */
@@ -12,36 +56,7 @@ export interface MeasureContent<TMeasureValues extends JSONObject = any, TMetada
     /**
      * Define the origin of the measure.
      */
-    origin: {
-        /**
-         * Name of the measure (e.g. from the Device)
-         */
-        measureName: string;
-        /**
-         * Type of the origin
-         */
-        type: "user" | "device";
-        /**
-         * Payload uuids that were used to create this measure.
-         */
-        payloadUuids?: Array<string>;
-        /**
-         * Model of the device
-         *
-         * @example "AbeewayTemp"
-         */
-        deviceModel?: string;
-        /**
-         * Reference of the device
-         */
-        reference?: string;
-        /**
-         * ID of the origin. Can be:
-         * - device id if origin type is `device`
-         * - kuid of the request if origin type is `user`
-         */
-        _id?: string;
-    };
+    origin: MeasureOrigin;
 }
 export type Measurement<TMeasureValues extends JSONObject = any> = {
     /**

package/dist/lib/modules/measure/types/MeasureEvents.d.ts

@@ -17,6 +17,13 @@ export type EventMeasureIngest = {
         }
     ];
 };
+/**
+ * Event before starting to process new measures.
+ *
+ * Useful to enrich measures before they are saved.
+ *
+ * Only measures documents can be modified
+ */
 export type EventMeasureProcessBefore = {
     name: "device-manager:measures:process:before";
     args: [

package/dist/lib/modules/model/ModelService.d.ts

@@ -7,9 +7,9 @@ export declare class ModelService {
     private get sdk();
     constructor(plugin: DeviceManagerPlugin);
     registerAskEvents(): void;
-    writeAsset(engineGroup: string, model: string, metadataMappings: JSONObject, defaultMetadata: JSONObject, measures: JSONObject): Promise<KDocument<AssetModelContent>>;
+    writeAsset(engineGroup: string, model: string, metadataMappings: JSONObject, defaultMetadata: JSONObject, measures: AssetModelContent["asset"]["measures"]): Promise<KDocument<AssetModelContent>>;
     private checkDefaultValues;
-    writeDevice(model: string, metadataMappings: JSONObject, defaultMetadata: JSONObject, measures: JSONObject): Promise<KDocument<DeviceModelContent>>;
+    writeDevice(model: string, metadataMappings: JSONObject, defaultMetadata: JSONObject, measures: DeviceModelContent["device"]["measures"]): Promise<KDocument<DeviceModelContent>>;
     writeMeasure(type: string, valuesMappings: JSONObject): Promise<KDocument<MeasureModelContent>>;
     deleteAsset(_id: string): Promise<void>;
     deleteDevice(_id: string): Promise<void>;

package/dist/lib/modules/model/ModelsController.d.ts

@@ -1,13 +1,13 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { ModelService } from "./ModelService";
-import { ApiModelCreateAssetResult, ApiModelCreateDeviceResult, ApiModelCreateMeasureResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult } from "./types/ModelApi";
+import { ApiModelWriteAssetResult, ApiModelWriteDeviceResult, ApiModelWriteMeasureResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult } from "./types/ModelApi";
 export declare class ModelsController {
     private modelService;
     definition: ControllerDefinition;
     constructor(modelService: ModelService);
-    writeAsset(request: KuzzleRequest): Promise<ApiModelCreateAssetResult>;
-    writeDevice(request: KuzzleRequest): Promise<ApiModelCreateDeviceResult>;
-    writeMeasure(request: KuzzleRequest): Promise<ApiModelCreateMeasureResult>;
+    writeAsset(request: KuzzleRequest): Promise<ApiModelWriteAssetResult>;
+    writeDevice(request: KuzzleRequest): Promise<ApiModelWriteDeviceResult>;
+    writeMeasure(request: KuzzleRequest): Promise<ApiModelWriteMeasureResult>;
     deleteAsset(request: KuzzleRequest): Promise<ApiModelDeleteAssetResult>;
     deleteDevice(request: KuzzleRequest): Promise<ApiModelDeleteDeviceResult>;
     deleteMeasure(request: KuzzleRequest): Promise<ApiModelDeleteMeasureResult>;

package/dist/lib/modules/model/exports.d.ts

@@ -0,0 +1,3 @@
+export * from "./types/ModelApi";
+export * from "./types/ModelContent";
+export * from "./types/ModelDefinition";

package/dist/lib/modules/model/index.d.ts

@@ -2,5 +2,6 @@ export * from "./collections/modelsMappings";
 export * from "./types/ModelApi";
 export * from "./types/ModelContent";
 export * from "./types/ModelDefinition";
+export * from "./types/ModelEvents";
 export * from "./ModelModule";
 export * from "./ModelSerializer";

package/dist/lib/modules/model/types/ModelApi.d.ts

@@ -3,38 +3,35 @@ import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "./Mo
 interface ModelsControllerRequest {
     controller: "device-manager/models";
 }
-export interface ApiModelCreateAssetRequest extends ModelsControllerRequest {
+export interface ApiModelWriteAssetRequest extends ModelsControllerRequest {
     action: "writeAsset";
     body: {
         engineGroup: string;
         model: string;
-        metadataMappings: JSONObject;
-        defaultValues: JSONObject;
+        metadataMappings?: JSONObject;
+        defaultValues?: JSONObject;
+        measures?: AssetModelContent["asset"]["measures"];
     };
 }
-export type ApiModelCreateAssetResult = KDocument<AssetModelContent>;
-export interface ApiModelCreateDeviceRequest extends ModelsControllerRequest {
+export type ApiModelWriteAssetResult = KDocument<AssetModelContent>;
+export interface ApiModelWriteDeviceRequest extends ModelsControllerRequest {
     action: "writeDevice";
     body: {
         model: string;
-        metadataMappings: JSONObject;
-        defaultValues: JSONObject;
+        metadataMappings?: JSONObject;
+        defaultValues?: JSONObject;
+        measures: DeviceModelContent["device"]["measures"];
     };
 }
-export type ApiModelCreateDeviceResult = KDocument<DeviceModelContent>;
-export interface ApiModelCreateMeasureRequest extends ModelsControllerRequest {
+export type ApiModelWriteDeviceResult = KDocument<DeviceModelContent>;
+export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     action: "writeMeasure";
     body: {
         type: string;
-        unit: {
-            name: string;
-            sign: string;
-            type: string;
-        };
         valuesMappings: JSONObject;
     };
 }
-export type ApiModelCreateMeasureResult = KDocument<MeasureModelContent>;
+export type ApiModelWriteMeasureResult = KDocument<MeasureModelContent>;
 export interface ApiModelDeleteAssetRequest extends ModelsControllerRequest {
     action: "deleteAsset";
     _id: string;

package/dist/lib/modules/model/types/ModelContent.d.ts

@@ -1,4 +1,5 @@
 import { JSONObject, KDocumentContent } from "kuzzle";
+import { NamedMeasures } from "../../../modules/decoder";
 import { MeasureDefinition } from "../../measure";
 export interface MeasureModelContent extends KDocumentContent {
     type: "measure";
@@ -39,15 +40,15 @@ export interface AssetModelContent extends KDocumentContent {
         /**
          * List of accepted measures for this model
          *
-         * Record<name, type>
+         * Array<{ type: string, name: string }>
          *
          * @example
          *
-         * {
-         *   "externalTemperature": "temperature",
-         * }
+         * [
+         *   { type: "temperature", name: "externalTemperature" }
+         * ]
          */
-        measures: Record<string, string>;
+        measures: NamedMeasures;
     };
 }
 export interface DeviceModelContent extends KDocumentContent {
@@ -82,15 +83,15 @@ export interface DeviceModelContent extends KDocumentContent {
         /**
          * List of decoded measures for this model
          *
-         * Record<name, type>
+         * Array<{ type: string, name: string }>
          *
          * @example
          *
-         * {
-         *   "temperature1": "temperature",
-         * }
+         * [
+         *   { type: "temperature", name: "externalTemperature" }
+         * ]
          */
-        measures: Record<string, string>;
+        measures: NamedMeasures;
     };
 }
 export type ModelContent = MeasureModelContent | AssetModelContent | DeviceModelContent;

package/dist/lib/modules/model/types/ModelDefinition.d.ts

@@ -5,7 +5,7 @@ import { Decoder, NamedMeasures } from "../../../modules/decoder";
  *
  * @example
  *   {
- *     measuresNames: [
+ *     measures: [
  *       { name: "temperatureExt", type: "temperature" },
  *       { name: "temperatureInt", type: "temperature" },
  *       { name: "position", type: "position" },
@@ -24,11 +24,11 @@ export type AssetModelDefinition = {
     /**
      * Array describing measures names and types
      */
-    measuresNames: NamedMeasures;
+    measures: NamedMeasures;
     /**
      * Metadata mappings definition
      */
-    metadataMappings: JSONObject;
+    metadataMappings?: JSONObject;
     /**
      * Default metadata values
      */

package/dist/lib/modules/shared/exports.d.ts

@@ -0,0 +1,3 @@
+export * from "./types/DigitalTwinContent";
+export * from "./types/Metadata";
+export * from "./types/EmbeddedMeasure";

package/dist/lib/modules/shared/index.d.ts

@@ -1,6 +1,9 @@
 export * from "./types/DigitalTwinContent";
 export * from "./types/Metadata";
 export * from "./types/EmbeddedMeasure";
+export * from "./types/KuzzleRole";
 export * from "./utils/lock";
 export * from "./utils/flattenObject";
 export * from "./utils/ask";
+export * from "./utils/snakeCase";
+export * from "./Module";

package/dist/lib/modules/shared/utils/snakeCase.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Convert a string to snake_case
+ *
+ * @todo use Inflector.snakeCase when
+ * https://github.com/kuzzleio/kuzzle/pull/2415 is released
+ */
+export declare function snakeCase(str: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle-device-manager-types",
-  "version": "2.0.0-rc35",
+  "version": "2.0.0",
   "description": "Shared types for Kuzzle Device Manager",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "types": "dist/index.d.ts",

package/dist/lib/modules/asset/roles/assetsAdmin.d.ts

@@ -1,16 +0,0 @@
-export declare const assetsAdmin: {
-    controllers: {
-        "device-manager/assets": {
-            actions: {
-                "*": boolean;
-            };
-        };
-        "device-manager/models": {
-            actions: {
-                deleteAsset: boolean;
-                listAssets: boolean;
-                writeAsset: boolean;
-            };
-        };
-    };
-};

package/dist/lib/modules/asset/roles/assetsReader.d.ts

@@ -1,16 +0,0 @@
-export declare const assetsReader: {
-    controllers: {
-        "device-manager/assets": {
-            actions: {
-                get: boolean;
-                getMeasures: boolean;
-                search: boolean;
-            };
-        };
-        "device-manager/models": {
-            actions: {
-                listAssets: boolean;
-            };
-        };
-    };
-};

package/dist/lib/modules/decoder/roles/decodersAdmin.d.ts

@@ -1,9 +0,0 @@
-export declare const decodersAdmin: {
-    controllers: {
-        "device-manager/decoders": {
-            actions: {
-                "*": boolean;
-            };
-        };
-    };
-};

package/dist/lib/modules/device/roles/devicesAdmin.d.ts

@@ -1,22 +0,0 @@
-export declare const devicesAdmin: {
-    controllers: {
-        "device-manager/devices": {
-            actions: {
-                create: boolean;
-                delete: boolean;
-                get: boolean;
-                linkAsset: boolean;
-                search: boolean;
-                unlinkAsset: boolean;
-                update: boolean;
-            };
-        };
-        "device-manager/models": {
-            actions: {
-                deleteDevice: boolean;
-                listDevices: boolean;
-                writeDevice: boolean;
-            };
-        };
-    };
-};

package/dist/lib/modules/device/roles/devicesPlatformAdmin.d.ts

@@ -1,16 +0,0 @@
-export declare const devicesPlatformAdmin: {
-    controllers: {
-        "device-manager/devices": {
-            actions: {
-                "*": boolean;
-            };
-        };
-        "device-manager/models": {
-            actions: {
-                deleteDevice: boolean;
-                listDevices: boolean;
-                writeDevice: boolean;
-            };
-        };
-    };
-};

package/dist/lib/modules/device/roles/devicesReader.d.ts

@@ -1,15 +0,0 @@
-export declare const devicesReader: {
-    controllers: {
-        "device-manager/devices": {
-            actions: {
-                get: boolean;
-                search: boolean;
-            };
-        };
-        "device-manager/models": {
-            actions: {
-                listDevices: boolean;
-            };
-        };
-    };
-};

package/dist/lib/modules/measure/MeasuresController.d.ts

@@ -1,9 +0,0 @@
-import { ControllerDefinition, KuzzleRequest } from "kuzzle";
-import { MeasureService } from "./MeasureService";
-import { ApiMeasurePushResult } from "./types/MeasureApi";
-export declare class MeasuresController {
-    private measureService;
-    definition: ControllerDefinition;
-    constructor(measureService: MeasureService);
-    push(request: KuzzleRequest): Promise<ApiMeasurePushResult>;
-}

package/dist/lib/modules/measure/roles/measuresAdmin.d.ts

@@ -1,16 +0,0 @@
-export declare const measuresAdmin: {
-    controllers: {
-        "device-manager/measures": {
-            actions: {
-                "*": boolean;
-            };
-        };
-        "device-manager/models": {
-            actions: {
-                deleteMeasure: boolean;
-                listMeasures: boolean;
-                writeMeasure: boolean;
-            };
-        };
-    };
-};

package/dist/lib/modules/measure/roles/measuresReader.d.ts

@@ -1,9 +0,0 @@
-export declare const measuresReader: {
-    controllers: {
-        "device-manager/models": {
-            actions: {
-                listMeasures: boolean;
-            };
-        };
-    };
-};

package/dist/lib/modules/measure/types/MeasureApi.d.ts

@@ -1,23 +0,0 @@
-import { JSONObject, KDocument } from "kuzzle";
-import { AssetContent } from "../../../modules/asset";
-interface MeasuresControllerRequest {
-    controller: "device-manager/measures";
-    engineId: string;
-}
-export interface ApiMeasurePushRequest extends MeasuresControllerRequest {
-    action: "push";
-    refresh?: string;
-    body: {
-        assetId: string;
-        measure: {
-            name: string;
-            type: string;
-            measuredAt?: number;
-            values: JSONObject;
-        };
-    };
-}
-export type ApiMeasurePushResult = {
-    asset: KDocument<AssetContent>;
-};
-export {};