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

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,13 @@ 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;
 }

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/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/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,17 @@ 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>>;
+    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 +32,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 +48,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 +64,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 +80,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 +96,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/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/ModelService.d.ts

@@ -14,51 +14,47 @@ export declare class ModelService extends BaseService {
     private checkModelsConflicts;
     private checkDefaultValues;
     private checkGroupAffinity;
-    writeAsset(engineGroups: string[], model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {
+    writeAsset(tenantClasses: string[], model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {
         [valueName: string]: LocaleDetails;
-    }, engineIds?: string[], icon?: string): Promise<KDocument<AssetModelContent>>;
+    }, indexes?: string[], icon?: string): Promise<KDocument<AssetModelContent>>;
     writeDevice(model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, icon?: string): Promise<KDocument<DeviceModelContent>>;
-    writeGroup(engineGroups: string[], model: string, affinity: JSONObject, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, icon?: string, locales?: {
+    writeGroup(tenantClasses: string[], model: string, affinity: JSONObject, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, icon?: string, locales?: {
         [valueName: string]: LocaleDetails;
     }): Promise<KDocument<GroupModelContent>>;
     writeMeasure(type: string, valuesMappings: JSONObject, validationSchema?: SchemaObject, valuesDetails?: MeasureValuesDetails, locales?: {
         [valueName: string]: LocaleDetails;
-    }, engineIds?: string[], icon?: string): Promise<KDocument<MeasureModelContent>>;
+    }, indexes?: string[], icon?: string): Promise<KDocument<MeasureModelContent>>;
     deleteAsset(_id: string): Promise<void>;
     deleteDevice(_id: string): Promise<void>;
     deleteGroup(_id: string): Promise<void>;
     deleteMeasure(_id: string): Promise<void>;
     /**
-     * List all asset models regardless of engine group scope.
+     * List all asset models regardless of tenant class scope.
      * Used for super admin global view.
      */
     listAllAssets(): Promise<KDocument<AssetModelContent>[]>;
     /**
      * Check if an engine (tenant) exists by its ID.
      */
-    engineExists(engineId: string): Promise<boolean>;
+    engineExists(index: string): Promise<boolean>;
     /**
-     * Check if the requesting user has access to an engine.
+     * Find tenant classes that don't exist.
      */
-    userHasEngineAccess(request: KuzzleRequest, engineId: string): Promise<boolean>;
-    /**
-     * Find engine groups that don't exist.
-     */
-    findInvalidEngineGroups(engineGroups: string[]): Promise<string[]>;
-    listAsset(engineGroups: string[], engineId?: string): Promise<KDocument<AssetModelContent>[]>;
+    findInvalidTenantClasses(tenantClasses: string[]): Promise<string[]>;
+    listAsset(tenantClasses: string[], index?: string): Promise<KDocument<AssetModelContent>[]>;
     listDevices(): Promise<KDocument<DeviceModelContent>[]>;
-    listGroups(engineGroups: string[]): Promise<KDocument<GroupModelContent>[]>;
-    listMeasures(engineId?: string): Promise<KDocument<MeasureModelContent>[]>;
-    searchAssets(engineGroups: string[], engineId: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<AssetModelContent>>>;
+    listGroups(tenantClasses: string[]): Promise<KDocument<GroupModelContent>[]>;
+    listMeasures(index?: string): Promise<KDocument<MeasureModelContent>[]>;
+    searchAssets(tenantClasses: string[], index: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<AssetModelContent>>>;
     searchDevices(searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<DeviceModelContent>>>;
-    searchGroups(engineGroups: string[], searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<GroupModelContent>>>;
-    searchMeasures(engineId: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<MeasureModelContent>>>;
+    searchGroups(tenantClasses: string[], searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<GroupModelContent>>>;
+    searchMeasures(index: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<MeasureModelContent>>>;
     assetExists(model: string): Promise<boolean>;
     deviceExists(model: string): Promise<boolean>;
-    getAsset(engineGroups: string[], engineId: string | undefined, model: string): Promise<KDocument<AssetModelContent>>;
+    getAsset(tenantClasses: string[], index: string | undefined, model: string): Promise<KDocument<AssetModelContent>>;
     getDevice(model: string): Promise<KDocument<DeviceModelContent>>;
     getGroup(model: string): Promise<KDocument<GroupModelContent>>;
-    getMeasure(type: string, engineId?: string): Promise<KDocument<MeasureModelContent>>;
+    getMeasure(type: string, index?: string): Promise<KDocument<MeasureModelContent>>;
     /**
      * Checks that creating/updating a measure model does not shadow an existing
      * one at a different scope (global vs tenant-scoped).
@@ -67,7 +63,7 @@ export declare class ModelService extends BaseService {
     /**
      * Update an asset model
      */
-    updateAsset(engineGroups: string[], engineId: string | undefined, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels, locales: {
+    updateAsset(tenantClasses: string[], index: string | undefined, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels, locales: {
         [valueName: string]: LocaleDetails;
     }, icon: string | undefined, request: KuzzleRequest): Promise<KDocument<AssetModelContent>>;
 }

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

@@ -17,7 +17,7 @@ export declare class ModelsRegister {
     /**
      * Registers an asset model.
      *
-     * @param engineGroups - The engine group names.
+     * @param tenantClasses - The tenant class names.
      * @param model - The name of the asset model, which must be in PascalCase.
      * @param measures - The measures associated with this asset model.
      * @param metadataMappings - The metadata mappings for the model, defaults to an empty object.
@@ -28,7 +28,7 @@ export declare class ModelsRegister {
      * @param icon - Optional icon representing the model.
      * @throws PluginImplementationError if the model name is not in PascalCase.
      */
-    registerAsset(engineGroups: string[], model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, tooltipModels?: TooltipModels, locales?: {
+    registerAsset(tenantClasses: string[], model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, tooltipModels?: TooltipModels, locales?: {
         [valueName: string]: LocaleDetails;
     }, icon?: string): void;
     /**
@@ -48,7 +48,7 @@ export declare class ModelsRegister {
      * Registers a group model.
      *
      *
-     * @param engineGroups - The engine group names.
+     * @param tenantClasses - The tenant class names.
      * @param model - The name of the group model, which must be in PascalCase.
      * @param affinity - The type of object accepted and their model affinity.
      * @param metadataMappings - The metadata mappings for the model, defaults to an empty object.
@@ -59,7 +59,7 @@ export declare class ModelsRegister {
      * @param locales - Optional translations specific to the model.
      * @throws PluginImplementationError if the model name is not in PascalCase.
      */
-    registerGroup(engineGroups: string[], model: string, affinity: GroupAffinity, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, icon?: string, locales?: {
+    registerGroup(tenantClasses: string[], model: string, affinity: GroupAffinity, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, icon?: string, locales?: {
         [valueName: string]: LocaleDetails;
     }): void;
     registerMeasure(type: string, measureDefinition: MeasureDefinition): void;

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

@@ -8,7 +8,7 @@ interface ModelsControllerRequest {
 export interface ApiModelGetAssetRequest extends ModelsControllerRequest {
     action: "getAsset";
     model: string;
-    engineGroups: string[];
+    tenantClasses: string[];
 }
 export type ApiModelGetAssetResult = KDocument<AssetModelContent>;
 export interface ApiModelGetDeviceRequest extends ModelsControllerRequest {
@@ -24,14 +24,14 @@ export type ApiModelGetGroupResult = KDocument<GroupModelContent>;
 export interface ApiModelGetMeasureRequest extends ModelsControllerRequest {
     action: "getMeasure";
     type: string;
-    engineId?: string;
+    index?: string;
 }
 export type ApiModelGetMeasureResult = KDocument<MeasureModelContent>;
 export interface ApiModelWriteAssetRequest extends ModelsControllerRequest {
     action: "writeAsset";
     body: {
-        engineGroups: string[];
-        engineIds?: string[];
+        tenantClasses: string[];
+        indexes?: string[];
         model: string;
         icon?: string;
         metadataDetails?: MetadataDetails;
@@ -63,7 +63,7 @@ export interface ApiModelWriteGroupRequest extends ModelsControllerRequest {
     action: "writeGroup";
     body: {
         affinity: GroupAffinity;
-        engineGroups: string[];
+        tenantClasses: string[];
         model: string;
         icon?: string;
         metadataDetails?: MetadataDetails;
@@ -80,7 +80,7 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     action: "writeMeasure";
     body: {
         type: string;
-        engineIds?: string[];
+        indexes?: string[];
         icon?: string;
         locales?: {
             [valueName: string]: LocaleDetails;
@@ -93,7 +93,7 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
 export type ApiModelWriteMeasureResult = KDocument<MeasureModelContent>;
 export interface ApiModelUpdateAssetRequest extends ModelsControllerRequest {
     action: "updateAsset";
-    engineGroups: string[];
+    tenantClasses: string[];
     model: string;
     body: {
         icon?: string;
@@ -131,7 +131,7 @@ export interface ApiModelDeleteMeasureRequest extends ModelsControllerRequest {
 export type ApiModelDeleteMeasureResult = void;
 export interface ApiModelListAssetsRequest extends ModelsControllerRequest {
     action: "listAssets";
-    engineGroups: string[];
+    tenantClasses: string[];
 }
 export type ApiModelListAssetsResult = {
     models: KDocument<AssetModelContent>[];
@@ -146,7 +146,7 @@ export type ApiModelListDevicesResult = {
 };
 export interface ApiModelListGroupsRequest extends ModelsControllerRequest {
     action: "listGroups";
-    engineGroups: string[];
+    tenantClasses: string[];
 }
 export type ApiModelListGroupsResult = {
     models: KDocument<GroupModelContent>[];
@@ -154,7 +154,7 @@ export type ApiModelListGroupsResult = {
 };
 export interface ApiModelListMeasuresRequest extends ModelsControllerRequest {
     action: "listMeasures";
-    engineId?: string;
+    index?: string;
 }
 export type ApiModelListMeasuresResult = {
     models: KDocument<MeasureModelContent>[];
@@ -162,7 +162,7 @@ export type ApiModelListMeasuresResult = {
 };
 export interface ApiModelSearchAssetsRequest extends ModelsControllerRequest {
     action: "searchAssets";
-    engineGroups: string[];
+    tenantClasses: string[];
     from?: number;
     size?: number;
     scrollTTL?: string;
@@ -179,7 +179,7 @@ export interface ApiModelSearchDevicesRequest extends ModelsControllerRequest {
 export type ApiModelSearchDevicesResult = SearchResult<KHit<DeviceModelContent>>;
 export interface ApiModelSearchGroupsRequest extends ModelsControllerRequest {
     action: "searchGroups";
-    engineGroups: string[];
+    tenantClasses: string[];
     from?: number;
     size?: number;
     scrollTTL?: string;
@@ -188,7 +188,7 @@ export interface ApiModelSearchGroupsRequest extends ModelsControllerRequest {
 export type ApiModelSearchGroupsResult = SearchResult<KHit<GroupModelContent>>;
 export interface ApiModelSearchMeasuresRequest extends ModelsControllerRequest {
     action: "searchMeasures";
-    engineId?: string;
+    index?: string;
     from?: number;
     size?: number;
     scrollTTL?: string;

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

@@ -3,8 +3,8 @@ import { NamedMeasures } from "../../decoder";
 import { MeasureDefinition } from "../../measure";
 export interface MeasureModelContent extends KDocumentContent {
     type: "measure";
-    engineGroups?: string[];
-    engineIds?: string[];
+    tenantClasses?: string[];
+    indexes?: string[];
     measure: MeasureDefinition & {
         type: string;
         locales?: {
@@ -155,13 +155,13 @@ export interface TooltipModels {
 }
 export interface AssetModelContent extends KDocumentContent {
     type: "asset";
-    engineGroups: string[];
+    tenantClasses: string[];
     /**
      * Optional list of engine IDs (tenant IDs) this model is scoped to.
      * When set, the model is only available to the specified tenants.
-     * When absent, the model is available to all tenants in the engineGroups.
+     * When absent, the model is available to all tenants in the tenantClasses.
      */
-    engineIds?: string[];
+    indexes?: string[];
     asset: {
         /**
          * Name of the model
@@ -408,7 +408,7 @@ export interface DeviceModelContent extends KDocumentContent {
 }
 export interface GroupModelContent extends KDocumentContent {
     type: "group";
-    engineGroups: string[];
+    tenantClasses: string[];
     group: {
         /**
          * Name of the model

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

@@ -2,8 +2,8 @@ import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelC
 export type AskModelAssetGet = {
     name: "ask:device-manager:model:asset:get";
     payload: {
-        engineGroups: string[];
-        engineId?: string;
+        tenantClasses: string[];
+        index?: string;
         model: string;
     };
     result: AssetModelContent;
@@ -19,7 +19,7 @@ export type AskModelMeasureGet = {
     name: "ask:device-manager:model:measure:get";
     payload: {
         type: string;
-        engineId?: string;
+        index?: string;
     };
     result: MeasureModelContent;
 };

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

@@ -18,7 +18,7 @@ export interface EngineDocument extends KDocumentContent {
 export type AskEngineList = {
     name: "ask:device-manager:engine:list";
     payload: {
-        group?: string;
+        tenantClass?: string;
     };
     result: EngineContent[];
 };
@@ -79,10 +79,10 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      */
     getEngines(): Promise<EngineDocument[]>;
     updateMeasuresSchema(): Promise<void>;
-    onCreate(index: string, group?: string): Promise<{
+    onCreate(index: string, tenantClass?: string): Promise<{
         collections: any[];
     }>;
-    onUpdate(index: string, group?: string): Promise<{
+    onUpdate(index: string, tenantClass?: string): Promise<{
         collections: any[];
     }>;
     onDelete(index: string): Promise<{
@@ -91,44 +91,44 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
     /**
      * Generate assets mappings and create the assets collection in the engine
      *
-     * @param engineId The target engine Id
-     * @param engineGroup The engine group
+     * @param index The target engine Id
+     * @param tenantClass The tenant class
      *
      * @throws If it failed during the assets collection creation
      */
-    createAssetsCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    createAssetsCollection(index: string, tenantClass: string): Promise<InternalCollection>;
     /**
      * Generate assets mappings and create the assets history collection in the engine
      *
-     * @param engineId The target engine Id
-     * @param engineGroup The engine group
+     * @param index The target engine Id
+     * @param tenantClass The tenant class
      *
      * @throws If it failed during the assets history collection creation
      */
-    createAssetsHistoryCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    createAssetsHistoryCollection(index: string, tenantClass: string): Promise<InternalCollection>;
     /**
      * Create the groups collection with the groups mappings in the engine
      *
-     * @param engineId The target engine Id
-     * @param engineGroup The engine group
+     * @param index The target engine Id
+     * @param tenantClass The tenant class
      *
      * @throws If it failed during the groups collection creation
      */
-    createGroupsCollection(engineId: string): Promise<InternalCollection>;
+    createGroupsCollection(index: string): Promise<InternalCollection>;
     /**
      * Generate devices mappings and create the devices collection in the engine
      *
-     * @param engineId The target engine Id
-     * @param engineGroup The engine group
+     * @param index The target engine Id
+     * @param tenantClass The tenant class
      *
      * @throws If it failed during the devices collection creation
      */
-    createDevicesCollection(engineId: string): Promise<InternalCollection>;
+    createDevicesCollection(index: string): Promise<InternalCollection>;
     /**
      * Generate devices mappings and create the devices collection in the engine
      *
-     * @param engineId The target engine Id
-     * @param engineGroup The engine group
+     * @param index The target engine Id
+     * @param tenantClass The tenant class
      *
      * @throws If it failed during the devices collection creation
      */
@@ -136,12 +136,12 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
     /**
      * Generate measures mappings and create the measures collection in the engine
      *
-     * @param engineId The target engine Id
-     * @param engineGroup The engine group
+     * @param index The target engine Id
+     * @param tenantClass The tenant class
      *
      * @throws If it failed during the measures collection creation
      */
-    createMeasuresCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    createMeasuresCollection(index: string, tenantClass: string): Promise<InternalCollection>;
     /**
      * Create a collection with custom mappings in an engine
      *
@@ -156,7 +156,7 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * Generate ES mappings from twin models and theirs associated measures, all fetched from the database
      *
      * @param digitalTwinType The target twin type
-     * @param engineGroup The twin engine group
+     * @param tenantClass The twin tenant class
      * @returns The complete ES mappings produces by merging all the target type twins
      */
     private getDigitalTwinMappingsFromDB;
@@ -172,7 +172,7 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
     /**
      * Generate ES mappings from measures and theirs associated assets, all fetched via the database
      *
-     * @param engineGroup The target engine group
+     * @param tenantClass The target tenant class
      * @returns The complete ES mappings produced by merging models mappings
      */
     private getMeasuresMappingsFromDB;
@@ -188,16 +188,16 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
     /**
      * Retrieve a certain type of models associated to an engine
      *
-     * @param engineId The target engine Id
+     * @param index The target engine Id
      * @param type The desired model type
-     * @param engineGroup The target engine group
+     * @param tenantClass The target tenant class
      * @returns An array of the generic type provided
      */
     private getModels;
     /**
      * Detach all devices of an index in the platform index
      *
-     * @param engineId The target engine Id
+     * @param index The target engine Id
      * @returns {any}
      */
     private detachDevicesFromPlatformIndex;

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

@@ -24,7 +24,7 @@ export declare class DeviceManagerPlugin extends Plugin {
         /**
          * Register an asset model
          *
-         * @param engineGroups Engine group names
+         * @param tenantClasses Tenant class names
          * @param model Name of the asset model. Must follow a naming convention in PascalCase.
          * @param definition Object containing the asset model definition, including:
          *        - measures: Array describing measure names and their types.
@@ -124,7 +124,7 @@ export declare class DeviceManagerPlugin extends Plugin {
          * );
          * ```
          */
-        registerAsset: (engineGroups: string[], model: string, definition: AssetModelDefinition) => void;
+        registerAsset: (tenantClasses: string[], model: string, definition: AssetModelDefinition) => void;
         /**
          * Register a device.
          *
@@ -232,7 +232,7 @@ export declare class DeviceManagerPlugin extends Plugin {
          * );
          * ```
          */
-        registerGroup: (engineGroups: string[], model: string, definition: GroupModelDefinition) => void;
+        registerGroup: (tenantClasses: string[], model: string, definition: GroupModelDefinition) => void;
         /**
          * Register a new measure
          *
@@ -270,5 +270,12 @@ export declare class DeviceManagerPlugin extends Plugin {
      * Initialize the config document if it does not exists
      */
     private initializeConfig;
+    /**
+     * Moves the tenant scope of the models written before the rename from the
+     * former `engineIds` field to `indexes`. Idempotent: once a document carries
+     * `indexes` and no `engineIds`, it is left alone. Models are few, so the
+     * whole set fits in one search.
+     */
+    private migrateModelIndexes;
     private pipeCheckEngine;
 }

package/dist/lib/modules/shared/services/AbstractExporter.d.ts

@@ -22,7 +22,7 @@ export interface Column {
     isMeasure?: boolean;
     isIsoDate?: boolean;
 }
-export type ExportStreamAugmenter = (result: SearchResult<KHit<KDocumentContentGeneric>>, columns: Column[], engineId: string) => Promise<void>;
+export type ExportStreamAugmenter = (result: SearchResult<KHit<KDocumentContentGeneric>>, columns: Column[], index: string) => Promise<void>;
 export declare abstract class AbstractExporter<P extends ExportParams = ExportParams> {
     protected plugin: DeviceManagerPlugin;
     protected target: InternalCollection;
@@ -32,18 +32,18 @@ export declare abstract class AbstractExporter<P extends ExportParams = ExportPa
     protected get sdk(): import("kuzzle").EmbeddedSDK;
     protected get ms(): any;
     protected get log(): import("kuzzle-logger").KuzzleLogger;
-    protected getEngine(engineId: string): Promise<EngineContent>;
-    protected abstract exportRedisKey(engineId: string, exportId: string): string;
-    protected abstract getLink(engineId: string, exportId: UUID, params: P): string;
+    protected getEngine(index: string): Promise<EngineContent>;
+    protected abstract exportRedisKey(index: string, exportId: string): string;
+    protected abstract getLink(index: string, exportId: UUID, params: P): string;
     /**
      * Retrieve a prepared export and write each document as a CSV in the stream
      *
      * This method never returns a rejected promise, but write potential error in
      * the stream.
      */
-    abstract sendExport(engineId: string, exportId: string): Promise<Readable>;
-    prepareExport(engineId: string, user: User, params: P): Promise<string>;
+    abstract sendExport(index: string, exportId: string): Promise<Readable>;
+    prepareExport(index: string, user: User, params: P): Promise<string>;
     protected formatHit(columns: Column[], hit: KHit<KDocumentContentGeneric>): string[];
-    getExport(engineId: string, exportId: string): Promise<P>;
-    getExportStream(request: SearchResult<KHit<KDocumentContentGeneric>>, columns: Column[], engineId: string): Promise<PassThrough>;
+    getExport(index: string, exportId: string): Promise<P>;
+    getExportStream(request: SearchResult<KHit<KDocumentContentGeneric>>, columns: Column[], index: string): Promise<PassThrough>;
 }

package/dist/lib/modules/shared/services/BaseService.d.ts

@@ -2,7 +2,7 @@ import { ArgsDocumentControllerCreate, ArgsDocumentControllerDelete, ArgsDocumen
 import { DeviceManagerPlugin, DeviceManagerConfiguration, InternalCollection } from "../../plugin";
 interface PayloadRequest {
     collection: InternalCollection;
-    engineId: string;
+    index: string;
 }
 export type SearchParams = ReturnType<KuzzleRequest["getSearchParams"]>;
 export declare abstract class BaseService {
@@ -12,7 +12,7 @@ export declare abstract class BaseService {
     protected get sdk(): EmbeddedSDK;
     protected get config(): DeviceManagerConfiguration;
     protected get impersonatedSdk(): (user: User) => EmbeddedSDK;
-    protected normalizeKuzzleRequest(request: KuzzleRequest, { collection, engineId }: PayloadRequest): KuzzleRequest;
+    protected normalizeKuzzleRequest(request: KuzzleRequest, { collection, index }: PayloadRequest): KuzzleRequest;
     /**
      * Wrapper to SDK create method with trigger generic:document events
      *
@@ -22,7 +22,7 @@ export declare abstract class BaseService {
      * @param {ArgsDocumentControllerCreate} [options]
      * @returns {Promise<KDocument>}
      */
-    protected getDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, documentId: string, { collection, engineId }: PayloadRequest, options?: ArgsDocumentControllerCreate): Promise<KDocument<T>>;
+    protected getDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, documentId: string, { collection, index }: PayloadRequest, options?: ArgsDocumentControllerCreate): Promise<KDocument<T>>;
     /**
      * Wrapper to SDK create method with trigger generic:document events
      *
@@ -32,7 +32,7 @@ export declare abstract class BaseService {
      * @param {ArgsDocumentControllerCreate} [options]
      * @returns {Promise<KDocument>}
      */
-    protected createDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, document: KDocument<T>, { collection, engineId }: PayloadRequest, options?: ArgsDocumentControllerCreate): Promise<KDocument<T>>;
+    protected createDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, document: KDocument<T>, { collection, index }: PayloadRequest, options?: ArgsDocumentControllerCreate): Promise<KDocument<T>>;
     /**
      * Wrapper to SDK update method with trigger generic:document events
      *
@@ -42,7 +42,7 @@ export declare abstract class BaseService {
      * @param {ArgsDocumentControllerUpdate} [options]
      * @returns {Promise<KDocument>}
      */
-    protected updateDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, document: KDocument<Partial<T>>, { collection, engineId }: PayloadRequest, options?: ArgsDocumentControllerUpdate): Promise<KDocument<T>>;
+    protected updateDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, document: KDocument<Partial<T>>, { collection, index }: PayloadRequest, options?: ArgsDocumentControllerUpdate): Promise<KDocument<T>>;
     /**
      * Wrapper to SDK delete method with trigger generic:document events
      *
@@ -52,7 +52,7 @@ export declare abstract class BaseService {
      * @param {ArgsDocumentControllerUpdate} [options]
      * @returns {Promise<{ _id: string }>}
      */
-    protected deleteDocument(request: KuzzleRequest, documentId: string, { collection, engineId }: PayloadRequest, options?: ArgsDocumentControllerDelete): Promise<{
+    protected deleteDocument(request: KuzzleRequest, documentId: string, { collection, index }: PayloadRequest, options?: ArgsDocumentControllerDelete): Promise<{
         _id: string;
     }>;
     /**
@@ -64,6 +64,6 @@ export declare abstract class BaseService {
      * @param {PayloadRequest} payload
      * @returns {Promise<SearchResult<KHit>>}
      */
-    protected searchDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, { from, size, scrollTTL: scroll }: SearchParams, { collection, engineId }: PayloadRequest): Promise<SearchResult<KHit<T>>>;
+    protected searchDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, { from, size, scrollTTL: scroll }: SearchParams, { collection, index }: PayloadRequest): Promise<SearchResult<KHit<T>>>;
 }
 export {};

package/dist/lib/modules/shared/services/DigitalTwinExporter.d.ts

@@ -7,9 +7,9 @@ export declare class DigitalTwinExporter extends AbstractExporter {
     protected plugin: DeviceManagerPlugin;
     protected target: InternalCollection;
     constructor(plugin: DeviceManagerPlugin, target: InternalCollection, config?: Partial<ExporterOption>);
-    protected exportRedisKey(engineId: string, exportId: string): string;
-    protected getLink(engineId: string, exportId: UUID): string;
-    sendExport(engineId: string, exportId: string): Promise<import("stream").PassThrough>;
+    protected exportRedisKey(index: string, exportId: string): string;
+    protected getLink(index: string, exportId: UUID): string;
+    sendExport(index: string, exportId: string): Promise<import("stream").PassThrough>;
     /**
      * Get the deduplicated Named Measures get from models
      */

package/dist/lib/modules/shared/services/DigitalTwinService.d.ts

@@ -19,11 +19,11 @@ export declare class DigitalTwinService extends BaseService {
     /**
      * Gets the last measures of a digital twin
      */
-    getLastMeasures(engineId: string, digitalTwinId: string, measureCount?: number): Promise<MeasureContent[]>;
+    getLastMeasures(index: string, digitalTwinId: string, measureCount?: number): Promise<MeasureContent[]>;
     /**
      * Link a device to an asset.
      */
-    linkAssetDevice(engineId: string, deviceId: string, assetId: string, measureSlots: {
+    linkAssetDevice(index: string, deviceId: string, assetId: string, measureSlots: {
         asset: string;
         device: string;
     }[], implicitMeasuresLinking: boolean, request: KuzzleRequest): Promise<{
@@ -44,9 +44,9 @@ export declare class DigitalTwinService extends BaseService {
     /**
      * Gets the last measures of multiple digital twins
      */
-    mGetLastMeasures(engineId: string, digitalTwinIds: string[], measureCount?: number): Promise<Record<string, MeasureContent[]>>;
-    getLastMeasuredAt(engineId: string, digitalTwinId: string): Promise<number>;
-    mGetLastMeasuredAt(engineId: string, digitalTwinIds: string[]): Promise<ApiDigitalTwinMGetLastMeasuredAtResult>;
+    mGetLastMeasures(index: string, digitalTwinIds: string[], measureCount?: number): Promise<Record<string, MeasureContent[]>>;
+    getLastMeasuredAt(index: string, digitalTwinId: string): Promise<number>;
+    mGetLastMeasuredAt(index: string, digitalTwinIds: string[]): Promise<ApiDigitalTwinMGetLastMeasuredAtResult>;
     private getAggregationQueryParameters;
     /**
      * Checks if the asset does not already have a linked device using one of the
@@ -78,13 +78,13 @@ export declare class DigitalTwinService extends BaseService {
     }>;
     /**
      * Retrieve the model document of an asset
-     * @param {any} engineGroup:string
+     * @param {any} tenantClass:string
      * @param {any} model:string
      * @returns {any}
      */
-    protected getAssetModel(engineGroup: string, model: string, engineId?: string): Promise<AssetModelContent>;
+    protected getAssetModel(tenantClass: string, model: string, index?: string): Promise<AssetModelContent>;
     protected getDeviceModel(model: string): Promise<DeviceModelContent>;
-    getEngine(engineId: string): Promise<JSONObject>;
+    getEngine(index: string): Promise<JSONObject>;
     protected getDeviceProvisioning(deviceId: string): Promise<import("kuzzle").KDocument<DeviceProvisioningContent>>;
     protected checkDeviceAttachedToEngine(device: KDocument<DeviceProvisioningContent>): void;
 }

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

@@ -1,7 +1,7 @@
 import { DigitalTwinMeasures } from "./DigitalTwinMeasures";
 interface DigitalTwinControllerRequest<ControllerName extends string> {
     controller: ControllerName;
-    engineId: string;
+    index: string;
 }
 export interface ApiDigitalTwinGetLastMeasuresRequest<ControllerName extends string> extends DigitalTwinControllerRequest<ControllerName> {
     action: "getLastMeasures";

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

@@ -3,7 +3,7 @@ import { MeasureContent } from "../../measure";
 export type AskDigitalTwinLastMeasuresGet = {
     name: "ask:device-manager:asset:get-last-measures" | "ask:device-manager:device:get-last-measures";
     payload: {
-        engineId: string;
+        index: string;
         digitalTwinId: string;
     };
     result: MeasureContent[];
@@ -11,7 +11,7 @@ export type AskDigitalTwinLastMeasuresGet = {
 export type AskDigitalTwinLink = {
     name: "ask:device-manager:device:link-asset" | "ask:device-manager:asset:link-device";
     payload: {
-        engineId: string;
+        index: string;
         assetId: string;
         deviceId: string;
         user: User;

package/package.json

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