kuzzle-device-manager-types 3.0.0-next.7 → 3.0.0-next.8

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

@@ -32,7 +32,7 @@ export declare class AssetService extends DigitalTwinService {
      */
     delete(engineId: string, assetId: string, request: KuzzleRequest): Promise<void>;
     search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<AssetContent>>>;
-    migrateTenant(user: User, assetsList: string[], engineId: string, newEngineId: string): Promise<ApiAssetMigrateTenantResult>;
+    migrateTenant(user: User, assetsList: string[], engineId: string, newEngineId: string, includeDevices: boolean, request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
     /**
      * Replace an asset metadata
      */
@@ -46,6 +46,5 @@ export declare class AssetService extends DigitalTwinService {
      * @param model
      */
     updateModelLocales(request: KuzzleRequest, model: string): Promise<ApiAssetUpdateModelLocales[]>;
-    private getEngine;
     private refreshModel;
 }

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

@@ -1,7 +1,7 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { AssetService } from "./AssetService";
-import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult, ApiAssetGetLastMeasuresResult, ApiAssetMGetLastMeasuredAtResult, ApiAssetMGetLastMeasuresResult, ApiAssetGetLastMeasuredAtResult, ApiAssetUpdateModelLocales } from "./types/AssetApi";
+import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult, ApiAssetGetLastMeasuresResult, ApiAssetMGetLastMeasuredAtResult, ApiAssetMGetLastMeasuresResult, ApiAssetGetLastMeasuredAtResult, ApiAssetUpdateModelLocales, ApiAssetLinkDevicesResult, ApiAssetUnlinkDevicesResult } from "./types/AssetApi";
 export declare class AssetsController {
     private plugin;
     private assetService;
@@ -42,4 +42,12 @@ export declare class AssetsController {
      * @param request
      */
     updateModelLocales(request: KuzzleRequest): Promise<ApiAssetUpdateModelLocales[]>;
+    /**
+     * Link an asset to devices.
+     */
+    linkDevices(request: KuzzleRequest): Promise<ApiAssetLinkDevicesResult>;
+    /**
+     * Unlink assets from a device.
+     */
+    unlinkDevices(request: KuzzleRequest): Promise<ApiAssetUnlinkDevicesResult>;
 }

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

@@ -4,6 +4,7 @@ import { ApiDigitalTwinGetLastMeasuredAtRequest, ApiDigitalTwinGetLastMeasuredAt
 import { AssetContent } from "./AssetContent";
 type AssetsControllerName = "device-manager/assets";
 import { ApiMeasureSource } from "../../measure/types/MeasureSources";
+import { DeviceContent } from "lib/modules/device";
 interface AssetsControllerRequest {
     controller: AssetsControllerName;
     engineId: string;
@@ -155,6 +156,7 @@ export interface ApiAssetMigrateTenantRequest extends AssetsControllerRequest {
     body: {
         assetsList: string[];
         newEngineId: string;
+        includeDevices?: boolean;
     };
 }
 export type ApiAssetMigrateTenantResult = {
@@ -169,4 +171,85 @@ export type ApiAssetUpdateModelLocales = {
     engineIndex: string;
     result: UpdateByQueryResponse<AssetContent>;
 };
+export interface ApiAssetlinkDevicesRequest extends AssetsControllerRequest {
+    action: "linkDevices";
+    _id: string;
+    refresh?: string;
+    body: {
+        linkedMeasures: Array<{
+            deviceId: string;
+            /**
+             * This option allows to not specify the names of all the measures that should
+             * be linked to the asset.
+             *
+             * The algorithm will go through all the measures names provided by the device
+             * and add the one who are present with the same name in the asset.
+             *
+             * It will not add the measure if:
+             *   - it has been specified in the link request
+             *   - it was already present in the asset
+             *
+             * @example
+             *   if the device provide a measure of type "temperature" with the name "temp"
+             *   if the asset has declared a measure of type "temperature" with the name "temp"
+             *   then the measure will be automatically added in the link and will later be propagated to the asset
+             */
+            implicitMeasuresLinking?: boolean;
+            /**
+             * Names of the linked measures.
+             *
+             * Array<{ asset: string, device: string }>
+             *
+             * @example
+             *
+             * [
+             *   { asset: "externalTemperature", device: "temperature" }
+             * ]
+             */
+            measureSlots?: Array<{
+                asset: string;
+                device: string;
+            }>;
+        }>;
+    };
+}
+export type ApiAssetLinkDevicesResult = {
+    asset: KDocument<AssetContent>;
+    devices: KDocument<DeviceContent>[];
+};
+export interface ApiAssetUnlinkDevicesRequest extends AssetsControllerRequest {
+    action: "unlinkDevices";
+    _id: string;
+    strict?: boolean;
+    refresh?: string;
+    body: {
+        linkedMeasures: Array<{
+            deviceId: string;
+            /**
+             * This option allows to not specify the names of all the measures that should
+             * be unlinked from the asset.
+             */
+            allMeasures?: boolean;
+            /**
+             * Names of the linked measures.
+             *
+             * Array<{ asset: string, device: string }>
+             *
+             * @example
+             *
+             * [
+             *   { asset: "externalTemperature", device: "temperature" }
+             * ]
+             */
+            measureSlots?: Array<{
+                asset: string;
+                device: string;
+            }>;
+        }>;
+    };
+}
+export type ApiAssetUnlinkDevicesResult = {
+    asset: KDocument<AssetContent>;
+    devices: KDocument<DeviceContent>[];
+};
 export {};

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

@@ -1,17 +1,16 @@
-import { JSONObject } from "kuzzle-sdk";
 import { DigitalTwinContent, Metadata } from "../../shared";
 /**
  * Asset document content
  */
-export interface AssetContent<TMeasures extends JSONObject = any, TMetadata extends Metadata = any> extends DigitalTwinContent<TMeasures, TMetadata> {
+export interface AssetContent<TMetadata extends Metadata = any> extends DigitalTwinContent<TMetadata> {
     /**
-     * Link with attached device
+     * Link with attached devices
      */
-    linkedDevices: Array<{
+    linkedMeasures: Array<{
         /**
          * Device ID
          */
-        _id: string;
+        deviceId: string;
         /**
          * Names of the linked measures
          *
@@ -20,13 +19,12 @@ export interface AssetContent<TMeasures extends JSONObject = any, TMetadata exte
          * @example
          *
          * [
-         *   { asset: "externalTemperature", device: "temperature", type: "temperature" }
+         *   { asset: "externalTemperature", device: "temperature" }
          * ]
          */
-        measureNames: Array<{
+        measureSlots: Array<{
             asset: string;
             device: string;
-            type: string;
         }>;
     }>;
     /**
@@ -49,4 +47,4 @@ export type AssetMeasureContext<TMetadata extends Metadata = Metadata> = {
      * Name of the measure for the Asset
      */
     measureName: string;
-} & Pick<AssetContent<JSONObject, TMetadata>, "model" | "reference" | "metadata" | "groups">;
+} & Pick<AssetContent<TMetadata>, "model" | "reference" | "metadata" | "groups">;

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

@@ -1,4 +1,4 @@
-import { JSONObject, KDocumentContent } from "kuzzle-sdk";
+import { KDocumentContent } from "kuzzle-sdk";
 import { Metadata } from "../../shared";
 import { AssetContent } from "./AssetContent";
 export type AssetHistoryMetadata = {
@@ -24,7 +24,7 @@ export type AssetHistoryEvent = AssetHistoryEventMetadata | AssetHistoryEventLin
 /**
  * Asset History document content
  */
-export interface AssetHistoryContent<TAssetHistoryEvent extends AssetHistoryEvent = any, TMeasures extends JSONObject = any, TMetadata extends Metadata = any> extends KDocumentContent {
+export interface AssetHistoryContent<TAssetHistoryEvent extends AssetHistoryEvent = any, TMetadata extends Metadata = any> extends KDocumentContent {
     /**
      * Name of the event who caused the historization
      *
@@ -41,7 +41,7 @@ export interface AssetHistoryContent<TAssetHistoryEvent extends AssetHistoryEven
     /**
      * Asset content after the event
      */
-    asset: AssetContent<TMeasures, TMetadata>;
+    asset: AssetContent<TMetadata>;
     /**
      * Timestamp of the event according to its type
      *

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

@@ -3,23 +3,18 @@ import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { DecodedMeasurement } from "../measure";
 import { DeviceManagerPlugin } from "../plugin";
 import { DigitalTwinService, Metadata, SearchParams } from "../shared";
-import { AssetContent } from "./../asset";
-import { ApiDeviceLinkAssetRequest } from "./types/DeviceApi";
-import { DeviceContent } from "./types/DeviceContent";
+import { DeviceProvisioningContent, DeviceContent } from "./types/DeviceContent";
 export declare class DeviceService extends DigitalTwinService {
     constructor(plugin: DeviceManagerPlugin);
     registerAskEvents(): void;
     private _create;
+    private _createDeviceProvisioning;
     /**
      * Create a new device.
      *
-     * @todo creating a device in the "device-manager" index should be a separate
-     * 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, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     get(engineId: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
-    private getInternalDevices;
     /**
      * Replace a device metadata
      */
@@ -37,7 +32,6 @@ export declare class DeviceService extends DigitalTwinService {
      * @param engineId Engine id to attach to
      * @param deviceId Device id to attach
      * @param options.refresh Wait for ES indexation
-     * @param options.strict If true, throw if an operation isn't possible
      */
     private _attachEngine;
     /**
@@ -55,48 +49,9 @@ export declare class DeviceService extends DigitalTwinService {
      * @param {string} deviceId Id of the device
      * @param {KuzzleRequest} request kuzzle request
      */
-    detachEngine(deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
-    /**
-     * Link a device to an asset.
-     */
-    linkAsset(engineId: string, deviceId: string, assetId: string, measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"], implicitMeasuresLinking: boolean, request: KuzzleRequest): Promise<{
-        asset: KDocument<AssetContent>;
-        device: KDocument<DeviceContent>;
-    }>;
+    detachEngine(deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceProvisioningContent>>;
     receiveMeasures(engineId: string, deviceId: string, measures: DecodedMeasurement[], payloadUuids: string[], request: KuzzleRequest): Promise<void>;
-    /**
-     * Checks if the asset does not already have a linked device using one of the
-     * requested measure names.
-     */
-    private checkAlreadyProvidedMeasures;
-    /**
-     * Goes through the device available measures and add them into the link if:
-     *  - they are not already provided by another device
-     *  - they are not already present in the link request
-     *  - they are declared in the asset model
-     */
-    private generateMissingAssetMeasureNames;
-    /**
-     * Internal logic of unlink a device of an asset
-     *
-     * @param {string} deviceId Id of the device
-     * @param {KuzzleRequest} request kuzzle request
-     */
-    private _unlinkAsset;
-    /**
-     * Unlink a device of an asset with lock
-     *
-     * @param {string} deviceId Id of the device
-     * @param {KuzzleRequest} request kuzzle request
-     */
-    unlinkAsset(deviceId: string, request: KuzzleRequest): Promise<{
-        asset: KDocument<AssetContent>;
-        device: KDocument<DeviceContent>;
-    }>;
     private checkEngineExists;
     private checkAttachedToEngine;
-    private getEngine;
-    private getDeviceModel;
-    private getAssetModel;
     private refreshModel;
 }

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

@@ -1,7 +1,7 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { DeviceService } from "./DeviceService";
-import { ApiDeviceAttachEngineResult, ApiDeviceCreateResult, ApiDeviceDeleteResult, ApiDeviceDetachEngineResult, ApiDeviceGetResult, ApiDeviceLinkAssetResult, ApiDeviceSearchResult, ApiDeviceUnlinkAssetResult, ApiDeviceUpdateResult, ApiDeviceGetMeasuresResult, ApiDeviceUpsertResult, ApiDeviceGetLastMeasuresResult, ApiDeviceMGetLastMeasuresResult, ApiDeviceGetLastMeasuredAtResult, ApiDeviceMGetLastMeasuredAtResult, ApiDeviceMetadataReplaceResult } from "./types/DeviceApi";
+import { ApiDeviceAttachEngineResult, ApiDeviceCreateResult, ApiDeviceDeleteResult, ApiDeviceDetachEngineResult, ApiDeviceGetResult, ApiDeviceLinkAssetsResult, ApiDeviceSearchResult, ApiDeviceUnlinkAssetsResult, ApiDeviceUpdateResult, ApiDeviceGetMeasuresResult, ApiDeviceUpsertResult, ApiDeviceGetLastMeasuresResult, ApiDeviceMGetLastMeasuresResult, ApiDeviceGetLastMeasuredAtResult, ApiDeviceMGetLastMeasuredAtResult, ApiDeviceMetadataReplaceResult } from "./types/DeviceApi";
 export declare class DevicesController {
     private plugin;
     private deviceService;
@@ -28,13 +28,13 @@ export declare class DevicesController {
      */
     detachEngine(request: KuzzleRequest): Promise<ApiDeviceDetachEngineResult>;
     /**
-     * Link a device to an asset.
+     * Link a device to several assets.
      */
-    linkAsset(request: KuzzleRequest): Promise<ApiDeviceLinkAssetResult>;
+    linkAssets(request: KuzzleRequest): Promise<ApiDeviceLinkAssetsResult>;
     /**
-     * Unlink a device from an asset.
+     * Unlink assets from a device.
      */
-    unlinkAsset(request: KuzzleRequest): Promise<ApiDeviceUnlinkAssetResult>;
+    unlinkAssets(request: KuzzleRequest): Promise<ApiDeviceUnlinkAssetsResult>;
     getMeasures(request: KuzzleRequest): Promise<ApiDeviceGetMeasuresResult>;
     getLastMeasures(request: KuzzleRequest): Promise<ApiDeviceGetLastMeasuresResult>;
     mGetLastMeasures(request: KuzzleRequest): Promise<ApiDeviceMGetLastMeasuresResult>;

package/dist/lib/modules/device/collections/deviceMappings.d.ts

@@ -5,3 +5,9 @@ import { CollectionMappings } from "kuzzle";
  * Those mappings does not contains the `measures` and `metadata` mappings.
  */
 export declare const devicesMappings: CollectionMappings;
+/**
+ * Mappings for the "devices" collection of the platform index.
+ *
+ * Those mappings does not contains the `measures`, `groups` and `metadata` mappings.
+ */
+export declare const devicesPlatformMappings: CollectionMappings;

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

@@ -10,9 +10,9 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
         create: true,
         delete: true,
         get: true,
-        linkAsset: true,
+        linkAssets: true,
         search: true,
-        unlinkAsset: true,
+        unlinkAssets: true,
         update: true,
         getMeasures: true,
         exportMeasures: true,

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

@@ -59,14 +59,39 @@ export interface ApiDeviceSearchRequest extends DevicesControllerRequest {
     body: JSONObject;
 }
 export type ApiDeviceSearchResult = SearchResult<KHit<DeviceContent>>;
-export interface ApiDeviceUnlinkAssetRequest extends DevicesControllerRequest {
-    action: "unlinkAsset";
+export interface ApiDeviceUnlinkAssetsRequest extends DevicesControllerRequest {
+    action: "unlinkAssets";
     _id: string;
     strict?: boolean;
     refresh?: string;
+    body: {
+        linkedMeasures: Array<{
+            assetId: string;
+            /**
+             * This option allows to not specify the names of all the measures that should
+             * be unlinked from the asset.
+             */
+            allMeasures?: boolean;
+            /**
+             * Names of the linked measures.
+             *
+             * Array<{ asset: string, device: string }>
+             *
+             * @example
+             *
+             * [
+             *   { asset: "externalTemperature", device: "temperature" }
+             * ]
+             */
+            measureSlots?: Array<{
+                asset: string;
+                device: string;
+            }>;
+        }>;
+    };
 }
-export type ApiDeviceUnlinkAssetResult = {
-    asset: KDocument<AssetContent>;
+export type ApiDeviceUnlinkAssetsResult = {
+    assets: KDocument<AssetContent>[];
     device: KDocument<DeviceContent>;
 };
 export interface ApiDeviceAttachEngineRequest extends DevicesControllerRequest {
@@ -81,48 +106,50 @@ export interface ApiDeviceDetachEngineRequest extends DevicesControllerRequest {
     refresh?: string;
 }
 export type ApiDeviceDetachEngineResult = void;
-export interface ApiDeviceLinkAssetRequest extends DevicesControllerRequest {
-    action: "linkAsset";
+export interface ApiDeviceLinkAssetsRequest extends DevicesControllerRequest {
+    action: "linkAssets";
     _id: string;
     refresh?: string;
-    assetId: string;
-    /**
-     * This option allows to not specify the names of all the measures that should
-     * be linked to the asset.
-     *
-     * The algorithm will go through all the measures names provided by the device
-     * and add the one who are present with the same name in the asset.
-     *
-     * It will not add the measure if:
-     *   - it has been specified in the link request
-     *   - it was already present in the asset
-     *
-     * @example
-     *   if the device provide a measure of type "temperature" with the name "temp"
-     *   if the asset has declared a measure of type "temperature" with the name "temp"
-     *   then the measure will be automatically added in the link and will later be propagated to the asset
-     */
-    implicitMeasuresLinking?: boolean;
-    body?: {
-        /**
-         * Names of the linked measures.
-         *
-         * Array<{ asset: string, device: string }>
-         *
-         * @example
-         *
-         * [
-         *   { asset: "externalTemperature", device: "temperature" }
-         * ]
-         */
-        measureNames?: Array<{
-            asset: string;
-            device: string;
+    body: {
+        linkedMeasures: Array<{
+            assetId: string;
+            /**
+             * This option allows to not specify the names of all the measures that should
+             * be linked to the asset.
+             *
+             * The algorithm will go through all the measures names provided by the device
+             * and add the one who are present with the same name in the asset.
+             *
+             * It will not add the measure if:
+             *   - it has been specified in the link request
+             *   - it was already present in the asset
+             *
+             * @example
+             *   if the device provide a measure of type "temperature" with the name "temp"
+             *   if the asset has declared a measure of type "temperature" with the name "temp"
+             *   then the measure will be automatically added in the link and will later be propagated to the asset
+             */
+            implicitMeasuresLinking?: boolean;
+            /**
+             * Names of the linked measures.
+             *
+             * Array<{ asset: string, device: string }>
+             *
+             * @example
+             *
+             * [
+             *   { asset: "externalTemperature", device: "temperature" }
+             * ]
+             */
+            measureSlots?: Array<{
+                asset: string;
+                device: string;
+            }>;
         }>;
     };
 }
-export type ApiDeviceLinkAssetResult = {
-    asset: KDocument<AssetContent>;
+export type ApiDeviceLinkAssetsResult = {
+    assets: KDocument<AssetContent>[];
     device: KDocument<DeviceContent>;
 };
 export interface ApiDeviceGetMeasuresRequest extends DevicesControllerRequest {

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

@@ -1,13 +1,33 @@
-import { JSONObject } from "kuzzle-sdk";
+import { JSONObject, KDocumentContent } from "kuzzle-sdk";
 import { DigitalTwinContent, Metadata } from "../../shared";
 /**
  * Device document content
  */
-export interface DeviceContent<TMeasures extends JSONObject = any, TMetadata extends Metadata = any> extends DigitalTwinContent<TMeasures, TMetadata> {
+export interface DeviceContent<TMetadata extends Metadata = any> extends DigitalTwinContent<TMetadata> {
     /**
-     * Linked asset unique identifier
+     * Link with attached assets
      */
-    assetId: string | null;
+    linkedMeasures: Array<{
+        /**
+         * Asset ID
+         */
+        assetId: string;
+        /**
+         * Slots of the linked measures
+         *
+         * Array<{ asset: string, device: string, type: string }>
+         *
+         * @example
+         *
+         * [
+         *   { asset: "externalTemperature", device: "temperature", }
+         * ]
+         */
+        measureSlots: Array<{
+            asset: string;
+            device: string;
+        }>;
+    }>;
     /**
      */
     engineId: string;
@@ -19,3 +39,27 @@ export interface DeviceContent<TMeasures extends JSONObject = any, TMetadata ext
         date: number;
     }>;
 }
+/**
+ * Platform index Device document content
+ */
+interface DeviceProvisioningContentFields extends Pick<DeviceContent, "model" | "reference" | "engineId" | "measureSlots"> {
+    /**
+     * Date of provisioning of the device on the platform
+     */
+    provisionedAt: number;
+    /**
+     * Date of last measure from the device
+     */
+    lastMeasuredAt: number | null;
+    /**
+     * An array containing the 5 last measures from the device
+     */
+    lastMeasures: Array<{
+        measureName: string;
+        values: JSONObject;
+        measuredAt: number;
+        type: string;
+    }>;
+}
+export type DeviceProvisioningContent = DeviceProvisioningContentFields & KDocumentContent;
+export {};

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

@@ -3,7 +3,6 @@ import { KDocument } from "kuzzle-sdk";
 import { DeviceModelContent } from "../../../modules/model";
 import { Metadata } from "../../../modules/shared";
 import { DeviceContent } from "./DeviceContent";
-import { ApiDeviceLinkAssetRequest } from "./DeviceApi";
 export type EventDeviceUpdateBefore = {
     name: "device-manager:device:update:before";
     args: [{
@@ -18,28 +17,6 @@ export type EventDeviceUpdateAfter = {
         metadata: Metadata;
     }];
 };
-/**
- * @internal
- */
-export type AskDeviceLinkAsset = {
-    name: "ask:device-manager:device:link-asset";
-    payload: {
-        engineId: string;
-        assetId: string;
-        deviceId: string;
-        user: User;
-        measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"];
-    };
-    result: void;
-};
-export type AskDeviceUnlinkAsset = {
-    name: "ask:device-manager:device:unlink-asset";
-    payload: {
-        deviceId: string;
-        user: User;
-    };
-    result: void;
-};
 export type AskDeviceDetachEngine = {
     name: "ask:device-manager:device:detach-engine";
     payload: {

package/dist/lib/modules/group/GroupsController.d.ts

@@ -1,6 +1,6 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
-import { ApiGroupAddAssetsResult, ApiGroupAddDevicesResult, ApiGroupCreateResult, ApiGroupDeleteResult, ApiGroupGetResult, ApiGroupListItemsResult, ApiGroupMCreateResult, ApiGroupMUpdateResult, ApiGroupMUpsertResult, ApiGroupRemoveAssetsResult, ApiGroupRemoveDeviceResult, ApiGroupSearchResult, ApiGroupUpdateResult, ApiGroupUpsertResult, GroupsBodyRequest } from "./types/GroupsApi";
+import { ApiGroupAddAssetsResult, ApiGroupAddDevicesResult, ApiGroupCreateResult, ApiGroupDeleteResult, ApiGroupGetResult, ApiGroupListItemsResult, ApiGroupMCreateResult, ApiGroupMUpdateResult, ApiGroupMUpsertResult, ApiGroupRemoveAssetsResult, ApiGroupRemoveDevicesResult, ApiGroupSearchResult, ApiGroupUpdateResult, ApiGroupUpsertResult, GroupsBodyRequest } from "./types/GroupsApi";
 import { GroupsService } from "./GroupsService";
 export declare class GroupsController {
     private plugin;
@@ -25,10 +25,10 @@ export declare class GroupsController {
     delete(request: KuzzleRequest): Promise<ApiGroupDeleteResult>;
     search(request: KuzzleRequest): Promise<ApiGroupSearchResult>;
     listItems(request: KuzzleRequest): Promise<ApiGroupListItemsResult>;
-    addAsset(request: KuzzleRequest): Promise<ApiGroupAddAssetsResult>;
-    removeAsset(request: KuzzleRequest): Promise<ApiGroupRemoveAssetsResult>;
-    addDevice(request: KuzzleRequest): Promise<ApiGroupAddDevicesResult>;
-    removeDevice(request: KuzzleRequest): Promise<ApiGroupRemoveDeviceResult>;
+    addAssets(request: KuzzleRequest): Promise<ApiGroupAddAssetsResult>;
+    removeAssets(request: KuzzleRequest): Promise<ApiGroupRemoveAssetsResult>;
+    addDevices(request: KuzzleRequest): Promise<ApiGroupAddDevicesResult>;
+    removeDevices(request: KuzzleRequest): Promise<ApiGroupRemoveDevicesResult>;
     mCreate(request: KuzzleRequest): Promise<ApiGroupMCreateResult>;
     mUpdate(request: KuzzleRequest): Promise<ApiGroupMUpdateResult>;
     mUpsert(request: KuzzleRequest): Promise<ApiGroupMUpsertResult>;

package/dist/lib/modules/group/GroupsService.d.ts

@@ -19,15 +19,15 @@ export declare class GroupsService extends BaseService {
         size?: number;
     }, request: KuzzleRequest): Promise<{
         assets: {
-            hits: import("kuzzle-sdk").KHit<AssetContent<any, any>>[];
+            hits: import("kuzzle-sdk").KHit<AssetContent<any>>[];
             total: number;
         };
         devices: {
-            hits: import("kuzzle-sdk").KHit<DeviceContent<any, any>>[];
+            hits: import("kuzzle-sdk").KHit<DeviceContent<any>>[];
             total: number;
         };
     }>;
-    addAsset(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+    addAssets(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
         group: KDocument<GroupContent>;
         successes: {
             _id: string;
@@ -43,7 +43,7 @@ export declare class GroupsService extends BaseService {
             reason: string;
         }[];
     }>;
-    removeAsset(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+    removeAssets(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
         group: KDocument<GroupContent>;
         successes: {
             _id: string;
@@ -59,7 +59,7 @@ export declare class GroupsService extends BaseService {
             reason: string;
         }[];
     }>;
-    addDevice(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
+    addDevices(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
         group: KDocument<GroupContent>;
         successes: {
             _id: string;
@@ -75,7 +75,7 @@ export declare class GroupsService extends BaseService {
             reason: string;
         }[];
     }>;
-    removeDevice(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
+    removeDevices(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
         group: KDocument<GroupContent>;
         successes: {
             _id: string;

package/dist/lib/modules/group/types/GroupsApi.d.ts

@@ -68,7 +68,7 @@ export type ApiGroupListItemsResult = {
     };
 };
 export interface ApiGroupAddAssetsRequest extends GroupControllerRequest {
-    action: "addAsset";
+    action: "addAssets";
     body: {
         path: string;
         assetIds: string[];
@@ -76,29 +76,29 @@ export interface ApiGroupAddAssetsRequest extends GroupControllerRequest {
 }
 export type ApiGroupAddAssetsResult = UpdateLinkResponse;
 export interface ApiGroupRemoveAssetsRequest extends GroupControllerRequest {
-    action: "removeAsset";
+    action: "removeAssets";
     body: {
         path: string;
         assetIds: string[];
     };
 }
 export type ApiGroupRemoveAssetsResult = UpdateLinkResponse;
-export interface ApiGroupAddDeviceRequest extends GroupControllerRequest {
-    action: "addDevice";
+export interface ApiGroupAddDevicesRequest extends GroupControllerRequest {
+    action: "addDevices";
     body: {
         path: string;
         deviceIds: string[];
     };
 }
 export type ApiGroupAddDevicesResult = UpdateLinkResponse;
-export interface ApiGroupRemoveDeviceRequest extends GroupControllerRequest {
-    action: "removeDevice";
+export interface ApiGroupRemoveDevicesRequest extends GroupControllerRequest {
+    action: "removeDevices";
     body: {
         path: string;
         deviceIds: string[];
     };
 }
-export type ApiGroupRemoveDeviceResult = UpdateLinkResponse;
+export type ApiGroupRemoveDevicesResult = UpdateLinkResponse;
 export interface ApiGroupMCreateRequest extends GroupControllerRequest {
     action: "mCreate";
     body: {

package/dist/lib/modules/plugin/DeviceManagerEngine.d.ts

@@ -42,7 +42,7 @@ export type AskEngineUpdateConflict = {
 export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlugin> {
     config: DeviceManagerConfiguration;
     get app(): Backend;
-    constructor(plugin: Plugin, adminConfigManager: ConfigManager, engineConfigManager: ConfigManager);
+    constructor(plugin: Plugin, platformConfigManager: ConfigManager, engineConfigManager: ConfigManager);
     /**
      * Return conflicts between the new and already present twin models
      *
@@ -124,6 +124,15 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @throws If it failed during the devices collection creation
      */
     createDevicesCollection(engineId: string): Promise<InternalCollection>;
+    /**
+     * Generate devices mappings and create the devices collection in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the devices collection creation
+     */
+    createPlatformDevicesCollection(): Promise<InternalCollection>;
     /**
      * Generate measures mappings and create the measures collection in the engine
      *
@@ -186,10 +195,10 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      */
     private getModels;
     /**
-     * Detach all devices of an index in the admin index
+     * Detach all devices of an index in the platform index
      *
      * @param engineId The target engine Id
      * @returns {any}
      */
-    private detachDevicesFromAdminIndex;
+    private detachDevicesFromPlatformIndex;
 }

package/dist/lib/modules/plugin/DeviceManagerPlugin.d.ts

@@ -6,7 +6,7 @@ import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
 export declare class DeviceManagerPlugin extends Plugin {
     config: DeviceManagerConfiguration;
     private deviceManagerEngine;
-    private adminConfigManager;
+    private platformConfigManager;
     private engineConfigManager;
     private engineController;
     private assetModule;
@@ -254,7 +254,7 @@ export declare class DeviceManagerPlugin extends Plugin {
      */
     init(config: JSONObject, context: PluginContext): Promise<void>;
     /**
-     * Initialize the administration index of the plugin
+     * Initialize the platform index of the plugin
      */
     private initDatabase;
     /**

package/dist/lib/modules/plugin/types/DeviceManagerConfiguration.d.ts

@@ -16,13 +16,13 @@ export type DeviceManagerConfiguration = {
         autoUpdate: true;
     };
     /**
-     * Administration index name
+     * Platform index name
      */
-    adminIndex: string;
+    platformIndex: string;
     /**
-     * Administration collections mappings (in admin index)
+     * Collection mappings for the platform index
      */
-    adminCollections: {
+    platformCollections: {
         config: {
             name: string;
             mappings: JSONObject;

package/dist/lib/modules/shared/services/DigitalTwinService.d.ts

@@ -1,7 +1,16 @@
+import { KuzzleRequest } from "kuzzle";
+import { JSONObject, KDocument } from "kuzzle-sdk";
 import { MeasureContent } from "../../measure";
 import { DeviceManagerPlugin, InternalCollection } from "../../plugin";
 import { ApiDigitalTwinMGetLastMeasuredAtResult } from "../types/DigitalTwinApi";
 import { BaseService } from "./BaseService";
+import { AssetContent } from "lib/modules/asset";
+import { DeviceContent, DeviceProvisioningContent } from "lib/modules/device";
+import { AssetModelContent, DeviceModelContent } from "lib/modules/model";
+type MeasureSlot = {
+    asset: string;
+    device: string;
+};
 export declare class DigitalTwinService extends BaseService {
     private targetCollection;
     private readonly digitalTwinType;
@@ -11,6 +20,27 @@ export declare class DigitalTwinService extends BaseService {
      * Gets the last measures of a digital twin
      */
     getLastMeasures(engineId: string, digitalTwinId: string, measureCount?: number): Promise<MeasureContent[]>;
+    /**
+     * Link a device to an asset.
+     */
+    linkAssetDevice(engineId: string, deviceId: string, assetId: string, measureSlots: {
+        asset: string;
+        device: string;
+    }[], implicitMeasuresLinking: boolean, request: KuzzleRequest): Promise<{
+        asset: KDocument<AssetContent>;
+        device: KDocument<DeviceContent>;
+    }>;
+    /**
+     * Unlink a device of an asset with lock
+     *
+     * @param {string} deviceId Id of the device
+     * @param {string} assetId Id of the asset
+     * @param {KuzzleRequest} request kuzzle request
+     */
+    unlinkAssetDevice(deviceId: string, assetId: string, measureSlots: MeasureSlot[], allMeasures: undefined | boolean, request: KuzzleRequest): Promise<{
+        asset: KDocument<AssetContent>;
+        device: KDocument<DeviceContent>;
+    }>;
     /**
      * Gets the last measures of multiple digital twins
      */
@@ -18,4 +48,43 @@ export declare class DigitalTwinService extends BaseService {
     getLastMeasuredAt(engineId: string, digitalTwinId: string): Promise<number>;
     mGetLastMeasuredAt(engineId: string, digitalTwinIds: string[]): Promise<ApiDigitalTwinMGetLastMeasuredAtResult>;
     private getAggregationQueryParameters;
+    /**
+     * Checks if the asset does not already have a linked device using one of the
+     * requested measure slots.
+     */
+    protected checkAssetAlreadyProvidedMeasures(asset: KDocument<AssetContent>, deviceId: string, requestedMeasureNames: MeasureSlot[]): void;
+    /**
+     * Checks if the device does not already have a linked asset using one of the
+     * requested measure slots.
+     */
+    protected checkDeviceAlreadyProvidingMeasures(device: KDocument<DeviceContent>, assetId: string, requestedMeasureNames: MeasureSlot[]): void;
+    /**
+     * Goes through the device available measures and add them into the link if:
+     *  - they are not already provided by another device
+     *  - they are not already present in the link request
+     *  - they are declared in the asset model
+     */
+    protected generateMissingAssetMeasureNames(asset: KDocument<AssetContent>, device: KDocument<DeviceContent>, assetModel: AssetModelContent, deviceModel: DeviceModelContent, requestedMeasureNames: MeasureSlot[]): void;
+    /**
+     * Internal logic of unlink a device of an asset
+     *
+     * @param {string} deviceId Id of the device
+     * @param {KuzzleRequest} request kuzzle request
+     */
+    protected _unlinkAssetDevice(deviceId: string, assetId: string, measureSlots: MeasureSlot[], allMeasures: undefined | boolean, request: KuzzleRequest): Promise<{
+        asset: KDocument<AssetContent>;
+        device: KDocument<DeviceContent>;
+    }>;
+    /**
+     * Retrieve the model document of an asset
+     * @param {any} engineGroup:string
+     * @param {any} model:string
+     * @returns {any}
+     */
+    protected getAssetModel(engineGroup: string, model: string): Promise<AssetModelContent>;
+    protected getDeviceModel(model: string): Promise<DeviceModelContent>;
+    protected getEngine(engineId: string): Promise<JSONObject>;
+    protected getDeviceProvisioning(deviceId: string): Promise<KDocument<DeviceProvisioningContent>>;
+    protected checkDeviceAttachedToEngine(device: KDocument<DeviceProvisioningContent>): void;
 }
+export {};

package/dist/lib/modules/shared/types/DigitalTwinContent.d.ts

@@ -1,16 +1,13 @@
-import { JSONObject, KDocumentContent } from "kuzzle-sdk";
+import { KDocumentContent } from "kuzzle-sdk";
 import { NamedMeasures } from "../../decoder";
 import { Metadata } from "./Metadata";
-import { DigitalTwinMeasures } from "./DigitalTwinMeasures";
 import { LocaleDetails } from "lib/modules/model";
-export interface DigitalTwinContent<TMeasures extends JSONObject = JSONObject, TMetadata extends Metadata = Metadata> extends KDocumentContent {
+export interface DigitalTwinContent<TMetadata extends Metadata = Metadata> extends KDocumentContent {
     model: string;
     modelLocales?: {
         [locale: string]: LocaleDetails;
     };
     reference: string;
     metadata: TMetadata;
-    measures: DigitalTwinMeasures<TMeasures>;
-    lastMeasuredAt: number;
     measureSlots: NamedMeasures;
 }

package/dist/lib/modules/shared/types/DigitalTwinEvents.d.ts

@@ -1,3 +1,4 @@
+import { User } from "kuzzle";
 import { MeasureContent } from "../../measure";
 export type AskDigitalTwinLastMeasuresGet = {
     name: "ask:device-manager:asset:get-last-measures" | "ask:device-manager:device:get-last-measures";
@@ -7,3 +8,32 @@ export type AskDigitalTwinLastMeasuresGet = {
     };
     result: MeasureContent[];
 };
+export type AskDigitalTwinLink = {
+    name: "ask:device-manager:device:link-asset" | "ask:device-manager:asset:link-device";
+    payload: {
+        engineId: string;
+        assetId: string;
+        deviceId: string;
+        user: User;
+        measureSlots: {
+            asset: string;
+            device: string;
+        }[];
+        implicitMeasuresLinking: undefined | boolean;
+    };
+    result: void;
+};
+export type AskDigitalTwinUnlink = {
+    name: `ask:device-manager:asset:unlink-device` | `ask:device-manager:device:unlink-asset`;
+    payload: {
+        deviceId: string;
+        assetId: string;
+        measureSlots: {
+            asset: string;
+            device: string;
+        }[];
+        allMeasures: undefined | boolean;
+        user: User;
+    };
+    result: void;
+};

package/dist/tests/application/assets/Container.d.ts

@@ -18,7 +18,7 @@ export type ContainerMeasurements = {
     position: PositionMeasurement;
     temperatureWeather: TemperatureMeasurement;
 };
-export interface ContainerAssetContent extends AssetContent<ContainerMeasurements, ContainerMetadata> {
+export interface ContainerAssetContent extends AssetContent<ContainerMetadata> {
     model: typeof modelName;
 }
 export declare const Container: AssetModel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle-device-manager-types",
-  "version": "3.0.0-next.7",
+  "version": "3.0.0-next.8",
   "description": "Shared types for Kuzzle Device Manager",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "main": "index.js",