kuzzle-device-manager-types 2.7.2 → 2.8.0-beta.1

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

@@ -4,5 +4,6 @@ export declare class AssetModule extends Module {
     private assetHistoryService;
     private assetController;
     private assetGroupsController;
+    private assetsGroupsService;
     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,14 @@ 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 engineGroup
+     * @param model
+     */
+    updateModelLocales(request: KuzzleRequest, engineGroup: string, 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/AssetsGroupsController.d.ts

@@ -1,10 +1,12 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { ApiGroupAddAssetsResult, ApiGroupCreateResult, ApiGroupDeleteResult, ApiGroupGetResult, ApiGroupRemoveAssetsResult, ApiGroupSearchResult, ApiGroupUpdateResult, AssetsGroupsBodyRequest } from "./types/AssetGroupsApi";
+import { AssetsGroupsService } from "./AssetsGroupsService";
 export declare class AssetsGroupsController {
     private plugin;
+    private assetsGroupsService;
     definition: ControllerDefinition;
-    constructor(plugin: DeviceManagerPlugin);
+    constructor(plugin: DeviceManagerPlugin, assetsGroupsService: AssetsGroupsService);
     private get sdk();
     private get as();
     checkParent(engineId: string, parent: AssetsGroupsBodyRequest["parent"]): Promise<void>;

package/dist/lib/modules/asset/AssetsGroupsService.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 { AssetsGroupContent } from "./types/AssetGroupContent";
+export declare class AssetsGroupsService extends BaseService {
+    constructor(plugin: DeviceManagerPlugin);
+    create(_id: string, engineId: string, metadata: JSONObject, model: string, name: string, parent: string | null, request: KuzzleRequest): Promise<KDocument<AssetsGroupContent>>;
+    get(engineId: string, _id: string, request: KuzzleRequest): Promise<KDocument<AssetsGroupContent>>;
+    update(request: KuzzleRequest, _id: string, engineId: string, updateContent: JSONObject): Promise<KDocument<AssetsGroupContent>>;
+    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<AssetsGroupContent>>>;
+    addAsset(engineId: string, _id: string, assetIds: string[], request: KuzzleRequest): Promise<{
+        assetsGroups: KDocument<AssetsGroupContent>;
+        successes: {
+            _id: string;
+            _source: JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                _source: JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    removeAsset(engineId: string, _id: string, assetIds: string[], request: KuzzleRequest): Promise<{
+        assetsGroups: KDocument<AssetsGroupContent>;
+        successes: {
+            _id: string;
+            _source: JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                _source: JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+}

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";
@@ -170,4 +170,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/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/measure/MeasureService.d.ts

@@ -88,4 +88,8 @@ export declare class MeasureService extends BaseService {
      */
     private findAssetMeasureNameFromDevice;
     private mutexUpdateAsset;
+    /**
+     * Create a new document in the collection asset-history, for each asset state
+     */
+    private historizeAssetStates;
 }

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";
@@ -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
      *
@@ -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;
@@ -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

@@ -6,6 +6,12 @@ export type DeviceManagerConfiguration = {
      * Useful to start the plugin even if the mappings are not up to date.
      */
     ignoreStartupErrors: boolean;
+    /**
+     * Should be set to true to historize measures in asset-history collection (deprecated)
+     *
+     * Should be enabled only for backward compatibility because it leads to important performance costs.
+     */
+    assetsHistorizesMeasures: boolean;
     engine: {
         /**
          * Auto update collection mappings with models
@@ -52,6 +58,7 @@ export type DeviceManagerConfiguration = {
         };
         assetGroups: {
             name: string;
+            mappings: JSONObject;
             settings?: JSONObject;
         };
         assetHistory: {

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

@@ -1,8 +1,12 @@
 import { JSONObject, KDocumentContent } from "kuzzle-sdk";
 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 { 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/dist/tests/application/tests/controller.d.ts

@@ -1,5 +1,6 @@
 import { Backend, Controller, KuzzleRequest } from "kuzzle";
 export declare class TestsController extends Controller {
     constructor(app: Backend);
+    setAssetsHistorizesMeasuresConfig(request: KuzzleRequest): Promise<void>;
     createDigitalTwinFromBackend(request: KuzzleRequest): Promise<void>;
 }

package/package.json

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