kuzzle-device-manager-types 2.4.0-beta.18 → 2.4.0-beta.19

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

@@ -19,6 +19,10 @@ 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;
+    /**
+     * 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 } 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/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/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/model/ModelService.d.ts

@@ -1,13 +1,14 @@
+import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
 import { BaseService } from "../shared";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings } from "./types/ModelContent";
+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;
     private checkModelsConflicts;
-    writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"]): Promise<KDocument<AssetModelContent>>;
+    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: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: DeviceModelContent["device"]["measures"]): Promise<KDocument<DeviceModelContent>>;
     writeMeasure(type: string, valuesMappings: JSONObject, valuesDetails?: MeasureValuesDetails): Promise<KDocument<MeasureModelContent>>;
@@ -22,4 +23,8 @@ export declare class ModelService extends BaseService {
     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/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 } from "./types/ModelApi";
 export declare class ModelsController {
     private modelService;
     definition: ControllerDefinition;
@@ -17,4 +17,5 @@ export declare class ModelsController {
     listAssets(request: KuzzleRequest): Promise<ApiModelListAssetsResult>;
     listDevices(): Promise<ApiModelListDevicesResult>;
     listMeasures(): Promise<ApiModelListMeasuresResult>;
+    updateAsset(request: KuzzleRequest): Promise<ApiModelUpdateAssetResult>;
 }

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

@@ -1,7 +1,7 @@
 import { DeviceManagerPlugin } from "../plugin";
 import { NamedMeasures } from "../decoder";
 import { MeasureDefinition } from "../measure";
-import { MetadataDetails, MetadataGroups, MetadataMappings } from "./types/ModelContent";
+import { MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
 import { JSONObject } from "kuzzle-sdk";
 export declare class ModelsRegister {
     private config;
@@ -22,9 +22,10 @@ export declare class ModelsRegister {
      * @param defaultMetadata - The default metadata values for the model, defaults to an empty object.
      * @param metadataDetails - Optional detailed metadata descriptions and localizations.
      * @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): void;
+    registerAsset(engineGroup: string, model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, tooltipModels?: TooltipModels): void;
     /**
      * Registers a device model.
      *

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

@@ -1,5 +1,5 @@
 import { JSONObject, KDocument } from "kuzzle-sdk";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings } from "./ModelContent";
+import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
 import { MeasureValuesDetails } from "../../measure/types/MeasureDefinition";
 interface ModelsControllerRequest {
     controller: "device-manager/models";
@@ -30,6 +30,7 @@ export interface ApiModelWriteAssetRequest extends ModelsControllerRequest {
         metadataMappings?: MetadataMappings;
         defaultValues?: JSONObject;
         measures?: AssetModelContent["asset"]["measures"];
+        tooltipModels?: TooltipModels;
     };
 }
 export type ApiModelWriteAssetResult = KDocument<AssetModelContent>;
@@ -54,6 +55,20 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     };
 }
 export type ApiModelWriteMeasureResult = KDocument<MeasureModelContent>;
+export interface ApiModelUpdateAssetRequest extends ModelsControllerRequest {
+    action: "updateAsset";
+    engineGroup: string;
+    model: string;
+    body: {
+        metadataDetails?: MetadataDetails;
+        metadataGroups?: MetadataGroups;
+        metadataMappings?: MetadataMappings;
+        defaultValues?: JSONObject;
+        measures?: AssetModelContent["asset"]["measures"];
+        tooltipModels?: TooltipModels;
+    };
+}
+export type ApiModelUpdateAssetResult = KDocument<AssetModelContent>;
 export interface ApiModelDeleteAssetRequest extends ModelsControllerRequest {
     action: "deleteAsset";
     _id: string;

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

@@ -43,6 +43,50 @@ export interface MetadataGroups {
         };
     };
 }
+export interface MetadataTooltipContent {
+    category: "metadata";
+    label?: {
+        locales: {
+            [locale: string]: LocaleDetails;
+        };
+    };
+    metadataPath: string;
+    suffix?: string;
+}
+export interface MeasureTooltipContent {
+    category: "measure";
+    label?: {
+        locales: {
+            [locale: string]: LocaleDetails;
+        };
+    };
+    measureSlot: string;
+    measureValuePath: string;
+    suffix?: string;
+}
+export interface StaticTooltipContent {
+    category: "static";
+    label?: {
+        locales: {
+            [locale: string]: LocaleDetails;
+        };
+    };
+    type: StaticTooltipContentType;
+    value: string;
+}
+export declare enum StaticTooltipContentType {
+    link = "link",
+    image = "image",
+    text = "text",
+    title = "title",
+    separator = "separator"
+}
+export interface TooltipModels {
+    [key: string]: {
+        tooltipLabel: string;
+        content: (MetadataTooltipContent | MeasureTooltipContent | StaticTooltipContent)[];
+    };
+}
 export interface AssetModelContent extends KDocumentContent {
     type: "asset";
     engineGroup: string;
@@ -122,6 +166,53 @@ export interface AssetModelContent extends KDocumentContent {
          * ]
          */
         measures: NamedMeasures;
