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

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,25 +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 { AssetModelContent, DeviceModelContent, MeasureModelContent } from "./types/ModelContent";
-export declare class ModelService {
-    private config;
-    private context;
-    private get sdk();
+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;
 }

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

@@ -1,5 +1,6 @@
-import { JSONObject, KDocument } from "kuzzle-sdk";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "./ModelContent";
+import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
+import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
+import { MeasureValuesDetails } from "../../measure/types/MeasureDefinition";
 interface ModelsControllerRequest {
     controller: "device-manager/models";
 }
@@ -24,9 +25,12 @@ export interface ApiModelWriteAssetRequest extends ModelsControllerRequest {
     body: {
         engineGroup: string;
         model: string;
-        metadataMappings?: JSONObject;
+        metadataDetails?: MetadataDetails;
+        metadataGroups?: MetadataGroups;
+        metadataMappings?: MetadataMappings;
         defaultValues?: JSONObject;
         measures?: AssetModelContent["asset"]["measures"];
+        tooltipModels?: TooltipModels;
     };
 }
 export type ApiModelWriteAssetResult = KDocument<AssetModelContent>;
@@ -34,7 +38,9 @@ export interface ApiModelWriteDeviceRequest extends ModelsControllerRequest {
     action: "writeDevice";
     body: {
         model: string;
-        metadataMappings?: JSONObject;
+        metadataDetails?: MetadataDetails;
+        metadataGroups?: MetadataGroups;
+        metadataMappings?: MetadataMappings;
         defaultValues?: JSONObject;
         measures: DeviceModelContent["device"]["measures"];
     };
@@ -45,9 +51,24 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     body: {
         type: string;
         valuesMappings: JSONObject;
+        valuesDetails?: MeasureValuesDetails;
     };
 }
 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;
@@ -85,4 +106,29 @@ export type ApiModelListMeasuresResult = {
     models: KDocument<MeasureModelContent>[];
     total: number;
 };
+export interface ApiModelSearchAssetsRequest extends ModelsControllerRequest {
+    action: "searchAssets";
+    engineGroup: string;
+    from?: number;
+    size?: number;
+    scrollTTL?: string;
+    body?: JSONObject;
+}
+export type ApiModelSearchAssetsResult = SearchResult<KHit<AssetModelContent>>;
+export interface ApiModelSearchDevicesRequest extends ModelsControllerRequest {
+    action: "searchDevices";
+    from?: number;
+    size?: number;
+    scrollTTL?: string;
+    body?: JSONObject;
+}
+export type ApiModelSearchDevicesResult = SearchResult<KHit<DeviceModelContent>>;
+export interface ApiModelSearchMeasuresRequest extends ModelsControllerRequest {
+    action: "searchMeasures";
+    from?: number;
+    size?: number;
+    scrollTTL?: string;
+    body?: JSONObject;
+}
+export type ApiModelSearchMeasuresResult = SearchResult<KHit<MeasureModelContent>>;
 export {};

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

@@ -7,6 +7,129 @@ export interface MeasureModelContent extends KDocumentContent {
         type: string;
     };
 }
+export interface MetadataProperty {
+    type: string;
+    strategy?: string;
+    format?: string;
+}
+export interface MetadataObject {
+    properties: {
+        [key: string]: MetadataProperty | MetadataObject;
+    };
+}
+export interface MetadataMappings {
+    [key: string]: MetadataProperty | MetadataObject;
+}
+export interface LocaleDetails {
+    friendlyName: string;
+    description: string;
+}
+export interface BaseEditorHint {
+    readOnly?: boolean;
+    type: EditorHintEnum;
+}
+export declare enum EditorHintEnum {
+    BASE = "base",
+    OPTION_SELECTOR = "optionSelector",
+    DATETIME = "datetime"
+}
+/**
+ * Allows to display a list of values to choose in a dropdown, it has to be defined in the the editorHint property of the asset/device's metadataDetails.
+ */
+export interface OptionsSelectorEditorHint extends BaseEditorHint {
+    type: EditorHintEnum.OPTION_SELECTOR;
+    /**
+     * A list that contains all the values displayed in the dropdown.
+     */
+    values: string[] | number[] | boolean[];
+    /**
+     * Allow the user to add custom values.
+     */
+    customValueAllowed?: boolean;
+}
+/**
+ * Allows to display either a date picker with or without a time picker, or a clock picker, it has to be defined in the editorHint property of the asset/device's metadataDetails.
+ */
+export interface DatetimeEditorHint extends BaseEditorHint {
+    type: EditorHintEnum.DATETIME;
+    /**
+     * If true, displays a date picker, otherwise displays a clock picker.
+     */
+    date: boolean;
+    /**
+     * If `date` is true, setting this to true will add time picking to the date picker.
+     */
+    time?: boolean;
+}
+export interface MetadataDetails {
+    [key: string]: {
+        group?: string;
+        locales: {
+            [locale: string]: LocaleDetails;
+        };
+        /**
+         * To add new editor hint, create an interface with the properties that extends BaseEditorHint.
+         * Then add a new field in EditorHintEnum to define the type of your hint.
+         * Finally add the new editor hint interface with a pipe to take in account the new type.
+         */
+        editorHint?: BaseEditorHint | OptionsSelectorEditorHint | DatetimeEditorHint;
+    };
+}
+export interface MetadataGroupLocale {
+    groupFriendlyName: string;
+    description: string;
+}
+export interface MetadataGroups {
+    [groupName: string]: {
+        locales: {
+            [locale: string]: MetadataGroupLocale;
+        };
+    };
+}
+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;
@@ -27,7 +150,7 @@ export interface AssetModelContent extends KDocumentContent {
          *   }
          * }
          */
