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

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

@@ -1,5 +1,5 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
-import { AssetModelContent, DeviceModelContent, GroupModelContent, LocaleDetails, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
+import { AssetModelContent, DeviceModelContent, GroupAffinity, GroupModelContent, LocaleDetails, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
 import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../../measure/types/MeasureDefinition";
 interface ModelsControllerRequest {
@@ -8,7 +8,7 @@ interface ModelsControllerRequest {
 export interface ApiModelGetAssetRequest extends ModelsControllerRequest {
     action: "getAsset";
     model: string;
-    engineGroup: string;
+    engineGroups: string[];
 }
 export type ApiModelGetAssetResult = KDocument<AssetModelContent>;
 export interface ApiModelGetDeviceRequest extends ModelsControllerRequest {
@@ -24,12 +24,14 @@ export type ApiModelGetGroupResult = KDocument<GroupModelContent>;
 export interface ApiModelGetMeasureRequest extends ModelsControllerRequest {
     action: "getMeasure";
     type: string;
+    engineId?: string;
 }
 export type ApiModelGetMeasureResult = KDocument<MeasureModelContent>;
 export interface ApiModelWriteAssetRequest extends ModelsControllerRequest {
     action: "writeAsset";
     body: {
-        engineGroup: string;
+        engineGroups: string[];
+        engineIds?: string[];
         model: string;
         metadataDetails?: MetadataDetails;
         metadataGroups?: MetadataGroups;
@@ -58,7 +60,8 @@ export type ApiModelWriteDeviceResult = KDocument<DeviceModelContent>;
 export interface ApiModelWriteGroupRequest extends ModelsControllerRequest {
     action: "writeGroup";
     body: {
-        engineGroup: string;
+        affinity: GroupAffinity;
+        engineGroups: string[];
         model: string;
         metadataDetails?: MetadataDetails;
         metadataGroups?: MetadataGroups;
@@ -71,6 +74,7 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     action: "writeMeasure";
     body: {
         type: string;
+        engineIds?: string[];
         locales?: {
             [valueName: string]: LocaleDetails;
         };
@@ -82,7 +86,7 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
 export type ApiModelWriteMeasureResult = KDocument<MeasureModelContent>;
 export interface ApiModelUpdateAssetRequest extends ModelsControllerRequest {
     action: "updateAsset";
-    engineGroup: string;
+    engineGroups: string[];
     model: string;
     body: {
         metadataDetails?: MetadataDetails;
@@ -119,7 +123,7 @@ export interface ApiModelDeleteMeasureRequest extends ModelsControllerRequest {
 export type ApiModelDeleteMeasureResult = void;
 export interface ApiModelListAssetsRequest extends ModelsControllerRequest {
     action: "listAssets";
-    engineGroup: string;
+    engineGroups: string[];
 }
 export type ApiModelListAssetsResult = {
     models: KDocument<AssetModelContent>[];
@@ -134,7 +138,7 @@ export type ApiModelListDevicesResult = {
 };
 export interface ApiModelListGroupsRequest extends ModelsControllerRequest {
     action: "listGroups";
-    engineGroup: string;
+    engineGroups: string[];
 }
 export type ApiModelListGroupsResult = {
     models: KDocument<GroupModelContent>[];
@@ -142,6 +146,7 @@ export type ApiModelListGroupsResult = {
 };
 export interface ApiModelListMeasuresRequest extends ModelsControllerRequest {
     action: "listMeasures";
+    engineId?: string;
 }
 export type ApiModelListMeasuresResult = {
     models: KDocument<MeasureModelContent>[];
@@ -149,7 +154,7 @@ export type ApiModelListMeasuresResult = {
 };
 export interface ApiModelSearchAssetsRequest extends ModelsControllerRequest {
     action: "searchAssets";
-    engineGroup: string;
+    engineGroups: string[];
     from?: number;
     size?: number;
     scrollTTL?: string;
@@ -166,7 +171,7 @@ export interface ApiModelSearchDevicesRequest extends ModelsControllerRequest {
 export type ApiModelSearchDevicesResult = SearchResult<KHit<DeviceModelContent>>;
 export interface ApiModelSearchGroupsRequest extends ModelsControllerRequest {
     action: "searchGroups";
-    engineGroup: string;
+    engineGroups: string[];
     from?: number;
     size?: number;
     scrollTTL?: string;
@@ -175,6 +180,7 @@ export interface ApiModelSearchGroupsRequest extends ModelsControllerRequest {
 export type ApiModelSearchGroupsResult = SearchResult<KHit<GroupModelContent>>;
 export interface ApiModelSearchMeasuresRequest extends ModelsControllerRequest {
     action: "searchMeasures";
+    engineId?: string;
     from?: number;
     size?: number;
     scrollTTL?: string;

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

@@ -1,8 +1,10 @@
 import { JSONObject, KDocumentContent } from "kuzzle-sdk";
-import { NamedMeasures } from "../../../modules/decoder";
+import { NamedMeasures } from "../../decoder";
 import { MeasureDefinition } from "../../measure";
 export interface MeasureModelContent extends KDocumentContent {
     type: "measure";
+    engineGroups?: string[];
+    engineIds?: string[];
     measure: MeasureDefinition & {
         type: string;
         locales?: {
@@ -23,6 +25,23 @@ export interface MetadataObject {
 export interface MetadataMappings {
     [key: string]: MetadataProperty | MetadataObject;
 }
+export interface GroupAffinity {
+    /**
+     * Type of elements accepted in the group
+     */
+    type: Array<"assets" | "devices">;
+    /**
+     * Models accepted in the group
+     */
+    models: {
+        assets?: string[];
+        devices?: string[];
+    };
+    /**
+     * Weather the affinities are a strict restriction or not
+     */
+    strict: boolean;
+}
 export interface LocaleDetails {
     friendlyName: string;
     description: string;
@@ -136,7 +155,13 @@ export interface TooltipModels {
 }
 export interface AssetModelContent extends KDocumentContent {
     type: "asset";
-    engineGroup: string;
+    engineGroups: string[];
+    /**
+     * Optional list of engine IDs (tenant IDs) this model is scoped to.
+     * When set, the model is only available to the specified tenants.
+     * When absent, the model is available to all tenants in the engineGroups.
+     */
+    engineIds?: string[];
     asset: {
         /**
          * Name of the model
@@ -268,6 +293,9 @@ export interface AssetModelContent extends KDocumentContent {
          * ]
          */
         tooltipModels?: TooltipModels;
+        /**
+         * Translations specific to the model
+         */
         locales?: {
             [locale: string]: LocaleDetails;
         };
@@ -364,12 +392,16 @@ export interface DeviceModelContent extends KDocumentContent {
 }
 export interface GroupModelContent extends KDocumentContent {
     type: "group";
-    engineGroup: string;
+    engineGroups: string[];
     group: {
         /**
          * Name of the model
          */
         model: string;
+        /**
+         * Group types and model affinities
+         */
+        affinity: GroupAffinity;
         /**
          * Metadata mappings.
          *

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

@@ -1,6 +1,6 @@
 import { JSONObject } from "kuzzle-sdk";
-import { Decoder, NamedMeasures } from "../../../modules/decoder";
-import { LocaleDetails, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
+import { Decoder, NamedMeasures } from "../../decoder";
+import { GroupAffinity, LocaleDetails, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
 /**
  * Define an asset model
  *
@@ -279,6 +279,10 @@ export type DeviceModelDefinition = {
  *
  */
 export type GroupModelDefinition = {
+    /**
+     * Metadata mappings definition
+     */
+    affinity: GroupAffinity;
     /**
      * Metadata mappings definition
      */

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

@@ -2,7 +2,8 @@ import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelC
 export type AskModelAssetGet = {
     name: "ask:device-manager:model:asset:get";
     payload: {
-        engineGroup: string;
+        engineGroups: string[];
+        engineId?: string;
         model: string;
     };
     result: AssetModelContent;
@@ -18,6 +19,7 @@ export type AskModelMeasureGet = {
     name: "ask:device-manager:model:measure:get";
     payload: {
         type: string;
+        engineId?: string;
     };
     result: MeasureModelContent;
 };

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
      *
@@ -107,14 +107,14 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      */
     createAssetsHistoryCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
     /**
-     * Create the assets groups collection with the assets groups mappings in the engine
+     * Create the groups collection with the groups mappings in the engine
      *
      * @param engineId The target engine Id
      * @param engineGroup The engine group
      *
-     * @throws If it failed during the assets groups collection creation
+     * @throws If it failed during the groups collection creation
      */
-    createAssetsGroupsCollection(engineId: string): Promise<InternalCollection>;
+    createGroupsCollection(engineId: string): Promise<InternalCollection>;
     /**
      * Generate devices mappings and create the devices collection in the engine
      *
@@ -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

@@ -1,27 +1,29 @@
 import { Plugin, PluginContext } from "kuzzle";
 import { JSONObject } from "kuzzle-sdk";
 import { MeasureDefinition } from "../measure";
-import { AssetModelDefinition, DeviceModelDefinition, GroupModelDefinition } from "../model";
+import { DecodersRegister } from "../decoder";
+import { AssetModelDefinition, DeviceModelDefinition, GroupModelDefinition, ModelsRegister } from "../model";
 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;
     private deviceModule;
+    private groupModule;
     private decoderModule;
     private measureModule;
     private modelModule;
-    private modelsRegister;
-    private decodersRegister;
+    readonly modelsRegister: ModelsRegister;
+    readonly decodersRegister: DecodersRegister;
     private get sdk();
     get models(): {
         /**
          * Register an asset model
          *
-         * @param engineGroup Engine group name
+         * @param engineGroups Engine group names
          * @param model Name of the asset model. Must follow a naming convention in PascalCase.
          * @param definition Object containing the asset model definition, including:
          *        - measures: Array describing measure names and their types.
@@ -121,7 +123,7 @@ export declare class DeviceManagerPlugin extends Plugin {
          * );
          * ```
          */
-        registerAsset: (engineGroup: string, model: string, definition: AssetModelDefinition) => void;
+        registerAsset: (engineGroups: string[], model: string, definition: AssetModelDefinition) => void;
         /**
          * Register a device.
          *
@@ -229,7 +231,7 @@ export declare class DeviceManagerPlugin extends Plugin {
          * );
          * ```
          */
-        registerGroup: (engineGroup: string, model: string, definition: GroupModelDefinition) => void;
+        registerGroup: (engineGroups: string[], model: string, definition: GroupModelDefinition) => void;
         /**
          * Register a new measure
          *
@@ -253,7 +255,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

@@ -6,12 +6,6 @@ export type DeviceManagerConfiguration = {
      * Useful to start the plugin even if the mappings are not up to date.
      */
     ignoreStartupErrors: boolean;
-    /**
-     * Should be set to true to historize measures in asset-history collection (deprecated)
-     *
-     * Should be enabled only for backward compatibility because it leads to important performance costs.
-     */
-    assetsHistorizesMeasures: boolean;
     engine: {
         /**
          * Auto update collection mappings with models
@@ -22,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;
@@ -51,21 +45,21 @@ export type DeviceManagerConfiguration = {
             mappings: JSONObject;
             settings?: JSONObject;
         };
-        asset: {
+        assets: {
             name: string;
             mappings: CollectionMappings;
             settings?: JSONObject;
         };
-        assetGroups: {
+        groups: {
             name: string;
-            mappings: JSONObject;
+            mappings: CollectionMappings;
             settings?: JSONObject;
         };
         assetHistory: {
             name: string;
             settings?: JSONObject;
         };
-        device: {
+        devices: {
             name: string;
             mappings: CollectionMappings;
             settings?: JSONObject;
@@ -73,6 +67,7 @@ export type DeviceManagerConfiguration = {
         measures: {
             name: string;
             settings?: JSONObject;
+            mappings: CollectionMappings;
         };
     };
 };

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

@@ -1,7 +1,7 @@
 export declare enum InternalCollection {
     ASSETS = "assets",
     ASSETS_HISTORY = "assets-history",
-    ASSETS_GROUPS = "assets-groups",
+    GROUPS = "groups",
     DEVICES = "devices",
     MEASURES = "measures",
     MODELS = "models",

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

@@ -1,2 +1,3 @@
 export * from "./DeviceManagerConfiguration";
 export * from "./Pipes";
+export * from "./InternalCollection";

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

@@ -22,10 +22,12 @@ export interface Column {
     isMeasure?: boolean;
     isIsoDate?: boolean;
 }
+export type ExportStreamAugmenter = (result: SearchResult<KHit<KDocumentContentGeneric>>, columns: Column[], engineId: string) => Promise<void>;
 export declare abstract class AbstractExporter<P extends ExportParams = ExportParams> {
     protected plugin: DeviceManagerPlugin;
     protected target: InternalCollection;
     protected config: ExporterOption;
+    protected exportStreamAugmenters: ExportStreamAugmenter[];
     constructor(plugin: DeviceManagerPlugin, target: InternalCollection, config?: Partial<ExporterOption>);
     protected get sdk(): import("kuzzle").EmbeddedSDK;
     protected get ms(): any;
@@ -43,5 +45,5 @@ export declare abstract class AbstractExporter<P extends ExportParams = ExportPa
     prepareExport(engineId: string, user: User, params: P): Promise<string>;
     protected formatHit(columns: Column[], hit: KHit<KDocumentContentGeneric>): string[];
     getExport(engineId: string, exportId: string): Promise<P>;
-    getExportStream(request: SearchResult<KHit<KDocumentContentGeneric>>, columns: Column[]): Promise<PassThrough>;
+    getExportStream(request: SearchResult<KHit<KDocumentContentGeneric>>, columns: Column[], engineId: string): Promise<PassThrough>;
 }

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

@@ -1,8 +1,12 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { UUID } from "node:crypto";
-import { AbstractExporter } from "./AbstractExporter";
+import { DeviceManagerPlugin, InternalCollection } from "../../plugin";
+import { AbstractExporter, ExporterOption } from "./AbstractExporter";
 export declare class DigitalTwinExporter extends AbstractExporter {
+    protected plugin: DeviceManagerPlugin;
+    protected target: InternalCollection;
+    constructor(plugin: DeviceManagerPlugin, target: InternalCollection, config?: Partial<ExporterOption>);
     protected exportRedisKey(engineId: string, exportId: string): string;
     protected getLink(engineId: string, exportId: UUID): string;
     sendExport(engineId: string, exportId: string): Promise<import("stream").PassThrough>;
@@ -11,4 +15,5 @@ export declare class DigitalTwinExporter extends AbstractExporter {
      */
     private getNamedMeasures;
     private generateMeasureColumns;
+    private addMeasuresToExportStream;
 }

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

@@ -1,10 +1,18 @@
-import { JSONObject } from "kuzzle-sdk";
+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;
+    readonly targetCollection: InternalCollection;
     private readonly digitalTwinType;
     constructor(plugin: DeviceManagerPlugin, targetCollection: InternalCollection);
     protected registerAskEvents(): void;
@@ -12,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
      */
@@ -19,5 +48,44 @@ 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 to the asset by another device
+     *  - they are not already provided to another asset by the device
+     *  - they are not already present in the link request
+     *  - they are declared in the asset model
+     */
+    protected addAvailableLinkableMeasures(asset: KDocument<AssetContent>, device: KDocument<DeviceContent>, assetModel: AssetModelContent, deviceModel: DeviceModelContent, requestedMeasureSlots: 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, engineId?: string): Promise<AssetModelContent>;
+    protected getDeviceModel(model: string): Promise<DeviceModelContent>;
     getEngine(engineId: string): Promise<JSONObject>;
+    protected getDeviceProvisioning(deviceId: string): Promise<import("kuzzle").KDocument<DeviceProvisioningContent>>;
+    protected checkDeviceAttachedToEngine(device: KDocument<DeviceProvisioningContent>): void;
 }
+export {};

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

@@ -1,14 +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

@@ -1,4 +1,5 @@
-import { Metadata, AssetContent, TemperatureMeasurement, PositionMeasurement, AssetModel } from "../../../index";
+import { Metadata, AssetContent, AssetModel } from "../../../index";
+import { TemperatureMeasurement, PositionMeasurement } from "../measures";
 declare const modelName = "Container";
 export interface ContainerMetadata extends Metadata {
     height: number;
@@ -17,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/dist/tests/application/decoders/DummyTempDecoder.d.ts

@@ -1,5 +1,15 @@
 import { JSONObject } from "kuzzle-sdk";
 import { Decoder, DecodedPayload } from "../../../index";
+export declare const dummyTempDeviceMeasures: readonly [{
+    readonly name: "temperature";
+    readonly type: "temperature";
+}, {
+    readonly name: "accelerationSensor";
+    readonly type: "acceleration";
+}, {
+    readonly name: "battery";
+    readonly type: "battery";
+}];
 export declare class DummyTempDecoder extends Decoder {
     measures: readonly [{
         readonly name: "temperature";

package/dist/tests/application/decoders/DummyTempPositionDecoder.d.ts

@@ -1,5 +1,15 @@
 import { JSONObject } from "kuzzle-sdk";
 import { Decoder, DecodedPayload } from "../../../index";
+export declare const dummyTempPositionDeviceMeasures: readonly [{
+    readonly name: "temperature";
+    readonly type: "temperature";
+}, {
+    readonly name: "battery";
+    readonly type: "battery";
+}, {
+    readonly name: "position";
+    readonly type: "position";
+}];
 export declare class DummyTempPositionDecoder extends Decoder {
     measures: readonly [{
         readonly name: "temperature";