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

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

@@ -30,17 +30,12 @@ export interface AssetContent<TMeasures extends JSONObject = any, TMetadata exte
         }>;
     }>;
     /**
-     * Id's of asset groups
+     * Path'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/device/types/DeviceContent.d.ts

@@ -11,4 +11,11 @@ export interface DeviceContent<TMeasures extends JSONObject = any, TMetadata ext
     /**
      */
     engineId: string;
+    /**
+     * Path's of device's groups
+     */
+    groups: Array<{
+        path: string;
+        date: number;
+    }>;
 }

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

@@ -0,0 +1,31 @@
+import { ControllerDefinition, KuzzleRequest } from "kuzzle";
+import { DeviceManagerPlugin } from "../plugin";
+import { ApiGroupAddAssetsResult, ApiGroupAddDevicesResult, ApiGroupCreateResult, ApiGroupDeleteResult, ApiGroupGetResult, ApiGroupListItemsResult, ApiGroupRemoveAssetsResult, ApiGroupRemoveDeviceResult, ApiGroupSearchResult, ApiGroupUpdateResult, GroupsBodyRequest } from "./types/GroupsApi";
+import { GroupsService } from "./GroupsService";
+export declare class GroupsController {
+    private plugin;
+    private groupsService;
+    definition: ControllerDefinition;
+    constructor(plugin: DeviceManagerPlugin, groupsService: GroupsService);
+    private get sdk();
+    private get as();
+    /**
+     * 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>;
+    delete(request: KuzzleRequest): Promise<ApiGroupDeleteResult>;
+    search(request: KuzzleRequest): Promise<ApiGroupSearchResult>;
+    listItems(request: KuzzleRequest): Promise<ApiGroupListItemsResult>;
+    addAsset(request: KuzzleRequest): Promise<ApiGroupAddAssetsResult>;
+    removeAsset(request: KuzzleRequest): Promise<ApiGroupRemoveAssetsResult>;
+    addDevice(request: KuzzleRequest): Promise<ApiGroupAddDevicesResult>;
+    removeDevice(request: KuzzleRequest): Promise<ApiGroupRemoveDeviceResult>;
+}

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,94 @@
+import { JSONObject, KDocument } from "kuzzle-sdk";
+import { DeviceManagerPlugin } from "../plugin";
+import { BaseService, SearchParams } from "../shared";
+import { KuzzleRequest } from "kuzzle";
+import { AssetContent } from "../asset/types/AssetContent";
+import { GroupContent } from "./exports";
+import { DeviceContent } from "../device";
+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>>>;
+    listItems(engineId: string, _id: string, includeChildren: boolean, options: {
+        from?: number;
+        size?: number;
+    }, request: KuzzleRequest): Promise<{
+        assets: {
+            hits: import("kuzzle-sdk").KHit<AssetContent<any, any>>[];
+            total: number;
+        };
+        devices: {
+            hits: import("kuzzle-sdk").KHit<DeviceContent<any, any>>[];
+            total: number;
+        };
+    }>;
+    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;
+        }[];
+    }>;
+    addDevice(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
+        group: KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                _source: JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    removeDevice(engineId: string, path: string, deviceIds: 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/group/types/GroupsApi.d.ts

@@ -0,0 +1,96 @@
+import { JSONObject, KDocument, KHit, SearchResult, mUpdateResponse } from "kuzzle-sdk";
+import { GroupsBody, GroupContent } from "./GroupContent";
+import { DeviceContent } from "lib/modules/device";
+import { AssetContent } from "lib/modules/asset";
+type GroupsRequest = Omit<GroupsBody, "lastUpdate">;
+export type GroupsBodyRequest = Partial<GroupsRequest>;
+export type UpdateLinkResponse = mUpdateResponse & {
+    group: KDocument<GroupContent>;
+};
+interface GroupControllerRequest {
+    controller: "device-manager/groups";
+    engineId: string;
+}
+export interface ApiGroupCreateRequest extends GroupControllerRequest {
+    action: "create";
+    _id?: string;
+    body: GroupsBodyRequest;
+}
+export type ApiGroupCreateResult = KDocument<GroupContent>;
+export interface ApiGroupGetRequest extends GroupControllerRequest {
+    action: "get";
+    _id: string;
+}
+export type ApiGroupGetResult = KDocument<GroupContent>;
+export interface ApiGroupUpdateRequest extends GroupControllerRequest {
+    action: "update";
+    _id: string;
+    body: GroupsBodyRequest;
+}
+export type ApiGroupUpdateResult = KDocument<GroupContent>;
+export interface ApiGroupDeleteRequest extends GroupControllerRequest {
+    action: "delete";
+    _id: string;
+}
+export type ApiGroupDeleteResult = void;
+export interface ApiGroupSearchRequest extends GroupControllerRequest {
+    action: "search";
+    from?: number;
+    size?: number;
+    scrollTTL?: string;
+    lang?: "koncorde" | "elasticsearch";
+    body: JSONObject;
+}
+export type ApiGroupSearchResult = SearchResult<KHit<GroupContent>>;
+export interface ApiGroupListItemsRequest extends GroupControllerRequest {
+    action: "listItems";
+    from?: number;
+    size?: number;
+    body: {
+        includeChildren?: boolean;
+    };
+    _id: string;
+}
+export type ApiGroupListItemsResult = {
+    assets: {
+        hits: Array<KHit<AssetContent>>;
+        total: number;
+    };
+    devices: {
+        hits: Array<KHit<DeviceContent>>;
+        total: number;
+    };
+};
+export interface ApiGroupAddAssetsRequest extends GroupControllerRequest {
+    action: "addAsset";
+    body: {
+        path: string;
+        assetIds: string[];
+    };
+}
+export type ApiGroupAddAssetsResult = UpdateLinkResponse;
+export interface ApiGroupRemoveAssetsRequest extends GroupControllerRequest {
+    action: "removeAsset";
+    body: {
+        path: string;
+        assetIds: string[];
+    };
+}
+export type ApiGroupRemoveAssetsResult = UpdateLinkResponse;
+export interface ApiGroupAddDeviceRequest extends GroupControllerRequest {
+    action: "addDevice";
+    body: {
+        path: string;
+        deviceIds: string[];
+    };
+}
+export type ApiGroupAddDevicesResult = UpdateLinkResponse;
+export interface ApiGroupRemoveDeviceRequest extends GroupControllerRequest {
+    action: "removeDevice";
+    body: {
+        path: string;
+        deviceIds: string[];
+    };
+}
+export type ApiGroupRemoveDeviceResult = UpdateLinkResponse;
+export {};

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,38 @@ 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>>;
     private checkDefaultValues;
+    private checkGroupAffinity;
+    writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {
+        [valueName: string]: LocaleDetails;
+    }): Promise<KDocument<AssetModelContent>>;
     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, affinity: JSONObject, 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>;
 }