kuzzle-device-manager-types 3.0.0-next.25 → 3.0.0-next.27

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

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

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

@@ -1,7 +1,10 @@
+import { DeviceManagerPlugin } from "../plugin";
 import { Module } from "../shared/Module";
 export declare class AssetModule extends Module {
     private assetService;
     private assetHistoryService;
     private assetController;
+    private logger;
+    constructor(plugin: DeviceManagerPlugin);
     init(): Promise<void>;
 }

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

@@ -2,12 +2,14 @@ import { KuzzleRequest, User } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult, mReplaceResponse } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
 import { DigitalTwinService, Metadata, SearchParams } from "../shared";
+import { KuzzleLogger } from "kuzzle-logger";
 import { AssetHistoryService } from "./AssetHistoryService";
 import { ApiAssetMigrateTenantResult, ApiAssetUnlinkDevicesResult, ApiAssetUpdateModelLocales } from "./types/AssetApi";
 import { AssetContent } from "./types/AssetContent";
 export declare class AssetService extends DigitalTwinService {
     readonly assetHistoryService: AssetHistoryService;
-    constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService, assetLogger: KuzzleLogger);
     registerAskEvents(): void;
     get(engineId: string, assetId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**

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

@@ -4,13 +4,15 @@ import { DeviceManagerPlugin } from "../plugin";
 import { DigitalTwinExporter } from "../shared";
 import { AssetService } from "./AssetService";
 import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult, ApiAssetGetLastMeasuresResult, ApiAssetMGetLastMeasuredAtResult, ApiAssetMGetLastMeasuresResult, ApiAssetGetLastMeasuredAtResult, ApiAssetUpdateModelLocales, ApiAssetLinkDevicesResult, ApiAssetUnlinkDevicesResult, ApiAssetAddMeasureSlotResult, ApiAssetRemoveMeasureSlotResult } from "./types/AssetApi";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class AssetsController {
     readonly plugin: DeviceManagerPlugin;
     readonly assetService: AssetService;
     definition: ControllerDefinition;
     readonly exporter: DigitalTwinExporter;
     readonly measureExporter: MeasureExporter;
-    constructor(plugin: DeviceManagerPlugin, assetService: AssetService);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, assetService: AssetService, assetlogger: KuzzleLogger);
     get(request: KuzzleRequest): Promise<ApiAssetGetResult>;
     upsert(request: KuzzleRequest): Promise<ApiAssetUpsertResult>;
     update(request: KuzzleRequest): Promise<ApiAssetUpdateResult>;

package/dist/lib/modules/decoder/Decoder.d.ts

@@ -1,5 +1,6 @@
 import { HttpRoute, KuzzleRequest } from "kuzzle";
 import { JSONObject } from "kuzzle-sdk";
+import { KuzzleLogger } from "kuzzle-logger";
 import { DecodedPayload } from "./DecodedPayload";
 import { DecoderContent } from "./types/DecoderContent";
 /**
@@ -22,14 +23,7 @@ export declare abstract class Decoder {
     /**
      * Internal logger.
      */
-    log: {
-        debug: (message: any) => void;
-        error: (message: any) => void;
-        info: (message: any) => void;
-        silly: (message: any) => void;
-        verbose: (message: any) => void;
-        warn: (message: any) => void;
-    };
+    log: KuzzleLogger;
     /**
      * Device model name.
      *

package/dist/lib/modules/decoder/DecoderModule.d.ts

@@ -1,8 +1,13 @@
+import { DeviceManagerPlugin } from "../plugin";
 import { Module } from "../shared/Module";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class DecoderModule extends Module {
     private payloadService;
     private decoderController;
     private payloadsController;
+    readonly decoderLogger: KuzzleLogger;
+    readonly payloadLogger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin);
     private get decodersRegister();
     init(): Promise<void>;
 }

package/dist/lib/modules/decoder/DecodersController.d.ts

@@ -2,11 +2,13 @@ import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DecodersRegister } from "./DecodersRegister";
 import { PayloadService } from "./PayloadService";
 import { ApiDecoderListResult, ApiDecoderPrunePayloadsResult } from "./types/DecoderApi";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class DecodersController {
     private payloadService;
     private decodersRegister;
     definition: ControllerDefinition;
-    constructor(payloadService: PayloadService, decodersRegister: DecodersRegister);
+    readonly logger: KuzzleLogger;
+    constructor(payloadService: PayloadService, decodersRegister: DecodersRegister, logger: KuzzleLogger);
     /**
      * List all available decoders
      */

package/dist/lib/modules/decoder/DecodersRegister.d.ts

