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

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?: {
@@ -22,7 +22,20 @@ export interface MetadataObject {
         [key: string]: MetadataProperty | MetadataObject;
     };
 }
+/**
+ * Marks, in the metadataMappings of a model, a metadata defined in the metadata referential.
+ * Its mappings are the referential ones, they are already merged into the engines collections.
+ */
+export interface ReferentialMetadataMapping {
+    referential: true;
+}
 export interface MetadataMappings {
+    [key: string]: MetadataProperty | MetadataObject | ReferentialMetadataMapping;
+}
+/**
+ * Metadata mappings without referential markers, as merged into the engines collections
+ */
+export interface ResolvedMetadataMappings {
     [key: string]: MetadataProperty | MetadataObject;
 }
 export interface GroupAffinity {
@@ -95,9 +108,62 @@ export interface MetadataDetails {
          * Then add a new field in EditorHintEnum to define the type of your hint.
          * Finally add the new editor hint interface with a pipe to take in account the new type.
          */
-        editorHint?: BaseEditorHint | OptionsSelectorEditorHint | DatetimeEditorHint;
+        editorHint?: EditorHint;
+        /**
+         * Icon representing the metadata.
+         * Free-form string, e.g. a FontAwesome icon name, a URL to a PNG/SVG image, or inline SVG markup.
+         */
+        icon?: string;
     };
 }
