kuzzle-device-manager-types 2.4.0-beta.2 → 2.4.0-beta.21

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

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

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

@@ -1,38 +1,37 @@
-import { User } from "kuzzle";
+import { KuzzleRequest, User } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult, mReplaceResponse } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
-import { Metadata } from "../shared";
+import { DigitalTwinService, Metadata, SearchParams } from "../shared";
 import { AssetHistoryService } from "./AssetHistoryService";
+import { ApiAssetMigrateTenantResult } from "./types/AssetApi";
 import { AssetContent } from "./types/AssetContent";
-export declare class AssetService {
-    private context;
-    private config;
+export declare class AssetService extends DigitalTwinService {
     private assetHistoryService;
-    private get sdk();
-    private get app();
-    private get impersonatedSdk();
     constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService);
     registerAskEvents(): void;
-    get(engineId: string, assetId: string): Promise<KDocument<AssetContent>>;
+    get(engineId: string, assetId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
-     * Updates an asset metadata
+     * Update an asset metadata
      */
-    update(user: User, engineId: string, assetId: string, metadata: Metadata, { refresh }: {
-        refresh: any;
-    }): Promise<KDocument<AssetContent>>;
-    create(user: User, engineId: string, model: string, reference: string, metadata: JSONObject, { refresh }: {
-        refresh: any;
-    }): Promise<KDocument<AssetContent>>;
-    delete(user: User, engineId: string, assetId: string, { refresh, strict }: {
-        refresh: any;
-        strict: boolean;
-    }): Promise<void>;
-    search(engineId: string, searchBody: JSONObject, { from, size, scroll, lang, }: {
-        from?: number;
-        size?: number;
-        scroll?: string;
-        lang?: string;
-    }): Promise<SearchResult<KHit<AssetContent>>>;
+    update(engineId: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    /**
+     * Replace an asset metadata
+     */
+    replaceMetadata(engineId: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    /**
+     * Update or Create an asset metadata
+     */
+    upsert(engineId: string, model: string, reference: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    /**
+     * Create an asset metadata
+     */
+    create(engineId: string, model: string, reference: string, metadata: JSONObject, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    /**
+     * Delete an asset metadata
+     */
+    delete(engineId: string, assetId: string, request: KuzzleRequest): Promise<void>;
+    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<AssetContent>>>;
+    migrateTenant(user: User, assetsList: string[], engineId: string, newEngineId: string): Promise<ApiAssetMigrateTenantResult>;
     /**
      * Replace an asset metadata
      */

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

@@ -1,7 +1,7 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { AssetService } from "./AssetService";
-import { ApiAssetCreateResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult } from "./types/AssetApi";
+import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult, ApiAssetGetLastMeasuresResult, ApiAssetMGetLastMeasuredAtResult, ApiAssetMGetLastMeasuresResult, ApiAssetGetLastMeasuredAtResult } from "./types/AssetApi";
 export declare class AssetsController {
     private plugin;
     private assetService;
@@ -10,11 +10,18 @@ export declare class AssetsController {
     private measureExporter;
     constructor(plugin: DeviceManagerPlugin, assetService: AssetService);
     get(request: KuzzleRequest): Promise<ApiAssetGetResult>;
+    upsert(request: KuzzleRequest): Promise<ApiAssetUpsertResult>;
     update(request: KuzzleRequest): Promise<ApiAssetUpdateResult>;
+    replaceMetadata(request: KuzzleRequest): Promise<ApiAssetMetadataReplaceResult>;
     create(request: KuzzleRequest): Promise<ApiAssetCreateResult>;
     delete(request: KuzzleRequest): Promise<ApiAssetDeleteResult>;
     search(request: KuzzleRequest): Promise<ApiAssetSearchResult>;
     getMeasures(request: KuzzleRequest): Promise<ApiAssetGetMeasuresResult>;
+    getLastMeasures(request: KuzzleRequest): Promise<ApiAssetGetLastMeasuresResult>;
+    mGetLastMeasures(request: KuzzleRequest): Promise<ApiAssetMGetLastMeasuresResult>;
     exportMeasures(request: KuzzleRequest): Promise<any>;
     export(request: KuzzleRequest): Promise<any>;
+    migrateTenant(request: KuzzleRequest): Promise<ApiAssetMigrateTenantResult>;
+    getLastMeasuredAt(request: KuzzleRequest): Promise<ApiAssetGetLastMeasuredAtResult>;
+    mGetLastMeasuredAt(request: KuzzleRequest): Promise<ApiAssetMGetLastMeasuredAtResult>;
 }

package/dist/lib/modules/asset/roles/RoleAssetsReader.d.ts

@@ -9,8 +9,12 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
       actions: {
         get: true,
         getMeasures: true,
+        getLastMeasures: true,
+        mGetLastMeasures: true,
         exportMeasures: true,
         search: true,
+        getLastMeasuredAt: true,
+        mGetLastMeasuredAt: true,
       },
     },
     "device-manager/models": {

package/dist/lib/modules/asset/roles/specificRoles/RoleAssetsConfiguration.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to configurate an asset metadata.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleAssetsConfiguration: KuzzleRole;

package/dist/lib/modules/asset/roles/specificRoles/RoleAssetsCreation.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to create, update and delete an asset.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleAssetsCreation: KuzzleRole;

package/dist/lib/modules/asset/roles/specificRoles/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./RoleAssetsConfiguration";
+export * from "./RoleAssetsCreation";

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

@@ -1,9 +1,10 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { MeasureContent } from "../../../modules/measure";
-import { Metadata } from "../../shared";
+import { ApiDigitalTwinGetLastMeasuredAtRequest, ApiDigitalTwinGetLastMeasuredAtResult, ApiDigitalTwinGetLastMeasuresRequest, ApiDigitalTwinGetLastMeasuresResult, ApiDigitalTwinMGetLastMeasuredAtRequest, ApiDigitalTwinMGetLastMeasuredAtResult, ApiDigitalTwinMGetLastMeasuresRequest, ApiDigitalTwinMGetLastMeasuresResult, Metadata } from "../../shared";
 import { AssetContent } from "./AssetContent";
+type AssetsControllerName = "device-manager/assets";
 interface AssetsControllerRequest {
-    controller: "device-manager/assets";
+    controller: AssetsControllerName;
     engineId: string;
 }
 export interface ApiAssetGetRequest extends AssetsControllerRequest {
@@ -20,6 +21,26 @@ export interface ApiAssetUpdateRequest extends AssetsControllerRequest {
     };
 }
 export type ApiAssetUpdateResult = KDocument<AssetContent>;
+export interface ApiAssetMetadataReplaceRequest extends AssetsControllerRequest {
+    action: "replaceMetadata";
+    _id: string;
+    refresh?: string;
+    body: {
+        metadata: Metadata;
+    };
+}
+export type ApiAssetMetadataReplaceResult = KDocument<AssetContent>;
+export interface ApiAssetUpsertRequest extends AssetsControllerRequest {
+    action: "upsert";
+    _id: string;
+    refresh?: string;
+    body: {
+        model: string;
+        reference: string;
+        metadata: Metadata;
+    };
+}
+export type ApiAssetUpsertResult = KDocument<AssetContent>;
 export interface ApiAssetCreateRequest extends AssetsControllerRequest {
     action: "create";
     refresh?: string;
@@ -64,6 +85,10 @@ export type ApiAssetGetMeasuresResult = {
     measures: Array<KDocument<MeasureContent<JSONObject>>>;
     total: number;
 };
+export type ApiAssetGetLastMeasuresRequest = ApiDigitalTwinGetLastMeasuresRequest<AssetsControllerName>;
+export type ApiAssetGetLastMeasuresResult = ApiDigitalTwinGetLastMeasuresResult;
+export type ApiAssetMGetLastMeasuresRequest = ApiDigitalTwinMGetLastMeasuresRequest<AssetsControllerName>;
+export type ApiAssetMGetLastMeasuresResult = ApiDigitalTwinMGetLastMeasuresResult;
 /**
  * This action can be used only with WebSocket or POST
  *
@@ -96,4 +121,20 @@ export interface ApiAssetExportRequest extends AssetsControllerRequest {
 export type ApiAssetExportResult = {
     link: string;
 };
+export interface ApiAssetMigrateTenantRequest extends AssetsControllerRequest {
+    action: "migrateTenant";
+    engineId: string;
+    body: {
+        assetsList: string[];
+        newEngineId: string;
+    };
+}
+export type ApiAssetMigrateTenantResult = {
+    errors: string[];
+    successes: string[];
+};
+export type ApiAssetGetLastMeasuredAtRequest = ApiDigitalTwinGetLastMeasuredAtRequest<AssetsControllerName>;
+export type ApiAssetGetLastMeasuredAtResult = ApiDigitalTwinGetLastMeasuredAtResult;
+export type ApiAssetMGetLastMeasuredAtRequest = ApiDigitalTwinMGetLastMeasuredAtRequest<AssetsControllerName>;
+export type ApiAssetMGetLastMeasuredAtResult = ApiDigitalTwinMGetLastMeasuredAtResult;
 export {};

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

@@ -49,4 +49,4 @@ export type AssetMeasureContext<TMetadata extends Metadata = Metadata> = {
      * Name of the measure for the Asset
      */
     measureName: string;
-} & Pick<AssetContent<JSONObject, TMetadata>, "model" | "reference" | "metadata">;
+} & Pick<AssetContent<JSONObject, TMetadata>, "model" | "reference" | "metadata" | "groups">;

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

@@ -19,6 +19,17 @@ export type NamedMeasures = Array<{
  */
 export declare abstract class Decoder {
     private _http?;
+    /**
+     * 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;
+    };
     /**
      * Device model name.
      *

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

@@ -1,14 +1,11 @@
 import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument } from "kuzzle-sdk";
-import { DeviceManagerPlugin } from "../plugin";
 import { DeviceContent } from "../device";
 import { DecodedMeasurement } from "../measure";
+import { DeviceManagerPlugin } from "../plugin";
+import { BaseService } from "../shared";
 import { Decoder } from "./Decoder";
-export declare class PayloadService {
-    private config;
-    private context;
-    private get sdk();
-    private get app();
+export declare class PayloadService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     /**
      * Process a payload by validating and decode it with the `decoder` associated

package/dist/lib/modules/decoder/types/DecoderContent.d.ts

@@ -1,5 +1,6 @@
 import { NamedMeasures } from "../Decoder";
 export interface DecoderContent {
     deviceModel: string;
+    action?: string;
     measures: NamedMeasures;
 }

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

@@ -1,17 +1,14 @@
-import { Plugin, User } from "kuzzle";
+import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
-import { AssetContent } from "./../asset";
-import { Metadata } from "../shared";
 import { DecodedMeasurement } from "../measure";
-import { DeviceContent } from "./types/DeviceContent";
+import { DeviceManagerPlugin } from "../plugin";
+import { DigitalTwinService, Metadata, SearchParams } from "../shared";
+import { AssetContent } from "./../asset";
 import { ApiDeviceLinkAssetRequest } from "./types/DeviceApi";
-export declare class DeviceService {
-    private config;
-    private context;
-    private get sdk();
-    private get app();
-    private get impersonatedSdk();
-    constructor(plugin: Plugin);
+import { DeviceContent } from "./types/DeviceContent";
+export declare class DeviceService extends DigitalTwinService {
+    constructor(plugin: DeviceManagerPlugin);
+    registerAskEvents(): void;
     /**
      * Create a new device.
      *
@@ -19,23 +16,20 @@ export declare class DeviceService {
      * method since in this case "engineId" is not really an engine ID but still
      * required as an argument (in part to check the tenant rights)
      */
-    create(user: User, model: string, reference: string, metadata: JSONObject, { engineId, refresh, }?: {
-        engineId?: string;
-        refresh?: any;
-    }): Promise<KDocument<DeviceContent>>;
-    get(index: string, deviceId: string): Promise<KDocument<DeviceContent>>;
-    update(user: User, engineId: string, deviceId: string, metadata: Metadata, { refresh }: {
-        refresh: any;
-    }): Promise<KDocument<DeviceContent>>;
-    delete(user: User, engineId: string, deviceId: string, { refresh }: {
-        refresh: any;
-    }): Promise<void>;
-    search(engineId: string, searchBody: JSONObject, { from, size, scroll, lang, }: {
-        from?: number;
-        size?: number;
-        scroll?: string;
-        lang?: string;
-    }): Promise<SearchResult<KHit<DeviceContent>>>;
+    create(model: string, reference: string, metadata: JSONObject, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    get(engineId: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    private getInternalDevices;
+    /**
+     * Replace a device metadata
+     */
+    replaceMetadata(engineId: string, deviceId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    /**
+     * Update or Create an device metadata
+     */
+    upsert(engineId: string, model: string, reference: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    update(engineId: string, deviceId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    delete(engineId: string, deviceId: string, request: KuzzleRequest): Promise<void>;
+    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<DeviceContent>>>;
     /**
      * Attach the device to an engine
      *
@@ -44,29 +38,22 @@ export declare class DeviceService {
      * @param options.refresh Wait for ES indexation
      * @param options.strict If true, throw if an operation isn't possible
      */
-    attachEngine(user: User, engineId: string, deviceId: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<KDocument<DeviceContent>>;
+    attachEngine(engineId: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Detach a device from its attached engine
      *
-     * @param deviceId Device id
-     * @param options.refresh Wait for ES indexation
+     * @param {string} deviceId Id of the device
+     * @param {KuzzleRequest} request kuzzle request
      */
-    detachEngine(user: User, deviceId: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<KDocument<DeviceContent>>;
+    detachEngine(deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Link a device to an asset.
      */
-    linkAsset(user: User, engineId: string, deviceId: string, assetId: string, measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"], { refresh, implicitMeasuresLinking, }?: {
-        refresh?: any;
-        implicitMeasuresLinking?: boolean;
-    }): Promise<{
+    linkAsset(engineId: string, deviceId: string, assetId: string, measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"], implicitMeasuresLinking: boolean, request: KuzzleRequest): Promise<{
         asset: KDocument<AssetContent>;
         device: KDocument<DeviceContent>;
     }>;
-    receiveMeasures(engineId: string, deviceId: string, measures: DecodedMeasurement[], payloadUuids: string[]): Promise<void>;
+    receiveMeasures(engineId: string, deviceId: string, measures: DecodedMeasurement[], payloadUuids: string[], request: KuzzleRequest): Promise<void>;
     /**
      * Checks if the asset does not already have a linked device using one of the
      * requested measure names.
@@ -82,12 +69,10 @@ export declare class DeviceService {
     /**
      * Unlink a device of an asset
      *
-     * @param deviceId Id of the device
-     * @param options.refresh Wait for ES indexation
+     * @param {string} deviceId Id of the device
+     * @param {KuzzleRequest} request kuzzle request
      */
-    unlinkAsset(user: User, deviceId: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<{
+    unlinkAsset(deviceId: string, request: KuzzleRequest): Promise<{
         asset: KDocument<AssetContent>;
         device: KDocument<DeviceContent>;
     }>;

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

@@ -1,7 +1,7 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { DeviceService } from "./DeviceService";
-import { ApiDeviceAttachEngineResult, ApiDeviceCreateResult, ApiDeviceDeleteResult, ApiDeviceDetachEngineResult, ApiDeviceGetResult, ApiDeviceLinkAssetResult, ApiDeviceSearchResult, ApiDeviceUnlinkAssetResult, ApiDeviceUpdateResult, ApiDeviceGetMeasuresResult } from "./types/DeviceApi";
+import { ApiDeviceAttachEngineResult, ApiDeviceCreateResult, ApiDeviceDeleteResult, ApiDeviceDetachEngineResult, ApiDeviceGetResult, ApiDeviceLinkAssetResult, ApiDeviceSearchResult, ApiDeviceUnlinkAssetResult, ApiDeviceUpdateResult, ApiDeviceGetMeasuresResult, ApiDeviceUpsertResult, ApiDeviceGetLastMeasuresResult, ApiDeviceMGetLastMeasuresResult, ApiDeviceGetLastMeasuredAtResult, ApiDeviceMGetLastMeasuredAtResult, ApiDeviceMetadataReplaceResult } from "./types/DeviceApi";
 export declare class DevicesController {
     private plugin;
     private deviceService;
@@ -11,8 +11,10 @@ export declare class DevicesController {
     constructor(plugin: DeviceManagerPlugin, deviceService: DeviceService);
     get(request: KuzzleRequest): Promise<ApiDeviceGetResult>;
     update(request: KuzzleRequest): Promise<ApiDeviceUpdateResult>;
+    replaceMetadata(request: KuzzleRequest): Promise<ApiDeviceMetadataReplaceResult>;
     delete(request: KuzzleRequest): Promise<ApiDeviceDeleteResult>;
     search(request: KuzzleRequest): Promise<ApiDeviceSearchResult>;
+    upsert(request: KuzzleRequest): Promise<ApiDeviceUpsertResult>;
     /**
      * Create and provision a new device
      */
@@ -34,7 +36,11 @@ export declare class DevicesController {
      */
     unlinkAsset(request: KuzzleRequest): Promise<ApiDeviceUnlinkAssetResult>;
     getMeasures(request: KuzzleRequest): Promise<ApiDeviceGetMeasuresResult>;
+    getLastMeasures(request: KuzzleRequest): Promise<ApiDeviceGetLastMeasuresResult>;
+    mGetLastMeasures(request: KuzzleRequest): Promise<ApiDeviceMGetLastMeasuresResult>;
     exportMeasures(request: KuzzleRequest): Promise<any>;
     receiveMeasures(request: KuzzleRequest): Promise<void>;
     export(request: KuzzleRequest): Promise<any>;
+    getLastMeasuredAt(request: KuzzleRequest): Promise<ApiDeviceGetLastMeasuredAtResult>;
+    mGetLastMeasuredAt(request: KuzzleRequest): Promise<ApiDeviceMGetLastMeasuredAtResult>;
 }

package/dist/lib/modules/device/collections/deviceMappings.d.ts

@@ -1,51 +1,7 @@
+import { CollectionMappings } from "kuzzle";
 /**
  * Base mappings for the "devices" collection.
  *
  * Those mappings does not contains the `measures` and `metadata` mappings.
  */
-export declare const devicesMappings: {
-    dynamic: string;
-    properties: {
-        model: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        reference: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        assetId: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        engineId: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        metadata: {
-            properties: {};
-        };
-        measures: {
-            properties: {};
-        };
-        lastMeasuredAt: {
-            type: string;
-        };
-    };
-};
+export declare const devicesMappings: CollectionMappings;

package/dist/lib/modules/device/roles/RoleDevicesReader.d.ts

@@ -10,7 +10,11 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
         get: true,
         search: true,
         getMeasures: true,
+        getLastMeasures: true,
+        mGetLastMeasures: true,
         exportMeasures: true,
+        getLastMeasuredAt: true,
+        mGetLastMeasuredAt: true,
       },
     },
     "device-manager/models": {

package/dist/lib/modules/device/roles/specificRoles/RoleDevicesAssetAssociation.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to associate assets and devices.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleDevicesAssetAssociation: KuzzleRole;

package/dist/lib/modules/device/roles/specificRoles/RoleDevicesConfiguration.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to configure a device metadata.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleDevicesConfiguration: KuzzleRole;

package/dist/lib/modules/device/roles/specificRoles/RoleDevicesCreation.d.ts

@@ -0,0 +1,8 @@
+import { KuzzleRole } from "../../../shared/types/KuzzleRole";
+/**
+ * This role allows to create, update and delete a device.
+ *
+ * It's a tenant role.
+ *
+ */
+export declare const RoleDevicesCreation: KuzzleRole;

package/dist/lib/modules/device/roles/specificRoles/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./RoleDevicesAssetAssociation";
+export * from "./RoleDevicesConfiguration";
+export * from "./RoleDevicesCreation";

package/dist/lib/modules/device/types/DeviceApi.d.ts

@@ -1,10 +1,11 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { DecodedMeasurement, MeasureContent } from "../../measure";
 import { AssetContent } from "../../asset";
-import { Metadata } from "../../shared";
+import { ApiDigitalTwinGetLastMeasuredAtRequest, ApiDigitalTwinGetLastMeasuredAtResult, ApiDigitalTwinGetLastMeasuresRequest, ApiDigitalTwinGetLastMeasuresResult, ApiDigitalTwinMGetLastMeasuredAtRequest, ApiDigitalTwinMGetLastMeasuredAtResult, ApiDigitalTwinMGetLastMeasuresRequest, ApiDigitalTwinMGetLastMeasuresResult, Metadata } from "../../shared";
 import { DeviceContent } from "./DeviceContent";
+type DevicesControllerName = "device-manager/devices";
 interface DevicesControllerRequest {
-    controller: "device-manager/devices";
+    controller: DevicesControllerName;
     engineId: string;
 }
 export interface ApiDeviceGetRequest extends DevicesControllerRequest {
@@ -21,6 +22,18 @@ export interface ApiDeviceUpdateRequest extends DevicesControllerRequest {
     };
 }
 export type ApiDeviceUpdateResult = KDocument<DeviceContent>;
+export type ApiDeviceMetadataReplaceResult = KDocument<DeviceContent>;
+export interface ApiDeviceUpsertRequest extends DevicesControllerRequest {
+    action: "upsert";
+    _id: string;
+    refresh?: string;
+    body: {
+        model: string;
+        reference: string;
+        metadata: Metadata;
+    };
+}
+export type ApiDeviceUpsertResult = KDocument<DeviceContent>;
 export interface ApiDeviceCreateRequest extends DevicesControllerRequest {
     action: "create";
     refresh?: string;
@@ -131,6 +144,10 @@ export type ApiDeviceGetMeasuresResult = {
     measures: Array<KDocument<MeasureContent<JSONObject>>>;
     total: number;
 };
+export type ApiDeviceGetLastMeasuresRequest = ApiDigitalTwinGetLastMeasuresRequest<DevicesControllerName>;
+export type ApiDeviceGetLastMeasuresResult = ApiDigitalTwinGetLastMeasuresResult;
+export type ApiDeviceMGetLastMeasuresRequest = ApiDigitalTwinMGetLastMeasuresRequest<DevicesControllerName>;
+export type ApiDeviceMGetLastMeasuresResult = ApiDigitalTwinMGetLastMeasuresResult;
 /**
  * This action can be used only with WebSocket or POST
  *
@@ -177,4 +194,8 @@ export interface ApiDeviceExportRequest extends DevicesControllerRequest {
 export type ApiDeviceExportResult = {
     link: string;
 };
+export type ApiDeviceGetLastMeasuredAtRequest = ApiDigitalTwinGetLastMeasuredAtRequest<DevicesControllerName>;
+export type ApiDeviceGetLastMeasuredAtResult = ApiDigitalTwinGetLastMeasuredAtResult;
+export type ApiDeviceMGetLastMeasuredAtRequest = ApiDigitalTwinMGetLastMeasuredAtRequest<DevicesControllerName>;
+export type ApiDeviceMGetLastMeasuredAtResult = ApiDigitalTwinMGetLastMeasuredAtResult;
 export {};

package/dist/lib/modules/device/types/DeviceEvents.d.ts

@@ -2,6 +2,7 @@ import { User } from "kuzzle";
 import { KDocument } from "kuzzle-sdk";
 import { Metadata } from "../../../modules/shared";
 import { DeviceContent } from "./DeviceContent";
+import { ApiDeviceLinkAssetRequest } from "./DeviceApi";
 export type EventDeviceUpdateBefore = {
     name: "device-manager:device:update:before";
     args: [{
@@ -19,6 +20,17 @@ export type EventDeviceUpdateAfter = {
 /**
  * @internal
  */
+export type AskDeviceLinkAsset = {
+    name: "ask:device-manager:device:link-asset";
+    payload: {
+        engineId: string;
+        assetId: string;
+        deviceId: string;
+        user: User;
+        measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"];
+    };
+    result: void;
+};
 export type AskDeviceUnlinkAsset = {
     name: "ask:device-manager:device:unlink-asset";
     payload: {
@@ -27,3 +39,20 @@ export type AskDeviceUnlinkAsset = {
     };
     result: void;
 };
+export type AskDeviceDetachEngine = {
+    name: "ask:device-manager:device:detach-engine";
+    payload: {
+        deviceId: string;
+        user: User;
+    };
+    result: void;
+};
+export type AskDeviceAttachEngine = {
+    name: "ask:device-manager:device:attach-engine";
+    payload: {
+        engineId: string;
+        deviceId: string;
+        user: User;
+    };
+    result: void;
+};

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { UUID } from "node:crypto";
 import { KHit, User } from "kuzzle";
+import { UUID } from "node:crypto";
 import { AbstractExporter, Column, ExportParams } from "../shared";
 import { MeasureContent } from "./exports";
 interface MeasureSearchParams extends ExportParams {
@@ -38,7 +38,10 @@ export declare class MeasureExporter extends AbstractExporter<MeasureExportParam
      * Never return a rejected promise and write potential error on the stream
      */
     prepareExport(engineId: string, user: User, params: MeasureSearchParams): Promise<string>;
-    protected formatHit(columns: Column[], hit: KHit<MeasureContent>): any[];
+    protected formatHit(columns: Array<Column & {
+        shouldCheckName: boolean;
+        name: string;
+    }>, hit: KHit<MeasureContent>): any[];
     /**
      * Retrieve a prepared export and write each document as a CSV in the stream
      *