@@ -5,6 +5,7 @@ import { DecoderContent } from "./exports";
 export declare class DecodersRegister {
     private context;
     private plugin;
+    private logger;
     /**
      * Map<deviceModel, Decoder>
      */

package/dist/lib/modules/decoder/PayloadService.d.ts

@@ -5,8 +5,10 @@ import { DecodedMeasurement } from "../measure";
 import { DeviceManagerPlugin } from "../plugin";
 import { BaseService } from "../shared";
 import { Decoder } from "./Decoder";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class PayloadService extends BaseService {
-    constructor(plugin: DeviceManagerPlugin);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
     /**
      * Process a payload by validating and decode it with the `decoder` associated
      * with the device model. It :

package/dist/lib/modules/decoder/PayloadsController.d.ts

@@ -2,10 +2,12 @@ import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DecodersRegister } from "./DecodersRegister";
 import { PayloadService } from "./PayloadService";
 import { ApiPayloadReceiveUnkownResult } from "./types/PayloadApi";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class PayloadsController {
     private payloadService;
     private decodersRegister;
+    readonly logger: KuzzleLogger;
     definition: ControllerDefinition;
-    constructor(payloadService: PayloadService, decodersRegister: DecodersRegister);
+    constructor(payloadService: PayloadService, decodersRegister: DecodersRegister, logger: KuzzleLogger);
     receiveUnknown(request: KuzzleRequest): Promise<ApiPayloadReceiveUnkownResult>;
 }

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

@@ -1,6 +1,10 @@
+import { DeviceManagerPlugin } from "../plugin";
 import { Module } from "../shared/Module";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class DeviceModule extends Module {
     private deviceService;
     private deviceController;
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin);
     init(): Promise<void>;
 }

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

@@ -5,8 +5,10 @@ import { DeviceManagerPlugin } from "../plugin";
 import { DigitalTwinService, Metadata, SearchParams } from "../shared";
 import { DeviceProvisioningContent, DeviceContent } from "./types/DeviceContent";
 import { ApiDeviceUnlinkAssetsResult } from "./exports";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class DeviceService extends DigitalTwinService {
-    constructor(plugin: DeviceManagerPlugin);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
     registerAskEvents(): void;
     private _create;
     private _createDeviceProvisioning;

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

@@ -2,13 +2,15 @@ import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { DeviceService } from "./DeviceService";
 import { ApiDeviceAttachEngineResult, ApiDeviceCreateResult, ApiDeviceDeleteResult, ApiDeviceDetachEngineResult, ApiDeviceGetResult, ApiDeviceLinkAssetsResult, ApiDeviceSearchResult, ApiDeviceUnlinkAssetsResult, ApiDeviceUpdateResult, ApiDeviceGetMeasuresResult, ApiDeviceUpsertResult, ApiDeviceGetLastMeasuresResult, ApiDeviceMGetLastMeasuresResult, ApiDeviceGetLastMeasuredAtResult, ApiDeviceMGetLastMeasuredAtResult, ApiDeviceMetadataReplaceResult } from "./types/DeviceApi";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class DevicesController {
     private plugin;
     private deviceService;
     definition: ControllerDefinition;
     private exporter;
     private measureExporter;
-    constructor(plugin: DeviceManagerPlugin, deviceService: DeviceService);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, deviceService: DeviceService, logger: KuzzleLogger);
     get(request: KuzzleRequest): Promise<ApiDeviceGetResult>;
     update(request: KuzzleRequest): Promise<ApiDeviceUpdateResult>;
     replaceMetadata(request: KuzzleRequest): Promise<ApiDeviceMetadataReplaceResult>;

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

@@ -2,11 +2,13 @@ import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { ApiGroupAddAssetsResult, ApiGroupAddDevicesResult, ApiGroupCreateResult, ApiGroupDeleteResult, ApiGroupGetResult, ApiGroupListItemsResult, ApiGroupMCreateResult, ApiGroupMUpdateResult, ApiGroupMUpsertResult, ApiGroupRemoveAssetsResult, ApiGroupRemoveDevicesResult, ApiGroupSearchResult, ApiGroupUpdateResult, ApiGroupUpsertResult, GroupsBodyRequest } from "./types/GroupsApi";
 import { GroupsService } from "./GroupsService";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class GroupsController {
     private plugin;
     private groupsService;
     definition: ControllerDefinition;
-    constructor(plugin: DeviceManagerPlugin, groupsService: GroupsService);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, groupsService: GroupsService, logger: KuzzleLogger);
     private get sdk();
     private get as();
     /**

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

@@ -1,6 +1,10 @@
+import { DeviceManagerPlugin } from "../plugin";
 import { Module } from "../shared/Module";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class GroupsModule extends Module {
     private groupsController;
     private groupsService;
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin);
     init(): Promise<void>;
 }

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

@@ -5,8 +5,10 @@ import { KuzzleRequest } from "kuzzle";
 import { AssetContent } from "../asset/types/AssetContent";
 import { ApiGroupMCreateResult, ApiGroupMUpdateResult, ApiGroupMUpsertResult, GroupContent } from "./exports";
 import { DeviceContent } from "../device";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class GroupsService extends BaseService {
-    constructor(plugin: DeviceManagerPlugin);
+    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, path?: string, metadata?: Metadata): Promise<import("kuzzle").KDocument<GroupContent>>;

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

@@ -1,5 +1,9 @@
+import { DeviceManagerPlugin } from "../plugin";
 import { Module } from "../shared/Module";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class MeasureModule extends Module {
     private measureService;
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin);
     init(): Promise<void>;
 }

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

@@ -4,8 +4,10 @@ import { BaseService } from "../shared";
 import { DecodedMeasurement } from "./types/MeasureContent";
 import { MeasureSource } from "./types/MeasureSources";
 import { MeasureTarget } from "./types/MeasureTarget";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class MeasureService extends BaseService {
-    constructor(plugin: DeviceManagerPlugin);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
     /**
      * Register new measures updates :
      * - asset

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, engineGroup?: string): ApiMeasureTarget;
+export declare function toApiTarget(indexId: string, assetId: string, engineGroups?: 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;
-    engineGroup?: string;
+    engineGroups?: string[];
 }
 export declare function isTarget(target: any): target is AbstractMeasureTarget;
 export declare function isTargetDevice(target: any): target is DeviceMeasureTarget;

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

@@ -1,6 +1,10 @@
+import { DeviceManagerPlugin } from "../plugin";
 import { Module } from "../shared/Module";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class ModelModule extends Module {
     private modelService;
     private modelController;
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin);
     init(): Promise<void>;
 }

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

@@ -6,17 +6,19 @@ import { AssetModelContent, DeviceModelContent, GroupModelContent, LocaleDetails
 import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../measure";
 import { NamedMeasures } from "../decoder";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class ModelService extends BaseService {
-    constructor(plugin: DeviceManagerPlugin);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
     registerAskEvents(): void;
     private checkModelsConflicts;
     private checkDefaultValues;
     private checkGroupAffinity;
-    writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {
+    writeAsset(engineGroups: string[], model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {
         [valueName: string]: LocaleDetails;
     }, engineIds?: string[]): Promise<KDocument<AssetModelContent>>;
     writeDevice(model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures): Promise<KDocument<DeviceModelContent>>;
-    writeGroup(engineGroup: string, model: string, affinity: JSONObject, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups): Promise<KDocument<GroupModelContent>>;
+    writeGroup(engineGroups: string[], model: string, affinity: JSONObject, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups): Promise<KDocument<GroupModelContent>>;
     writeMeasure(type: string, valuesMappings: JSONObject, validationSchema?: SchemaObject, valuesDetails?: MeasureValuesDetails, locales?: {
         [valueName: string]: LocaleDetails;
     }, engineIds?: string[]): Promise<KDocument<MeasureModelContent>>;
@@ -24,17 +26,17 @@ export declare class ModelService extends BaseService {
     deleteDevice(_id: string): Promise<void>;
     deleteGroup(_id: string): Promise<void>;
     deleteMeasure(_id: string): Promise<void>;
-    listAsset(engineGroup: string, engineId?: string): Promise<KDocument<AssetModelContent>[]>;
+    listAsset(engineGroups: string[], engineId?: string): Promise<KDocument<AssetModelContent>[]>;
     listDevices(): Promise<KDocument<DeviceModelContent>[]>;
-    listGroups(engineGroup: string): Promise<KDocument<GroupModelContent>[]>;
+    listGroups(engineGroups: string[]): Promise<KDocument<GroupModelContent>[]>;
     listMeasures(engineId?: string): Promise<KDocument<MeasureModelContent>[]>;
-    searchAssets(engineGroup: string, engineId: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<AssetModelContent>>>;
+    searchAssets(engineGroups: string[], engineId: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<AssetModelContent>>>;
     searchDevices(searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<DeviceModelContent>>>;
-    searchGroups(engineGroup: string, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<GroupModelContent>>>;
+    searchGroups(engineGroups: string[], searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<GroupModelContent>>>;
     searchMeasures(engineId: string | undefined, searchParams: Partial<SearchParams>): Promise<SearchResult<KHit<MeasureModelContent>>>;
     assetExists(model: string): Promise<boolean>;
     deviceExists(model: string): Promise<boolean>;
-    getAsset(engineGroup: string, engineId: string | undefined, model: string): Promise<KDocument<AssetModelContent>>;
+    getAsset(engineGroups: string[], engineId: 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>>;
@@ -46,7 +48,7 @@ export declare class ModelService extends BaseService {
     /**
      * Update an asset model
      */
-    updateAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels, locales: {
+    updateAsset(engineGroups: string[], model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels, locales: {
         [valueName: string]: LocaleDetails;
     }, request: KuzzleRequest): Promise<KDocument<AssetModelContent>>;
 }

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

@@ -1,10 +1,12 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { ModelService } from "./ModelService";
 import { ApiModelWriteAssetResult, ApiModelWriteDeviceResult, ApiModelWriteMeasureResult, ApiModelUpdateAssetResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult, ApiModelGetAssetResult, ApiModelGetDeviceResult, ApiModelGetMeasureResult, ApiModelSearchAssetsResult, ApiModelSearchDevicesResult, ApiModelSearchMeasuresResult, ApiModelDeleteGroupResult, ApiModelGetGroupResult, ApiModelListGroupsResult, ApiModelSearchGroupsResult, ApiModelWriteGroupResult } from "./types/ModelApi";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class ModelsController {
     private modelService;
     definition: ControllerDefinition;
-    constructor(modelService: ModelService);
+    readonly logger: KuzzleLogger;
+    constructor(modelService: ModelService, logger: KuzzleLogger);
     getAsset(request: KuzzleRequest): Promise<ApiModelGetAssetResult>;
     getDevice(request: KuzzleRequest): Promise<ApiModelGetDeviceResult>;
     getGroup(request: KuzzleRequest): Promise<ApiModelGetGroupResult>;

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

@@ -10,13 +10,14 @@ export declare class ModelsRegister {
     private deviceModels;
     private groupModels;
     private measureModels;
+    private logger;
     private get sdk();
     init(plugin: DeviceManagerPlugin): void;
     loadModels(): Promise<void>;
     /**
      * Registers an asset model.
      *
-     * @param engineGroup - The engine group name.
+     * @param engineGroups - The engine group 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.
@@ -26,7 +27,7 @@ export declare class ModelsRegister {
      * @param tooltipModels - Optional model list for tooltip, containing labels and tooltip content.
      * @throws PluginImplementationError if the model name is not in PascalCase.
      */
-    registerAsset(engineGroup: string, model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, tooltipModels?: TooltipModels, locales?: {
+    registerAsset(engineGroups: string[], model: string, measures: NamedMeasures, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups, tooltipModels?: TooltipModels, locales?: {
         [valueName: string]: LocaleDetails;
     }): void;
     /**
@@ -45,7 +46,7 @@ export declare class ModelsRegister {
      * Registers a group model.
      *
      *
-     * @param engineGroup - The engine group name.
+     * @param engineGroups - The engine group 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.
@@ -54,7 +55,7 @@ export declare class ModelsRegister {
      * @param metadataGroups - Optional groups for organizing metadata, with localizations.
      * @throws PluginImplementationError if the model name is not in PascalCase.
      */
-    registerGroup(engineGroup: string, model: string, affinity: GroupAffinity, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups): void;
+    registerGroup(engineGroups: string[], model: string, affinity: GroupAffinity, metadataMappings?: MetadataMappings, defaultMetadata?: JSONObject, metadataDetails?: MetadataDetails, metadataGroups?: MetadataGroups): void;
     registerMeasure(type: string, measureDefinition: MeasureDefinition): void;
     private load;
 }

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

@@ -8,7 +8,7 @@ interface ModelsControllerRequest {
 export interface ApiModelGetAssetRequest extends ModelsControllerRequest {
     action: "getAsset";
     model: string;
-    engineGroup: string;
+    engineGroups: string[];
 }
 export type ApiModelGetAssetResult = KDocument<AssetModelContent>;
 export interface ApiModelGetDeviceRequest extends ModelsControllerRequest {
@@ -30,7 +30,7 @@ export type ApiModelGetMeasureResult = KDocument<MeasureModelContent>;
 export interface ApiModelWriteAssetRequest extends ModelsControllerRequest {
     action: "writeAsset";
     body: {
-        engineGroup: string;
+        engineGroups: string[];
         model: string;
         metadataDetails?: MetadataDetails;
         metadataGroups?: MetadataGroups;
@@ -60,7 +60,7 @@ export interface ApiModelWriteGroupRequest extends ModelsControllerRequest {
     action: "writeGroup";
     body: {
         affinity: GroupAffinity;
-        engineGroup: string;
+        engineGroups: string[];
         model: string;
         metadataDetails?: MetadataDetails;
         metadataGroups?: MetadataGroups;
@@ -85,7 +85,7 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
 export type ApiModelWriteMeasureResult = KDocument<MeasureModelContent>;
 export interface ApiModelUpdateAssetRequest extends ModelsControllerRequest {
     action: "updateAsset";
-    engineGroup: string;
+    engineGroups: string[];
     model: string;
     body: {
         metadataDetails?: MetadataDetails;
@@ -122,7 +122,7 @@ export interface ApiModelDeleteMeasureRequest extends ModelsControllerRequest {
 export type ApiModelDeleteMeasureResult = void;
 export interface ApiModelListAssetsRequest extends ModelsControllerRequest {
     action: "listAssets";
-    engineGroup: string;
+    engineGroups: string[];
 }
 export type ApiModelListAssetsResult = {
     models: KDocument<AssetModelContent>[];
@@ -137,7 +137,7 @@ export type ApiModelListDevicesResult = {
 };
 export interface ApiModelListGroupsRequest extends ModelsControllerRequest {
     action: "listGroups";
-    engineGroup: string;
+    engineGroups: string[];
 }
 export type ApiModelListGroupsResult = {
     models: KDocument<GroupModelContent>[];
@@ -153,7 +153,7 @@ export type ApiModelListMeasuresResult = {
 };
 export interface ApiModelSearchAssetsRequest extends ModelsControllerRequest {
     action: "searchAssets";
-    engineGroup: string;
+    engineGroups: string[];
     from?: number;
     size?: number;
     scrollTTL?: string;
@@ -170,7 +170,7 @@ export interface ApiModelSearchDevicesRequest extends ModelsControllerRequest {
 export type ApiModelSearchDevicesResult = SearchResult<KHit<DeviceModelContent>>;
 export interface ApiModelSearchGroupsRequest extends ModelsControllerRequest {
     action: "searchGroups";
-    engineGroup: string;
+    engineGroups: string[];
     from?: number;
     size?: number;
     scrollTTL?: string;

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

@@ -154,11 +154,11 @@ export interface TooltipModels {
 }
 export interface AssetModelContent extends KDocumentContent {
     type: "asset";
-    engineGroup: string;
+    engineGroups: 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 engineGroup.
+     * When absent, the model is available to all tenants in the engineGroups.
      */
     engineIds?: string[];
     asset: {
@@ -391,7 +391,7 @@ export interface DeviceModelContent extends KDocumentContent {
 }
 export interface GroupModelContent extends KDocumentContent {
     type: "group";
-    engineGroup: string;
+    engineGroups: string[];
     group: {
         /**
          * Name of the model

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

@@ -2,7 +2,7 @@ import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelC
 export type AskModelAssetGet = {
     name: "ask:device-manager:model:asset:get";
     payload: {
-        engineGroup: string;
+        engineGroups: string[];
         engineId?: string;
         model: string;
     };

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

@@ -23,7 +23,7 @@ export declare class DeviceManagerPlugin extends Plugin {
         /**
          * Register an asset model
          *
-         * @param engineGroup Engine group name
+         * @param engineGroups Engine group 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.
@@ -123,7 +123,7 @@ export declare class DeviceManagerPlugin extends Plugin {
          * );
          * ```
          */
-        registerAsset: (engineGroup: string, model: string, definition: AssetModelDefinition) => void;
+        registerAsset: (engineGroups: string[], model: string, definition: AssetModelDefinition) => void;
         /**
          * Register a device.
          *
@@ -231,7 +231,7 @@ export declare class DeviceManagerPlugin extends Plugin {
          * );
          * ```
          */
-        registerGroup: (engineGroup: string, model: string, definition: GroupModelDefinition) => void;
+        registerGroup: (engineGroups: string[], model: string, definition: GroupModelDefinition) => void;
         /**
          * Register a new measure
          *

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

@@ -31,14 +31,7 @@ export declare abstract class AbstractExporter<P extends ExportParams = ExportPa
     constructor(plugin: DeviceManagerPlugin, target: InternalCollection, config?: Partial<ExporterOption>);
     protected get sdk(): import("kuzzle").EmbeddedSDK;
     protected get ms(): any;
-    protected get log(): {
-        debug: (message: any) => void;
-        error: (message: any) => void;
-        info: (message: any) => void;
-        silly: (message: any) => void;
-        verbose: (message: any) => void;
-        warn: (message: any) => void;
-    };
+    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;

package/package.json

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