kuzzle-device-manager-types 3.0.0-next.3 → 3.0.0-next.4

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export * from "./lib/modules/measure/exports";
 export * from "./lib/modules/decoder/exports";
 export * from "./lib/modules/shared/exports";
 export * from "./lib/modules/model/exports";
+export * from "./lib/modules/group/exports";

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

@@ -3,6 +3,5 @@ export declare class AssetModule extends Module {
     private assetService;
     private assetHistoryService;
     private assetController;
-    private assetGroupsController;
     init(): Promise<void>;
 }

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

@@ -3,7 +3,7 @@ import { JSONObject, KDocument, KHit, SearchResult, mReplaceResponse } from "kuz
 import { DeviceManagerPlugin } from "../plugin";
 import { DigitalTwinService, Metadata, SearchParams } from "../shared";
 import { AssetHistoryService } from "./AssetHistoryService";
-import { ApiAssetMigrateTenantResult } from "./types/AssetApi";
+import { ApiAssetMigrateTenantResult, ApiAssetUpdateModelLocales } from "./types/AssetApi";
 import { AssetContent } from "./types/AssetContent";
 export declare class AssetService extends DigitalTwinService {
     private assetHistoryService;
@@ -39,6 +39,13 @@ export declare class AssetService extends DigitalTwinService {
     mReplaceAndHistorize(engineId: string, assets: KDocument<AssetContent>[], removedMetadata: string[], { refresh }: {
         refresh: any;
     }): Promise<mReplaceResponse>;
+    /**
+     * Retrieve locales with the specified model and search all assets related to the model to update the locales.
+     * The operation is historized.
+     * @param request
+     * @param model
+     */
+    updateModelLocales(request: KuzzleRequest, model: string): Promise<ApiAssetUpdateModelLocales[]>;
     private getEngine;
     private refreshModel;
 }

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, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult, ApiAssetGetLastMeasuresResult, ApiAssetMGetLastMeasuredAtResult, ApiAssetMGetLastMeasuresResult, ApiAssetGetLastMeasuredAtResult } from "./types/AssetApi";
+import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult, ApiAssetGetLastMeasuresResult, ApiAssetMGetLastMeasuredAtResult, ApiAssetMGetLastMeasuresResult, ApiAssetGetLastMeasuredAtResult, ApiAssetUpdateModelLocales } from "./types/AssetApi";
 export declare class AssetsController {
     private plugin;
     private assetService;
@@ -36,4 +36,10 @@ export declare class AssetsController {
     migrateTenant(request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
     getLastMeasuredAt(request: KuzzleRequest): Promise<ApiAssetGetLastMeasuredAtResult>;
     mGetLastMeasuredAt(request: KuzzleRequest): Promise<ApiAssetMGetLastMeasuredAtResult>;
+    /**
+     * Update modelLocales of all assets related to the specified asset model.
+     * This operation is done to make the search assets feature  up to date
+     * @param request
+     */
+    updateModelLocales(request: KuzzleRequest): Promise<ApiAssetUpdateModelLocales[]>;
 }

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

@@ -2,11 +2,7 @@ export * from "./types/AssetContent";
 export * from "./types/AssetHistoryContent";
 export * from "./types/AssetEvents";
 export * from "./types/AssetApi";
-export * from "./types/AssetGroupContent";
-export * from "./types/AssetGroupsApi";
 export * from "./roles/RoleAssetsAdmin";
 export * from "./roles/RoleAssetsReader";
-export * from "./roles/RoleAssetsGroupsAdmin";
-export * from "./roles/RoleAssetsGroupsReader";
 export * from "./collections/assetsMappings";
 export * from "./collections/assetsHistoryMappings";

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

@@ -1,6 +1,6 @@
 export * from "./collections/assetsMappings";
 export * from "./collections/assetsHistoryMappings";
-export * from "./collections/assetsGroupsMapping";
+export * from "../group/collections/groupsMappings";
 export * from "./types/AssetContent";
 export * from "./types/AssetHistoryContent";
 export * from "./types/AssetEvents";
@@ -9,5 +9,3 @@ export * from "./model/AssetSerializer";
 export * from "./AssetModule";
 export * from "./roles/RoleAssetsAdmin";
 export * from "./roles/RoleAssetsReader";
-export * from "./roles/RoleAssetsGroupsAdmin";
-export * from "./roles/RoleAssetsGroupsReader";

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

@@ -1,4 +1,4 @@
-import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
+import { JSONObject, KDocument, KHit, SearchResult, UpdateByQueryResponse } from "kuzzle-sdk";
 import { MeasureContent, Measurement } from "../../../modules/measure";
 import { ApiDigitalTwinGetLastMeasuredAtRequest, ApiDigitalTwinGetLastMeasuredAtResult, ApiDigitalTwinGetLastMeasuresRequest, ApiDigitalTwinGetLastMeasuresResult, ApiDigitalTwinMGetLastMeasuredAtRequest, ApiDigitalTwinMGetLastMeasuredAtResult, ApiDigitalTwinMGetLastMeasuresRequest, ApiDigitalTwinMGetLastMeasuresResult, Metadata } from "../../shared";
 import { AssetContent } from "./AssetContent";
@@ -7,11 +7,6 @@ import { ApiMeasureSource } from "../../measure/types/MeasureSources";
 interface AssetsControllerRequest {
     controller: AssetsControllerName;
     engineId: string;
-    /**
-     * ? Request parameter used by SoftTenant module
-     * ! Not used directly in this plugin
-     */
-    softTenantId?: string | string[] | null;
 }
 export interface ApiAssetGetRequest extends AssetsControllerRequest {
     action: "get";
@@ -170,4 +165,8 @@ export type ApiAssetGetLastMeasuredAtRequest = ApiDigitalTwinGetLastMeasuredAtRe
 export type ApiAssetGetLastMeasuredAtResult = ApiDigitalTwinGetLastMeasuredAtResult;
 export type ApiAssetMGetLastMeasuredAtRequest = ApiDigitalTwinMGetLastMeasuredAtRequest<AssetsControllerName>;
 export type ApiAssetMGetLastMeasuredAtResult = ApiDigitalTwinMGetLastMeasuredAtResult;
+export type ApiAssetUpdateModelLocales = {
+    engineIndex: string;
+    result: UpdateByQueryResponse<AssetContent>;
+};
 export {};

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

@@ -33,14 +33,9 @@ export interface AssetContent<TMeasures extends JSONObject = any, TMetadata exte
      * Id's of asset groups
      */
     groups: Array<{
-        id: string;
+        path: string;
         date: number;
     }>;
-    /**
-     * Id's of soft tenants
-     * ! Not used directly in this plugin
-     */
-    softTenant?: Array<string>;
 }
 /**
  * Asset description used to contextualize each measure data point
@@ -54,4 +49,4 @@ export type AssetMeasureContext<TMetadata extends Metadata = Metadata> = {
      * Name of the measure for the Asset
      */
     measureName: string;
-} & Pick<AssetContent<JSONObject, TMetadata>, "model" | "reference" | "metadata" | "groups" | "softTenant">;
+} & Pick<AssetContent<JSONObject, TMetadata>, "model" | "reference" | "metadata" | "groups">;

