dt-common-device 1.3.0 → 2.0.0

package/dist/device/local/services/IssueService.example.d.ts

@@ -0,0 +1,68 @@
+import { IssueService } from "./Issue.service";
+/**
+ * Example usage of the updated IssueService with IssueBuilder integration
+ * This file demonstrates various ways to use the IssueService with the new IssueBuilder
+ */
+export declare class IssueServiceExample {
+    private readonly issueService;
+    constructor(issueService: IssueService);
+    /**
+     * Example 1: Using the updated createIssue method with IssueBuilder
+     */
+    createIssueWithBuilder(): Promise<import("../../../types/issue.types").IssueDocument>;
+    /**
+     * Example 2: Using convenience methods for specific issue types
+     */
+    createSpecificIssues(): Promise<{
+        readinessIssue: import("../../../types/issue.types").IssueDocument;
+        operationsIssue: import("../../../types/issue.types").IssueDocument;
+        securityIssue: import("../../../types/issue.types").IssueDocument;
+        energyIssue: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 3: Using device-specific issue methods
+     */
+    createDeviceIssues(): Promise<{
+        deviceIssue1: import("../../../types/issue.types").IssueDocument;
+        deviceIssue2: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 4: Using hub-specific issue methods
+     */
+    createHubIssues(): Promise<{
+        hubIssue1: import("../../../types/issue.types").IssueDocument;
+        hubIssue2: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 5: Using user-specific issue methods
+     */
+    createUserIssues(): Promise<{
+        userIssue: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 6: Using maintenance and urgent issue methods
+     */
+    createMaintenanceAndUrgentIssues(): Promise<{
+        maintenanceIssue: import("../../../types/issue.types").IssueDocument;
+        urgentIssue: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 7: Using static factory methods with IssueBuilder
+     */
+    createIssuesWithStaticMethods(): Promise<{
+        issue1: import("../../../types/issue.types").IssueDocument;
+        issue2: import("../../../types/issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 8: Creating multiple issues efficiently
+     */
+    createMultipleIssues(): Promise<import("../../../types/issue.types").IssueDocument[]>;
+    /**
+     * Example 9: Creating issue with due date calculation
+     */
+    createIssueWithDueDate(): Promise<import("../../../types/issue.types").IssueDocument>;
+    /**
+     * Example 10: Backward compatibility - still works with CreateIssueData
+     */
+    createIssueWithLegacyData(): Promise<import("../../../types/issue.types").IssueDocument>;
+}

package/dist/device/local/services/IssueService.example.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueServiceExample = void 0;
+const IssueBuilder_1 = require("../entities/IssueBuilder");
+const issue_types_1 = require("../../../types/issue.types");
+/**
+ * Example usage of the updated IssueService with IssueBuilder integration
+ * This file demonstrates various ways to use the IssueService with the new IssueBuilder
+ */
+class IssueServiceExample {
+    constructor(issueService) {
+        this.issueService = issueService;
+    }
+    /**
+     * Example 1: Using the updated createIssue method with IssueBuilder
+     */
+    async createIssueWithBuilder() {
+        const issueBuilder = new IssueBuilder_1.IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+            .setPropertyId("prop123")
+            .setTitle("Device Maintenance Required")
+            .setDescription("Device requires scheduled maintenance")
+            .setEntityId("device456")
+            .setEntityType(issue_types_1.EntityType.DEVICE)
+            .setPriority(issue_types_1.IssuePriority.HIGH)
+            .setAssignedTo("tech789")
+            .setCreatedBy("user123")
+            .setDueDate(new Date("2024-01-15"));
+        // Pass the IssueBuilder directly to createIssue
+        const issue = await this.issueService.createIssue(issueBuilder);
+        return issue;
+    }
+    /**
+     * Example 2: Using convenience methods for specific issue types
+     */
+    async createSpecificIssues() {
+        // Create a readiness issue
+        const readinessIssue = await this.issueService.createReadinessIssue("prop123", "System Maintenance Required", "System maintenance is scheduled for tonight", "admin", "system456", issue_types_1.EntityType.PROPERTY, "maintenance-team", new Date("2024-01-20"));
+        // Create an operations issue
+        const operationsIssue = await this.issueService.createOperationsIssue("prop123", "Device Temperature High", "Device temperature exceeds normal operating range", "monitor", "device789", issue_types_1.EntityType.DEVICE, "tech-support", new Date("2024-01-10"));
+        // Create a security issue
+        const securityIssue = await this.issueService.createSecurityIssue("prop123", "Unauthorized Access Attempt", "Multiple failed login attempts detected", "security-system", "user123", issue_types_1.EntityType.USER, "security-team", new Date("2024-01-05"));
+        // Create an energy issue
+        const energyIssue = await this.issueService.createEnergyIssue("prop123", "High Energy Consumption", "Energy usage is 20% above normal levels", "energy-monitor", "zone456", issue_types_1.EntityType.COLLECTION, "energy-manager", new Date("2024-01-25"));
+        return { readinessIssue, operationsIssue, securityIssue, energyIssue };
+    }
+    /**
+     * Example 3: Using device-specific issue methods
+     */
+    async createDeviceIssues() {
+        // Create a device issue with default category and priority
+        const deviceIssue1 = await this.issueService.createDeviceIssue("device123", "prop456", "Device Battery Low", "Device battery level is below 20%", "system", undefined, // Use default category
+        undefined, // Use default priority
+        "maintenance-team", new Date("2024-01-12"));
+        // Create a device issue with custom category and priority
+        const deviceIssue2 = await this.issueService.createDeviceIssue("device789", "prop456", "Device Firmware Update Available", "New firmware version is available for installation", "firmware-manager", issue_types_1.IssuesCategory.READINESS, issue_types_1.IssuePriority.MEDIUM, "admin", new Date("2024-01-20"));
+        return { deviceIssue1, deviceIssue2 };
+    }
+    /**
+     * Example 4: Using hub-specific issue methods
+     */
+    async createHubIssues() {
+        // Create a hub issue with default settings
+        const hubIssue1 = await this.issueService.createHubIssue("hub123", "prop456", "Hub Connection Lost", "Hub has lost connection to the network", "network-monitor", undefined, // Use default category
+        undefined, // Use default priority
+        "network-admin", new Date("2024-01-05"));
+        // Create a hub issue with custom settings
+        const hubIssue2 = await this.issueService.createHubIssue("hub789", "prop456", "Hub Maintenance Required", "Hub requires scheduled maintenance", "maintenance-system", issue_types_1.IssuesCategory.READINESS, issue_types_1.IssuePriority.LOW, "technician", new Date("2024-01-15"));
+        return { hubIssue1, hubIssue2 };
+    }
+    /**
+     * Example 5: Using user-specific issue methods
+     */
+    async createUserIssues() {
+        // Create a user issue
+        const userIssue = await this.issueService.createUserIssue("user456", "prop303", "User Access Review Required", "User access permissions need review", "access-control", issue_types_1.IssuesCategory.SECURITY, issue_types_1.IssuePriority.MEDIUM, "hr-admin", new Date("2024-01-30"));
+        return { userIssue };
+    }
+    /**
+     * Example 6: Using maintenance and urgent issue methods
+     */
+    async createMaintenanceAndUrgentIssues() {
+        // Create a maintenance issue
+        const maintenanceIssue = await this.issueService.createMaintenanceIssue("prop505", "Scheduled Device Maintenance", "Regular maintenance is scheduled for this device", "maintenance-scheduler", "device789", issue_types_1.EntityType.DEVICE, "technician", new Date("2024-01-12"));
+        // Create an urgent issue
+        const urgentIssue = await this.issueService.createUrgentIssue("prop606", "Critical Hub Failure", "Hub is experiencing critical failures", "monitoring-system", "hub123", issue_types_1.EntityType.HUB, "emergency-tech", new Date("2024-01-03"));
+        return { maintenanceIssue, urgentIssue };
+    }
+    /**
+     * Example 7: Using static factory methods with IssueBuilder
+     */
+    async createIssuesWithStaticMethods() {
+        // Create a device issue using static factory method
+        const deviceIssue = IssueBuilder_1.IssueBuilder.createDeviceIssue("device123", "prop456")
+            .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+            .setTitle("Device Offline")
+            .setDescription("Device has been offline for more than 5 minutes")
+            .setPriority(issue_types_1.IssuePriority.HIGH)
+            .setAssignedTo("tech-support")
+            .setCreatedBy("monitor")
+            .setDueDate(new Date("2024-01-10"));
+        const issue1 = await this.issueService.createIssue(deviceIssue);
+        // Create a hub issue using static factory method
+        const hubIssue = IssueBuilder_1.IssueBuilder.createHubIssue("hub789", "prop202")
+            .setCategory(issue_types_1.IssuesCategory.SECURITY)
+            .setTitle("Hub Security Breach")
+            .setDescription("Unauthorized access attempt detected on hub")
+            .setPriority(issue_types_1.IssuePriority.CRITICAL)
+            .setAssignedTo("security-team")
+            .setCreatedBy("security-system")
+            .setDueDate(new Date("2024-01-05"));
+        const issue2 = await this.issueService.createIssue(hubIssue);
+        return { issue1, issue2 };
+    }
+    /**
+     * Example 8: Creating multiple issues efficiently
+     */
+    async createMultipleIssues() {
+        const issues = [];
+        // Create multiple device issues efficiently
+        const deviceIds = ["device1", "device2", "device3"];
+        const propertyId = "prop123";
+        for (const deviceId of deviceIds) {
+            const issueBuilder = IssueBuilder_1.IssueBuilder.createDeviceIssue(deviceId, propertyId)
+                .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+                .setTitle(`Device ${deviceId} Status`)
+                .setDescription(`Status check for device ${deviceId}`)
+                .setPriority(issue_types_1.IssuePriority.MEDIUM)
+                .setAssignedTo("batch-processor")
+                .setCreatedBy("batch-processor")
+                .setDueDate(new Date("2024-01-15"));
+            const issue = await this.issueService.createIssue(issueBuilder);
+            issues.push(issue);
+        }
+        return issues;
+    }
+    /**
+     * Example 9: Creating issue with due date calculation
+     */
+    async createIssueWithDueDate() {
+        const dueDate = new Date();
+        dueDate.setDate(dueDate.getDate() + 7); // Due in 7 days
+        const issueBuilder = new IssueBuilder_1.IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.READINESS)
+            .setPropertyId("prop808")
+            .setTitle("System Update Required")
+            .setDescription("System requires critical security update")
+            .setEntityType(issue_types_1.EntityType.PROPERTY)
+            .setPriority(issue_types_1.IssuePriority.HIGH)
+            .setAssignedTo("system-admin")
+            .setCreatedBy("update-manager")
+            .setDueDate(dueDate);
+        const issue = await this.issueService.createIssue(issueBuilder);
+        return issue;
+    }
+    /**
+     * Example 10: Backward compatibility - still works with CreateIssueData
+     */
+    async createIssueWithLegacyData() {
+        const issueData = {
+            category: issue_types_1.IssuesCategory.OPERATIONS,
+            propertyId: "prop123",
+            title: "Legacy Issue",
+            description: "This issue was created using the old CreateIssueData format",
+            entityId: "device456",
+            entityType: issue_types_1.EntityType.DEVICE,
+            priority: issue_types_1.IssuePriority.MEDIUM,
+            assignedTo: "tech-support",
+            createdBy: "legacy-system",
+            dueDate: new Date("2024-01-20")
+        };
+        // This still works with the updated createIssue method
+        const issue = await this.issueService.createIssue(issueData);
+        return issue;
+    }
+}
+exports.IssueServiceExample = IssueServiceExample;

package/dist/device/local/services/index.d.ts

@@ -1,5 +1,7 @@
-export { LocalDeviceService } from "./Device.service";
-export { LocalHubService } from "./Hub.service";
-export { LocalConnectionService } from "./Connection.service";
-export { LocalPropertyService } from "./Property.service";
-export { LocalScheduleService } from "./Schedule.service";
+export * from "./Alert.service";
+export * from "./Connection.service";
+export * from "./Device.service";
+export * from "./Hub.service";
+export * from "./Issue.service";
+export * from "./Property.service";
+export * from "./Schedule.service";

package/dist/device/local/services/index.js

@@ -1,13 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalScheduleService = exports.LocalPropertyService = exports.LocalConnectionService = exports.LocalHubService = exports.LocalDeviceService = void 0;
-var Device_service_1 = require("./Device.service");
-Object.defineProperty(exports, "LocalDeviceService", { enumerable: true, get: function () { return Device_service_1.LocalDeviceService; } });
-var Hub_service_1 = require("./Hub.service");
-Object.defineProperty(exports, "LocalHubService", { enumerable: true, get: function () { return Hub_service_1.LocalHubService; } });
-var Connection_service_1 = require("./Connection.service");
-Object.defineProperty(exports, "LocalConnectionService", { enumerable: true, get: function () { return Connection_service_1.LocalConnectionService; } });
-var Property_service_1 = require("./Property.service");
-Object.defineProperty(exports, "LocalPropertyService", { enumerable: true, get: function () { return Property_service_1.LocalPropertyService; } });
-var Schedule_service_1 = require("./Schedule.service");
-Object.defineProperty(exports, "LocalScheduleService", { enumerable: true, get: function () { return Schedule_service_1.LocalScheduleService; } });
+__exportStar(require("./Alert.service"), exports);
+__exportStar(require("./Connection.service"), exports);
+__exportStar(require("./Device.service"), exports);
+__exportStar(require("./Hub.service"), exports);
+__exportStar(require("./Issue.service"), exports);
+__exportStar(require("./Property.service"), exports);
+__exportStar(require("./Schedule.service"), exports);

package/dist/events/BaseEventHandler.d.ts

@@ -0,0 +1,43 @@
+import { DeviceEvent } from "./interfaces/DeviceEvent";
+import { IEventHandler } from "./interfaces/IEventHandler";
+import { ILogger } from "../types/config.types";
+import { LocalDeviceService } from "../device/local/services/Device.service";
+export declare abstract class BaseEventHandler implements IEventHandler {
+    protected readonly supportedEventTypes: string[];
+    protected readonly priority: number;
+    protected readonly logger: ILogger;
+    protected readonly localDeviceService: LocalDeviceService;
+    constructor(supportedEventTypes: string[], priority?: number);
+    /**
+     * Handle a single event - to be implemented by specific handlers
+     */
+    handleEvent(event: DeviceEvent): Promise<void>;
+    beforeEvent(event: DeviceEvent): Promise<void>;
+    abstract onEvent(event: DeviceEvent): Promise<void>;
+    afterEvent(event: DeviceEvent): Promise<void>;
+    /**
+     * Handle multiple events - default implementation processes them sequentially
+     */
+    handleEvents(events: DeviceEvent[]): Promise<void>;
+    onStateChange(deviceId: string, state: Record<string, any>, event: DeviceEvent): Promise<void>;
+    /**
+     * Check if this handler can process the given event type
+     */
+    canHandle(eventType: string): boolean;
+    /**
+     * Get the priority of this handler
+     */
+    getPriority(): number;
+    /**
+     * Get the event types this handler can process
+     */
+    getSupportedEventTypes(): string[];
+    /**
+     * Common validation method
+     */
+    protected validateEvent(event: DeviceEvent): boolean;
+    /**
+     * Common error handling method
+     */
+    protected handleError(error: any, context: string): Promise<void>;
+}

package/dist/events/BaseEventHandler.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEventHandler = void 0;
+const config_1 = require("../config/config");
+const Device_service_1 = require("../device/local/services/Device.service");
+class BaseEventHandler {
+    constructor(supportedEventTypes, priority = 100) {
+        this.supportedEventTypes = supportedEventTypes;
+        this.priority = priority;
+        this.logger = (0, config_1.getConfig)().LOGGER;
+        this.localDeviceService = new Device_service_1.LocalDeviceService();
+    }
+    /**
+     * Handle a single event - to be implemented by specific handlers
+     */
+    async handleEvent(event) {
+        try {
+            await this.beforeEvent(event);
+            await this.onEvent(event);
+        }
+        catch (error) {
+            this.logger.error(`${this.constructor.name}: Error during event processing`, {
+                eventName: event.eventName,
+                deviceId: event.deviceId,
+                error,
+            });
+            throw error;
+        }
+        finally {
+            await this.afterEvent(event);
+        }
+    }
+    async beforeEvent(event) {
+        this.logger.info("[DT | CDL]:[BaseEventHandler]: Before event - Handle Before Event");
+    }
+    async afterEvent(event) {
+        this.logger.info("[DT | CDL]:[BaseEventHandler]: After event - Event processing completed", {
+            eventName: event.eventName,
+            deviceId: event.deviceId,
+            handler: this.constructor.name,
+        });
+        //TODO: Implement AUDIT Here!
+    }
+    /**
+     * Handle multiple events - default implementation processes them sequentially
+     */
+    async handleEvents(events) {
+        try {
+            this.logger.info(`Processing ${events.length} events with ${this.constructor.name}`);
+            for (const event of events) {
+                if (this.canHandle(event.eventName || "unknown")) {
+                    await this.handleEvent(event);
+                }
+                else {
+                    this.logger.warn(`Event type ${event.eventName} not supported by ${this.constructor.name}`);
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error(`${this.constructor.name}: handleEvents Error`, error);
+        }
+    }
+    async onStateChange(deviceId, state, event) {
+        try {
+            await this.localDeviceService.setState(deviceId, state);
+            await this.afterEvent(event);
+        }
+        catch (error) {
+            this.logger.error(`[DT | CDL]:[BaseEventHandler]: Error during state change: ${error.message || error.toString()}`);
+        }
+    }
+    /**
+     * Check if this handler can process the given event type
+     */
+    canHandle(eventType) {
+        return this.supportedEventTypes.includes(eventType);
+    }
+    /**
+     * Get the priority of this handler
+     */
+    getPriority() {
+        return this.priority;
+    }
+    /**
+     * Get the event types this handler can process
+     */
+    getSupportedEventTypes() {
+        return this.supportedEventTypes;
+    }
+    /**
+     * Common validation method
+     */
+    validateEvent(event) {
+        if (!event) {
+            this.logger.error("Event is null or undefined");
+            return false;
+        }
+        if (!event.eventName) {
+            this.logger.error("Event name is missing");
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Common error handling method
+     */
+    async handleError(error, context) {
+        this.logger.error(`${this.constructor.name}: ${context} Error`, error);
+    }
+}
+exports.BaseEventHandler = BaseEventHandler;

package/dist/events/BaseEventTransformer.d.ts

@@ -0,0 +1,26 @@
+import { ILogger } from "../types/config.types";
+import { DeviceEvent } from "./interfaces/DeviceEvent";
+import { IEventTransformer } from "./interfaces/IEventTransformer";
+export declare abstract class BaseEventTransformer implements IEventTransformer {
+    protected readonly deviceType: string;
+    protected rawData: any;
+    protected readonly logger: ILogger;
+    constructor(deviceType: string, rawData: any);
+    parseData(rawData: any): any;
+    /**
+     * Transform parsed data into DeviceEvent format - to be implemented by device-specific transformers
+     */
+    abstract transform(parsedData: any): DeviceEvent | DeviceEvent[];
+    /**
+     * Validate transformed event - default implementation, can be overridden
+     */
+    validate(transformedEvent: DeviceEvent): boolean;
+    /**
+     * Get the device type this transformer handles
+     */
+    getDeviceType(): string;
+    /**
+     * Execute the full transformation pipeline
+     */
+    executeTransformation(): DeviceEvent[];
+}

package/dist/events/BaseEventTransformer.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEventTransformer = void 0;
+const config_1 = require("../config/config");
+class BaseEventTransformer {
+    constructor(deviceType, rawData) {
+        this.deviceType = deviceType;
+        this.rawData = rawData;
+        this.logger = (0, config_1.getConfig)().LOGGER;
+    }
+    // Parse raw event data - to be implemented by device-specific transformers
+    parseData(rawData) {
+        try {
+            this.logger.info(`${this.deviceType}EventTransformer: Parsed event data`);
+            return rawData;
+        }
+        catch (error) {
+            this.logger.error(`${this.deviceType}EventTransformer: Error parsing data`, error);
+            return null;
+        }
+    }
+    /**
+     * Validate transformed event - default implementation, can be overridden
+     */
+    validate(transformedEvent) {
+        try {
+            // Basic validation - ensure required fields exist
+            if (!transformedEvent) {
+                this.logger.error("Transformed event is null or undefined");
+                return false;
+            }
+            // Add more validation logic as needed
+            return true;
+        }
+        catch (error) {
+            this.logger.error("BaseEventTransformer: validate Error", error);
+            return false;
+        }
+    }
+    /**
+     * Get the device type this transformer handles
+     */
+    getDeviceType() {
+        return this.deviceType;
+    }
+    /**
+     * Execute the full transformation pipeline
+     */
+    executeTransformation() {
+        try {
+            this.logger.info(`Starting transformation for device type: ${this.deviceType}`);
+            // Step 1: Parse the raw data
+            const parsedData = this.parseData(this.rawData);
+            // Step 2: Transform to DeviceEvent format
+            const transformedResult = this.transform(parsedData);
+            // Step 3: Convert to array format
+            // TODO: Check if any service sends multiple events
+            const events = Array.isArray(transformedResult)
+                ? transformedResult
+                : [transformedResult];
+            // Step 4: Validate each event
+            const validEvents = events.filter((event) => this.validate(event));
+            this.logger.info(`Transformation completed. ${validEvents.length} valid events created.`);
+            return validEvents;
+        }
+        catch (error) {
+            this.logger.error("BaseEventTransformer: executeTransformation Error", error);
+            return [];
+        }
+    }
+}
+exports.BaseEventTransformer = BaseEventTransformer;

package/dist/events/DeviceEventHandler.d.ts

@@ -0,0 +1,15 @@
+import { IDevice } from "../device/local/interfaces";
+import { BaseEventHandler } from "./BaseEventHandler";
+import { DeviceEvent, DeviceEventEntity, EventConstructionOptions } from "./interfaces/DeviceEvent";
+export declare class DeviceEventHandler extends BaseEventHandler {
+    private readonly localHubService;
+    constructor();
+    onEvent(event: DeviceEvent): Promise<void>;
+    updateDeviceEventData(deviceData: IDevice, event: DeviceEvent): Promise<void>;
+    extractHubDetails(device: IDevice): Promise<any[]>;
+    constructDeviceEventEntity(eventData: any, device: IDevice, hubDetails: any[], options?: EventConstructionOptions): DeviceEventEntity;
+    dumpToEventOperation(data: any, device: IDevice): Promise<void>;
+    updateTablesBasedOnEventType(eventData: any, device: IDevice): Promise<void>;
+    updateDeviceStatus(data: any, device: IDevice): Promise<void>;
+    updateDeviceBattery(data: any, device: IDevice): Promise<void>;
+}