kuzzle-device-manager-types 2.11.0 → 3.0.0-3-dev.1

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export * from "./lib/modules/measure/exports";
 export * from "./lib/modules/decoder/exports";
 export * from "./lib/modules/shared/exports";
 export * from "./lib/modules/model/exports";
+export * from "./lib/modules/group/exports";

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

@@ -1,13 +1,10 @@
-import { Module } from "../shared/Module";
 import { DeviceManagerPlugin } from "../plugin";
+import { Module } from "../shared/Module";
 export declare class AssetModule extends Module {
     private assetService;
     private assetHistoryService;
     private assetController;
-    private assetGroupsController;
-    private assetsGroupsService;
     private logger;
-    private assetsGroupsLogger;
     constructor(plugin: DeviceManagerPlugin);
     init(): Promise<void>;
 }

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

@@ -2,13 +2,13 @@ import { KuzzleRequest, User } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult, mReplaceResponse } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
 import { DigitalTwinService, Metadata, SearchParams } from "../shared";
+import { KuzzleLogger } from "kuzzle-logger";
 import { AssetHistoryService } from "./AssetHistoryService";
-import { ApiAssetMigrateTenantResult, ApiAssetUpdateModelLocales } from "./types/AssetApi";
+import { ApiAssetMigrateTenantResult, ApiAssetUnlinkDevicesResult, ApiAssetUpdateModelLocales } from "./types/AssetApi";
 import { AssetContent } from "./types/AssetContent";