+        /**
+         * List of tooltip models for this asset model
+         *
+         * @example
+         * [
+         *   "defaultTooltipKey": {
+         *     "tooltipLabel": "Default tooltip model",
+         *     "content": [
+         *       {
+         *         "metadataPath": "geolocation",
+         *         "label": {
+         *           "locales": {
+         *             "en": {
+         *               "description": "",
+         *               "friendlyName": "Container position"
+         *             },
+         *             "fr": {
+         *               "description": "",
+         *               "friendlyName": "Position du conteneur"
+         *             }
+         *           }
+         *         },
+         *         "category": "metadata"
+         *       },
+         *       {
+         *         "measureValuePath": "externalTemperature",
+         *         "measureSlot": "externalTemperature",
+         *         "label": {
+         *           "locales": {
+         *             "en": {
+         *               "description": "",
+         *               "friendlyName": "External temperature"
+         *             },
+         *             "fr": {
+         *               "description": "",
+         *               "friendlyName": "Température extérieure"
+         *             }
+         *           }
+         *         },
+         *         "category": "measure",
+         *         "suffix": "°C"
+         *       }
+         *     ]
+         *   }
+         * ]
+         */
+        tooltipModels?: TooltipModels;
     };
 }
 export interface DeviceModelContent extends KDocumentContent {

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 { MetadataDetails, MetadataGroups, MetadataMappings } from "./ModelContent";
+import { MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
 /**
  * Define an asset model
  *
@@ -36,16 +36,57 @@ import { MetadataDetails, MetadataGroups, MetadataMappings } from "./ModelConten
  *     metadataGroups: {
  *       buildingEnv: {
  *         locales: {
- *          en: {
- *            groupFriendlyName: "Building environment",
- *            description: "The building environment"
- *          },
- *          fr: {
- *            groupFriendlyName: "Environnement du bâtiment",
- *            description: "L'environnement du bâtiment"
- *          }
+ *           en: {
+ *             groupFriendlyName: "Building environment",
+ *             description: "The building environment"
+ *           },
+ *           fr: {
+ *             groupFriendlyName: "Environnement du bâtiment",
+ *             description: "L'environnement du bâtiment"
+ *           }
  *         }
  *       }
+ *     },
+ *     tooltipModels: {
+ *       "defaultTooltipKey": {
+ *         "tooltipLabel": "Default Tooltip Model",
+ *         "content": [
+ *           {
+ *             "category": "metadata",
+ *             "label": {
+ *               "locales": {
+ *                 "en": {
+ *                   "friendlyName": "Container position",
+ *                   "description": ""
+ *                 },
+ *                 "fr": {
+ *                   "friendlyName": "Position du conteneur",
+ *                   "description": ""
+ *                 }
+ *               }
+ *             },
+ *             "metadataPath": "geolocation"
+ *           },
+ *           {
+ *             "category": "measure",
+ *             "label": {
+ *               "locales": {
+ *                 "en": {
+ *                   "friendlyName": "External temperature",
+ *                   "description": ""
+ *                 },
+ *                 "fr": {
+ *                   "friendlyName": "Température extérieure",
+ *                   "description": ""
+ *                 }
+ *               }
+ *             },
+ *             "measureSlot": "externalTemperature",
+ *             "measureValuePath": "externalTemperature",
+ *             "suffix": "°C"
+ *           }
+ *         ]
+ *       }
  *     }
  *   }
  *
@@ -71,6 +112,10 @@ export type AssetModelDefinition = {
      * Metadata groups
      */
     metadataGroups?: MetadataGroups;
+    /**
+     * Tooltip models
+     */
+    tooltipModels?: TooltipModels;
 };
 /**
  * Define a device model

package/dist/lib/modules/plugin/DeviceManagerPlugin.d.ts

@@ -29,6 +29,7 @@ export declare class DeviceManagerPlugin extends Plugin {
          *        - defaultMetadata: Default values for metadata fields, applied when actual data is not provided.
          *        - metadataDetails: Optional detailed descriptions for each metadata, including group association and localizations.
          *        - metadataGroups: Optional description of metadata groups, organizing metadata logically, with localizations for group names.
+         *        - tooltipModels: Optional tooltip model list, containing each labels and tooltip content to display.
          *
          * @example
          * ```
@@ -74,6 +75,47 @@ export declare class DeviceManagerPlugin extends Plugin {
          *           }
          *         }
          *       }
+         *     },
+         *     tooltipModels: {
+         *       "defaultTooltipKey": {
+         *         "tooltipLabel": "Default Tooltip Model",
+         *         "content": [
+         *           {
+         *             "category": "metadata",
+         *             "label": {
+         *               "locales": {
+         *                 "en": {
+         *                   "friendlyName": "Container position",
+         *                   "description": ""
+         *                 },
+         *                 "fr": {
+         *                   "friendlyName": "Position du conteneur",
+         *                   "description": ""
+         *                 }
+         *               }
+         *             },
+         *             "metadataPath": "geolocation"
+         *           },
+         *           {
+         *             "category": "measure",
+         *             "label": {
+         *               "locales": {
+         *                 "en": {
+         *                   "friendlyName": "External temperature",
+         *                   "description": ""
+         *                 },
+         *                 "fr": {
+         *                   "friendlyName": "Température extérieure",
+         *                   "description": ""
+         *                 }
+         *               }
+         *             },
+         *             "measureSlot": "externalTemperature",
+         *             "measureValuePath": "externalTemperature",
+         *             "suffix": "°C"
+         *           }
+         *         ]
+         *       }
          *     }
          *   }
          * );

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

@@ -26,32 +26,46 @@ export type DeviceManagerConfiguration = {
         config: {
             name: string;
             mappings: JSONObject;
-            settings: JSONObject;
+            settings?: JSONObject;
         };
         devices: {
             name: string;
             mappings: JSONObject;
-            settings: JSONObject;
+            settings?: JSONObject;
         };
         payloads: {
             name: string;
             mappings: JSONObject;
-            settings: JSONObject;
+            settings?: JSONObject;
         };
     };
     engineCollections: {
         config: {
             name: string;
             mappings: JSONObject;
-            settings: JSONObject;
+            settings?: JSONObject;
         };
         asset: {
             name: string;
             mappings: CollectionMappings;
+            settings?: JSONObject;
+        };
+        assetGroups: {
+            name: string;
+            settings?: JSONObject;
+        };
+        assetHistory: {
+            name: string;
+            settings?: JSONObject;
         };
         device: {
             name: string;
             mappings: CollectionMappings;
+            settings?: JSONObject;
+        };
+        measures: {
+            name: string;
+            settings?: JSONObject;
         };
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle-device-manager-types",
-  "version": "2.4.0-beta.18",
+  "version": "2.4.0-beta.19",
   "description": "Shared types for Kuzzle Device Manager",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "main": "index.js",