kuzzle-device-manager-types 2.4.0-beta.2 → 2.4.0-beta.20

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

@@ -1,9 +1,7 @@
 import { DeviceManagerPlugin } from "../plugin";
+import { BaseService } from "../shared";
 import { AssetHistoryContent, AssetHistoryEvent } from "./types/AssetHistoryContent";
-export declare class AssetHistoryService {
-    private context;
-    private config;
-    private get sdk();
+export declare class AssetHistoryService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     add<TAssetHistoryEvent extends AssetHistoryEvent>(engineId: string, histories: AssetHistoryContent[]): Promise<void>;
 }

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

@@ -1,38 +1,37 @@
-import { User } from "kuzzle";
+import { KuzzleRequest, User } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult, mReplaceResponse } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
-import { Metadata } from "../shared";
+import { BaseService, Metadata, SearchParams } from "../shared";
 import { AssetHistoryService } from "./AssetHistoryService";
+import { ApiAssetMigrateTenantResult } from "./types/AssetApi";
 import { AssetContent } from "./types/AssetContent";
-export declare class AssetService {
-    private context;
-    private config;
+export declare class AssetService extends BaseService {
     private assetHistoryService;
-    private get sdk();
-    private get app();
-    private get impersonatedSdk();
     constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService);
     registerAskEvents(): void;
-    get(engineId: string, assetId: string): Promise<KDocument<AssetContent>>;
+    get(engineId: string, assetId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
-     * Updates an asset metadata
+     * Update an asset metadata
      */
-    update(user: User, engineId: string, assetId: string, metadata: Metadata, { refresh }: {
-        refresh: any;
-    }): Promise<KDocument<AssetContent>>;
-    create(user: User, engineId: string, model: string, reference: string, metadata: JSONObject, { refresh }: {
-        refresh: any;
-    }): Promise<KDocument<AssetContent>>;
-    delete(user: User, engineId: string, assetId: string, { refresh, strict }: {
-        refresh: any;
-        strict: boolean;
-    }): Promise<void>;
-    search(engineId: string, searchBody: JSONObject, { from, size, scroll, lang, }: {
-        from?: number;
-        size?: number;
-        scroll?: string;
-        lang?: string;
-    }): Promise<SearchResult<KHit<AssetContent>>>;
+    update(engineId: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    /**
+     * Replace an asset metadata
+     */
+    replaceMetadata(engineId: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    /**
+     * Update or Create an asset metadata
+     */
+    upsert(engineId: string, model: string, reference: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    /**
+     * Create an asset metadata
+     */
+    create(engineId: string, model: string, reference: string, metadata: JSONObject, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    /**
+     * Delete an asset metadata
+     */
+    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>;
     /**
      * Replace an asset metadata
      */

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, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult } from "./types/AssetApi";
+import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult } from "./types/AssetApi";
 export declare class AssetsController {
     private plugin;
     private assetService;
@@ -10,11 +10,14 @@ export declare class AssetsController {
     private measureExporter;
     constructor(plugin: DeviceManagerPlugin, assetService: AssetService);
     get(request: KuzzleRequest): Promise<ApiAssetGetResult>;
+    upsert(request: KuzzleRequest): Promise<ApiAssetUpsertResult>;
     update(request: KuzzleRequest): Promise<ApiAssetUpdateResult>;
+    replaceMetadata(request: KuzzleRequest): Promise<ApiAssetMetadataReplaceResult>;
     create(request: KuzzleRequest): Promise<ApiAssetCreateResult>;
     delete(request: KuzzleRequest): Promise<ApiAssetDeleteResult>;
     search(request: KuzzleRequest): Promise<ApiAssetSearchResult>;
     getMeasures(request: KuzzleRequest): Promise<ApiAssetGetMeasuresResult>;
     exportMeasures(request: KuzzleRequest): Promise<any>;
     export(request: KuzzleRequest): Promise<any>;
+    migrateTenant(request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
 }

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

@@ -20,6 +20,26 @@ export interface ApiAssetUpdateRequest extends AssetsControllerRequest {
     };
 }
 export type ApiAssetUpdateResult = KDocument<AssetContent>;
+export interface ApiAssetMetadataReplaceRequest extends AssetsControllerRequest {
+    action: "replaceMetadata";
+    _id: string;
+    refresh?: string;
+    body: {
+        metadata: Metadata;
+    };
+}
+export type ApiAssetMetadataReplaceResult = KDocument<AssetContent>;
+export interface ApiAssetUpsertRequest extends AssetsControllerRequest {
+    action: "upsert";
+    _id: string;
+    refresh?: string;
+    body: {
+        model: string;
+        reference: string;
+        metadata: Metadata;
+    };
+}
+export type ApiAssetUpsertResult = KDocument<AssetContent>;
 export interface ApiAssetCreateRequest extends AssetsControllerRequest {
     action: "create";
     refresh?: string;
@@ -96,4 +116,16 @@ export interface ApiAssetExportRequest extends AssetsControllerRequest {
 export type ApiAssetExportResult = {
     link: string;
 };
+export interface ApiAssetMigrateTenantRequest extends AssetsControllerRequest {
+    action: "migrateTenant";
+    engineId: string;
+    body: {
+        assetsList: string[];
+        newEngineId: string;
+    };
+}
+export type ApiAssetMigrateTenantResult = {
+    errors: string[];
+    successes: string[];
+};
 export {};

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

@@ -49,4 +49,4 @@ export type AssetMeasureContext<TMetadata extends Metadata = Metadata> = {
      * Name of the measure for the Asset
      */
     measureName: string;
-} & Pick<AssetContent<JSONObject, TMetadata>, "model" | "reference" | "metadata">;
+} & Pick<AssetContent<JSONObject, TMetadata>, "model" | "reference" | "metadata" | "groups">;

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

@@ -19,6 +19,17 @@ export type NamedMeasures = Array<{
  */
 export declare abstract class Decoder {
     private _http?;
+    /**
+     * Internal logger.
+     */
+    log: {
+        debug: (message: any) => void;
+        error: (message: any) => void;
+        info: (message: any) => void;
+        silly: (message: any) => void;
+        verbose: (message: any) => void;
+        warn: (message: any) => void;
+    };
     /**
      * Device model name.
      *

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

@@ -1,14 +1,11 @@
 import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument } from "kuzzle-sdk";
-import { DeviceManagerPlugin } from "../plugin";
 import { DeviceContent } from "../device";
 import { DecodedMeasurement } from "../measure";
+import { DeviceManagerPlugin } from "../plugin";
+import { BaseService } from "../shared";
 import { Decoder } from "./Decoder";
-export declare class PayloadService {
-    private config;
-    private context;
-    private get sdk();
-    private get app();
+export declare class PayloadService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     /**
      * Process a payload by validating and decode it with the `decoder` associated

package/dist/lib/modules/decoder/types/DecoderContent.d.ts

@@ -1,5 +1,6 @@
 import { NamedMeasures } from "../Decoder";
 export interface DecoderContent {
     deviceModel: string;
+    action?: string;
     measures: NamedMeasures;
 }

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

@@ -1,17 +1,14 @@
-import { Plugin, User } from "kuzzle";
+import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
-import { AssetContent } from "./../asset";
-import { Metadata } from "../shared";
 import { DecodedMeasurement } from "../measure";
-import { DeviceContent } from "./types/DeviceContent";
+import { DeviceManagerPlugin } from "../plugin";
+import { BaseService, Metadata, SearchParams } from "../shared";
+import { AssetContent } from "./../asset";
 import { ApiDeviceLinkAssetRequest } from "./types/DeviceApi";
-export declare class DeviceService {
-    private config;
-    private context;
-    private get sdk();
-    private get app();
-    private get impersonatedSdk();
-    constructor(plugin: Plugin);
+import { DeviceContent } from "./types/DeviceContent";
+export declare class DeviceService extends BaseService {
+    constructor(plugin: DeviceManagerPlugin);
+    registerAskEvents(): void;
     /**
      * Create a new device.
      *
@@ -19,23 +16,16 @@ export declare class DeviceService {
      * method since in this case "engineId" is not really an engine ID but still
      * required as an argument (in part to check the tenant rights)
      */
-    create(user: User, model: string, reference: string, metadata: JSONObject, { engineId, refresh, }?: {
-        engineId?: string;
-        refresh?: any;
-    }): Promise<KDocument<DeviceContent>>;
-    get(index: string, deviceId: string): Promise<KDocument<DeviceContent>>;
-    update(user: User, engineId: string, deviceId: string, metadata: Metadata, { refresh }: {
-        refresh: any;
-    }): Promise<KDocument<DeviceContent>>;
-    delete(user: User, engineId: string, deviceId: string, { refresh }: {
-        refresh: any;
-    }): Promise<void>;
-    search(engineId: string, searchBody: JSONObject, { from, size, scroll, lang, }: {
-        from?: number;
-        size?: number;
-        scroll?: string;
-        lang?: string;
-    }): Promise<SearchResult<KHit<DeviceContent>>>;
+    create(model: string, reference: string, metadata: JSONObject, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    get(engineId: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    private getInternalDevices;
+    /**
+     * Update or Create an device metadata
+     */
+    upsert(engineId: string, model: string, reference: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    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>>>;
     /**
      * Attach the device to an engine
      *
@@ -44,29 +34,22 @@ export declare class DeviceService {
      * @param options.refresh Wait for ES indexation
      * @param options.strict If true, throw if an operation isn't possible
      */
-    attachEngine(user: User, engineId: string, deviceId: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<KDocument<DeviceContent>>;
+    attachEngine(engineId: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Detach a device from its attached engine
      *
-     * @param deviceId Device id
-     * @param options.refresh Wait for ES indexation
+     * @param {string} deviceId Id of the device
+     * @param {KuzzleRequest} request kuzzle request
      */
-    detachEngine(user: User, deviceId: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<KDocument<DeviceContent>>;
+    detachEngine(deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Link a device to an asset.
      */
-    linkAsset(user: User, engineId: string, deviceId: string, assetId: string, measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"], { refresh, implicitMeasuresLinking, }?: {
-        refresh?: any;
-        implicitMeasuresLinking?: boolean;
-    }): Promise<{
+    linkAsset(engineId: string, deviceId: string, assetId: string, measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"], implicitMeasuresLinking: boolean, request: KuzzleRequest): Promise<{
         asset: KDocument<AssetContent>;
         device: KDocument<DeviceContent>;
     }>;
-    receiveMeasures(engineId: string, deviceId: string, measures: DecodedMeasurement[], payloadUuids: string[]): Promise<void>;
+    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.
@@ -82,12 +65,10 @@ export declare class DeviceService {
     /**
      * Unlink a device of an asset
      *
-     * @param deviceId Id of the device
-     * @param options.refresh Wait for ES indexation
+     * @param {string} deviceId Id of the device
+     * @param {KuzzleRequest} request kuzzle request
      */
-    unlinkAsset(user: User, deviceId: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<{
+    unlinkAsset(deviceId: string, request: KuzzleRequest): Promise<{
         asset: KDocument<AssetContent>;
         device: KDocument<DeviceContent>;
     }>;

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 } from "./types/DeviceApi";
+import { ApiDeviceAttachEngineResult, ApiDeviceCreateResult, ApiDeviceDeleteResult, ApiDeviceDetachEngineResult, ApiDeviceGetResult, ApiDeviceLinkAssetResult, ApiDeviceSearchResult, ApiDeviceUnlinkAssetResult, ApiDeviceUpdateResult, ApiDeviceGetMeasuresResult, ApiDeviceUpsertResult } from "./types/DeviceApi";
 export declare class DevicesController {
     private plugin;
     private deviceService;
@@ -13,6 +13,7 @@ export declare class DevicesController {
     update(request: KuzzleRequest): Promise<ApiDeviceUpdateResult>;
     delete(request: KuzzleRequest): Promise<ApiDeviceDeleteResult>;
     search(request: KuzzleRequest): Promise<ApiDeviceSearchResult>;
+    upsert(request: KuzzleRequest): Promise<ApiDeviceUpsertResult>;
     /**
      * Create and provision a new device
      */

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

@@ -1,51 +1,7 @@
+import { CollectionMappings } from "kuzzle";
 /**
  * Base mappings for the "devices" collection.
  *
  * Those mappings does not contains the `measures` and `metadata` mappings.
  */
-export declare const devicesMappings: {
-    dynamic: string;
-    properties: {
-        model: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        reference: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        assetId: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        engineId: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        metadata: {
-            properties: {};
-        };
-        measures: {
-            properties: {};
-        };
-        lastMeasuredAt: {
-            type: string;
-        };
-    };
-};
+export declare const devicesMappings: CollectionMappings;

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

@@ -21,6 +21,17 @@ export interface ApiDeviceUpdateRequest extends DevicesControllerRequest {
     };
 }
 export type ApiDeviceUpdateResult = KDocument<DeviceContent>;
+export interface ApiDeviceUpsertRequest extends DevicesControllerRequest {
+    action: "upsert";
+    _id: string;
+    refresh?: string;
+    body: {
+        model: string;
+        reference: string;
+        metadata: Metadata;
+    };
+}
+export type ApiDeviceUpsertResult = KDocument<DeviceContent>;
 export interface ApiDeviceCreateRequest extends DevicesControllerRequest {
     action: "create";
     refresh?: string;

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

@@ -2,6 +2,7 @@ import { User } from "kuzzle";
 import { KDocument } from "kuzzle-sdk";
 import { Metadata } from "../../../modules/shared";
 import { DeviceContent } from "./DeviceContent";
+import { ApiDeviceLinkAssetRequest } from "./DeviceApi";
 export type EventDeviceUpdateBefore = {
     name: "device-manager:device:update:before";
     args: [{
@@ -19,6 +20,17 @@ export type EventDeviceUpdateAfter = {
 /**
  * @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: {
@@ -27,3 +39,20 @@ export type AskDeviceUnlinkAsset = {
     };
     result: void;
 };
+export type AskDeviceDetachEngine = {
+    name: "ask:device-manager:device:detach-engine";
+    payload: {
+        deviceId: string;
+        user: User;
+    };
+    result: void;
+};
+export type AskDeviceAttachEngine = {
+    name: "ask:device-manager:device:attach-engine";
+    payload: {
+        engineId: string;
+        deviceId: string;
+        user: User;
+    };
+    result: void;
+};

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { UUID } from "node:crypto";
 import { KHit, User } from "kuzzle";
+import { UUID } from "node:crypto";
 import { AbstractExporter, Column, ExportParams } from "../shared";
 import { MeasureContent } from "./exports";
 interface MeasureSearchParams extends ExportParams {
@@ -38,7 +38,10 @@ export declare class MeasureExporter extends AbstractExporter<MeasureExportParam
      * Never return a rejected promise and write potential error on the stream
      */
     prepareExport(engineId: string, user: User, params: MeasureSearchParams): Promise<string>;
-    protected formatHit(columns: Column[], hit: KHit<MeasureContent>): any[];
+    protected formatHit(columns: Array<Column & {
+        shouldCheckName: boolean;
+        name: string;
+    }>, hit: KHit<MeasureContent>): any[];
     /**
      * Retrieve a prepared export and write each document as a CSV in the stream
      *

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

@@ -1,13 +1,9 @@
 import { JSONObject, KDocument } from "kuzzle";
 import { DeviceContent } from "../device";
 import { DeviceManagerPlugin } from "../plugin";
-import { Metadata } from "../shared";
+import { BaseService, Metadata } from "../shared";
 import { DecodedMeasurement } from "./types/MeasureContent";
-export declare class MeasureService {
-    private config;
-    private context;
-    private get sdk();
-    private get app();
+export declare class MeasureService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     /**
      * Register new measures from a device, updates :

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

@@ -35,6 +35,21 @@ export declare const measuresMappings: {
                 metadata: {
                     properties: {};
                 };
+                groups: {
+                    properties: {
+                        id: {
+                            type: string;
+                            fields: {
+                                text: {
+                                    type: string;
+                                };
+                            };
+                        };
+                        date: {
+                            type: string;
+                        };
+                    };
+                };
             };
         };
         /**
@@ -48,6 +63,9 @@ export declare const measuresMappings: {
                 measureName: {
                     type: string;
                 };
+                deviceMetadata: {
+                    properties: {};
+                };
                 payloadUuids: {
                     type: string;
                 };

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

@@ -10,6 +10,10 @@ export type MeasureOriginDevice = {
      * Name of the measure in the device
      */
     measureName: string;
+    /**
+     * Origin device metadata
+     */
+    deviceMetadata?: Metadata;
     /**
      * Payload uuids that were used to create this measure.
      */

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

@@ -1,15 +1,40 @@
 import { JSONObject } from "kuzzle-sdk";
+interface MeasureLocales {
+    [localeString: string]: {
+        friendlyName: string;
+        unit?: string;
+    };
+}
+export interface MeasureValuesDetails {
+    [valueName: string]: MeasureLocales;
+}
 /**
  * Represents a measure definition registered by the Device Manager
  *
  * @example
- * {
- *   valuesMappings: { temperature: { type: 'float' } },
- * }
+ *{
+ * valuesMappings: { temperature: { type: "float" } },
+ * valuesDetails: {
+ *   temperature: {
+ *     en: {
+ *       friendlyName: "Temperature",
+ *       unit: "°C",
+ *     },
+ *     fr: {
+ *       friendlyName: "Température",
+ *       unit: "°C",
+ *     },
+ *   },
+ * },
+ *}
  */
 export interface MeasureDefinition {
     /**
      * Mappings for the measurement values in order to index the fields
      */
     valuesMappings: JSONObject;
+    valuesDetails?: {
+        [valueName: string]: MeasureLocales;
+    };
 }
+export {};

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

@@ -0,0 +1,7 @@
+import { JSONObject, KuzzleError } from "kuzzle";
+export declare class MappingsConflictsError extends KuzzleError {
+    private conflicts;
+    constructor(message: string, conflicts: JSONObject, id?: string, code?: number);
+    get name(): string;
+    toJSON(): JSONObject;
+}

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

@@ -1,16 +1,17 @@
+import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "./types/ModelContent";
-export declare class ModelService {
-    private config;
-    private context;
-    private get sdk();
+import { BaseService } from "../shared";
+import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
+import { MeasureValuesDetails } from "../measure";
+export declare class ModelService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     registerAskEvents(): void;
-    writeAsset(engineGroup: string, model: string, metadataMappings: JSONObject, defaultMetadata: JSONObject, measures: AssetModelContent["asset"]["measures"]): Promise<KDocument<AssetModelContent>>;
+    private checkModelsConflicts;
+    writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels): Promise<KDocument<AssetModelContent>>;
     private checkDefaultValues;
-    writeDevice(model: string, metadataMappings: JSONObject, defaultMetadata: JSONObject, measures: DeviceModelContent["device"]["measures"]): Promise<KDocument<DeviceModelContent>>;
-    writeMeasure(type: string, valuesMappings: JSONObject): Promise<KDocument<MeasureModelContent>>;
+    writeDevice(model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: DeviceModelContent["device"]["measures"]): Promise<KDocument<DeviceModelContent>>;
+    writeMeasure(type: string, valuesMappings: JSONObject, valuesDetails?: MeasureValuesDetails): Promise<KDocument<MeasureModelContent>>;
     deleteAsset(_id: string): Promise<void>;
     deleteDevice(_id: string): Promise<void>;
     deleteMeasure(_id: string): Promise<void>;
@@ -22,4 +23,8 @@ export declare class ModelService {
     getAsset(engineGroup: string, model: string): Promise<KDocument<AssetModelContent>>;
     getDevice(model: string): Promise<KDocument<DeviceModelContent>>;
     getMeasure(type: string): Promise<KDocument<MeasureModelContent>>;
+    /**
+     * Update an asset model
+     */
+    updateAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels, request: KuzzleRequest): Promise<KDocument<AssetModelContent>>;
 }

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

@@ -0,0 +1,30 @@
+import { TwinModelContent, TwinType } from "../plugin";
+import { MeasureModelContent } from "./exports";
+export type ConflictChunk = {
+    sourceModel: string;
+    newModel: string;
+    modelType: string;
+    conflicts: MappingsConflict[];
+};
+export type MappingsConflict = {
+    path: string;
+    currentType: string | undefined;
+    newType: string | undefined;
+};
+/**
+ * Return every conflicts between the mappings of twins and a new twin model
+ *
+ * @param twinType The target twin type
+ * @param models The already present twin models
+ * @param additional The new asset
+ * @returns An array of ConflictChunk between current twins and the new twin
+ */
+export declare function getTwinConflicts<TDigitalTwin extends TwinModelContent>(twinType: TwinType, models: TDigitalTwin[], additional: TDigitalTwin): ConflictChunk[];
+/**
+ * Return every conflicts between the mappings of measure models and a new measure model
+ *
+ * @param measures The already present measure models
+ * @param additional The new measure
+ * @returns An array of ConflictChunk between current measures and the new measure
+ */
+export declare function getMeasureConflicts(measures: MeasureModelContent[], additional: MeasureModelContent): ConflictChunk[];