-        metadataMappings: JSONObject;
+        metadataMappings: MetadataMappings;
         /**
          * Default values for metadata.
          *
@@ -37,6 +160,51 @@ export interface AssetModelContent extends KDocumentContent {
          * }
          */
         defaultMetadata: JSONObject;
+        /**
+         * Metadata details
+         * @example
+         * {
+         *   "extTemp": {
+         *     "group": "buildingEnv",
+         *     "locales": {
+         *       "en": {
+         *          "friendlyName": "External temperature",
+         *          "description": "Building external temperature"
+         *       },
+         *       "fr": {
+         *         "friendlyName": "Température extérieure",
+         *         "description": "Température à l'exterieur du bâtiment"
+         *       },
+         *     },
+         *     "editorHint": {
+         *       "readOnly": true,
+         *       "type": EditorHintEnum.OPTION_SELECTOR,
+         *       "values": ["red", "blue"],
+         *       "customValueAllowed": true,
+         *     },
+         *   },
+         * }
+         */
+        metadataDetails?: MetadataDetails;
+        /**
+         * Metadata groups list
+         * @example
+         * {
+         *   "buildingEnv": {
+         *     "locales": {
+         *       "en": {
+         *         "groupFriendlyName": "Building environment",
+         *         "description": "The building environment"
+         *       },
+         *       "fr": {
+         *         "groupFriendlyName": "Environnement du bâtiment",
+         *         "description": "L'environnement du bâtiment"
+         *       }
+         *     }
+         *   }
+         * }
+         */
+        metadataGroups?: MetadataGroups;
         /**
          * List of accepted measures for this model
          *
@@ -49,6 +217,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 {
@@ -70,7 +285,7 @@ export interface DeviceModelContent extends KDocumentContent {
          *   }
          * }
          */
-        metadataMappings: JSONObject;
+        metadataMappings: MetadataMappings;
         /**
          * Default values for metadata.
          *
@@ -80,6 +295,52 @@ export interface DeviceModelContent extends KDocumentContent {
          * }
          */
         defaultMetadata: JSONObject;
+        /**
+         * Metadata details
+         * @example
+         * {
+         *   "sensorVersion": {
+         *     "group": "sensorSpecs",
+         *     "locales": {
+         *       "en": {
+         *          "friendlyName": "Sensor version",
+         *          "description": "Firmware version of the sensor"
+         *       },
+         *       "fr": {
+         *         "friendlyName": "Version du capteur",
+         *         "description": "Version du micrologiciel du capteur"
+         *       },
+         *     },
+         *     "editorHint": {
+         *       "readOnly": false,
+         *       "type": EditorHintEnum.DATETIME,
+         *       "date": true,
+         *       "time": true,
+         *       "customTimeZoneAllowed": true,
+         *     },
+         *   },
+         * }
+         */
+        metadataDetails?: MetadataDetails;
+        /**
+         * Metadata groups list
+         * @example
+         * {
+         *   "sensorSpecs": {
+         *     "locales": {
+         *       "en": {
+         *         "groupFriendlyName": "Sensor specifications",
+         *         "description" : "All sensors specifications"
+         *       },
+         *       "fr": {
+         *         "groupFriendlyName": "Spécifications techniques",
+         *         "description": "Toutes les spécifications techniques"
+         *       },
+         *     }
+         *   }
+         * }
+         */
+        metadataGroups?: MetadataGroups;
         /**
          * List of decoded measures for this model
          *