+export type EditorHint = BaseEditorHint | OptionsSelectorEditorHint | DatetimeEditorHint;
+/**
+ * A metadata defined once in the application metadata referential.
+ * Its mappings are merged into the engines collections when it is written,
+ * models use it with `{ referential: true }` in their metadataMappings.
+ */
+export interface MetadataReferentialEntry {
+    /**
+     * Mappings of the metadata.
+     * They cannot be modified once written, as they are merged into the engines collections.
+     *
+     * @example
+     * { type: "keyword" }
+     * { properties: { name: { type: "keyword" } } }
+     */
+    mappings: MetadataProperty | MetadataObject;
+    /**
+     * Default translations of the metadata, copied into the metadataDetails of a model using it
+     */
+    locales: {
+        [locale: string]: LocaleDetails;
+    };
+    /**
+     * Default editor hint of the metadata
+     */
+    editorHint?: EditorHint;
+    /**
+     * Default value of the metadata
+     */
+    defaultValue?: unknown;
+    /**
+     * Default icon of the metadata.
+     * Free-form string, e.g. a FontAwesome icon name, a URL to a PNG/SVG image, or inline SVG markup.
+     */
+    icon?: string;
+    /**
+     * Set by the plugin: true for a metadata registered from code.
+     * It is written at every startup and cannot be modified or deleted through the API.
+     */
+    managed?: boolean;
+}
+export interface MetadataReferential {
+    [name: string]: MetadataReferentialEntry;
+}
+export interface MetadataReferentialContent extends KDocumentContent {
+    type: "metadata-referential";
+    metadata: MetadataReferential;
+}
 export interface MetadataGroupLocale {
     groupFriendlyName: string;
     description: string;
@@ -155,13 +221,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 +474,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/ModelDefinition.d.ts

@@ -118,7 +118,8 @@ export type AssetModelDefinition = {
      */
     icon?: string;
     /**
-     * Metadata mappings definition
+     * Metadata mappings definition.
+     * Use `{ referential: true }` for a metadata of the metadata referential.
      */
     metadataMappings?: MetadataMappings;
     /**
@@ -201,7 +202,8 @@ export type DeviceModelDefinition = {
      */
     icon?: string;
     /**
-     * Metadata mappings definition
+     * Metadata mappings definition.
+     * Use `{ referential: true }` for a metadata of the metadata referential.
      */
     metadataMappings?: MetadataMappings;
     /**
@@ -296,7 +298,8 @@ export type GroupModelDefinition = {
      */
     icon?: string;
     /**
-     * Metadata mappings definition
+     * Metadata mappings definition.
+     * Use `{ referential: true }` for a metadata of the metadata referential.
      */
     metadataMappings?: MetadataMappings;
     /**

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

@@ -1,9 +1,9 @@
-import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelContent } from "./ModelContent";
+import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelContent, MetadataReferential } from "./ModelContent";
 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;
 };
@@ -30,3 +30,8 @@ export type AskModelGroupGet = {
     };
     result: GroupModelContent;
 };
+export type AskModelMetadataReferentialGet = {
+    name: "ask:device-manager:model:metadata-referential:get";
+    payload: void;
+    result: MetadataReferential;
+};

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

@@ -5,6 +5,7 @@ import { DeviceManagerPlugin } from "./DeviceManagerPlugin";
 import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
 import { InternalCollection } from "./types/InternalCollection";
 import { ConflictChunk } from "../model/ModelsConflicts";
+import { MetadataMappings } from "../model/types/ModelContent";
 export type TwinType = "asset" | "device";
 export type TwinModelContent = AssetModelContent | DeviceModelContent;
 export interface EngineDocument extends KDocumentContent {
@@ -18,7 +19,7 @@ export interface EngineDocument extends KDocumentContent {
 export type AskEngineList = {
     name: "ask:device-manager:engine:list";
     payload: {
-        group?: string;
+        tenantClass?: string;
     };
     result: EngineContent[];
 };
@@ -39,10 +40,42 @@ export type AskEngineUpdateConflict = {
     };
     result: ConflictChunk[];
 };
+/**
+ * Checks a metadata of the metadata referential against the actual metadata mappings
+ * of the assets, devices and groups collections of every engine
+ */
+export type AskEngineMetadataConflict = {
+    name: "ask:device-manager:engine:doesMetadataConflict";
+    payload: {
+        metadataMappings: MetadataMappings;
+    };
+    result: ConflictChunk[];
+};
 export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlugin> {
     config: DeviceManagerConfiguration;
     get app(): Backend;
     constructor(plugin: Plugin, platformConfigManager: ConfigManager, engineConfigManager: ConfigManager);
+    /**
+     * Returns the actual metadata mappings of an engine collection
+     *
+     * @returns The mappings of the metadata properties, empty if the collection does not exist
+     */
+    private getCollectionMetadataMappings;
+    /**
+     * Return conflicts between the metadata mappings of models and the actual mappings
+     * of their collection in an engine
+     *
+     * @param engineIndex The target engine
+     * @param modelType The models type
+     * @param models The new or updated models, with their referential metadata resolved
+     * @returns An array of ConflictChunk
+     */
+    private getModelsMetadataConflicts;
+    /**
+     * Merges the mappings of the metadata referential and of models into metadata mappings.
+     * Every referential metadata is merged, used by a model or not.
+     */
+    private mergeMetadataMappings;
     /**
      * Return conflicts between the new and already present twin models
      *
@@ -79,10 +112,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 +124,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 +169,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 +189,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 +205,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 +221,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

@@ -2,7 +2,7 @@ import { Plugin, PluginContext } from "kuzzle";
 import { JSONObject } from "kuzzle-sdk";
 import { MeasureDefinition } from "../measure";
 import { DecoderModule, DecodersRegister } from "../decoder";
-import { AssetModelDefinition, DeviceModelDefinition, GroupModelDefinition, ModelsRegister } from "../model";
+import { AssetModelDefinition, DeviceModelDefinition, GroupModelDefinition, MetadataReferentialEntry, ModelsRegister } from "../model";
 import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
 export declare class DeviceManagerPlugin extends Plugin {
     config: DeviceManagerConfiguration;
@@ -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
          *
@@ -249,6 +249,41 @@ export declare class DeviceManagerPlugin extends Plugin {
          * ```
          */
         registerMeasure: (name: string, measureDefinition: MeasureDefinition) => void;
+        /**
+         * Register a metadata in the metadata referential.
+         *
+         * Its mappings are merged into the assets, devices and groups collections of every engine,
+         * and cannot be modified afterwards.
+         * Asset, device and group models then use it with `{ referential: true }` in their
+         * metadataMappings instead of redefining its mappings.
+         * A model defining inline a metadata that conflicts with the referential is rejected.
+         *
+         * @param name Name of the metadata
+         * @param definition Mappings, default translations, editor hint, default value and icon
+         *
+         * @example
+         * ```
+         * deviceManager.models.registerMetadata("color", {
+         *   mappings: { type: "keyword" },
+         *   locales: {
+         *     en: { friendlyName: "Color", description: "Color of the asset" },
+         *     fr: { friendlyName: "Couleur", description: "Couleur de l'asset" },
+         *   },
+         *   editorHint: {
+         *     type: EditorHintEnum.OPTION_SELECTOR,
+         *     values: ["red", "blue"],
+         *   },
+         *   defaultValue: "red",
+         *   icon: "palette",
+         * });
+         *
+         * deviceManager.models.registerAsset("commons", "Container", {
+         *   measures: [],
+         *   metadataMappings: { color: { referential: true } },
+         * });
+         * ```
+         */
+        registerMetadata: (name: string, definition: MetadataReferentialEntry) => void;
     };
     constructor();
     /**
@@ -270,5 +305,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/plugin/types/DeviceManagerConfiguration.d.ts

@@ -15,6 +15,17 @@ export type DeviceManagerConfiguration = {
          */
         autoUpdate: true;
     };
+    models: {
+        metadata: {
+            /**
+             * Only accept new metadata referenced from the metadata referential in the models written through the API.
+             *
+             * New inline metadataMappings keys are rejected, the inline metadata already defined
+             * by a model are kept (legacy). Models registered from code are not affected.
+             */
+            referentialOnly: boolean;
+        };
+    };
     /**
      * Platform index name
      */

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;