-import { KuzzleLogger } from "kuzzle-logger";
 export declare class AssetService extends DigitalTwinService {
+    readonly assetHistoryService: AssetHistoryService;
     readonly logger: KuzzleLogger;
-    private assetHistoryService;
     constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService, assetLogger: KuzzleLogger);
     registerAskEvents(): void;
     get(engineId: string, assetId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
@@ -34,7 +34,8 @@ 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>;
+    unlinkDevices(assetId: string, allMeasures: boolean, deviceIds: string[], measureSlots: string[], request: KuzzleRequest): Promise<ApiAssetUnlinkDevicesResult>;
+    migrateTenant(user: User, assetsList: string[], engineId: string, newEngineId: string, includeDevices: boolean, request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
     /**
      * Replace an asset metadata
      */
@@ -48,5 +49,7 @@ export declare class AssetService extends DigitalTwinService {
      * @param model
      */
     updateModelLocales(request: KuzzleRequest, model: string): Promise<ApiAssetUpdateModelLocales[]>;
+    addMeasureSlot(assetId: string, measureSlot: AssetContent["measureSlots"][0], engineId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    removeMeasureSlot(assetId: string, measureSlotName: string, engineId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     private refreshModel;
 }

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

@@ -1,14 +1,16 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
+import { MeasureExporter } from "../measure";
 import { DeviceManagerPlugin } from "../plugin";
+import { DigitalTwinExporter } from "../shared";
 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, ApiAssetAddMeasureSlotResult, ApiAssetRemoveMeasureSlotResult } from "./types/AssetApi";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class AssetsController {
-    private plugin;
-    private assetService;
+    readonly plugin: DeviceManagerPlugin;
+    readonly assetService: AssetService;
     definition: ControllerDefinition;
-    private exporter;
-    private measureExporter;
+    readonly exporter: DigitalTwinExporter;
+    readonly measureExporter: MeasureExporter;
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin, assetService: AssetService, assetlogger: KuzzleLogger);
     get(request: KuzzleRequest): Promise<ApiAssetGetResult>;
@@ -31,8 +33,8 @@ export declare class AssetsController {
      * @throws If the asset does not exists
      */
     private getTypeFromMeasureSlot;
-    mMeasureIngest(request: KuzzleRequest): Promise<void>;
-    measureIngest(request: KuzzleRequest): Promise<void>;
+    mIngestMeasure(request: KuzzleRequest): Promise<void>;
+    ingestMeasure(request: KuzzleRequest): Promise<void>;
     exportMeasures(request: KuzzleRequest): Promise<any>;
     export(request: KuzzleRequest): Promise<any>;
     migrateTenant(request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
@@ -44,4 +46,20 @@ 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>;
+    /**
+     * Remove a measure slot from an asset
+     */
+    addMeasureSlot(request: KuzzleRequest): Promise<ApiAssetAddMeasureSlotResult>;
+    /**
+     * Remove a measure slot from an asset
+     */
+    removeMeasureSlot(request: KuzzleRequest): Promise<ApiAssetRemoveMeasureSlotResult>;
 }

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

@@ -2,11 +2,7 @@ export * from "./types/AssetContent";
 export * from "./types/AssetHistoryContent";
 export * from "./types/AssetEvents";
 export * from "./types/AssetApi";
-export * from "./types/AssetGroupContent";
-export * from "./types/AssetGroupsApi";
 export * from "./roles/RoleAssetsAdmin";
 export * from "./roles/RoleAssetsReader";
-export * from "./roles/RoleAssetsGroupsAdmin";
-export * from "./roles/RoleAssetsGroupsReader";
 export * from "./collections/assetsMappings";
 export * from "./collections/assetsHistoryMappings";

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

@@ -1,6 +1,6 @@
 export * from "./collections/assetsMappings";
 export * from "./collections/assetsHistoryMappings";
-export * from "./collections/assetsGroupsMapping";
+export * from "../group/collections/groupsMappings";
 export * from "./types/AssetContent";
 export * from "./types/AssetHistoryContent";
 export * from "./types/AssetEvents";
@@ -9,5 +9,3 @@ export * from "./model/AssetSerializer";
 export * from "./AssetModule";
 export * from "./roles/RoleAssetsAdmin";
 export * from "./roles/RoleAssetsReader";
-export * from "./roles/RoleAssetsGroupsAdmin";
-export * from "./roles/RoleAssetsGroupsReader";

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

@@ -1,17 +1,13 @@
 import { JSONObject, KDocument, KHit, SearchResult, UpdateByQueryResponse } from "kuzzle-sdk";
-import { MeasureContent, Measurement } from "../../../modules/measure";
+import { MeasureContent, Measurement } from "../../measure";
 import { ApiDigitalTwinGetLastMeasuredAtRequest, ApiDigitalTwinGetLastMeasuredAtResult, ApiDigitalTwinGetLastMeasuresRequest, ApiDigitalTwinGetLastMeasuresResult, ApiDigitalTwinMGetLastMeasuredAtRequest, ApiDigitalTwinMGetLastMeasuredAtResult, ApiDigitalTwinMGetLastMeasuresRequest, ApiDigitalTwinMGetLastMeasuresResult, Metadata } from "../../shared";
 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;
-    /**
-     * ? Request parameter used by SoftTenant module
-     * ! Not used directly in this plugin
-     */
-    softTenantId?: string | string[] | null;
 }
 export interface ApiAssetGetRequest extends AssetsControllerRequest {
     action: "get";
@@ -92,13 +88,13 @@ export type ApiAssetGetMeasuresResult = {
 };
 type TypelessApiMeasureSource = Omit<ApiMeasureSource, "type">;
 export interface ApiAssetMeasureIngestRequest extends AssetsControllerRequest {
-    action: "measureIngest";
+    action: "ingestMeasure";
     assetId: string;
     engineId: string;
     slotName: string;
     body: {
         dataSource: TypelessApiMeasureSource;
-        measuredAt: number | string;
+        measuredAt: number;
         values: JSONObject;
     };
 }
@@ -107,7 +103,7 @@ type APIDecodedMeasurement = Omit<Measurement, "type"> & {
     slotName: string;
 };
 export interface ApiAssetmMeasureIngestRequest extends AssetsControllerRequest {
-    action: "mMeasureIngest";
+    action: "mIngestMeasure";
     assetId: string;
     engineId: string;
     body: {
@@ -158,6 +154,7 @@ export interface ApiAssetMigrateTenantRequest extends AssetsControllerRequest {
     body: {
         assetsList: string[];
         newEngineId: string;
+        includeDevices?: boolean;
     };
 }
 export type ApiAssetMigrateTenantResult = {
@@ -172,4 +169,122 @@ 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: {
+        /**
+         * This options allows to unlink all the measures of the asset
+         */
+        allMeasures?: boolean;
+        /**
+         * Names of the measure slots of the asset to unlink.
+         *
+         * string[]
+         *
+         * @example
+         *
+         * ['externalTemperature','position']
+         */
+        measureSlots?: string[];
+        /**
+         * Ids of the devices to unlink.
+         *
+         * string[]
+         *
+         * @example
+         *
+         * ['First-asset','Second-asset']
+         */
+        devices?: string[];
+    };
+}
+export type ApiAssetUnlinkDevicesResult = {
+    asset: KDocument<AssetContent>;
+    devices: KDocument<DeviceContent>[];
+};
+export interface ApiAssetAddMeasureSlotRequest extends AssetsControllerRequest {
+    action: "addMeasureSlot";
+    _id: string;
+    body: {
+        /**
+         * Measure slot containing the name of the slot and it's type of measurement
+         *
+         * { name: string , type: string}
+         *
+         * @example
+         *
+         *   { name: "externalTemperature", type: "temperature" }
+         */
+        measureSlot: {
+            name: string;
+            type: string;
+        };
+    };
+}
+export type ApiAssetAddMeasureSlotResult = KDocument<AssetContent>;
+export interface ApiAssetRemoveMeasureSlotRequest extends AssetsControllerRequest {
+    action: "removeMeasureSlot";
+    _id: string;
+    body: {
+        /**
+         * Name of the measure slot to be removed
+         *
+         *
+         * @example
+         *
+         *   measureSlot: "externalTemperature",
+         */
+        measureSlot: string;
+    };
+}
+export type ApiAssetRemoveMeasureSlotResult = KDocument<AssetContent>;
 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,27 +19,21 @@ 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;
         }>;
     }>;
     /**
-     * Id's of asset groups
+     * Path's of asset groups
      */
     groups: Array<{
-        id: string;
+        path: string;
         date: number;
     }>;
-    /**
-     * Id's of soft tenants
-     * ! Not used directly in this plugin
-     */
-    softTenant?: Array<string>;
 }
 /**
  * Asset description used to contextualize each measure data point
@@ -54,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" | "softTenant">;
+} & Pick<AssetContent<TMetadata>, "model" | "reference" | "metadata" | "groups">;

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

@@ -1,16 +1,9 @@
-import { JSONObject, KDocumentContent } from "kuzzle-sdk";
+import { KDocumentContent } from "kuzzle-sdk";
 import { Metadata } from "../../shared";
 import { AssetContent } from "./AssetContent";
 export type AssetHistoryMetadata = {
     names: string[];
 };
-export type AssetHistoryEventMeasure = {
-    name: "measure";
-    measure: {
-        names: string[];
-    };
-    metadata?: AssetHistoryMetadata;
-};
 export type AssetHistoryEventMetadata = {
     name: "metadata";
     metadata: AssetHistoryMetadata;
@@ -27,11 +20,11 @@ export type AssetHistoryEventUnlink = {
         deviceId: string;
     };
 };
-export type AssetHistoryEvent = AssetHistoryEventMeasure | AssetHistoryEventMetadata | AssetHistoryEventLink | AssetHistoryEventUnlink;
+export type AssetHistoryEvent = AssetHistoryEventMetadata | AssetHistoryEventLink | AssetHistoryEventUnlink;
 /**
  * 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
      *
@@ -48,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/decoder/DecodedPayload.d.ts

@@ -43,5 +43,7 @@ export declare class DecodedPayload<TDecoder extends Decoder = Decoder> {
      * Get the metadata for a device
      */
     getMetadata(deviceReference: string): JSONObject;
+    hasMeasurements(): boolean;
+    hasMetadata(): boolean;
     private validateMeasurement;
 }

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

@@ -1,8 +1,8 @@
 import { HttpRoute, KuzzleRequest } from "kuzzle";
 import { JSONObject } from "kuzzle-sdk";
+import { KuzzleLogger } from "kuzzle-logger";
 import { DecodedPayload } from "./DecodedPayload";
 import { DecoderContent } from "./types/DecoderContent";
-import { KuzzleLogger } from "kuzzle-logger";
 /**
  * Array of measures declaration
  *

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

@@ -6,8 +6,8 @@ import { KuzzleLogger } from "kuzzle-logger";
 export declare class DecodersController {
     private payloadService;
     private decodersRegister;
-    readonly logger: KuzzleLogger;
     definition: ControllerDefinition;
+    readonly logger: KuzzleLogger;
     constructor(payloadService: PayloadService, decodersRegister: DecodersRegister, logger: KuzzleLogger);
     /**
      * List all available decoders
@@ -17,6 +17,9 @@ export declare class DecodersController {
      * Clean payload collection for a time period
      */
     prunePayloads(request: KuzzleRequest): Promise<ApiDecoderPrunePayloadsResult>;
+    /**
+     * Route request to appropriate decoder
+     */
     route(request: KuzzleRequest): Promise<{
         valid: boolean;
     }>;

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

@@ -36,4 +36,5 @@ export declare class PayloadService extends BaseService {
         deviceModel?: string;
     }): Promise<number>;
     receiveUnknown(deviceModel: string, payload: JSONObject, apiAction: string): Promise<void>;
+    private getDeviceMeasureSource;
 }

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

@@ -3,25 +3,21 @@ 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";
+import { ApiDeviceUnlinkAssetsResult } from "./exports";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class DeviceService extends DigitalTwinService {
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
     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
      */
@@ -33,13 +29,13 @@ export declare class DeviceService extends DigitalTwinService {
     update(engineId: string, deviceId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     delete(engineId: string, deviceId: string, request: KuzzleRequest): Promise<void>;
     search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<DeviceContent>>>;
+    unlinkAssets(deviceId: string, allMeasures: boolean, assetIds: string[], measureSlots: string[], request: KuzzleRequest): Promise<ApiDeviceUnlinkAssetsResult>;
     /**
      * Internal logic to attach the device to an engine
      *
      * @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;
     /**
@@ -57,46 +53,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 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";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class DevicesController {
     private plugin;
@@ -30,13 +30,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,