package/dist/lib/modules/{asset/AssetsGroupsController.d.ts → group/GroupsController.d.ts}

@@ -1,15 +1,23 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
-import { ApiGroupAddAssetsResult, ApiGroupCreateResult, ApiGroupDeleteResult, ApiGroupGetResult, ApiGroupRemoveAssetsResult, ApiGroupSearchResult, ApiGroupUpdateResult, AssetsGroupsBodyRequest } from "./types/AssetGroupsApi";
-export declare class AssetsGroupsController {
+import { ApiGroupAddAssetsResult, ApiGroupCreateResult, ApiGroupDeleteResult, ApiGroupGetResult, ApiGroupRemoveAssetsResult, ApiGroupSearchResult, ApiGroupUpdateResult, GroupsBodyRequest } from "./types/GroupsApi";
+import { GroupsService } from "./GroupsService";
+export declare class GroupsController {
     private plugin;
+    private groupsService;
     definition: ControllerDefinition;
-    constructor(plugin: DeviceManagerPlugin);
+    constructor(plugin: DeviceManagerPlugin, groupsService: GroupsService);
     private get sdk();
     private get as();
-    checkParent(engineId: string, parent: AssetsGroupsBodyRequest["parent"]): Promise<void>;
-    checkChildren(engineId: string, children: AssetsGroupsBodyRequest["children"]): Promise<void>;
-    checkGroupName(engineId: string, name: AssetsGroupsBodyRequest["name"], assetId?: string): Promise<void>;
+    /**
+     * Check that the path property is valid, and closest parent exists.
+     * @param {string} engineId Engine ID
+     * @param {string} path The path of a group
+     * @throws {BadRequestError} If the path is not a string or if the path is not valid.
+     * @returns {void}
+     */
+    checkPath(engineId: string, path: GroupsBodyRequest["path"], groupId?: string): Promise<void>;
+    checkGroupName(engineId: string, name: GroupsBodyRequest["name"], assetId?: string): Promise<void>;
     create(request: KuzzleRequest): Promise<ApiGroupCreateResult>;
     get(request: KuzzleRequest): Promise<ApiGroupGetResult>;
     update(request: KuzzleRequest): Promise<ApiGroupUpdateResult>;

package/dist/lib/modules/group/GroupsModule.d.ts

@@ -0,0 +1,6 @@
+import { Module } from "../shared/Module";
+export declare class GroupsModule extends Module {
+    private groupsController;
+    private groupsService;
+    init(): Promise<void>;
+}

package/dist/lib/modules/group/GroupsService.d.ts

@@ -0,0 +1,47 @@
+import { JSONObject, KDocument } from "kuzzle-sdk";
+import { DeviceManagerPlugin } from "../plugin";
+import { BaseService, SearchParams } from "../shared";
+import { KuzzleRequest } from "kuzzle";
+import { GroupContent } from "./exports";
+export declare class GroupsService extends BaseService {
+    constructor(plugin: DeviceManagerPlugin);
+    create(_id: string, engineId: string, metadata: JSONObject, model: string, name: string, path: string, request: KuzzleRequest): Promise<KDocument<GroupContent>>;
+    get(engineId: string, _id: string, request: KuzzleRequest): Promise<KDocument<GroupContent>>;
+    update(request: KuzzleRequest, _id: string, engineId: string, updateContent: JSONObject): Promise<KDocument<GroupContent>>;
+    delete(_id: string, engineId: string, request: KuzzleRequest): Promise<{
+        _id: string;
+    }>;
+    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<import("kuzzle-sdk").SearchResult<import("kuzzle-sdk").KHit<GroupContent>>>;
+    addAsset(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+        group: KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                _source: JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    removeAsset(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+        group: KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                _source: JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+}

package/dist/lib/modules/group/collections/groupsMappings.d.ts

@@ -0,0 +1,2 @@
+import { CollectionMappings } from "kuzzle";
+export declare const groupsMappings: CollectionMappings;

package/dist/lib/modules/group/exports.d.ts

@@ -0,0 +1,5 @@
+export * from "./types/GroupContent";
+export * from "./types/GroupsApi";
+export * from "./roles/RoleGroupsAdmin";
+export * from "./roles/RoleGroupsReader";
+export * from "./collections/groupsMappings";

package/dist/lib/modules/group/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./collections/groupsMappings";
+export * from "./GroupsModule";
+export * from "./roles/RoleGroupsAdmin";
+export * from "./roles/RoleGroupsReader";

package/dist/lib/modules/{asset/roles/RoleAssetsGroupsAdmin.d.ts → group/roles/RoleGroupsAdmin.d.ts}

@@ -1,12 +1,12 @@
 import { KuzzleRole } from "../../shared/types/KuzzleRole";
 /**
- * This role allows to manage assets and their models.
+ * This role allows to manage groups and their models.
  *
  * It's a tenant role.
  *
  * @example
  *
-    "device-manager/assets": {
+    "device-manager/groups": {
       actions: {
         "*": true,
       },
@@ -21,4 +21,4 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
       },
     },
  */
-export declare const RoleAssetsGroupsAdmin: KuzzleRole;
+export declare const RoleGroupsAdmin: KuzzleRole;

package/dist/lib/modules/{asset/roles/RoleAssetsGroupsReader.d.ts → group/roles/RoleGroupsReader.d.ts}

@@ -1,12 +1,12 @@
 import { KuzzleRole } from "../../shared/types/KuzzleRole";
 /**
- * This role allows to manage assets and their models.
+ * This role allows to manage groups and their models.
  *
  * It's a tenant role.
  *
  * @example
  *
-    "device-manager/assets": {
+    "device-manager/groups": {
       actions: {
         "*": true,
       },
@@ -21,4 +21,4 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
       },
     },
  */
-export declare const RoleAssetsGroupsReader: KuzzleRole;
+export declare const RoleGroupsReader: KuzzleRole;

package/dist/lib/modules/group/types/GroupContent.d.ts

@@ -0,0 +1,10 @@
+import { KDocumentContent } from "kuzzle-sdk";
+import { Metadata } from "lib/modules/shared";
+export interface GroupsBody<TMetadata extends Metadata = Metadata> extends KDocumentContent {
+    name: string;
+    model?: string | null;
+    path: string;
+    lastUpdate: number;
+    metadata?: TMetadata;
+}
+export type GroupContent<TMetadata extends Metadata = any> = GroupsBody<TMetadata>;

package/dist/lib/modules/{asset/types/AssetGroupsApi.d.ts → group/types/GroupsApi.d.ts}

@@ -1,31 +1,31 @@
 import { JSONObject, KDocument, KHit, SearchResult, mUpdateResponse } from "kuzzle-sdk";
-import { AssetsGroupsBody, AssetsGroupContent } from "./AssetGroupContent";
-type AssetsGroupsRequest = Omit<AssetsGroupsBody, "lastUpdate">;
-export type AssetsGroupsBodyRequest = Partial<AssetsGroupsRequest> & Omit<AssetsGroupsRequest, "parent" | "type">;
+import { GroupsBody, GroupContent } from "./GroupContent";
+type GroupsRequest = Omit<GroupsBody, "lastUpdate">;
+export type GroupsBodyRequest = Partial<GroupsRequest>;
 export type UpdateAssetLinkResponse = mUpdateResponse & {
-    assetsGroups: KDocument<AssetsGroupContent>;
+    group: KDocument<GroupContent>;
 };
 interface GroupControllerRequest {
-    controller: "device-manager/assetsGroup";
+    controller: "device-manager/groups";
     engineId: string;
 }
 export interface ApiGroupCreateRequest extends GroupControllerRequest {
     action: "create";
     _id?: string;
-    body: Omit<AssetsGroupsBodyRequest, "children">;
+    body: GroupsBodyRequest;
 }
-export type ApiGroupCreateResult = KDocument<AssetsGroupContent>;
+export type ApiGroupCreateResult = KDocument<GroupContent>;
 export interface ApiGroupGetRequest extends GroupControllerRequest {
     action: "get";
     _id: string;
 }
-export type ApiGroupGetResult = KDocument<AssetsGroupContent>;
+export type ApiGroupGetResult = KDocument<GroupContent>;
 export interface ApiGroupUpdateRequest extends GroupControllerRequest {
     action: "update";
     _id: string;
-    body: AssetsGroupsBodyRequest;
+    body: GroupsBodyRequest;
 }
-export type ApiGroupUpdateResult = KDocument<AssetsGroupContent>;
+export type ApiGroupUpdateResult = KDocument<GroupContent>;
 export interface ApiGroupDeleteRequest extends GroupControllerRequest {
     action: "delete";
     _id: string;
@@ -39,19 +39,19 @@ export interface ApiGroupSearchRequest extends GroupControllerRequest {
     lang?: "koncorde" | "elasticsearch";
     body: JSONObject;
 }
-export type ApiGroupSearchResult = SearchResult<KHit<AssetsGroupContent>>;
+export type ApiGroupSearchResult = SearchResult<KHit<GroupContent>>;
 export interface ApiGroupAddAssetsRequest extends GroupControllerRequest {
     action: "addAsset";
-    _id: string;
     body: {
+        path: string;
         assetIds: string[];
     };
 }
 export type ApiGroupAddAssetsResult = UpdateAssetLinkResponse;
 export interface ApiGroupRemoveAssetsRequest extends GroupControllerRequest {
     action: "removeAsset";
-    _id: string;
     body: {
+        path: string;
         assetIds: string[];
     };
 }

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

@@ -37,7 +37,7 @@ export declare const measuresMappings: {
                 };
                 groups: {
                     properties: {
-                        id: {
+                        path: {
                             type: string;
                             fields: {
                                 text: {
@@ -50,14 +50,6 @@ export declare const measuresMappings: {
                         };
                     };
                 };
-                softTenant: {
-                    type: string;
-                    fields: {
-                        text: {
-                            type: string;
-                        };
-                    };
-                };
             };
         };
         /**

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

@@ -1,5 +1,6 @@
 import { SchemaObject } from "ajv";
 import { JSONObject } from "kuzzle-sdk";
+import { LocaleDetails } from "lib/modules/model";
 interface MeasureLocales {
     [localeString: string]: {
         friendlyName: string;
@@ -44,6 +45,9 @@ export interface MeasureValuesDetails {
  *}
  */
 export interface MeasureDefinition {
+    locales?: {
+        [valueName: string]: LocaleDetails;
+    };
     /**
      * Mappings for the measurement values in order to index the fields
      */

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, LocaleDetails, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
 import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../measure";
 import { NamedMeasures } from "../decoder";
@@ -10,26 +10,37 @@ 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: NamedMeasures, tooltipModels: TooltipModels): Promise<KDocument<AssetModelContent>>;
+    writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {
+        [valueName: string]: LocaleDetails;
+    }): Promise<KDocument<AssetModelContent>>;
     private checkDefaultValues;
     writeDevice(model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures): Promise<KDocument<DeviceModelContent>>;
-    writeMeasure(type: string, valuesMappings: JSONObject, validationSchema?: SchemaObject, valuesDetails?: MeasureValuesDetails): Promise<KDocument<MeasureModelContent>>;
+    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, locales?: {
+        [valueName: string]: LocaleDetails;
+    }): 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
      */
-    updateAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels, request: KuzzleRequest): Promise<KDocument<AssetModelContent>>;
+    updateAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels, locales: {
+        [valueName: string]: LocaleDetails;
+    }, request: KuzzleRequest): Promise<KDocument<AssetModelContent>>;
 }

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

@@ -1,13 +1,14 @@
 import { DeviceManagerPlugin } from "../plugin";
 import { NamedMeasures } from "../decoder";
 import { MeasureDefinition } from "../measure";
-import { MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
+import { LocaleDetails, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
 import { JSONObject } from "kuzzle-sdk";
 export declare class ModelsRegister {
     private config;
     private context;
     private assetModels;
     private deviceModels;
+    private groupModels;
     private measureModels;
     private get sdk();
     init(plugin: DeviceManagerPlugin): void;
@@ -25,7 +26,9 @@ export declare class ModelsRegister {
      * @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;
+    registerAsset(engineGroup: string, model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, tooltipModels?: TooltipModels, locales?: {
+        [valueName: string]: LocaleDetails;
+    }): void;
     /**
      * Registers a device model.
      *
@@ -38,6 +41,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, LocaleDetails, 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;
@@ -32,6 +37,9 @@ export interface ApiModelWriteAssetRequest extends ModelsControllerRequest {
         defaultValues?: JSONObject;
         measures?: AssetModelContent["asset"]["measures"];
         tooltipModels?: TooltipModels;
+        locales?: {
+            [valueName: string]: LocaleDetails;
+        };
     };
 }
 export type ApiModelWriteAssetResult = KDocument<AssetModelContent>;
@@ -47,10 +55,25 @@ 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: {
         type: string;
+        locales?: {
+            [valueName: string]: LocaleDetails;
+        };
         valuesMappings: JSONObject;
         validationSchema?: SchemaObject;
         valuesDetails?: MeasureValuesDetails;
@@ -68,6 +91,9 @@ export interface ApiModelUpdateAssetRequest extends ModelsControllerRequest {
         defaultValues?: JSONObject;
         measures?: AssetModelContent["asset"]["measures"];
         tooltipModels?: TooltipModels;
+        locales?: {
+            [valueName: string]: LocaleDetails;
+        };
     };
 }
 export type ApiModelUpdateAssetResult = KDocument<AssetModelContent>;
@@ -81,6 +107,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 +132,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 +164,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

@@ -5,6 +5,9 @@ export interface MeasureModelContent extends KDocumentContent {
     type: "measure";
     measure: MeasureDefinition & {
         type: string;
+        locales?: {
+            [valueName: string]: LocaleDetails;
+        };
     };
 }
 export interface MetadataProperty {
@@ -265,6 +268,9 @@ export interface AssetModelContent extends KDocumentContent {
          * ]
          */
         tooltipModels?: TooltipModels;
+        locales?: {
+            [locale: string]: LocaleDetails;
+        };
     };
 }
 export interface DeviceModelContent extends KDocumentContent {
@@ -356,4 +362,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

@@ -1,6 +1,6 @@
 import { JSONObject } from "kuzzle-sdk";
 import { Decoder, NamedMeasures } from "../../../modules/decoder";
-import { MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
+import { LocaleDetails, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
 /**
  * Define an asset model
  *
@@ -94,7 +94,17 @@ import { MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from
  *           }
  *         ]
  *       }
- *     }
+ *     },
+ *     locales: {
+ *       en: {
+ *         friendlyName: 'Container (translation by model)',
+ *         description: 'Containerized container',
+ *       },
+ *       fr: {
+ *         friendlyName: 'Conteneur (traduit par model)',
+ *         description: 'Conteneur conteneurisé',
+ *       },
+ *     },
  *   }
  *
  */
@@ -123,6 +133,9 @@ export type AssetModelDefinition = {
      * Tooltip models
      */
     tooltipModels?: TooltipModels;
+    locales?: {
+        [valueName: string]: LocaleDetails;
+    };
 };
 /**
  * Define a device model
@@ -196,3 +209,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";
@@ -18,7 +18,7 @@ export interface EngineDocument extends KDocumentContent {
 export type AskEngineList = {
     name: "ask:device-manager:engine:list";
     payload: {
-        group: string | null;
+        group?: string;
     };
     result: EngineContent[];
 };
@@ -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
      *
@@ -98,14 +107,14 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      */
     createAssetsHistoryCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
     /**
-     * Create the assets groups collection with the assets groups mappings in the engine
+     * Create the groups collection with the groups mappings in the engine
      *
      * @param engineId The target engine Id
      * @param engineGroup The engine group
      *
-     * @throws If it failed during the assets groups collection creation
+     * @throws If it failed during the groups collection creation
      */
-    createAssetsGroupsCollection(engineId: string): Promise<InternalCollection>;
+    createGroupsCollection(engineId: string): Promise<InternalCollection>;
     /**
      * Generate devices mappings and create the devices collection in the engine
      *
@@ -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
      *
@@ -175,4 +185,11 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @returns An array of the generic type provided
      */
     private getModels;
+    /**
+     * Detach all devices of an index in the admin index
+     *
+     * @param engineId The target engine Id
+     * @returns {any}
+     */
+    private detachDevicesFromAdminIndex;
 }

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;
@@ -11,6 +11,7 @@ export declare class DeviceManagerPlugin extends Plugin {
     private engineController;
     private assetModule;
     private deviceModule;
+    private groupModule;
     private decoderModule;
     private measureModule;
     private modelModule;
@@ -177,6 +178,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

@@ -50,8 +50,9 @@ export type DeviceManagerConfiguration = {
             mappings: CollectionMappings;
             settings?: JSONObject;
         };
-        assetGroups: {
+        groups: {
             name: string;
+            mappings: CollectionMappings;
             settings?: JSONObject;
         };
         assetHistory: {

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

@@ -1,7 +1,7 @@
 export declare enum InternalCollection {
     ASSETS = "assets",
     ASSETS_HISTORY = "assets-history",
-    ASSETS_GROUPS = "assets-groups",
+    GROUPS = "groups",
     DEVICES = "devices",
     MEASURES = "measures",
     MODELS = "models",

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

@@ -1 +1,2 @@
 export * from "./DeviceManagerConfiguration";
+export * from "./Pipes";

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

@@ -2,8 +2,12 @@ import { JSONObject, KDocumentContent } from "kuzzle-sdk";
 import { NamedMeasures } from "../../decoder";
 import { Metadata } from "./Metadata";
 import { DigitalTwinMeasures } from "./DigitalTwinMeasures";
+import { LocaleDetails } from "lib/modules/model";
 export interface DigitalTwinContent<TMeasures extends JSONObject = JSONObject, TMetadata extends Metadata = Metadata> extends KDocumentContent {
     model: string;
+    modelLocales?: {
+        [locale: string]: LocaleDetails;
+    };
     reference: string;
     metadata: TMetadata;
     measures: DigitalTwinMeasures<TMeasures>;

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 { GroupContent } from "lib/modules/group/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 GroupContent<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": "3.0.0-next.3",
+  "version": "3.0.0-next.4",
   "description": "Shared types for Kuzzle Device Manager",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "main": "index.js",

package/dist/lib/modules/asset/collections/assetsGroupsMapping.d.ts

@@ -1,2 +0,0 @@
-import { CollectionMappings } from "kuzzle";
-export declare const assetGroupsMappings: CollectionMappings;

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

@@ -1,9 +0,0 @@
-import { KDocumentContent } from "kuzzle-sdk";
-export interface AssetsGroupsBody {
-    name: string;
-    type: string | null;
-    children: string[];
-    parent: string | null;
-    lastUpdate: number;
-}
-export type AssetsGroupContent = AssetsGroupsBody & KDocumentContent;

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

@@ -1,2 +0,0 @@
-export * from "./DummyTempDecoder";
-export * from "./DummyTempPositionDecoder";