kuzzle-device-manager-types 2.4.0-beta.8 → 2.4.0-dev.1

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

@@ -1,20 +1,34 @@
 import { KuzzleRequest, User } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult, mReplaceResponse } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
-import { Metadata, BaseService, SearchParams } from "../shared";
+import { DigitalTwinService, Metadata, SearchParams } from "../shared";
 import { AssetHistoryService } from "./AssetHistoryService";
-import { AssetContent } from "./types/AssetContent";
 import { ApiAssetMigrateTenantResult } from "./types/AssetApi";
-export declare class AssetService extends BaseService {
+import { AssetContent } from "./types/AssetContent";
+export declare class AssetService extends DigitalTwinService {
     private assetHistoryService;
     constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService);
     registerAskEvents(): void;
     get(engineId: string, assetId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
-     * Updates an asset metadata
+     * Update an asset metadata
      */
     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>;

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, ApiAssetMigrateTenantResult } from "./types/AssetApi";
+import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult, ApiAssetGetLastMeasuresResult, ApiAssetMGetLastMeasuredAtResult, ApiAssetMGetLastMeasuresResult, ApiAssetGetLastMeasuredAtResult } from "./types/AssetApi";
 export declare class AssetsController {
     private plugin;
     private assetService;
@@ -10,12 +10,18 @@ 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>;
+    getLastMeasures(request: KuzzleRequest): Promise<ApiAssetGetLastMeasuresResult>;
+    mGetLastMeasures(request: KuzzleRequest): Promise<ApiAssetMGetLastMeasuresResult>;
     exportMeasures(request: KuzzleRequest): Promise<any>;
     export(request: KuzzleRequest): Promise<any>;
     migrateTenant(request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
+    getLastMeasuredAt(request: KuzzleRequest): Promise<ApiAssetGetLastMeasuredAtResult>;
+    mGetLastMeasuredAt(request: KuzzleRequest): Promise<ApiAssetMGetLastMeasuredAtResult>;
 }

package/dist/lib/modules/asset/roles/RoleAssetsReader.d.ts

@@ -9,8 +9,12 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
       actions: {
         get: true,
         getMeasures: true,
+        getLastMeasures: true,
+        mGetLastMeasures: true,
         exportMeasures: true,
         search: true,
+        getLastMeasuredAt: true,
+        mGetLastMeasuredAt: true,
       },
     },
     "device-manager/models": {

package/dist/lib/modules/asset/roles/specificRoles/RoleAssetsConfiguration.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to configurate an asset metadata.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleAssetsConfiguration: KuzzleRole;

package/dist/lib/modules/asset/roles/specificRoles/RoleAssetsCreation.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to create, update and delete an asset.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleAssetsCreation: KuzzleRole;

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

@@ -0,0 +1,2 @@
+export * from "./RoleAssetsConfiguration";
+export * from "./RoleAssetsCreation";

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

@@ -1,9 +1,10 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { MeasureContent } from "../../../modules/measure";
-import { Metadata } from "../../shared";
+import { ApiDigitalTwinGetLastMeasuredAtRequest, ApiDigitalTwinGetLastMeasuredAtResult, ApiDigitalTwinGetLastMeasuresRequest, ApiDigitalTwinGetLastMeasuresResult, ApiDigitalTwinMGetLastMeasuredAtRequest, ApiDigitalTwinMGetLastMeasuredAtResult, ApiDigitalTwinMGetLastMeasuresRequest, ApiDigitalTwinMGetLastMeasuresResult, Metadata } from "../../shared";
 import { AssetContent } from "./AssetContent";
+type AssetsControllerName = "device-manager/assets";
 interface AssetsControllerRequest {
-    controller: "device-manager/assets";
+    controller: AssetsControllerName;
     engineId: string;
 }
 export interface ApiAssetGetRequest extends AssetsControllerRequest {
@@ -20,6 +21,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;
@@ -64,6 +85,10 @@ export type ApiAssetGetMeasuresResult = {
     measures: Array<KDocument<MeasureContent<JSONObject>>>;
     total: number;
 };
+export type ApiAssetGetLastMeasuresRequest = ApiDigitalTwinGetLastMeasuresRequest<AssetsControllerName>;
+export type ApiAssetGetLastMeasuresResult = ApiDigitalTwinGetLastMeasuresResult;
+export type ApiAssetMGetLastMeasuresRequest = ApiDigitalTwinMGetLastMeasuresRequest<AssetsControllerName>;
+export type ApiAssetMGetLastMeasuresResult = ApiDigitalTwinMGetLastMeasuresResult;
 /**
  * This action can be used only with WebSocket or POST
  *
@@ -108,4 +133,8 @@ export type ApiAssetMigrateTenantResult = {
     errors: string[];
     successes: string[];
 };
+export type ApiAssetGetLastMeasuredAtRequest = ApiDigitalTwinGetLastMeasuredAtRequest<AssetsControllerName>;
+export type ApiAssetGetLastMeasuredAtResult = ApiDigitalTwinGetLastMeasuredAtResult;
+export type ApiAssetMGetLastMeasuredAtRequest = ApiDigitalTwinMGetLastMeasuredAtRequest<AssetsControllerName>;
+export type ApiAssetMGetLastMeasuredAtResult = ApiDigitalTwinMGetLastMeasuredAtResult;
 export {};

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,8 +1,8 @@
 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 extends BaseService {

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,12 +1,12 @@
 import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
-import { AssetContent } from "./../asset";
-import { DeviceManagerPlugin } from "../plugin";
-import { Metadata, BaseService, SearchParams } from "../shared";
 import { DecodedMeasurement } from "../measure";
-import { DeviceContent } from "./types/DeviceContent";
+import { DeviceManagerPlugin } from "../plugin";
+import { DigitalTwinService, Metadata, SearchParams } from "../shared";
+import { AssetContent } from "./../asset";
 import { ApiDeviceLinkAssetRequest } from "./types/DeviceApi";
-export declare class DeviceService extends BaseService {
+import { DeviceContent } from "./types/DeviceContent";
+export declare class DeviceService extends DigitalTwinService {
     constructor(plugin: DeviceManagerPlugin);
     registerAskEvents(): void;
     /**
@@ -18,6 +18,15 @@ export declare class DeviceService extends BaseService {
      */
     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
+     */
+    replaceMetadata(engineId: string, deviceId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    /**
+     * 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>>>;

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, ApiDeviceGetLastMeasuresResult, ApiDeviceMGetLastMeasuresResult, ApiDeviceGetLastMeasuredAtResult, ApiDeviceMGetLastMeasuredAtResult, ApiDeviceMetadataReplaceResult } from "./types/DeviceApi";
 export declare class DevicesController {
     private plugin;
     private deviceService;
@@ -11,8 +11,10 @@ export declare class DevicesController {
     constructor(plugin: DeviceManagerPlugin, deviceService: DeviceService);
     get(request: KuzzleRequest): Promise<ApiDeviceGetResult>;
     update(request: KuzzleRequest): Promise<ApiDeviceUpdateResult>;
+    replaceMetadata(request: KuzzleRequest): Promise<ApiDeviceMetadataReplaceResult>;
     delete(request: KuzzleRequest): Promise<ApiDeviceDeleteResult>;
     search(request: KuzzleRequest): Promise<ApiDeviceSearchResult>;
+    upsert(request: KuzzleRequest): Promise<ApiDeviceUpsertResult>;
     /**
      * Create and provision a new device
      */
@@ -34,7 +36,11 @@ export declare class DevicesController {
      */
     unlinkAsset(request: KuzzleRequest): Promise<ApiDeviceUnlinkAssetResult>;
     getMeasures(request: KuzzleRequest): Promise<ApiDeviceGetMeasuresResult>;
+    getLastMeasures(request: KuzzleRequest): Promise<ApiDeviceGetLastMeasuresResult>;
+    mGetLastMeasures(request: KuzzleRequest): Promise<ApiDeviceMGetLastMeasuresResult>;
     exportMeasures(request: KuzzleRequest): Promise<any>;
     receiveMeasures(request: KuzzleRequest): Promise<void>;
     export(request: KuzzleRequest): Promise<any>;
+    getLastMeasuredAt(request: KuzzleRequest): Promise<ApiDeviceGetLastMeasuredAtResult>;
+    mGetLastMeasuredAt(request: KuzzleRequest): Promise<ApiDeviceMGetLastMeasuredAtResult>;
 }

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

@@ -10,7 +10,11 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
         get: true,
         search: true,
         getMeasures: true,
+        getLastMeasures: true,
+        mGetLastMeasures: true,
         exportMeasures: true,
+        getLastMeasuredAt: true,
+        mGetLastMeasuredAt: true,
       },
     },
     "device-manager/models": {

package/dist/lib/modules/device/roles/specificRoles/RoleDevicesAssetAssociation.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to associate assets and devices.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleDevicesAssetAssociation: KuzzleRole;

package/dist/lib/modules/device/roles/specificRoles/RoleDevicesConfiguration.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to configure a device metadata.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleDevicesConfiguration: KuzzleRole;

package/dist/lib/modules/device/roles/specificRoles/RoleDevicesCreation.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to create, update and delete a device.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleDevicesCreation: KuzzleRole;

package/dist/lib/modules/device/roles/specificRoles/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./RoleDevicesAssetAssociation";
+export * from "./RoleDevicesConfiguration";
+export * from "./RoleDevicesCreation";

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

@@ -1,10 +1,11 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { DecodedMeasurement, MeasureContent } from "../../measure";
 import { AssetContent } from "../../asset";
-import { Metadata } from "../../shared";
+import { ApiDigitalTwinGetLastMeasuredAtRequest, ApiDigitalTwinGetLastMeasuredAtResult, ApiDigitalTwinGetLastMeasuresRequest, ApiDigitalTwinGetLastMeasuresResult, ApiDigitalTwinMGetLastMeasuredAtRequest, ApiDigitalTwinMGetLastMeasuredAtResult, ApiDigitalTwinMGetLastMeasuresRequest, ApiDigitalTwinMGetLastMeasuresResult, Metadata } from "../../shared";
 import { DeviceContent } from "./DeviceContent";
+type DevicesControllerName = "device-manager/devices";
 interface DevicesControllerRequest {
-    controller: "device-manager/devices";
+    controller: DevicesControllerName;
     engineId: string;
 }
 export interface ApiDeviceGetRequest extends DevicesControllerRequest {
@@ -21,6 +22,18 @@ export interface ApiDeviceUpdateRequest extends DevicesControllerRequest {
     };
 }
 export type ApiDeviceUpdateResult = KDocument<DeviceContent>;
+export type ApiDeviceMetadataReplaceResult = 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;
@@ -131,6 +144,10 @@ export type ApiDeviceGetMeasuresResult = {
     measures: Array<KDocument<MeasureContent<JSONObject>>>;
     total: number;
 };
+export type ApiDeviceGetLastMeasuresRequest = ApiDigitalTwinGetLastMeasuresRequest<DevicesControllerName>;
+export type ApiDeviceGetLastMeasuresResult = ApiDigitalTwinGetLastMeasuresResult;
+export type ApiDeviceMGetLastMeasuresRequest = ApiDigitalTwinMGetLastMeasuresRequest<DevicesControllerName>;
+export type ApiDeviceMGetLastMeasuresResult = ApiDigitalTwinMGetLastMeasuresResult;
 /**
  * This action can be used only with WebSocket or POST
  *
@@ -177,4 +194,8 @@ export interface ApiDeviceExportRequest extends DevicesControllerRequest {
 export type ApiDeviceExportResult = {
     link: string;
 };
+export type ApiDeviceGetLastMeasuredAtRequest = ApiDigitalTwinGetLastMeasuredAtRequest<DevicesControllerName>;
+export type ApiDeviceGetLastMeasuredAtResult = ApiDigitalTwinGetLastMeasuredAtResult;
+export type ApiDeviceMGetLastMeasuredAtRequest = ApiDigitalTwinMGetLastMeasuredAtRequest<DevicesControllerName>;
+export type ApiDeviceMGetLastMeasuredAtResult = ApiDigitalTwinMGetLastMeasuredAtResult;
 export {};

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

@@ -1,7 +1,5 @@
-/// <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 +36,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/collections/measuresMappings.d.ts

@@ -63,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,23 +1,33 @@
-import { JSONObject, KDocument } from "kuzzle-sdk";
+import { KuzzleRequest } from "kuzzle";
+import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
-import { BaseService } from "../shared";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "./types/ModelContent";
+import { BaseService, SearchParams } 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>;
     listAsset(engineGroup: string): Promise<KDocument<AssetModelContent>[]>;
     listDevices(): Promise<KDocument<DeviceModelContent>[]>;
     listMeasures(): Promise<KDocument<MeasureModelContent>[]>;
+    searchAssets(engineGroup: string, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<AssetModelContent>>>;
+    searchDevices(searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<DeviceModelContent>>>;
+    searchMeasures(searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<MeasureModelContent>>>;
     assetExists(model: string): Promise<boolean>;
     deviceExists(model: string): Promise<boolean>;
     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[];

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

@@ -1,6 +1,6 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { ModelService } from "./ModelService";
-import { ApiModelWriteAssetResult, ApiModelWriteDeviceResult, ApiModelWriteMeasureResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult, ApiModelGetAssetResult, ApiModelGetDeviceResult, ApiModelGetMeasureResult } from "./types/ModelApi";
+import { ApiModelWriteAssetResult, ApiModelWriteDeviceResult, ApiModelWriteMeasureResult, ApiModelUpdateAssetResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult, ApiModelGetAssetResult, ApiModelGetDeviceResult, ApiModelGetMeasureResult, ApiModelSearchAssetsResult, ApiModelSearchDevicesResult, ApiModelSearchMeasuresResult } from "./types/ModelApi";
 export declare class ModelsController {
     private modelService;
     definition: ControllerDefinition;
@@ -17,4 +17,8 @@ export declare class ModelsController {
     listAssets(request: KuzzleRequest): Promise<ApiModelListAssetsResult>;
     listDevices(): Promise<ApiModelListDevicesResult>;
     listMeasures(): Promise<ApiModelListMeasuresResult>;
+    searchAssets(request: KuzzleRequest): Promise<ApiModelSearchAssetsResult>;
+    searchDevices(request: KuzzleRequest): Promise<ApiModelSearchDevicesResult>;
+    searchMeasures(request: KuzzleRequest): Promise<ApiModelSearchMeasuresResult>;
+    updateAsset(request: KuzzleRequest): Promise<ApiModelUpdateAssetResult>;
 }

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

@@ -1,7 +1,8 @@
-import { JSONObject } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
 import { NamedMeasures } from "../decoder";
 import { MeasureDefinition } from "../measure";
+import { MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
+import { JSONObject } from "kuzzle-sdk";
 export declare class ModelsRegister {
     private config;
     private context;
@@ -11,8 +12,32 @@ export declare class ModelsRegister {
     private get sdk();
     init(plugin: DeviceManagerPlugin): void;
     loadModels(): Promise<void>;
-    registerAsset(engineGroup: string, model: string, measures: NamedMeasures, metadataMappings?: JSONObject, defaultMetadata?: JSONObject): void;
-    registerDevice(model: string, measures: NamedMeasures, metadataMappings?: JSONObject, defaultMetadata?: JSONObject): void;
+    /**
+     * Registers an asset model.
+     *
+     * @param engineGroup - The engine group name.
+     * @param model - The name of the asset model, which must be in PascalCase.
+     * @param measures - The measures associated with this asset model.
+     * @param metadataMappings - The metadata mappings for the model, defaults to an empty object.
+     * @param defaultMetadata - The default metadata values for the model, defaults to an empty object.
+     * @param metadataDetails - Optional detailed metadata descriptions, localizations and definition.
+     * @param metadataGroups - Optional groups for organizing metadata, with localizations.
+     * @param tooltipModels - Optional model list for tooltip, containing labels and tooltip content.
+     * @throws PluginImplementationError if the model name is not in PascalCase.
+     */
+    registerAsset(engineGroup: string, model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, tooltipModels?: TooltipModels): void;
+    /**
+     * Registers a device model.
+     *
+     * @param model - The name of the device model, which must be in PascalCase.
+     * @param measures - The measures associated with this device model.
+     * @param metadataMappings - The metadata mappings for the model, defaults to an empty object.
+     * @param defaultMetadata - The default metadata values for the model, defaults to an empty object.
+     * @param metadataDetails - Optional detailed metadata descriptions, localizations and definition.
+     * @param metadataGroups - Optional groups for organizing metadata, with localizations.
+     * @throws PluginImplementationError if the model name is not in PascalCase.
+     */
+    registerDevice(model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups): void;
     registerMeasure(type: string, measureDefinition: MeasureDefinition): void;
     private load;
 }