dt-common-device 3.0.10 → 3.0.12

package/dist/queue/types/http.types.d.ts

@@ -1,11 +1,13 @@
+import { IncomingHttpHeaders } from "http";
+import { SERVICE_NAME } from "../../constants";
 export interface HttpCallOption {
-    headers?: Record<string, string>;
+    headers?: IncomingHttpHeaders;
     body?: any;
     params?: Record<string, any>;
     queueOptions?: {
         connectionId: string;
         connectionProvider: string;
-        microservice: string;
+        microservice: SERVICE_NAME;
     };
 }
 export interface HttpRequestOptions {
@@ -13,10 +15,10 @@ export interface HttpRequestOptions {
     url: string;
     body?: any;
     params?: Record<string, any>;
-    headers?: Record<string, string>;
+    headers?: IncomingHttpHeaders;
     queueOptions?: {
         connectionId: string;
         connectionProvider: string;
-        microservice: string;
+        microservice: SERVICE_NAME;
     };
 }

package/dist/queue/types/queue.types.d.ts

@@ -1,31 +1,14 @@
-export interface QueueConfig {
-    concurrency: number;
-    removeOnComplete: {
-        age: number;
-        count: number;
+import { IncomingHttpHeaders } from "http";
+import { SERVICE_NAME } from "../../constants";
+export interface RequestQueueOptions {
+    method: string;
+    url: string;
+    body?: any;
+    params?: Record<string, any>;
+    headers?: IncomingHttpHeaders;
+    queueOptions?: {
+        connectionId: string;
+        connectionProvider: string;
+        microservice: SERVICE_NAME;
     };
-    removeOnFail: {
-        age: number;
-        count: number;
-    };
-    lockDuration: number;
-    stalledInterval: number;
-}
-export interface JobOptions {
-    attempts: number;
-    removeOnComplete: {
-        age: number;
-        count: number;
-    };
-    removeOnFail: {
-        age: number;
-        count: number;
-    };
-}
-export interface QueueMetrics {
-    totalJobs: number;
-    completedJobs: number;
-    failedJobs: number;
-    pendingJobs: number;
-    activeJobs: number;
 }

package/dist/queue/utils/jobUtils.d.ts

@@ -1,10 +1,8 @@
-import { Job } from "bullmq";
-import { IJobResult } from "../interfaces";
+import { SERVICE_NAME } from "../../constants";
 export declare class JobUtils {
-    static waitForJobCompletion(job: Job, queueKey: string, jobResults: Map<string, IJobResult>): Promise<any>;
     static extractConnectionDetails(options: any): {
         connectionId: string;
         provider: string;
-        microservice: string;
+        microservice: SERVICE_NAME;
     };
 }

package/dist/queue/utils/jobUtils.js

@@ -2,54 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JobUtils = void 0;
 class JobUtils {
-    static async waitForJobCompletion(job, queueKey, jobResults) {
-        return new Promise((resolve, reject) => {
-            let timeoutId;
-            let checkCount = 0;
-            const maxChecks = 600;
-            const checkJob = async () => {
-                if (++checkCount >= maxChecks) {
-                    clearTimeout(timeoutId);
-                    return reject(new Error("Job timeout: Request took too long"));
-                }
-                try {
-                    const state = await job.getState();
-                    if (state === "completed") {
-                        clearTimeout(timeoutId);
-                        const memoryResult = jobResults.get(job.id);
-                        if (memoryResult?.resolved) {
-                            return memoryResult.result !== undefined
-                                ? resolve(memoryResult.result)
-                                : reject(new Error(memoryResult.error || "Unknown error"));
-                        }
-                        // Fallback to job result
-                        resolve(await job.returnvalue);
-                    }
-                    else if (state === "failed") {
-                        clearTimeout(timeoutId);
-                        const memoryResult = jobResults.get(job.id);
-                        const errorMsg = memoryResult?.error ||
-                            (await job.failedReason) ||
-                            "Unknown error";
-                        reject(new Error(`Job failed: ${errorMsg}`));
-                    }
-                    else {
-                        timeoutId = setTimeout(checkJob, checkCount < 10 ? 50 : 100);
-                    }
-                }
-                catch (error) {
-                    clearTimeout(timeoutId);
-                    reject(new Error(`Error checking job: ${error.message}`));
-                }
-            };
-            checkJob();
-            // Backup timeout
-            setTimeout(() => {
-                clearTimeout(timeoutId);
-                reject(new Error("Request timeout: Maximum wait time exceeded"));
-            }, 60000);
-        });
-    }
     static extractConnectionDetails(options) {
         const { connectionId, connectionProvider: provider, microservice, } = options?.queueOptions ?? {};
         if (!connectionId)

package/dist/queue/utils/queueUtils.d.ts

@@ -1,5 +1,12 @@
+import { HttpCallOption } from "../types/http.types";
+import { IRateLimitConfig } from "../interfaces";
 export declare class QueueUtils {
     static getQueueKey(microservice: string, connectionId: string, provider: string): string;
+    static getRequestQueueKey(connectionId: string, provider: string): string;
     static getOrCreateQueue(queueKey: string, queues: Map<string, any>): any;
     static getOrCreateWorker(queueKey: string, workers: Map<string, any>, processFunction: (job: any) => Promise<any>, jobResults: Map<string, any>): void;
+    static waitForRateLimitExpiry(connectionId: string, provider: string, rateLimitConfigs: Map<string, IRateLimitConfig>): Promise<void>;
+    static executeHttpRequest(url: string, method: string, options: HttpCallOption, connectionId: string, provider: string): Promise<any>;
+    static addJobToQueue(queueKey: string, jobData: any, delay: number, queues: Map<string, any>): Promise<string>;
+    static waitForJobCompletion(jobId: string, queueKey: string, jobResults: Map<string, any>): Promise<any>;
 }

package/dist/queue/utils/queueUtils.js

@@ -1,12 +1,21 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueUtils = void 0;
+const rateLimit_utils_1 = require("./rateLimit.utils");
+const axios_1 = __importDefault(require("axios"));
+const dt_audit_library_1 = require("dt-audit-library");
 const config_1 = require("../../config/config");
 const redis_1 = require("../../db/redis");
 class QueueUtils {
     static getQueueKey(microservice, connectionId, provider) {
         return `${microservice}_${provider}_${connectionId}`;
     }
+    static getRequestQueueKey(connectionId, provider) {
+        return `${connectionId}_${provider}`;
+    }
     static getOrCreateQueue(queueKey, queues) {
         return (queues.get(queueKey) ??
             queues
@@ -27,10 +36,9 @@ class QueueUtils {
             lockDuration: 300000,
             stalledInterval: 60000,
         });
-        // Simplified event handlers
+        // Event handlers for job tracking
         worker.on("completed", (job) => {
             (0, config_1.getConfig)().LOGGER.info(`HTTP request completed: ${job.id} [${queueKey}]`);
-            // job.returnvalue is the actual result, not a Promise
             const result = job.returnvalue;
             jobResults.set(job.id, {
                 result,
@@ -47,10 +55,112 @@ class QueueUtils {
             });
         });
         worker.on("error", (err) => (0, config_1.getConfig)().LOGGER.error(`Worker error for ${queueKey}: ${err.message}`));
-        worker.on("stalled", (jobId) => (0, config_1.getConfig)().LOGGER.warn(`Job ${jobId} stalled in worker ${queueKey}`));
-        worker.on("active", (job) => (0, config_1.getConfig)().LOGGER.info(`HTTP request started: ${job.id} [${queueKey}]`));
         workers.set(queueKey, worker);
         (0, config_1.getConfig)().LOGGER.info(`Worker initialized for queue: ${queueKey}`);
     }
+    static async waitForRateLimitExpiry(connectionId, provider, rateLimitConfigs) {
+        const key = `rate_limit:${provider}:${connectionId}`;
+        const config = rateLimitConfigs.get(provider);
+        if (!config)
+            return;
+        while (true) {
+            const timestamps = await rateLimit_utils_1.RateLimitUtils.getRawRequestTimestamps(key);
+            const now = Date.now();
+            const windowStart = now - config.windowMs;
+            const recentRequests = timestamps.filter((t) => t > windowStart);
+            if (recentRequests.length < config.maxRequests) {
+                // Rate limit not exceeded, we can proceed
+                break;
+            }
+            // Calculate when the earliest request will expire
+            const earliestRequest = recentRequests[0];
+            const nextAvailableTime = earliestRequest + config.windowMs;
+            const delay = Math.max(nextAvailableTime - now, 1000); // At least 1 second
+            (0, config_1.getConfig)().LOGGER.info(`Rate limit exceeded for ${provider} [${connectionId}]. Waiting ${delay}ms until next allowed request. Current requests in window: ${recentRequests.length}/${config.maxRequests}`);
+            // Wait for the calculated delay
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    static async executeHttpRequest(url, method, options, connectionId, provider) {
+        (0, config_1.getConfig)().LOGGER.info(`Executing: ${method} ${url} -> ${provider} [${connectionId}]`);
+        try {
+            // Record the request first
+            await rateLimit_utils_1.RateLimitUtils.recordRequest(connectionId, provider);
+            // Execute the HTTP request
+            const response = await (0, axios_1.default)({
+                method: method.toLowerCase(),
+                url: url,
+                headers: options.headers || {},
+                timeout: 30000,
+                ...(options.body && { data: options.body }),
+                ...(options.params && { params: options.params }),
+            });
+            (0, config_1.getConfig)().LOGGER.info(`HTTP request successful: ${method} ${url} for ${provider} [${connectionId}]`);
+            // Return only the response data
+            return response.data;
+        }
+        catch (error) {
+            (0, config_1.getConfig)().LOGGER.error(`HTTP request failed: ${error.message}`);
+            await (0, dt_audit_library_1.publishAudit)({
+                eventType: "http.request.error",
+                properties: {
+                    connectionId,
+                    provider,
+                    endpoint: url,
+                    method,
+                    timestamp: Date.now(),
+                    reason: "execution_error",
+                    errorMessage: error.message,
+                    error: error,
+                },
+            });
+            // Throw the error instead of returning it
+            throw error;
+        }
+    }
+    static async addJobToQueue(queueKey, jobData, delay, queues) {
+        const queue = this.getOrCreateQueue(queueKey, queues);
+        const job = await queue.add("http-request", jobData, {
+            delay,
+            attempts: 1,
+            removeOnComplete: { age: 300, count: 1 },
+            removeOnFail: { age: 300, count: 1 },
+        });
+        return job.id;
+    }
+    static async waitForJobCompletion(jobId, queueKey, jobResults) {
+        return new Promise((resolve, reject) => {
+            let timeoutId;
+            let checkCount = 0;
+            const maxChecks = 600;
+            const checkJob = async () => {
+                if (++checkCount >= maxChecks) {
+                    clearTimeout(timeoutId);
+                    return reject(new Error("Job timeout: Request took too long"));
+                }
+                try {
+                    const memoryResult = jobResults.get(jobId);
+                    if (memoryResult?.resolved) {
+                        clearTimeout(timeoutId);
+                        return memoryResult.result !== undefined
+                            ? resolve(memoryResult.result)
+                            : reject(new Error(memoryResult.error || "Unknown error"));
+                    }
+                    // Continue checking
+                    timeoutId = setTimeout(checkJob, checkCount < 10 ? 50 : 100);
+                }
+                catch (error) {
+                    clearTimeout(timeoutId);
+                    reject(new Error(`Error checking job: ${error.message}`));
+                }
+            };
+            checkJob();
+            // Backup timeout
+            setTimeout(() => {
+                clearTimeout(timeoutId);
+                reject(new Error("Request timeout: Maximum wait time exceeded"));
+            }, 60000);
+        });
+    }
 }
 exports.QueueUtils = QueueUtils;

package/dist/queue/utils/rateLimit.utils.d.ts

@@ -1,6 +1,6 @@
 import { IRateLimitConfig } from "../interfaces";
 export declare class RateLimitUtils {
-    private static redisClient;
+    private static readonly redisClient;
     static checkRateLimit(connectionId: string, provider: string, rateLimitConfigs: Map<string, IRateLimitConfig>): Promise<boolean>;
     static initializeRateLimitConfigs(): Map<string, IRateLimitConfig>;
     static isRateLimitAllowed(connectionId: string, provider: string, rateLimitConfigs: Map<string, IRateLimitConfig>): Promise<boolean>;

package/dist/queue/utils/rateLimit.utils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RateLimitUtils = void 0;
 const redis_1 = require("../../db/redis");
 const config_1 = require("../../config/config");
+const constants_1 = require("../../constants");
 class RateLimitUtils {
     static async checkRateLimit(connectionId, provider, rateLimitConfigs) {
         const config = rateLimitConfigs.get(provider);
@@ -32,10 +33,45 @@ class RateLimitUtils {
     static initializeRateLimitConfigs() {
         const configs = new Map();
         // Configure rate limits for different providers
-        configs.set("Sensibo", {
+        configs.set(constants_1.CONNECTION_PROVIDERS.SENSIBO, {
             maxRequests: 5,
             windowMs: 60000,
-            provider: "Sensibo",
+            provider: constants_1.CONNECTION_PROVIDERS.SENSIBO,
+        });
+        configs.set(constants_1.CONNECTION_PROVIDERS.TTLOCK, {
+            maxRequests: 5,
+            windowMs: 60000,
+            provider: constants_1.CONNECTION_PROVIDERS.TTLOCK,
+        });
+        configs.set(constants_1.CONNECTION_PROVIDERS.SCHLAGE, {
+            maxRequests: 5,
+            windowMs: 60000,
+            provider: constants_1.CONNECTION_PROVIDERS.SCHLAGE,
+        });
+        configs.set(constants_1.CONNECTION_PROVIDERS.SMARTTHINGS, {
+            maxRequests: 5,
+            windowMs: 60000,
+            provider: constants_1.CONNECTION_PROVIDERS.SMARTTHINGS,
+        });
+        configs.set(constants_1.CONNECTION_PROVIDERS.YALEWIFI, {
+            maxRequests: 5,
+            windowMs: 60000,
+            provider: constants_1.CONNECTION_PROVIDERS.YALEWIFI,
+        });
+        configs.set(constants_1.CONNECTION_PROVIDERS.TUYA, {
+            maxRequests: 5,
+            windowMs: 1000,
+            provider: constants_1.CONNECTION_PROVIDERS.TUYA,
+        });
+        configs.set(constants_1.CONNECTION_PROVIDERS.SALTOKS, {
+            maxRequests: 5,
+            windowMs: 60000,
+            provider: constants_1.CONNECTION_PROVIDERS.SALTOKS,
+        });
+        configs.set(constants_1.CONNECTION_PROVIDERS.VERDANT, {
+            maxRequests: 5,
+            windowMs: 60000,
+            provider: constants_1.CONNECTION_PROVIDERS.VERDANT,
         });
         return configs;
     }

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "dt-common-device",
-  "version": "3.0.10",
+  "version": "3.0.12",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
     "patch": "npm version patch && npm run build && npm publish",

package/.eslintrc.js

@@ -1,44 +0,0 @@
-module.exports = {
-  parser: "@typescript-eslint/parser",
-  extends: ["eslint:recommended", "@typescript-eslint/recommended"],
-  plugins: ["@typescript-eslint"],
-  env: {
-    node: true,
-    es2020: true,
-  },
-  parserOptions: {
-    ecmaVersion: 2020,
-    sourceType: "module",
-  },
-  rules: {
-    // Security rules
-    "no-eval": "error",
-    "no-implied-eval": "error",
-    "no-new-func": "error",
-    "no-script-url": "error",
-    "no-unsafe-finally": "error",
-
-    // TypeScript security
-    "@typescript-eslint/no-explicit-any": "warn",
-    "@typescript-eslint/no-unsafe-assignment": "warn",
-    "@typescript-eslint/no-unsafe-call": "warn",
-    "@typescript-eslint/no-unsafe-member-access": "warn",
-    "@typescript-eslint/no-unsafe-return": "warn",
-
-    // Code quality
-    "@typescript-eslint/explicit-function-return-type": "warn",
-    "@typescript-eslint/no-unused-vars": "error",
-    "@typescript-eslint/prefer-const": "error",
-    "@typescript-eslint/no-var-requires": "error",
-
-    // Error handling
-    "no-console": "warn",
-    "no-throw-literal": "error",
-
-    // Best practices
-    "prefer-const": "error",
-    "no-var": "error",
-    "object-shorthand": "error",
-  },
-  ignorePatterns: ["dist/", "node_modules/", "*.js"],
-};

package/dist/device/cloud/interface.d.ts

@@ -1,101 +0,0 @@
-import { IConnection, IConnectionConnectParams, IDevice, IDeviceAccountResponse, IDeviceCommand, ISmartthingsDeviceCommand, ICommandResponse } from "./types";
-/**
- * Class interface for device cloud operations and connection management
- */
-export interface IDeviceCloudService {
-    /**
-     * Creates a new connection for device management
-     * @param data - Connection data
-     * @param userId - User identifier
-     * @returns Promise with connection result
-     */
-    createConnection(data: IConnection, userId: string): Promise<any>;
-    /**
-     * Gets device account information for a connection
-     * @param connection - Connection object
-     * @returns Promise with device account response
-     */
-    getDeviceAccount(connection: IConnection): Promise<IDeviceAccountResponse>;
-    /**
-     * Gets all devices for a connection
-     * @param connection - Connection object
-     * @returns Promise with array of devices
-     */
-    getDevices(connection: IConnection): Promise<IDevice[]>;
-    /**
-     * Filters devices based on connection and device list
-     * @param connection - Connection object
-     * @param devices - Array of devices to filter
-     * @returns Promise with filtered devices
-     */
-    filterDevices(connection: IConnection, devices: any[]): Promise<IDevice[]>;
-    /**
-     * Connects to a device service
-     * @param connection - Connection object
-     * @param connectionConnect - Connection parameters
-     * @returns Promise with connection result
-     */
-    connect(connection: IConnection, connectionConnect: IConnectionConnectParams): Promise<any>;
-}
-/**
- * Interface for device command operations
- */
-export interface IDeviceCommandManager {
-    /**
-     * Invokes a command on a device
-     * @param command - Device command to execute
-     * @param deviceId - Device identifier
-     * @returns Promise with command response
-     */
-    invokeCommand(command: IDeviceCommand, deviceId: string): Promise<ICommandResponse>;
-}
-/**
- * Interface for SmartThings specific device command operations
- */
-export interface ISmartthingsDeviceCommandManager extends IDeviceCommandManager {
-    /**
-     * Performs device action for SmartThings
-     * @param commands - Array of SmartThings device commands
-     * @param deviceId - Device identifier
-     * @param accessToken - Access token for authentication
-     * @returns Promise with action result
-     */
-    performDeviceAction(commands: ISmartthingsDeviceCommand[], deviceId: string, accessToken: string): Promise<any>;
-    /**
-     * Gets device status for SmartThings
-     * @param deviceId - Device identifier
-     * @param accessToken - Access token for authentication
-     * @returns Promise with device status
-     */
-    getDeviceStatus(deviceId: string, accessToken: string): Promise<any>;
-    /**
-     * Gets device lock status for SmartThings
-     * @param deviceId - Device identifier
-     * @param accessToken - Access token for authentication
-     * @returns Promise with lock status
-     */
-    getDeviceLockStatus(deviceId: string, accessToken: string): Promise<any>;
-}
-/**
- * Interface for device command factory
- */
-export interface IDeviceCommandManagerFactory {
-    /**
-     * Creates a device command manager for a specific connection provider
-     * @param connectionProvider - Connection provider type
-     * @param connection - Connection object
-     * @returns Device command manager instance
-     */
-    createDeviceCommandManager(connectionProvider: string, connection: IConnection): IDeviceCommandManager;
-}
-/**
- * Interface for device command classes
- */
-export interface IDeviceCommandClass {
-    /**
-     * Creates a SmartThings device command from a generic device command
-     * @param deviceCommand - Generic device command
-     * @returns SmartThings device command
-     */
-    fromDeviceCommand(deviceCommand: IDeviceCommand): ISmartthingsDeviceCommand;
-}

package/dist/device/cloud/interface.js

@@ -1,3 +0,0 @@
-"use strict";
-// Device Cloud Class Interface for DeviceThread Common Library
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/device/cloud/interfaces/IDeviceConnectionService.d.ts

@@ -1,7 +0,0 @@
-import { IConnection, IConnectionConnectParams, IDeviceAccountResponse } from "../types";
-export interface IDeviceConnectionService {
-    createConnection(data: IConnection, userId: string): Promise<any>;
-    getDeviceAccount(connection: IConnection): Promise<IDeviceAccountResponse>;
-    getDevices(connection: IConnection): Promise<any>;
-    connect(connection: IConnection, connectionConnect: IConnectionConnectParams): Promise<any>;
-}

package/dist/device/cloud/interfaces/IDeviceConnectionService.js

@@ -1,3 +0,0 @@
-"use strict";
-// Device Cloud Class Interface for DeviceThread Common Library
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/device/cloud/interfaces/IDevicesService.d.ts

@@ -1,9 +0,0 @@
-import { IConnection } from "../types";
-export interface IDeviceService {
-    getDevices(connection: IConnection): Promise<Record<string, any>[]>;
-    getDevice(connectionId: string, deviceId: string): Promise<Record<string, any>>;
-    getStatus(connectionId: string, deviceId: string): Promise<string | null>;
-    getState(deviceId: string): Promise<Record<string, any>>;
-    getGateways(connectionId: string): Promise<any[] | null>;
-    getGatewayDetails(connectionId: string, gatewayId: string): Promise<any>;
-}

package/dist/device/cloud/services/Device.service.d.ts

@@ -1,39 +0,0 @@
-import { IDeviceService } from "../interfaces";
-import { IConnection, IDevice } from "../types";
-export declare abstract class DeviceService implements IDeviceService {
-    deviceId: string;
-    propertyId: string;
-    name: string;
-    hubId: string[];
-    deviceType: {
-        id: string;
-        type: string;
-    };
-    status: {
-        online: boolean;
-        error?: {
-            type?: string;
-            message?: string;
-        };
-        lastUpdated?: string;
-    };
-    state?: Record<string, any>;
-    metaData?: Record<string, any>;
-    zone?: {
-        id: string;
-        name: string;
-        zoneType: string;
-        parentZone?: {
-            id: string;
-            name: string;
-            zoneType: string;
-        };
-    };
-    connection: IConnection;
-    constructor(device: IDevice);
-    abstract getDevices(connection: IConnection): Promise<Record<string, any>[]>;
-    abstract getDevice(connectionId: string, deviceId: string): Promise<any>;
-    abstract getBattery(deviceId: string): Promise<number | string>;
-    abstract getStatus(connectionId: string, deviceId: string): Promise<string>;
-    abstract getState(deviceId: string): Promise<string>;
-}

package/dist/device/cloud/services/Device.service.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceService = void 0;
-class DeviceService {
-    constructor(device) {
-        Object.assign(this, device);
-    }
-}
-exports.DeviceService = DeviceService;

package/dist/device/cloud/services/DeviceCloudService.d.ts

@@ -1,42 +0,0 @@
-import { IDeviceCloudService } from "../interface";
-import { IConnection, IDevice, IDeviceAccountResponse, IConnectionConnectParams } from "../types";
-/**
- * Device Cloud Service Class
- * Implements IDeviceCloudService interface with empty implementations
- * Implementation will be provided by the consuming project
- */
-export declare class DeviceCloudService implements IDeviceCloudService {
-    /**
-     * Creates a new connection for device management
-     * @param data - Connection data
-     * @param userId - User identifier
-     * @returns Promise with connection result
-     */
-    createConnection(data: IConnection, userId: string): Promise<any>;
-    /**
-     * Gets device account information for a connection
-     * @param connection - Connection object
-     * @returns Promise with device account response
-     */
-    getDeviceAccount(connection: IConnection): Promise<IDeviceAccountResponse>;
-    /**
-     * Gets all devices for a connection
-     * @param connection - Connection object
-     * @returns Promise with array of devices
-     */
-    getDevices(connection: IConnection): Promise<IDevice[]>;
-    /**
-     * Filters devices based on connection and device list
-     * @param connection - Connection object
-     * @param devices - Array of devices to filter
-     * @returns Promise with filtered devices
-     */
-    filterDevices(connection: IConnection, devices: any[]): Promise<IDevice[]>;
-    /**
-     * Connects to a device service
-     * @param connection - Connection object
-     * @param connectionConnect - Connection parameters
-     * @returns Promise with connection result
-     */
-    connect(connection: IConnection, connectionConnect: IConnectionConnectParams): Promise<any>;
-}