kuzzle-device-manager-types 2.4.3-dev.1 → 2.5.0-beta.1

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

@@ -19,6 +19,18 @@ export declare class AssetsController {
     getMeasures(request: KuzzleRequest): Promise<ApiAssetGetMeasuresResult>;
     getLastMeasures(request: KuzzleRequest): Promise<ApiAssetGetLastMeasuresResult>;
     mGetLastMeasures(request: KuzzleRequest): Promise<ApiAssetMGetLastMeasuresResult>;
+    /**
+     *
+     * @param indexId The asset index
+     * @param assetId The target asset ID
+     * @param measureName The measureName to get the type from
+     * @param engineGroup The target engine group
+     * @returns The measure type if used in the asset, null otherwise
+     * @throws If the asset does not exists
+     */
+    private getTypeFromMeasureSlot;
+    mMeasureIngest(request: KuzzleRequest): Promise<void>;
+    measureIngest(request: KuzzleRequest): Promise<void>;
     exportMeasures(request: KuzzleRequest): Promise<any>;
     export(request: KuzzleRequest): Promise<any>;
     migrateTenant(request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;

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

@@ -1,8 +1,9 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
-import { MeasureContent } from "../../../modules/measure";
+import { MeasureContent, Measurement } from "../../../modules/measure";
 import { ApiDigitalTwinGetLastMeasuredAtRequest, ApiDigitalTwinGetLastMeasuredAtResult, ApiDigitalTwinGetLastMeasuresRequest, ApiDigitalTwinGetLastMeasuresResult, ApiDigitalTwinMGetLastMeasuredAtRequest, ApiDigitalTwinMGetLastMeasuredAtResult, ApiDigitalTwinMGetLastMeasuresRequest, ApiDigitalTwinMGetLastMeasuresResult, Metadata } from "../../shared";
 import { AssetContent } from "./AssetContent";
 type AssetsControllerName = "device-manager/assets";
+import { ApiMeasureSource } from "../../measure/types/MeasureSources";
 interface AssetsControllerRequest {
     controller: AssetsControllerName;
     engineId: string;
@@ -85,6 +86,34 @@ export type ApiAssetGetMeasuresResult = {
     measures: Array<KDocument<MeasureContent<JSONObject>>>;
     total: number;
 };
+type TypelessApiMeasureSource = Omit<ApiMeasureSource, "type">;
+export interface ApiAssetMeasureIngestRequest extends AssetsControllerRequest {
+    action: "measureIngest";
+    assetId: string;
+    engineId: string;
+    engineGroup?: string;
+    slotName: string;
+    body: {
+        dataSource: TypelessApiMeasureSource;
+        measuredAt: number;
+        values: JSONObject;
+    };
+}
+export type ApiAssetMeasureIngestResult = void;
+type APIDecodedMeasurement = Omit<Measurement, "type"> & {
+    slotName: string;
+};
+export interface ApiAssetmMeasureIngestRequest extends AssetsControllerRequest {
+    action: "mMeasureIngest";
+    assetId: string;
+    engineId: string;
+    engineGroup?: string;
+    body: {
+        dataSource: TypelessApiMeasureSource;
+        measurements: APIDecodedMeasurement[];
+    };
+}
+export type ApiAssetmMeasureIngestResult = void;
 export type ApiAssetGetLastMeasuresRequest = ApiDigitalTwinGetLastMeasuresRequest<AssetsControllerName>;
 export type ApiAssetGetLastMeasuresResult = ApiDigitalTwinGetLastMeasuresResult;
 export type ApiAssetMGetLastMeasuresRequest = ApiDigitalTwinMGetLastMeasuresRequest<AssetsControllerName>;

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

@@ -3,8 +3,21 @@ import { DeviceContent } from "../device";
 import { DeviceManagerPlugin } from "../plugin";
 import { BaseService, Metadata } from "../shared";
 import { DecodedMeasurement } from "./types/MeasureContent";
+import { ApiMeasureSource } from "./types/MeasureSources";
+import { ApiMeasureTarget } from "./types/MeasureTarget";
 export declare class MeasureService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
+    /**
+     * Register new measures from an API, updates :
+     * - asset
+     * - engine measures
+     *
+     * This method represents the ingestion pipeline:
+     *  - trigger events `before` (measure enrichment)
+     *  - save documents (measures and asset)
+     *  - trigger events `after`
+     */
+    ingestApi(source: ApiMeasureSource, target: ApiMeasureTarget, measurements: DecodedMeasurement<JSONObject>[], payloadUuids: string[]): Promise<void>;
     /**
      * Register new measures from a device, updates :
      * - admin device
@@ -19,6 +32,8 @@ export declare class MeasureService extends BaseService {
      *  - trigger events `before` (measure enrichment)
      *  - save documents (measures, device and asset)
      *  - trigger events `after`
+     *
+     * @deprecated
      */
     ingest(device: KDocument<DeviceContent>, measurements: DecodedMeasurement<JSONObject>[], metadata: Metadata, payloadUuids: string[]): Promise<void>;
     private updateDeviceMeasures;
@@ -28,13 +43,48 @@ export declare class MeasureService extends BaseService {
      * @returns A map of each asset state by measuredAt timestamp.
      */
     private updateAssetMeasures;
+    /**
+     * Build the measures document received from the API
+     *
+     * @param source The API data source
+     * @param asset The target asset to build the measure for
+     * @param measure The decoded raw measures
+     * @param payloadUuids The uuid's of the payloads used to create the measure
+     *
+     * @returns A MeasurementContent builded from parameters
+     */
+    private buildApiMeasures;
     /**
      * Build the measures documents to save
      */
     private buildMeasures;
-    private tryGetLinkedAsset;
     /**
-     * Retrieve the measure name for the asset
+     * Find an asset by its ID and its engine ID.
+     *
+     * @param engineId The target index ID
+     * @param assetId the target asset ID
+     * @returns The asset or null if not found
+     */
+    private findAsset;
+    /**
+     * Check if the asset measure name is associated to the asset model
+     *
+     * @param measureName The measure name to check
+     * @param model The asset model the measureName should belong
+     *
+     * @returns True if the asset measure name belongs to the asset model, false otherwise
+     * @throws If the model does not exists
+     */
+    private isMeasureNameInModel;
+    /**
+     * Find the asset measure name from the device and its measure type
+     *
+     * @param deviceId The source device ID
+     * @param measureType The device measure type
+     * @param asset The asset the device is linked to
+     *
+     * @returns The asset measure name or null if it does not belong to the link
+     * @throws If the device is not linked to the asset
      */
-    private tryFindAssetMeasureName;
+    private findAssetMeasureNameFromDevice;
 }

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

@@ -0,0 +1,10 @@
+import { Metadata } from "../shared";
+import { MeasureOriginApi, MeasureOriginDevice } from "./types/MeasureContent";
+import { ApiMeasureSource, DeviceMeasureSource } from "./types/MeasureSources";
+export declare const enum DATA_SOURCE_METADATA_TYPE {
+    API = "api",
+    DEVICE = "device"
+}
+export declare function apiSourceToOriginApi(source: ApiMeasureSource, payloadUuids: string[]): MeasureOriginApi;
+export declare function toDeviceSource(dataSourceId: string, reference: string, model: string, metadata?: Metadata, lastMeasuredAt?: number): DeviceMeasureSource;
+export declare function deviceSourceToOriginDevice(source: DeviceMeasureSource, measureName: string, payloadUuids: string[]): MeasureOriginDevice;

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

@@ -0,0 +1,3 @@
+import { ApiMeasureTarget, DeviceMeasureTarget } from "./types/MeasureTarget";
+export declare function toApiTarget(indexId: string, assetId: string, engineGroup?: string): ApiMeasureTarget;
+export declare function toDeviceTarget(indexId: string, assetId?: string): DeviceMeasureTarget;

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

@@ -0,0 +1,12 @@
+import { ErrorObject } from "ajv";
+import { KuzzleError } from "kuzzle";
+export interface MeasureValidationChunks {
+    measureName: string;
+    validationErrors: ErrorObject[];
+}
+export declare class MeasureValidationError extends KuzzleError {
+    private errors;
+    constructor(message: string, errors: MeasureValidationChunks[], id?: string, code?: number);
+    get name(): string;
+    toJSON(): import("kuzzle").JSONObject;
+}

package/dist/lib/modules/measure/collections/measuresMappings.d.ts

@@ -66,6 +66,10 @@ export declare const measuresMappings: {
                 deviceMetadata: {
                     properties: {};
                 };
+                apiMetadata: {
+                    dynamic: string;
+                    properties: {};
+                };
                 payloadUuids: {
                     type: string;
                 };

package/dist/lib/modules/measure/types/MeasureContent.d.ts

@@ -1,58 +1,69 @@
 import { JSONObject, KDocumentContent } from "kuzzle-sdk";
 import { Metadata } from "../../../modules/shared";
 import { AssetMeasureContext } from "../../../modules/asset";
-export type MeasureOriginDevice = {
+interface AbstractMeasureOrigin {
     /**
      * Origin of the measure
      */
-    type: "device";
-    /**
-     * Name of the measure in the device
-     */
-    measureName: string;
-    /**
-     * Origin device metadata
-     */
-    deviceMetadata?: Metadata;
+    type: string;
     /**
      * Payload uuids that were used to create this measure.
      */
     payloadUuids: Array<string>;
+    /**
+     * Custom metadata provided by the user
+     */
+    metadata?: Metadata;
+}
+export interface MeasureOriginDevice extends AbstractMeasureOrigin {
+    type: "device";
     /**
      * Model of the device
      *
      * @example "AbeewayTemp"
      */
     deviceModel: string;
+    /**
+     * Name of the measure
+     */
+    measureName: string;
     /**
      * Reference of the device
      */
     reference: string;
+    /**
+     * Origin device metadata
+     */
+    deviceMetadata?: Metadata;
     /**
      * Device ID
      */
     _id: string;
-};
-export type MeasureOriginComputed = {
+}
+export interface MeasureOriginComputed extends AbstractMeasureOrigin {
     /**
      * Computed measures are not automatically added into the asset and device
      * documents at the end of the ingestion pipeline.
      */
     type: "computed";
-    /**
-     * String that identify the rule used to compute the measure
-     */
-    _id: string;
     /**
      * Name of the measure
      */
     measureName: string;
     /**
-     * Payload uuids that were used to create this measure for traceability.
+     * String that identify the rule used to compute the measure
      */
-    payloadUuids: Array<string>;
-};
-export type MeasureOrigin = MeasureOriginDevice | MeasureOriginComputed;
+    _id: string;
+}
+export interface MeasureOriginApi extends AbstractMeasureOrigin {
+    type: "api";
+    apiMetadata?: Metadata;
+    /**
+     * API ID
+     */
+    _id: string;
+}
+export type MeasureOrigin = MeasureOriginDevice | MeasureOriginComputed | MeasureOriginApi;
 /**
  * Represents the content of a measure document.
  */
@@ -88,3 +99,4 @@ export type Measurement<TMeasureValues extends JSONObject = any> = {
 export type DecodedMeasurement<TMeasureValues extends JSONObject = JSONObject> = {
     measureName: string;
 } & Measurement<TMeasureValues>;
+export {};

package/dist/lib/modules/measure/types/MeasureDefinition.d.ts

@@ -1,3 +1,4 @@
+import { SchemaObject } from "ajv";
 import { JSONObject } from "kuzzle-sdk";
 interface MeasureLocales {
     [localeString: string]: {
@@ -12,6 +13,20 @@ export interface MeasureValuesDetails {
  * Represents a measure definition registered by the Device Manager
  *
  * @example
+ * {
+ *   valuesMappings: { temperature: { type: 'float' } },
+ *   validationSchema: {
+        type: "object",
+        properties: {
+            temperature: {
+              type: "number",
+              multipleOf: 0.01
+            }
+        },
+        required: ["temperature"],
+        additionalProperties: false
+    }
+ * },
  *{
  * valuesMappings: { temperature: { type: "float" } },
  * valuesDetails: {
@@ -33,6 +48,10 @@ export interface MeasureDefinition {
      * Mappings for the measurement values in order to index the fields
      */
     valuesMappings: JSONObject;
+    /**
+     * Schema to validate the values against
+     */
+    validationSchema?: SchemaObject;
     valuesDetails?: {
         [valueName: string]: MeasureLocales;
     };

package/dist/lib/modules/measure/types/MeasureEvents.d.ts

@@ -3,8 +3,12 @@ import { DeviceContent } from "../../../modules/device";
 import { AssetContent } from "../../../modules/asset";
 import { Metadata } from "../../../modules/shared";
 import { DecodedMeasurement, MeasureContent } from "./MeasureContent";
+import { MeasureSource } from "./MeasureSources";
+import { MeasureTarget } from "./MeasureTarget";
 /**
  * @internal
+ *
+ * @deprecated Replaced by new Ask implementing data sources
  */
 export type AskMeasureIngest = {
     name: "device-manager:measures:ingest";
@@ -16,10 +20,25 @@ export type AskMeasureIngest = {
     };
     result: void;
 };
+/**
+ * @internal
+ */
+export type AskMeasureSourceIngest = {
+    name: "device-manager:measures:sourceIngest";
+    payload: {
+        source: MeasureSource;
+        target: MeasureTarget;
+        measurements: DecodedMeasurement<JSONObject>[];
+        payloadUuids: string[];
+    };
+    result: void;
+};
 /**
  * Event before starting to process new measures.
  *
  * Useful to enrich measures before they are saved.
+ *
+ * @deprecated Replaced by new triggers implementing data sources
  */
 export type EventMeasureProcessBefore = {
     name: "device-manager:measures:process:before";
@@ -31,10 +50,28 @@ export type EventMeasureProcessBefore = {
         }
     ];
 };
+/**
+ * Event before starting to process new measures from data source.
+ *
+ * Useful to enrich measures before they are saved.
+ */
+export type EventMeasureProcessSourceBefore = {
+    name: "device-manager:measures:process:sourceBefore";
+    args: [
+        {
+            source: MeasureSource;
+            target: MeasureTarget;
+            asset?: AssetContent;
+            measures: MeasureContent[];
+        }
+    ];
+};
 /**
  * Tenant event before starting to process new measures.
  *
  * Useful to enrich measures before they are saved.
+ *
+ * @deprecated Replaced by new triggers implementing data sources
  */
 export type TenantEventMeasureProcessBefore = {
     name: `engine:${string}:device-manager:measures:process:before`;
@@ -46,9 +83,27 @@ export type TenantEventMeasureProcessBefore = {
         }
     ];
 };
+/**
+ * Tenant event before starting to process new measures from data source.
+ *
+ * Useful to enrich measures before they are saved.
+ */
+export type TenantEventMeasureProcessSourceBefore = {
+    name: `engine:${string}:device-manager:measures:process:sourceBefore`;
+    args: [
+        {
+            source: MeasureSource;
+            target: MeasureTarget;
+            asset?: AssetContent;
+            measures: MeasureContent[];
+        }
+    ];
+};
 /**
  * Event triggered after updating device and asset with new measures but
  * before persistence in database.
+ *
+ * @deprecated Replaced by new triggers implementing data sources
  */
 export type EventMeasurePersistBefore = {
     name: "device-manager:measures:persist:before";
@@ -60,9 +115,26 @@ export type EventMeasurePersistBefore = {
         }
     ];
 };
+/**
+ * Event triggered after updating the data source and asset with new measures but
+ * before persistence in database.
+ */
+export type EventMeasurePersistSourceBefore = {
+    name: "device-manager:measures:persist:sourceBefore";
+    args: [
+        {
+            source: MeasureSource;
+            target: MeasureTarget;
+            asset?: AssetContent;
+            measures: MeasureContent[];
+        }
+    ];
+};
 /**
  * Tenant event triggered after updating device and asset with new measures but
  * before persistence in database.
+ *
+ * @deprecated Replaced by new triggers implementing data sources
  */
 export type TenantEventMeasurePersistBefore = {
     name: `engine:${string}:device-manager:measures:persist:before`;
@@ -74,6 +146,26 @@ export type TenantEventMeasurePersistBefore = {
         }
     ];
 };
+/**
+ * Tenant event triggered after updating the data source and asset with new measures but
+ * before persistence in database.
+ */
+export type TenantEventMeasurePersistSourceBefore = {
+    name: `engine:${string}:device-manager:measures:persist:sourceBefore`;
+    args: [
+        {
+            source: MeasureSource;
+            target: MeasureTarget;
+            asset?: AssetContent;
+            measures: MeasureContent[];
+        }
+    ];
+};
+/**
+ * Event after processing new measures.
+ *
+ * @deprecated Replaced by new triggers implementing data sources
+ */
 export type EventMeasureProcessAfter = {
     name: "device-manager:measures:process:after";
     args: [
@@ -84,6 +176,25 @@ export type EventMeasureProcessAfter = {
         }
     ];
 };
+/**
+ * Event after processing new measures from data source.
+ */
+export type EventMeasureProcessSourceAfter = {
+    name: "device-manager:measures:process:sourceAfter";
+    args: [
+        {
+            source: MeasureSource;
+            target: MeasureTarget;
+            asset?: AssetContent;
+            measures: MeasureContent[];
+        }
+    ];
+};
+/**
+ * Tenant event after processing new measures.
+ *
+ * @deprecated Replaced by new triggers implementing data sources
+ */
 export type TenantEventMeasureProcessAfter = {
     name: `engine:${string}:device-manager:measures:process:after`;
     args: [
@@ -94,3 +205,18 @@ export type TenantEventMeasureProcessAfter = {
         }
     ];
 };
+/**
+ * Tenant event after processing new measures from data source.
+ *
+ */
+export type TenantEventMeasureProcessSourceAfter = {
+    name: `engine:${string}:device-manager:measures:process:sourceAfter`;
+    args: [
+        {
+            source: MeasureSource;
+            target: MeasureTarget;
+            asset?: AssetContent;
+            measures: MeasureContent[];
+        }
+    ];
+};

package/dist/lib/modules/measure/types/MeasureSources.d.ts

@@ -0,0 +1,20 @@
+import { Metadata } from "../../shared";
+interface AbstractMeasureSource {
+    type: string;
+    id: string;
+    metadata?: Metadata;
+}
+export interface DeviceMeasureSource extends AbstractMeasureSource {
+    type: "device";
+    reference: string;
+    model: string;
+    lastMeasuredAt?: number;
+}
+export interface ApiMeasureSource extends AbstractMeasureSource {
+    type: "api";
+}
+export declare function isSource(source: any): source is AbstractMeasureSource;
+export declare function isSourceDevice(source: any): source is DeviceMeasureSource;
+export declare function isSourceApi(source: any): source is ApiMeasureSource;
+export type MeasureSource = DeviceMeasureSource | ApiMeasureSource;
+export {};

package/dist/lib/modules/measure/types/MeasureTarget.d.ts

@@ -0,0 +1,18 @@
+interface AbstractMeasureTarget {
+    type: string;
+    assetId?: string;
+    indexId: string;
+}
+export interface DeviceMeasureTarget extends AbstractMeasureTarget {
+    type: "device";
+}
+export interface ApiMeasureTarget extends AbstractMeasureTarget {
+    type: "api";
+    assetId: string;
+    engineGroup?: string;
+}
+export declare function isTarget(target: any): target is AbstractMeasureTarget;
+export declare function isTargetDevice(target: any): target is DeviceMeasureTarget;
+export declare function isTargetApi(target: any): target is ApiMeasureTarget;
+export type MeasureTarget = DeviceMeasureTarget | ApiMeasureTarget;
+export {};

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

@@ -1,7 +1,8 @@
-import { JSONObject, KuzzleError } from "kuzzle";
+import { KuzzleError } from "kuzzle";
+import { ConflictChunk } from "./ModelsConflicts";
 export declare class MappingsConflictsError extends KuzzleError {
     private conflicts;
-    constructor(message: string, conflicts: JSONObject, id?: string, code?: number);
+    constructor(message: string, conflicts: ConflictChunk[], id?: string, code?: number);
     get name(): string;
-    toJSON(): JSONObject;
+    toJSON(): import("kuzzle").JSONObject;
 }

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

@@ -0,0 +1,3 @@
+import { NamedMeasures } from "../decoder";
+declare function getNamedMeasuresDuplicates(measures: NamedMeasures): string[];
+export { getNamedMeasuresDuplicates };

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

@@ -0,0 +1,7 @@
+import { KuzzleError } from "kuzzle";
+export declare class MeasuresNamesDuplicatesError extends KuzzleError {
+    private duplicates;
+    constructor(message: string, duplicates: string[], id?: string, code?: number);
+    get name(): string;
+    toJSON(): import("kuzzle").JSONObject;
+}

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

@@ -3,15 +3,17 @@ import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
 import { BaseService, SearchParams } from "../shared";
 import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./types/ModelContent";
+import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../measure";
+import { NamedMeasures } from "../decoder";
 export declare class ModelService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     registerAskEvents(): void;
     private checkModelsConflicts;
-    writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"], tooltipModels: TooltipModels): Promise<KDocument<AssetModelContent>>;
+    writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels): Promise<KDocument<AssetModelContent>>;
     private checkDefaultValues;
-    writeDevice(model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: DeviceModelContent["device"]["measures"]): Promise<KDocument<DeviceModelContent>>;
-    writeMeasure(type: string, valuesMappings: JSONObject, valuesDetails?: MeasureValuesDetails): Promise<KDocument<MeasureModelContent>>;
+    writeDevice(model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures): Promise<KDocument<DeviceModelContent>>;
+    writeMeasure(type: string, valuesMappings: JSONObject, validationSchema?: SchemaObject, valuesDetails?: MeasureValuesDetails): Promise<KDocument<MeasureModelContent>>;
     deleteAsset(_id: string): Promise<void>;
     deleteDevice(_id: string): Promise<void>;
     deleteMeasure(_id: string): Promise<void>;

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

@@ -1,5 +1,6 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
+import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../../measure/types/MeasureDefinition";
 interface ModelsControllerRequest {
     controller: "device-manager/models";
@@ -51,6 +52,7 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     body: {
         type: string;
         valuesMappings: JSONObject;
+        validationSchema?: SchemaObject;
         valuesDetails?: MeasureValuesDetails;
     };
 }

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

@@ -69,6 +69,7 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @returns An array of the available engines
      */
     getEngines(): Promise<EngineDocument[]>;
+    updateMeasuresSchema(): Promise<void>;
     onCreate(index: string, group?: string): Promise<{
         collections: any[];
     }>;

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

@@ -181,7 +181,7 @@ export declare class DeviceManagerPlugin extends Plugin {
          * Register a new measure
          *
          * @param name Name of the measure
-         * @param valuesMappings Mappings for the measure values
+         * @param measureDefinition Values of the measure
          *
          * @example
          * ```

package/dist/lib/modules/shared/errors/SchemaValidationError.d.ts

@@ -0,0 +1,8 @@
+import { ErrorObject } from "ajv";
+import { KuzzleError } from "kuzzle";
+export declare class SchemaValidationError extends KuzzleError {
+    private schemaErrors;
+    constructor(message: string, schemaErrors: ErrorObject[], id?: string, code?: number);
+    get name(): string;
+    toJSON(): import("kuzzle").JSONObject;
+}

package/dist/lib/modules/shared/utils/AJValidator.d.ts

@@ -0,0 +1,26 @@
+import { SchemaObject } from "ajv";
+/**
+ * Compile and add the schema to the AJV cache
+ *
+ * @param scemaID The schema unique identifier
+ * @param schema The schema to add
+ *
+ * @returns The newly created validator for the schema
+ * @throws If the provided schema is not valid
+ */
+export declare function addSchemaToCache(schemaID: string, schema: SchemaObject): import("ajv/dist/core").default;
+/**
+ * Search the corresponding validator in the AJV cache.
+ *
+ * @param schemaID The desired schema identifier
+ *
+ * @returns The desired schema validator
+ * @throws If the schema cannot be found
+ */
+export declare function getValidator(schemaID: string): import("ajv/dist/types").AnyValidateFunction<unknown>;
+/**
+ * Get and return the previous AJV errors
+ *
+ * @returns an array of ErrorObject
+ */
+export declare function getAJVErrors(): import("ajv").ErrorObject<string, Record<string, any>, unknown>[];

package/dist/tests/application/assets/MagicHouse.d.ts

@@ -0,0 +1,2 @@
+import { AssetModelDefinition } from "../../../index";
+export declare const magicHouseAssetDefinition: AssetModelDefinition;

package/dist/tests/application/measures/Magicule.d.ts

@@ -0,0 +1,5 @@
+import { MeasureDefinition } from "lib/modules/measure";
+export type MagiculeMeasurement = {
+    magicule: number;
+};
+export declare const magiculeMeasureDefinition: MeasureDefinition;

package/package.json

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