kuzzle-device-manager-types 3.0.0-3-dev.19 → 3.0.0-3-dev.21

package/dist/bin/migration/migrate-tenant-classes.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -5,5 +5,5 @@ import { KuzzleLogger } from "kuzzle-logger";
 export declare class AssetHistoryService extends BaseService {
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin, assetLogger: KuzzleLogger);
-    add<TAssetHistoryEvent extends AssetHistoryEvent>(engineId: string, histories: AssetHistoryContent[]): Promise<void>;
+    add<TAssetHistoryEvent extends AssetHistoryEvent>(index: string, histories: AssetHistoryContent[]): Promise<void>;
 }

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

@@ -11,35 +11,35 @@ export declare class AssetService extends DigitalTwinService {
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService, assetLogger: KuzzleLogger);
     registerAskEvents(): void;
-    get(engineId: string, assetId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    get(index: string, assetId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
      * Update an asset metadata
      */
-    update(engineId: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    update(index: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
      * Replace an asset metadata
      */
-    replaceMetadata(engineId: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    replaceMetadata(index: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
      * Update or Create an asset metadata
      */
-    upsert(engineId: string, model: string, reference: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    upsert(index: string, model: string, reference: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     private _create;
     /**
      * Create an asset metadata
      */
-    create(engineId: string, model: string, reference: string, metadata: JSONObject, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    create(index: string, model: string, reference: string, metadata: JSONObject, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
      * Delete an asset metadata
      */
-    delete(engineId: string, assetId: string, request: KuzzleRequest): Promise<void>;
-    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<AssetContent>>>;
+    delete(index: string, assetId: string, request: KuzzleRequest): Promise<void>;
+    search(index: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<AssetContent>>>;
     unlinkDevices(assetId: string, allMeasures: boolean, deviceIds: string[], measureSlots: string[], request: KuzzleRequest): Promise<ApiAssetUnlinkDevicesResult>;
-    migrateTenant(user: User, assetsList: string[], engineId: string, newEngineId: string, includeDevices: boolean, request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
+    migrateTenant(user: User, assetsList: string[], index: string, newIndex: string, includeDevices: boolean, request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
     /**
      * Replace an asset metadata
      */
-    mReplaceAndHistorize(engineId: string, assets: KDocument<AssetContent>[], removedMetadata: string[], { refresh }: {
+    mReplaceAndHistorize(index: string, assets: KDocument<AssetContent>[], removedMetadata: string[], { refresh }: {
         refresh: any;
     }): Promise<mReplaceResponse>;
     /**
@@ -49,13 +49,19 @@ export declare class AssetService extends DigitalTwinService {
      * @param model
      */
     updateModelLocales(request: KuzzleRequest, model: string): Promise<ApiAssetUpdateModelLocales[]>;
-    addMeasureSlot(assetId: string, measureSlot: AssetContent["measureSlots"][0], engineId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
-    removeMeasureSlot(assetId: string, measureSlotName: string, engineId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    addMeasureSlot(assetId: string, measureSlot: AssetContent["measureSlots"][0], index: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    removeMeasureSlot(assetId: string, measureSlotName: string, index: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
      * Update the display name of a measure slot on an asset
      */
     updateMeasureSlotDisplayName(assetId: string, measureSlotName: string, displayName: {
         [locale: string]: string;
-    }, engineId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    }, index: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     private refreshModel;
+    /**
+     * Lists the engines whose assets use the given model:
+     * the model indexes for a tenant-scoped model, every engine for a commons model,
+     * and the engines of the model tenantClasses otherwise.
+     */
+    private getModelEngines;
 }

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

@@ -28,7 +28,7 @@ export declare class AssetsController {
      * @param indexId The asset index
      * @param assetId The target asset ID
      * @param measureName The measureName to get the type from
-     * @param engineGroup The target engine group
+     * @param tenantClass The target tenant class
      * @returns The measure type if used in the asset, null otherwise
      * @throws If the asset does not exists
      */

package/dist/lib/modules/asset/roles/RoleAssetsAdmin.d.ts

@@ -18,6 +18,7 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
         getAsset: true,
         writeAsset: true,
         listMeasures: true,
+        getMetadataReferential: true,
       },
     },
  */

package/dist/lib/modules/asset/roles/RoleAssetsReader.d.ts

@@ -22,6 +22,7 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
         listAssets: true,
         listMeasures: true,
         getAsset: true,
+        getMetadataReferential: true,
       },
     },
  */

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

@@ -7,7 +7,7 @@ import { ApiMeasureSource } from "../../measure/types/MeasureSources";
 import { DeviceContent } from "lib/modules/device";
 interface AssetsControllerRequest {
     controller: AssetsControllerName;
-    engineId: string;
+    index: string;
 }
 export interface ApiAssetGetRequest extends AssetsControllerRequest {
     action: "get";
@@ -90,7 +90,7 @@ type TypelessApiMeasureSource = Omit<ApiMeasureSource, "type">;
 export interface ApiAssetMeasureIngestRequest extends AssetsControllerRequest {
     action: "ingestMeasure";
     assetId: string;
-    engineId: string;
+    index: string;
     slotName: string;
     body: {
         dataSource: TypelessApiMeasureSource;
@@ -105,7 +105,7 @@ type APIDecodedMeasurement = Omit<Measurement, "type"> & {
 export interface ApiAssetmMeasureIngestRequest extends AssetsControllerRequest {
     action: "mIngestMeasure";
     assetId: string;
-    engineId: string;
+    index: string;
     body: {
         dataSource: TypelessApiMeasureSource;
         measurements: APIDecodedMeasurement[];
@@ -120,7 +120,7 @@ export type ApiAssetMGetLastMeasuresResult = ApiDigitalTwinMGetLastMeasuresResul
  * This action can be used only with WebSocket or POST
  *
  * Then the export can be download using HTTP Get and the following route:
- *  `/_/device-manager/:engineId/devices/:_id/measures/_export/:exportId`
+ *  `/_/device-manager/:index/devices/:_id/measures/_export/:exportId`
  */
 export interface ApiAssetExportMeasuresRequest extends AssetsControllerRequest {
     action: "exportMeasures";
@@ -150,10 +150,10 @@ export type ApiAssetExportResult = {
 };
 export interface ApiAssetMigrateTenantRequest extends AssetsControllerRequest {
     action: "migrateTenant";
-    engineId: string;
+    index: string;
     body: {
         assetsList: string[];
-        newEngineId: string;
+        newIndex: string;
         includeDevices?: boolean;
     };
 }

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

@@ -30,7 +30,7 @@ export type AskAssetRefreshModel = {
 export type AskAssetHistoryAdd<TAssetHistoryEvent extends AssetHistoryEvent> = {
     name: "ask:device-manager:asset:history:add";
     payload: {
-        engineId: string;
+        index: string;
         histories: AssetHistoryContent<TAssetHistoryEvent>[];
     };
     result: void;

package/dist/lib/modules/device/DeviceService.d.ts

@@ -17,29 +17,29 @@ export declare class DeviceService extends DigitalTwinService {
      *
      */
     create(model: string, reference: string, metadata: JSONObject, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
-    get(engineId: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    get(index: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Replace a device metadata
      */
-    replaceMetadata(engineId: string, deviceId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    replaceMetadata(index: string, deviceId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Update the display name of a measure slot on a device
      */
-    updateMeasureSlotDisplayName(engineId: string, deviceId: string, measureSlotName: string, displayName: {
+    updateMeasureSlotDisplayName(index: string, deviceId: string, measureSlotName: string, displayName: {
         [locale: string]: string;
     }, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Update or Create an device metadata
      */
-    upsert(engineId: string, model: string, reference: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
-    update(engineId: string, deviceId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
-    delete(engineId: string, deviceId: string, request: KuzzleRequest): Promise<void>;
-    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<DeviceContent>>>;
+    upsert(index: string, model: string, reference: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    update(index: string, deviceId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    delete(index: string, deviceId: string, request: KuzzleRequest): Promise<void>;
+    search(index: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<DeviceContent>>>;
     unlinkAssets(deviceId: string, allMeasures: boolean, assetIds: string[], measureSlots: string[], request: KuzzleRequest): Promise<ApiDeviceUnlinkAssetsResult>;
     /**
      * Internal logic to attach the device to an engine
      *
-     * @param engineId Engine id to attach to
+     * @param index Engine id to attach to
      * @param deviceId Device id to attach
      * @param options.refresh Wait for ES indexation
      */
@@ -47,12 +47,12 @@ export declare class DeviceService extends DigitalTwinService {
     /**
      * Attach the device to an engine
      *
-     * @param engineId Engine id to attach to
+     * @param index Engine id to attach to
      * @param deviceId Device id to attach
      * @param options.refresh Wait for ES indexation
      * @param options.strict If true, throw if an operation isn't possible
      */
-    attachEngine(engineId: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    attachEngine(index: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Detach a device from its attached engine
      *
@@ -60,7 +60,7 @@ export declare class DeviceService extends DigitalTwinService {
      * @param {KuzzleRequest} request kuzzle request
      */
     detachEngine(deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceProvisioningContent>>;
-    receiveMeasures(engineId: string, deviceId: string, measures: DecodedMeasurement[], payloadUuids: string[], request: KuzzleRequest): Promise<void>;
+    receiveMeasures(index: string, deviceId: string, measures: DecodedMeasurement[], payloadUuids: string[], request: KuzzleRequest): Promise<void>;
     private checkEngineExists;
     private checkAttachedToEngine;
     private refreshModel;

package/dist/lib/modules/device/roles/RoleDevicesAdmin.d.ts

@@ -25,6 +25,7 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
         getDevice: true,
         writeDevice: true,
         listMeasures: true,
+        getMetadataReferential: true,
       },
     },
  */

package/dist/lib/modules/device/roles/RoleDevicesReader.d.ts

@@ -22,6 +22,7 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
         listDevices: true,
         getDevice: true,
         listMeasures: true,
+        getMetadataReferential: true,
       },
     },
     }

package/dist/lib/modules/device/types/DeviceApi.d.ts

@@ -6,7 +6,7 @@ import { DeviceContent } from "./DeviceContent";
 type DevicesControllerName = "device-manager/devices";
 interface DevicesControllerRequest {
     controller: DevicesControllerName;
-    engineId: string;
+    index: string;
 }
 export interface ApiDeviceGetRequest extends DevicesControllerRequest {
     action: "get";
@@ -204,7 +204,7 @@ export type ApiDeviceMGetLastMeasuresResult = ApiDigitalTwinMGetLastMeasuresResu
  * This action can be used only with WebSocket or POST
  *
  * Then the export can be download using HTTP Get and the following route:
- *  `/_/device-manager/:engineId/devices/:_id/measures/_export/:exportId`
+ *  `/_/device-manager/:index/devices/:_id/measures/_export/:exportId`
  */
 export interface ApiDeviceExportMeasuresRequest extends DevicesControllerRequest {
     action: "exportMeasures";

package/dist/lib/modules/device/types/DeviceContent.d.ts

@@ -30,7 +30,7 @@ export interface DeviceContent<TMetadata extends Metadata = any> extends Digital
     }>;
     /**
      */
-    engineId: string | null;
+    index: string | null;
     /**
      * Path's of device's groups
      */
@@ -42,7 +42,7 @@ export interface DeviceContent<TMetadata extends Metadata = any> extends Digital
 /**
  * Platform index Device document content
  */
-interface DeviceProvisioningContentFields extends Pick<DeviceContent, "model" | "reference" | "engineId" | "measureSlots"> {
+interface DeviceProvisioningContentFields extends Pick<DeviceContent, "model" | "reference" | "index" | "measureSlots"> {
     /**
      * Date of provisioning of the device on the platform
      */

package/dist/lib/modules/device/types/DeviceEvents.d.ts

@@ -28,7 +28,7 @@ export type AskDeviceDetachEngine = {
 export type AskDeviceAttachEngine = {
     name: "ask:device-manager:device:attach-engine";
     payload: {
-        engineId: string;
+        index: string;
         deviceId: string;
         user: User;
     };

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

@@ -13,13 +13,13 @@ export declare class GroupsController {
     private get as();
     /**
      * Check that the path property is valid, and closest parent exists.
-     * @param {string} engineId Engine ID
+     * @param {string} index 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>;
+    checkPath(index: string, path: GroupsBodyRequest["path"], groupId?: string): Promise<void>;
+    checkGroupName(index: string, name: GroupsBodyRequest["name"], assetId?: string): Promise<void>;
     create(request: KuzzleRequest): Promise<ApiGroupCreateResult>;
     get(request: KuzzleRequest): Promise<ApiGroupGetResult>;
     upsert(request: KuzzleRequest): Promise<ApiGroupUpsertResult>;

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

@@ -9,17 +9,22 @@ import { KuzzleLogger } from "kuzzle-logger";
 export declare class GroupsService extends BaseService {
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
-    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<import("kuzzle").KDocument<GroupContent>>;
-    update(request: KuzzleRequest, _id: string, engineId: string, name?: string, metadata?: Metadata): Promise<import("kuzzle").KDocument<GroupContent>>;
+    /**
+     * Refreshes the metadata of the groups of a model, in every engine of the model scope:
+     * added metadata are set to their default value, removed metadata are deleted.
+     */
+    private refreshModel;
+    create(_id: string, index: string, metadata: JSONObject, model: string, name: string, path: string, request: KuzzleRequest): Promise<KDocument<GroupContent>>;
+    get(index: string, _id: string, request: KuzzleRequest): Promise<import("kuzzle").KDocument<GroupContent>>;
+    update(request: KuzzleRequest, _id: string, index: string, name?: string, metadata?: Metadata): Promise<import("kuzzle").KDocument<GroupContent>>;
     private _updatePath;
-    moveGroup(engineId: string, _id: string, targetGroupId: string | null, request: KuzzleRequest): Promise<{
+    moveGroup(index: string, _id: string, targetGroupId: string | null, request: KuzzleRequest): Promise<{
         group: KDocument<GroupContent>;
         targetGroupId: string | null;
     }>;
-    delete(_id: string, engineId: string, request: KuzzleRequest): Promise<string>;
-    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<import("kuzzle").SearchResult<import("kuzzle").KHit<GroupContent>>>;
-    listItems(engineId: string, _id: string, includeChildren: boolean, options: {
+    delete(_id: string, index: string, request: KuzzleRequest): Promise<string>;
+    search(index: string, searchParams: SearchParams, request: KuzzleRequest): Promise<import("kuzzle").SearchResult<import("kuzzle").KHit<GroupContent>>>;
+    listItems(index: string, _id: string, includeChildren: boolean, options: {
         from?: number;
         size?: number;
     }, request: KuzzleRequest): Promise<{
@@ -32,7 +37,7 @@ export declare class GroupsService extends BaseService {
             total: number;
         };
     }>;
-    addAssets(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+    addAssets(index: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
         group: import("kuzzle").KDocument<GroupContent>;
         successes: {
             _id: string;
@@ -48,7 +53,7 @@ export declare class GroupsService extends BaseService {
             reason: string;
         }[];
     }>;
-    removeAssets(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+    removeAssets(index: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
         group: import("kuzzle").KDocument<GroupContent>;
         successes: {
             _id: string;
@@ -64,7 +69,7 @@ export declare class GroupsService extends BaseService {
             reason: string;
         }[];
     }>;
-    addDevices(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
+    addDevices(index: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
         group: import("kuzzle").KDocument<GroupContent>;
         successes: {
             _id: string;
@@ -80,7 +85,7 @@ export declare class GroupsService extends BaseService {
             reason: string;
         }[];
     }>;
-    removeDevices(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
+    removeDevices(index: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
         group: import("kuzzle").KDocument<GroupContent>;
         successes: {
             _id: string;
@@ -96,20 +101,20 @@ export declare class GroupsService extends BaseService {
             reason: string;
         }[];
     }>;
-    mCreate(engineId: string, groups: Array<{
+    mCreate(index: string, groups: Array<{
         _id: string;
         metadata: Metadata;
         model: string;
         name: string;
         path: string;
     }>): Promise<ApiGroupMCreateResult>;
-    mUpdate(engineId: string, groups: Array<{
+    mUpdate(index: string, groups: Array<{
         _id: string;
         metadata: Metadata;
         model: string;
         name: string;
     }>, request: KuzzleRequest): Promise<ApiGroupMUpdateResult>;
-    mUpsert(engineId: string, groups: Array<{
+    mUpsert(index: string, groups: Array<{
         _id: string;
         metadata: Metadata;
         model: string;

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

@@ -2,3 +2,4 @@ export * from "./collections/groupsMappings";
 export * from "./GroupsModule";
 export * from "./roles/RoleGroupsAdmin";
 export * from "./roles/RoleGroupsReader";
+export * from "./types/GroupEvents";

package/dist/lib/modules/group/roles/RoleGroupsAdmin.d.ts

@@ -18,6 +18,7 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
         getAsset: true,
         writeAsset: true,
         listMeasures: true,
+        getMetadataReferential: true,
       },
     },
  */

package/dist/lib/modules/group/roles/RoleGroupsReader.d.ts

@@ -18,6 +18,7 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
         getAsset: true,
         writeAsset: true,
         listMeasures: true,
+        getMetadataReferential: true,
       },
     },
  */

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

@@ -0,0 +1,8 @@
+import { GroupModelContent } from "../../model/types/ModelContent";
+export type AskGroupRefreshModel = {
+    name: "ask:device-manager:group:refresh-model";
+    payload: {
+        groupModel: GroupModelContent;
+    };
+    result: void;
+};

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

@@ -9,7 +9,7 @@ export type UpdateLinkResponse = mUpdateResponse & {
 };
 interface GroupControllerRequest {
     controller: "device-manager/groups";
-    engineId: string;
+    index: string;
 }
 export interface ApiGroupCreateRequest extends GroupControllerRequest {
     action: "create";

package/dist/lib/modules/measure/MeasureExporter.d.ts

@@ -19,12 +19,12 @@ interface MeasureExportParams extends ExportParams {
     model: string;
 }
 export declare class MeasureExporter extends AbstractExporter<MeasureExportParams> {
-    protected exportRedisKey(engineId: string, exportId: string): string;
-    protected getLink(engineId: string, exportId: UUID, params: MeasureExportParams): string;
+    protected exportRedisKey(index: string, exportId: string): string;
+    protected getLink(index: string, exportId: UUID, params: MeasureExportParams): string;
     /**
      * Searches for measures and return them in a standard JSON
      */
-    search(engineId: string, params: MeasureSearchParams, options?: MeasuresSearchOptions): Promise<{
+    search(index: string, params: MeasureSearchParams, options?: MeasuresSearchOptions): Promise<{
         measures: KHit<MeasureContent<any, any>>[];
         total: number;
     }>;
@@ -37,7 +37,7 @@ export declare class MeasureExporter extends AbstractExporter<MeasureExportParam
      *
      * Never return a rejected promise and write potential error on the stream
      */
-    prepareExport(engineId: string, user: User, params: MeasureSearchParams): Promise<string>;
+    prepareExport(index: string, user: User, params: MeasureSearchParams): Promise<string>;
     protected formatHit(columns: Array<Column & {
         shouldCheckName: boolean;
         name: string;
@@ -48,7 +48,7 @@ export declare class MeasureExporter extends AbstractExporter<MeasureExportParam
      * This method never returns a rejected promise, but write potential error in
      * the stream.
      */
-    sendExport(engineId: string, exportId: string): Promise<import("stream").PassThrough>;
+    sendExport(index: string, exportId: string): Promise<import("stream").PassThrough>;
     private generateMeasureColumns;
     private prepareMeasureSearch;
 }

package/dist/lib/modules/measure/MeasureService.d.ts

@@ -29,14 +29,14 @@ export declare class MeasureService extends BaseService {
      * @param asset The target asset to build the measure for
      * @param measure The decoded raw measures
      * @param payloadUuids The uuid's of the payloads used to create the measure
-     * @param engineGroup engineGroup of model
+     * @param tenantClass tenantClass of model
      * @returns A MeasurementContent builded from parameters
      */
     private buildApiMeasures;
     /**
      * Find an asset by its ID and its engine ID.
      *
-     * @param engineId The target index ID
+     * @param index The target index ID
      * @param assetId the target asset ID
      * @returns The asset or null if not found
      */

package/dist/lib/modules/measure/MeasureTargetBuilder.d.ts

@@ -1,3 +1,3 @@
 import { ApiMeasureTarget, DeviceMeasureTarget } from "./types/MeasureTarget";
-export declare function toApiTarget(indexId: string, assetId: string, engineGroups?: string[]): ApiMeasureTarget;
+export declare function toApiTarget(indexId: string, assetId: string, tenantClasses?: string[]): ApiMeasureTarget;
 export declare function toDeviceTarget(indexId: string, assetId?: string): DeviceMeasureTarget;

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

@@ -9,7 +9,7 @@ export interface DeviceMeasureTarget extends AbstractMeasureTarget {
 export interface ApiMeasureTarget extends AbstractMeasureTarget {
     type: "api";
     assetId: string;
-    engineGroups?: string[];
+    tenantClasses?: string[];
 }
 export declare function isTarget(target: any): target is AbstractMeasureTarget;
 export declare function isTargetDevice(target: any): target is DeviceMeasureTarget;

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

@@ -0,0 +1,119 @@
+import { EmbeddedSDK } from "kuzzle";
+import { JSONObject, KDocument } from "kuzzle-sdk";
+import { ConflictChunk } from "./ModelsConflicts";
+import { AssetModelContent, DeviceModelContent, GroupModelContent, MetadataDetails, MetadataMappings, MetadataReferential, MetadataReferentialContent, MetadataReferentialEntry, ReferentialMetadataMapping, ResolvedMetadataMappings } from "./types/ModelContent";
+export declare const METADATA_REFERENTIAL_ID = "model-metadata-referential";
+/**
+ * Runs cb holding the metadata referential lock, taken by every write of the referential
+ * and of asset, device and group models, so their conflicts checks see each other writes
+ */
+export declare function withMetadataReferentialLock<T>(cb: () => Promise<T>): Promise<T>;
+export type MetadataModelContent = AssetModelContent | DeviceModelContent | GroupModelContent;
+export type MetadataModelType = MetadataModelContent["type"];
+/**
+ * Metadata related fields of an asset, device or group model
+ */
+export type ModelMetadataFields = {
+    metadataMappings: MetadataMappings;
+    defaultMetadata: JSONObject;
+    metadataDetails: MetadataDetails;
+};
+export type MetadataResolutionContext = {
+    modelType: MetadataModelType;
+    model: string;
+    /**
+     * Builds the error thrown on an invalid use of the referential.
+     * PluginImplementationError when registering from code, BadRequestError from the API.
+     */
+    createError: (message: string) => Error;
+};
+export type MetadataEnrichment = {
+    /**
+     * Metadata fields to store: referential markers are kept in metadataMappings,
+     * metadataDetails and defaultMetadata are enriched with the referential values
+     */
+    fields: ModelMetadataFields;
+    /**
+     * Metadata mappings with the referential markers replaced by the referential mappings
+     */
+    resolvedMappings: ResolvedMetadataMappings;
+    /**
+     * Inline metadata identical to a referential entry, which should use the referential instead
+     */
+    warnings: string[];
+};
+/**
+ * @returns true if the metadata mappings mark a metadata of the referential
+ */
+export declare function isReferentialMapping(mapping: unknown): mapping is ReferentialMetadataMapping;
+/**
+ * Lists the metadata of a model coming from the metadata referential
+ */
+export declare function getReferentialNames(metadataMappings?: MetadataMappings): string[];
+/**
+ * Replaces the referential markers of metadata mappings by the referential mappings.
+ * A marker of a metadata missing from the referential is dropped.
+ */
+export declare function resolveMetadataMappings(referential: MetadataReferential, metadataMappings?: MetadataMappings): ResolvedMetadataMappings;
+/**
+ * @returns The model with the referential markers of its metadata mappings resolved
+ */
+export declare function resolveModelMappings<T extends MetadataModelContent>(referential: MetadataReferential, content: T): T;
+/**
+ * Resolves the referential metadata of a stored model, to be read:
+ * the markers are replaced by the referential mappings, the details and default values
+ * are merged over the current referential values.
+ * A marker of a metadata missing from the referential is dropped.
+ *
+ * @returns The model with its referential metadata resolved
+ */
+export declare function resolveModelMetadata<T extends MetadataModelContent>(referential: MetadataReferential, content: T): T;
+/**
+ * Validates the shape of a metadata referential entry
+ *
+ * @throws The error built by createError if the entry is invalid
+ */
+export declare function checkMetadataReferentialEntry(name: string, entry: MetadataReferentialEntry, createError: (message: string) => Error): void;
+/**
+ * Validates the metadata mappings of a model against the metadata referential and enriches
+ * the details and default values of the metadata coming from the referential.
+ *
+ * A metadata of the referential is marked `{ referential: true }` in metadataMappings, the marker is kept.
+ * Its details are the referential locales (merged per locale), editorHint and icon, overridden by the
+ * model ones. Its default value is the referential one, unless the model defines one.
+ *
+ * An inline metadata with the name of a referential entry must have the same mappings (legacy).
+ *
+ * @throws The error built by createError on an invalid marker or an unknown metadata
+ * @throws MappingsConflictsError if an inline metadata conflicts with the referential
+ */
+export declare function enrichModelMetadata(referential: MetadataReferential, fields: Partial<ModelMetadataFields>, context: MetadataResolutionContext): MetadataEnrichment;
+/**
+ * Lists the conflicts between a referential entry and the inline metadata of the same name of models
+ */
+export declare function getEntryModelsConflicts(name: string, entry: MetadataReferentialEntry, models: MetadataModelContent[]): ConflictChunk[];
+/**
+ * Lists the inline metadata a model write adds: metadataMappings keys that neither
+ * use the referential nor are already defined inline by the stored model.
+ */
+export declare function getAddedInlineMetadata(metadataMappings: MetadataMappings, stored: MetadataModelContent | null): string[];
+/**
+ * Reads the metadata referential document
+ *
+ * @returns The referential metadata, empty if the document does not exist yet
+ */
+export declare function fetchMetadataReferential(sdk: EmbeddedSDK, platformIndex: string): Promise<MetadataReferential>;
+/**
+ * Writes the whole metadata referential document
+ */
+export declare function saveMetadataReferential(sdk: EmbeddedSDK, platformIndex: string, referential: MetadataReferential): Promise<import("kuzzle").KDocument<MetadataReferentialContent>>;
+/**
+ * Lists every stored asset, device and group model
+ */
+export declare function fetchMetadataModels(sdk: EmbeddedSDK, platformIndex: string): Promise<KDocument<MetadataModelContent>[]>;
+/**
+ * Lists every stored asset, device and group model using the given metadata of the referential.
+ *
+ * metadataMappings is not indexed, the filtering is done after fetching the models.
+ */
+export declare function fetchReferencingModels(sdk: EmbeddedSDK, platformIndex: string, name: string): Promise<KDocument<MetadataModelContent>[]>;