kuzzle-device-manager-types 2.10.2-dev.6 → 2.11.0-beta.1

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,9 +1,13 @@
 import { Module } from "../shared/Module";
+import { DeviceManagerPlugin } from "../plugin";
 export declare class AssetModule extends Module {
     private assetService;
     private assetHistoryService;
     private assetController;
     private assetGroupsController;
     private assetsGroupsService;
+    private logger;
+    private assetsGroupsLogger;
+    constructor(plugin: DeviceManagerPlugin);
     init(): Promise<void>;
 }

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

@@ -5,9 +5,11 @@ import { DigitalTwinService, Metadata, SearchParams } from "../shared";
 import { AssetHistoryService } from "./AssetHistoryService";
 import { ApiAssetMigrateTenantResult, ApiAssetUpdateModelLocales } from "./types/AssetApi";
 import { AssetContent } from "./types/AssetContent";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class AssetService extends DigitalTwinService {
+    readonly logger: KuzzleLogger;
     private assetHistoryService;
-    constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService);
+    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

@@ -2,13 +2,15 @@ import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { AssetService } from "./AssetService";
 import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult, ApiAssetGetLastMeasuresResult, ApiAssetMGetLastMeasuredAtResult, ApiAssetMGetLastMeasuresResult, ApiAssetGetLastMeasuredAtResult, ApiAssetUpdateModelLocales } from "./types/AssetApi";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class AssetsController {
     private plugin;
     private assetService;
     definition: ControllerDefinition;
     private exporter;
     private 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/asset/AssetsGroupsController.d.ts

@@ -2,11 +2,13 @@ import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { ApiGroupAddAssetsResult, ApiGroupCreateResult, ApiGroupDeleteResult, ApiGroupGetResult, ApiGroupRemoveAssetsResult, ApiGroupSearchResult, ApiGroupUpdateResult, AssetsGroupsBodyRequest } from "./types/AssetGroupsApi";
 import { AssetsGroupsService } from "./AssetsGroupsService";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class AssetsGroupsController {
     private plugin;
     private assetsGroupsService;
     definition: ControllerDefinition;
-    constructor(plugin: DeviceManagerPlugin, assetsGroupsService: AssetsGroupsService);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, assetsGroupsService: AssetsGroupsService, logger: KuzzleLogger);
     private get sdk();
     private get as();
     checkParent(engineId: string, parent: AssetsGroupsBodyRequest["parent"]): Promise<void>;

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

@@ -3,8 +3,10 @@ import { DeviceManagerPlugin } from "../plugin";
 import { BaseService, SearchParams } from "../shared";
 import { KuzzleRequest } from "kuzzle";
 import { AssetsGroupContent } from "./types/AssetGroupContent";
+import { KuzzleLogger } from "kuzzle-logger";
 export declare class AssetsGroupsService extends BaseService {
-    constructor(plugin: DeviceManagerPlugin);
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
     create(_id: string, engineId: string, metadata: JSONObject, model: string, name: string, parent: string | null, request: KuzzleRequest): Promise<KDocument<AssetsGroupContent>>;
     get(engineId: string, _id: string, request: KuzzleRequest): Promise<KDocument<AssetsGroupContent>>;
     update(request: KuzzleRequest, _id: string, engineId: string, updateContent: JSONObject): Promise<KDocument<AssetsGroupContent>>;
@@ -22,7 +24,7 @@ export declare class AssetsGroupsService extends BaseService {
         errors: {
             document: {
                 _id: string;
-                _source: JSONObject;
+                body: JSONObject;
             };
             status: number;
             reason: string;
@@ -38,7 +40,7 @@ export declare class AssetsGroupsService extends BaseService {
         errors: {
             document: {
                 _id: string;
-                _source: JSONObject;
+                body: JSONObject;
             };
             status: number;
             reason: string;

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

@@ -98,7 +98,7 @@ export interface ApiAssetMeasureIngestRequest extends AssetsControllerRequest {
     slotName: string;
     body: {
         dataSource: TypelessApiMeasureSource;
-        measuredAt: number;
+        measuredAt: number | string;
         values: JSONObject;
     };
 }

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

@@ -2,6 +2,7 @@ import { HttpRoute, KuzzleRequest } from "kuzzle";
 import { JSONObject } from "kuzzle-sdk";
 import { DecodedPayload } from "./DecodedPayload";
 import { DecoderContent } from "./types/DecoderContent";
+import { KuzzleLogger } from "kuzzle-logger";
 /**
  * Array of measures declaration
  *
@@ -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;
+    readonly logger: KuzzleLogger;
     definition: ControllerDefinition;
-    constructor(payloadService: PayloadService, decodersRegister: DecodersRegister);
+    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

@@ -6,8 +6,10 @@ import { DigitalTwinService, Metadata, SearchParams } from "../shared";
 import { AssetContent } from "./../asset";
 import { ApiDeviceLinkAssetRequest } from "./types/DeviceApi";
 import { DeviceContent } from "./types/DeviceContent";
+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;
     /**

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, ApiDeviceLinkAssetResult, ApiDeviceSearchResult, ApiDeviceUnlinkAssetResult, 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/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

@@ -5,8 +5,10 @@ import { BaseService, Metadata } from "../shared";
 import { DecodedMeasurement } from "./types/MeasureContent";
 import { ApiMeasureSource } from "./types/MeasureSources";
 import { ApiMeasureTarget } 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 from an API, 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;
     writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {

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

@@ -29,14 +29,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": "2.10.2-dev.6",
+  "version": "2.11.0-beta.1",
   "description": "Shared types for Kuzzle Device Manager",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "main": "index.js",