kuzzle-device-manager-types 3.0.0-next.1 → 3.0.0-next.10

package/dist/bin/migration/migration_platform_index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/migration/migration_tenant_index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/migration/utils.d.ts

@@ -0,0 +1,18 @@
+import { JSONObject } from "kuzzle-sdk";
+export declare function transformDocuments(collection: string, indexPath: string, callBack: (string: any) => JSONObject, endCallBack?: () => void): void;
+export declare function clearProperties(obj: any, properties: any): {};
+export interface ModelRegistry {
+    assets: {
+        [key: string]: {
+            type: string;
+            name: string;
+        }[];
+    };
+    devices: {
+        [key: string]: {
+            type: string;
+            name: string;
+        }[];
+    };
+}
+export declare function retrieveModelMeasureSlots(pathToPlatformIndex: string, callBack: (models: ModelRegistry) => void): void;

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

@@ -3,6 +3,5 @@ export declare class AssetModule extends Module {
     private assetService;
     private assetHistoryService;
     private assetController;
-    private assetGroupsController;
     init(): Promise<void>;
 }

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

@@ -3,7 +3,7 @@ import { JSONObject, KDocument, KHit, SearchResult, mReplaceResponse } from "kuz
 import { DeviceManagerPlugin } from "../plugin";
 import { DigitalTwinService, Metadata, SearchParams } from "../shared";
 import { AssetHistoryService } from "./AssetHistoryService";
-import { ApiAssetMigrateTenantResult } from "./types/AssetApi";
+import { ApiAssetMigrateTenantResult, ApiAssetUpdateModelLocales } from "./types/AssetApi";
 import { AssetContent } from "./types/AssetContent";
 export declare class AssetService extends DigitalTwinService {
     private assetHistoryService;
@@ -22,6 +22,7 @@ export declare class AssetService extends DigitalTwinService {
      * Update or Create an asset metadata
      */
     upsert(engineId: string, model: string, reference: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    private _create;
     /**
      * Create an asset metadata
      */
@@ -31,13 +32,19 @@ 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
      */
     mReplaceAndHistorize(engineId: string, assets: KDocument<AssetContent>[], removedMetadata: string[], { refresh }: {
         refresh: any;
     }): Promise<mReplaceResponse>;
-    private getEngine;
+    /**
+     * Retrieve locales with the specified model and search all assets related to the model to update the locales.
+     * The operation is historized.
+     * @param request
+     * @param model
+     */
+    updateModelLocales(request: KuzzleRequest, model: string): Promise<ApiAssetUpdateModelLocales[]>;
     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 } 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;
@@ -36,4 +36,18 @@ export declare class AssetsController {
     migrateTenant(request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
     getLastMeasuredAt(request: KuzzleRequest): Promise<ApiAssetGetLastMeasuredAtResult>;
     mGetLastMeasuredAt(request: KuzzleRequest): Promise<ApiAssetMGetLastMeasuredAtResult>;
+    /**
+     * Update modelLocales of all assets related to the specified asset model.
+     * This operation is done to make the search assets feature  up to date
+     * @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/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,9 +1,10 @@
-import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
+import { JSONObject, KDocument, KHit, SearchResult, UpdateByQueryResponse } from "kuzzle-sdk";
 import { MeasureContent, Measurement } from "../../../modules/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;
@@ -33,7 +34,6 @@ export interface ApiAssetMetadataReplaceRequest extends AssetsControllerRequest
 export type ApiAssetMetadataReplaceResult = KDocument<AssetContent>;
 export interface ApiAssetUpsertRequest extends AssetsControllerRequest {
     action: "upsert";
-    _id: string;
     refresh?: string;
     body: {
         model: string;
@@ -156,6 +156,7 @@ export interface ApiAssetMigrateTenantRequest extends AssetsControllerRequest {
     body: {
         assetsList: string[];
         newEngineId: string;
+        includeDevices?: boolean;
     };
 }
 export type ApiAssetMigrateTenantResult = {
@@ -166,4 +167,89 @@ export type ApiAssetGetLastMeasuredAtRequest = ApiDigitalTwinGetLastMeasuredAtRe
 export type ApiAssetGetLastMeasuredAtResult = ApiDigitalTwinGetLastMeasuredAtResult;
 export type ApiAssetMGetLastMeasuredAtRequest = ApiDigitalTwinMGetLastMeasuredAtRequest<AssetsControllerName>;
 export type ApiAssetMGetLastMeasuredAtResult = ApiDigitalTwinMGetLastMeasuredAtResult;
+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,20 +19,19 @@ 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;
     }>;
 }
@@ -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,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/types/DecoderApi.d.ts

@@ -4,7 +4,6 @@ interface DecodersControllerRequest {
 }
 export interface ApiDecoderListRequest extends DecodersControllerRequest {
     action: "list";
-    _id: string;
 }
 export type ApiDecoderListResult = {
     decoders: DecoderContent[];

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

@@ -3,22 +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
      */
@@ -30,6 +26,14 @@ 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>>>;
+    /**
+     * 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
+     */
+    private _attachEngine;
     /**
      * Attach the device to an engine
      *
@@ -45,41 +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;
-    /**
-     * Unlink a device of an asset
-     *
-     * @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

@@ -25,7 +25,6 @@ export type ApiDeviceUpdateResult = KDocument<DeviceContent>;
 export type ApiDeviceMetadataReplaceResult = KDocument<DeviceContent>;
 export interface ApiDeviceUpsertRequest extends DevicesControllerRequest {
     action: "upsert";
-    _id: string;
     refresh?: string;
     body: {
         model: string;
@@ -60,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 {
@@ -82,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 {