kuzzle-device-manager-types 2.8.0-dev.1 → 2.8.0-dev.2

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

@@ -1,9 +1,11 @@
 import { KDocumentContent } from "kuzzle-sdk";
-export interface AssetsGroupsBody {
+import { Metadata } from "lib/modules/shared";
+export interface AssetsGroupsBody<TMetadata extends Metadata = Metadata> extends KDocumentContent {
     name: string;
-    type: string | null;
+    model?: string | null;
     children: string[];
     parent: string | null;
     lastUpdate: number;
+    metadata?: TMetadata;
 }
-export type AssetsGroupContent = AssetsGroupsBody & KDocumentContent;
+export type AssetsGroupContent<TMetadata extends Metadata = any> = AssetsGroupsBody<TMetadata>;

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

@@ -2,7 +2,7 @@ import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
 import { BaseService, SearchParams } from "../shared";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
+import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
 import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../measure";
 import { NamedMeasures } from "../decoder";
@@ -13,20 +13,25 @@ export declare class ModelService extends BaseService {
     writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels): Promise<KDocument<AssetModelContent>>;
     private checkDefaultValues;
     writeDevice(model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures): Promise<KDocument<DeviceModelContent>>;
+    writeGroup(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups): Promise<KDocument<GroupModelContent>>;
     writeMeasure(type: string, valuesMappings: JSONObject, validationSchema?: SchemaObject, valuesDetails?: MeasureValuesDetails): Promise<KDocument<MeasureModelContent>>;
     deleteAsset(_id: string): Promise<void>;
     deleteDevice(_id: string): Promise<void>;
+    deleteGroup(_id: string): Promise<void>;
     deleteMeasure(_id: string): Promise<void>;
     listAsset(engineGroup: string): Promise<KDocument<AssetModelContent>[]>;
     listDevices(): Promise<KDocument<DeviceModelContent>[]>;
+    listGroups(engineGroup: string): Promise<KDocument<GroupModelContent>[]>;
     listMeasures(): Promise<KDocument<MeasureModelContent>[]>;
     searchAssets(engineGroup: string, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<AssetModelContent>>>;
     searchDevices(searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<DeviceModelContent>>>;
+    searchGroups(engineGroup: string, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<GroupModelContent>>>;
     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>>;
+    getGroup(model: string): Promise<KDocument<GroupModelContent>>;
     getMeasure(type: string): Promise<KDocument<MeasureModelContent>>;
     /**
      * Update an asset model

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

@@ -1,5 +1,5 @@
 import { TwinModelContent, TwinType } from "../plugin";
-import { MeasureModelContent } from "./exports";
+import { GroupModelContent, MeasureModelContent } from "./exports";
 export type ConflictChunk = {
     sourceModel: string;
     newModel: string;
@@ -20,6 +20,14 @@ export type MappingsConflict = {
  * @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 group models and a new group model
+ *
+ * @param groups The already present group models
+ * @param additional The new group model
+ * @returns An array of ConflictChunk between current groups and the new group
+ */
+export declare function getGroupConflicts(measures: GroupModelContent[], additional: GroupModelContent): ConflictChunk[];
 /**
  * Return every conflicts between the mappings of measure models and a new measure model
  *

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

@@ -1,24 +1,29 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { ModelService } from "./ModelService";
-import { ApiModelWriteAssetResult, ApiModelWriteDeviceResult, ApiModelWriteMeasureResult, ApiModelUpdateAssetResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult, ApiModelGetAssetResult, ApiModelGetDeviceResult, ApiModelGetMeasureResult, ApiModelSearchAssetsResult, ApiModelSearchDevicesResult, ApiModelSearchMeasuresResult } from "./types/ModelApi";
+import { ApiModelWriteAssetResult, ApiModelWriteDeviceResult, ApiModelWriteMeasureResult, ApiModelUpdateAssetResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult, ApiModelGetAssetResult, ApiModelGetDeviceResult, ApiModelGetMeasureResult, ApiModelSearchAssetsResult, ApiModelSearchDevicesResult, ApiModelSearchMeasuresResult, ApiModelDeleteGroupResult, ApiModelGetGroupResult, ApiModelListGroupsResult, ApiModelSearchGroupsResult, ApiModelWriteGroupResult } from "./types/ModelApi";
 export declare class ModelsController {
     private modelService;
     definition: ControllerDefinition;
     constructor(modelService: ModelService);
     getAsset(request: KuzzleRequest): Promise<ApiModelGetAssetResult>;
     getDevice(request: KuzzleRequest): Promise<ApiModelGetDeviceResult>;
+    getGroup(request: KuzzleRequest): Promise<ApiModelGetGroupResult>;
     getMeasure(request: KuzzleRequest): Promise<ApiModelGetMeasureResult>;
     writeAsset(request: KuzzleRequest): Promise<ApiModelWriteAssetResult>;
     writeDevice(request: KuzzleRequest): Promise<ApiModelWriteDeviceResult>;
+    writeGroup(request: KuzzleRequest): Promise<ApiModelWriteGroupResult>;
     writeMeasure(request: KuzzleRequest): Promise<ApiModelWriteMeasureResult>;
     deleteAsset(request: KuzzleRequest): Promise<ApiModelDeleteAssetResult>;
     deleteDevice(request: KuzzleRequest): Promise<ApiModelDeleteDeviceResult>;
+    deleteGroup(request: KuzzleRequest): Promise<ApiModelDeleteGroupResult>;
     deleteMeasure(request: KuzzleRequest): Promise<ApiModelDeleteMeasureResult>;
     listAssets(request: KuzzleRequest): Promise<ApiModelListAssetsResult>;
     listDevices(): Promise<ApiModelListDevicesResult>;
+    listGroups(request: KuzzleRequest): Promise<ApiModelListGroupsResult>;
     listMeasures(): Promise<ApiModelListMeasuresResult>;
     searchAssets(request: KuzzleRequest): Promise<ApiModelSearchAssetsResult>;
     searchDevices(request: KuzzleRequest): Promise<ApiModelSearchDevicesResult>;
+    searchGroups(request: KuzzleRequest): Promise<ApiModelSearchGroupsResult>;
     searchMeasures(request: KuzzleRequest): Promise<ApiModelSearchMeasuresResult>;
     updateAsset(request: KuzzleRequest): Promise<ApiModelUpdateAssetResult>;
 }

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

@@ -8,6 +8,7 @@ export declare class ModelsRegister {
     private context;
     private assetModels;
     private deviceModels;
+    private groupModels;
     private measureModels;
     private get sdk();
     init(plugin: DeviceManagerPlugin): void;
@@ -38,6 +39,19 @@ export declare class ModelsRegister {
      * @throws PluginImplementationError if the model name is not in PascalCase.
      */
     registerDevice(model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups): void;
+    /**
+     * Registers a group model.
+     *
+     *
+     * @param engineGroup - The engine group name.
+     * @param model - The name of the group model, which must be in PascalCase.
+     * @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.
+     */
+    registerGroup(engineGroup: string, model: string, 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,5 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
+import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
 import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../../measure/types/MeasureDefinition";
 interface ModelsControllerRequest {
@@ -16,6 +16,11 @@ export interface ApiModelGetDeviceRequest extends ModelsControllerRequest {
     model: string;
 }
 export type ApiModelGetDeviceResult = KDocument<DeviceModelContent>;
+export interface ApiModelGetGroupRequest extends ModelsControllerRequest {
+    action: "getGroup";
+    model: string;
+}
+export type ApiModelGetGroupResult = KDocument<GroupModelContent>;
 export interface ApiModelGetMeasureRequest extends ModelsControllerRequest {
     action: "getMeasure";
     type: string;
@@ -47,6 +52,18 @@ export interface ApiModelWriteDeviceRequest extends ModelsControllerRequest {
     };
 }
 export type ApiModelWriteDeviceResult = KDocument<DeviceModelContent>;
+export interface ApiModelWriteGroupRequest extends ModelsControllerRequest {
+    action: "writeGroup";
+    body: {
+        engineGroup: string;
+        model: string;
+        metadataDetails?: MetadataDetails;
+        metadataGroups?: MetadataGroups;
+        metadataMappings?: MetadataMappings;
+        defaultValues?: JSONObject;
+    };
+}
+export type ApiModelWriteGroupResult = KDocument<GroupModelContent>;
 export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     action: "writeMeasure";
     body: {
@@ -81,6 +98,11 @@ export interface ApiModelDeleteDeviceRequest extends ModelsControllerRequest {
     _id: string;
 }
 export type ApiModelDeleteDeviceResult = void;
+export interface ApiModelDeleteGroupRequest extends ModelsControllerRequest {
+    action: "deleteGroup";
+    _id: string;
+}
+export type ApiModelDeleteGroupResult = void;
 export interface ApiModelDeleteMeasureRequest extends ModelsControllerRequest {
     action: "deleteMeasure";
     _id: string;
@@ -101,6 +123,14 @@ export type ApiModelListDevicesResult = {
     models: KDocument<DeviceModelContent>[];
     total: number;
 };
+export interface ApiModelListGroupsRequest extends ModelsControllerRequest {
+    action: "listGroups";
+    engineGroup: string;
+}
+export type ApiModelListGroupsResult = {
+    models: KDocument<GroupModelContent>[];
+    total: number;
+};
 export interface ApiModelListMeasuresRequest extends ModelsControllerRequest {
     action: "listMeasures";
 }
@@ -125,6 +155,15 @@ export interface ApiModelSearchDevicesRequest extends ModelsControllerRequest {
     body?: JSONObject;
 }
 export type ApiModelSearchDevicesResult = SearchResult<KHit<DeviceModelContent>>;
+export interface ApiModelSearchGroupsRequest extends ModelsControllerRequest {
+    action: "searchGroups";
+    engineGroup: string;
+    from?: number;
+    size?: number;
+    scrollTTL?: string;
+    body?: JSONObject;
+}
+export type ApiModelSearchGroupsResult = SearchResult<KHit<GroupModelContent>>;
 export interface ApiModelSearchMeasuresRequest extends ModelsControllerRequest {
     action: "searchMeasures";
     from?: number;

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

@@ -356,4 +356,128 @@ export interface DeviceModelContent extends KDocumentContent {
         measures: NamedMeasures;
     };
 }
-export type ModelContent = MeasureModelContent | AssetModelContent | DeviceModelContent;
+export interface GroupModelContent extends KDocumentContent {
+    type: "group";
+    engineGroup: string;
+    group: {
+        /**
+         * Name of the model
+         */
+        model: string;
+        /**
+         * Metadata mappings.
+         *
+         * @example
+         * {
+         *   "company": {
+         *     "properties": {
+         *        "name": { "type": "keyword" },
+         *      }
+         *   }
+         * }
+         */
+        metadataMappings: MetadataMappings;
+        /**
+         * Default values for metadata.
+         *
+         * @example
+         * {
+         *    "company.name": "Firebird"
+         * }
+         */
+        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 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 type ModelContent = MeasureModelContent | AssetModelContent | DeviceModelContent | GroupModelContent;

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

@@ -196,3 +196,94 @@ export type DeviceModelDefinition = {
      */
     metadataGroups?: MetadataGroups;
 };
+/**
+ * Define a group model
+ *
+ * @example
+ *   {
+ *     metadataMappings: {
+ *       position: { type: "geo_point" },
+ *     },
+ *     defaultMetadata: {
+ *       position: {
+ *          lat: 41.12,
+ *          lon: -71.34
+ *       }
+ *     },
+ *     metadataDetails: {
+ *       "position": {
+ *         "group": "geolocation",
+ *         "locales": {
+ *           "en": {
+ *             "friendlyName": "Parking position",
+ *             "description": "The coordinates of the parking"
+ *           },
+ *           "fr": {
+ *             "friendlyName": "Position du parking",
+ *             "description": "Les coordonnées GPS du parking"
+ *           }
+ *         },
+ *       },
+ *     },
+ *     metadataGroups: {
+ *       geolocation: {
+ *         locales: {
+ *           en: {
+ *             groupFriendlyName: "Parking geolocation",
+ *             description: "The parking geolocation"
+ *           },
+ *           fr: {
+ *             groupFriendlyName: "Localisation du parking",
+ *             description: "La localisation du parking"
+ *           }
+ *         }
+ *       }
+ *     },
+ *     tooltipModels: {
+ *       "defaultTooltipKey": {
+ *         "tooltipLabel": "Default Tooltip Model",
+ *         "content": [
+ *           {
+ *             "category": "metadata",
+ *             "label": {
+ *               "locales": {
+ *                 "en": {
+ *                   "friendlyName": "Parking position",
+ *                   "description": ""
+ *                 },
+ *                 "fr": {
+ *                   "friendlyName": "Position du parking",
+ *                   "description": ""
+ *                 }
+ *               }
+ *             },
+ *             "metadataPath": "position"
+ *           },
+ *         ]
+ *       }
+ *     }
+ *   }
+ *
+ */
+export type GroupModelDefinition = {
+    /**
+     * Metadata mappings definition
+     */
+    metadataMappings?: MetadataMappings;
+    /**
+     * Default metadata values
+     */
+    defaultMetadata?: JSONObject;
+    /**
+     * Metadata details including tanslations and group.
+     */
+    metadataDetails?: MetadataDetails;
+    /**
+     * Metadata groups
+     */
+    metadataGroups?: MetadataGroups;
+    /**
+     * Tooltip models
+     */
+    tooltipModels?: TooltipModels;
+};

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

@@ -1,4 +1,4 @@
-import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "./ModelContent";
+import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelContent } from "./ModelContent";
 export type AskModelAssetGet = {
     name: "ask:device-manager:model:asset:get";
     payload: {
@@ -21,3 +21,10 @@ export type AskModelMeasureGet = {
     };
     result: MeasureModelContent;
 };
+export type AskModelGroupGet = {
+    name: "ask:device-manager:model:group:get";
+    payload: {
+        model: string;
+    };
+    result: GroupModelContent;
+};

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

@@ -1,6 +1,6 @@
 import { Backend, KDocumentContent, Plugin } from "kuzzle";
 import { AbstractEngine, ConfigManager, EngineContent } from "kuzzle-plugin-commons";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "../model";
+import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelContent } from "../model";
 import { DeviceManagerPlugin } from "./DeviceManagerPlugin";
 import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
 import { InternalCollection } from "./types/InternalCollection";
@@ -35,6 +35,7 @@ export type AskEngineUpdateConflict = {
             models: TwinModelContent[];
         };
         measuresModels?: MeasureModelContent[];
+        groupModels?: GroupModelContent[];
     };
     result: ConflictChunk[];
 };
@@ -54,6 +55,14 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @returns An array of conflict chunk
      */
     private doesTwinUpdateConflicts;
+    /**
+     * Return conflicts between the new and already present group models
+     *
+     * @param groupModels The already present group models
+     * @param additionalGroups The new or updated group models
+     * @returns An array of ConflictChunk
+     */
+    private doesGroupsUpdateConflicts;
     /**
      * Return conflicts between the new and already present measure models
      *
@@ -166,6 +175,7 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @returns The complete ES mappings produced by merging models mappings
      */
     private getMeasuresMappings;
+    getAssetGroupsMappingFromDB(): Promise<any>;
     /**
      * Retrieve a certain type of models associated to an engine
      *

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

@@ -1,7 +1,7 @@
 import { Plugin, PluginContext } from "kuzzle";
 import { JSONObject } from "kuzzle-sdk";
 import { MeasureDefinition } from "../measure";
-import { AssetModelDefinition, DeviceModelDefinition } from "../model";
+import { AssetModelDefinition, DeviceModelDefinition, GroupModelDefinition } from "../model";
 import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
 export declare class DeviceManagerPlugin extends Plugin {
     config: DeviceManagerConfiguration;
@@ -177,6 +177,59 @@ export declare class DeviceManagerPlugin extends Plugin {
          * ```
          */
         registerDevice: (model: string, definition: DeviceModelDefinition) => void;
+        /**
+         * Register a group.
+         *
+         * @param model Name of the group model
+         * @param definition Object containing the group model definition, including:
+         *                   - metadataMappings: Metadata mappings definition
+         *                   - defaultMetadata: Default metadata values
+         *                   - metadataDetails: Localizations, detailed metadata descriptions and definition
+         *                   - metadataGroups: Groups for organizing metadata, with localizations
+         *
+         * @example
+         * ```
+         * deviceManager.models.registerGroup(
+         *   "Parking",
+         *   {
+         *     metadataMappings: {
+         *       geolocation: { type: "geo_point" },
+         *     },
+         *     defaultMetadata: {
+         *
+         *     },
+         *     metadataDetails: {
+         *       geolocation: {
+         *         group: "access",
+         *         locales: {
+         *           en: {
+         *             friendlyName: "Parking location",
+         *             description: "GPS position of the parking"
+         *           },
+         *           fr: {
+         *             friendlyName: "Emplacement du parking",
+         *             description: "Position GPS du parking"
+         *           }
+         *         }
+         *       }
+         *     },
+         *     metadataGroups: {
+         *       access: {
+         *         locales: {
+         *           en: {
+         *             groupFriendlyName: "Parking access info"
+         *           },
+         *           fr: {
+         *             groupFriendlyName: "Information d'accès au parking"
+         *           }
+         *         }
+         *       }
+         *     }
+         *   }
+         * );
+         * ```
+         */
+        registerGroup: (engineGroup: string, model: string, definition: GroupModelDefinition) => void;
         /**
          * Register a new measure
          *

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

@@ -52,6 +52,7 @@ export type DeviceManagerConfiguration = {
         };
         assetGroups: {
             name: string;
+            mappings: JSONObject;
             settings?: JSONObject;
         };
         assetHistory: {

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

@@ -1,5 +1,5 @@
 import { MeasureDefinition } from "../../measure";
-import { AssetModelDefinition, DeviceModelDefinition } from "../../model";
+import { AssetModelDefinition, DeviceModelDefinition, GroupModelDefinition } from "../../model";
 interface ModelDefinition<Definition> {
     /**
      * Name of model
@@ -14,4 +14,5 @@ interface ModelDefinition<Definition> {
 export type AssetModel = ModelDefinition<AssetModelDefinition>;
 export type DeviceModel = ModelDefinition<DeviceModelDefinition>;
 export type MeasureModel = ModelDefinition<MeasureDefinition>;
+export type GroupModel = ModelDefinition<GroupModelDefinition>;
 export {};

package/dist/tests/application/groups/Parking.d.ts

@@ -0,0 +1,14 @@
+import { AssetsGroupContent } from "lib/modules/asset/exports";
+import { GroupModel, Metadata } from "lib/modules/shared";
+declare const modelName = "Parking";
+export interface ParkingMetadata extends Metadata {
+    geolocation: {
+        lat: number;
+        lon: number;
+    };
+}
+export interface ParkingGroupContent extends AssetsGroupContent<ParkingMetadata> {
+    model: typeof modelName;
+}
+export declare const Parking: GroupModel;
+export {};

package/dist/tests/application/groups/index.d.ts

@@ -0,0 +1 @@
+export * from "./Parking";

package/package.json

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