kuzzle-device-manager-types 3.0.0-next.26 → 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/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,8 +6,10 @@ 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;

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,6 +10,7 @@ export declare class ModelsRegister {
     private deviceModels;
     private groupModels;
     private measureModels;
+    private logger;
     private get sdk();
     init(plugin: DeviceManagerPlugin): void;
     loadModels(): Promise<void>;

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.26",
+  "version": "3.0.0-next.27",
   "description": "Shared types for Kuzzle Device Manager",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "main": "index.js",