dt-common-device 3.0.10 → 3.0.12

package/dist/audit/AuditProperties.d.ts

@@ -0,0 +1,16 @@
+export interface AuditProperties {
+    resource: string;
+    propertyId: string;
+    propertyName?: string;
+    userId?: string;
+    userName?: string;
+    deviceId: string;
+    deviceName: string;
+    zoneId?: string;
+    zoneName?: string;
+    accessGroupId?: string;
+    accessGroupName?: string;
+    scheduleId?: string;
+    scheduleName?: string;
+    [key: string]: any;
+}

package/dist/audit/AuditUtils.d.ts

@@ -0,0 +1,2 @@
+import { AuditProperties } from "./AuditProperties";
+export declare function buildAuditProperties(input: AuditProperties): Record<string, any>;

package/dist/audit/AuditUtils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAuditProperties = buildAuditProperties;
+const AUDIT_FIELDS = [
+    "resource",
+    "propertyId",
+    "propertyName",
+    "userId",
+    "userName",
+    "deviceId",
+    "deviceName",
+    "zoneId",
+    "zoneName",
+    "accessGroupId",
+    "accessGroupName",
+    "scheduleId",
+    "scheduleName",
+];
+function buildAuditProperties(input) {
+    // Normalize keys to camelCase for matching
+    const normalized = { ...input };
+    // Build the audit object with all standard fields
+    const audit = {};
+    for (const field of AUDIT_FIELDS) {
+        // Try to find a matching key in input (case-insensitive)
+        const foundKey = Object.keys(normalized).find((k) => k.toLowerCase() === field.toLowerCase());
+        audit[field] = foundKey ? normalized[foundKey] : undefined;
+    }
+    // Merge in all other event-specific data (but don't overwrite audit fields)
+    for (const key of Object.keys(normalized)) {
+        if (!audit.hasOwnProperty(key)) {
+            audit[key] = normalized[key];
+        }
+    }
+    return audit;
+}

package/dist/config/config.d.ts

@@ -1,8 +1,7 @@
 import { InternalEventSubscription } from "../events";
-import { IConfig, ILogger } from "./config.types";
+import { IConfig } from "./config.types";
 export declare function initialize(cfg: IConfig): Promise<void>;
 export declare function getConfig(): IConfig;
-export declare function getLogger(): ILogger;
 export declare function getEventSubscription(): InternalEventSubscription | null;
 export declare function checkRequiredEnv(): void;
 export declare function ensureAuditInitialized(): void;

package/dist/config/config.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initialize = initialize;
 exports.getConfig = getConfig;
-exports.getLogger = getLogger;
 exports.getEventSubscription = getEventSubscription;
 exports.checkRequiredEnv = checkRequiredEnv;
 exports.ensureAuditInitialized = ensureAuditInitialized;
@@ -83,10 +82,6 @@ function getConfig() {
     }
     return config;
 }
-// Direct logger export for easier usage
-function getLogger() {
-    return getConfig().LOGGER;
-}
 function getEventSubscription() {
     return eventSubscription;
 }
@@ -120,6 +115,10 @@ function ensureAuditInitialized() {
     (0, dt_audit_library_1.initializeAudit)(apiKey, host);
     auditInitialized = true;
 }
+// // Direct logger export for easier usage
+// export function getLogger(): ILogger {
+//   return getConfig().LOGGER;
+// }
 /**
  * Returns the PostgreSQL DB URI from environment variables.
  * Throws an error if not set.

package/dist/constants/Service.d.ts

@@ -5,6 +5,7 @@ export declare const SERVICE_NAMES: {
     readonly SCHEDULE: "smart-schedule";
     readonly DEVICE: "smart-device";
 };
+export type SERVICE_NAME = typeof SERVICE_NAMES[keyof typeof SERVICE_NAMES];
 export declare enum Source {
     USER = "user",
     CLOUD_EVENT = "cloud-event",

package/dist/device/local/events/EventHandler.js

@@ -9,9 +9,9 @@ class EventHandler {
         this.source = "dt-common-device";
     }
     async onDeviceCreate(body) {
-        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.CREATED, body, this.source);
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS, body, this.source);
         const payload = {
-            eventType: Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.CREATED,
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
             properties: {
                 ...body,
             },
@@ -19,9 +19,9 @@ class EventHandler {
         await (0, dt_audit_library_1.publishAudit)(payload);
     }
     async onDeviceUpdate(deviceId, body) {
-        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.UPDATED, { deviceId, body }, this.source);
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS, { deviceId, body }, this.source);
         const payload = {
-            eventType: Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.UPDATED,
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
             properties: {
                 ...body,
             },
@@ -29,9 +29,9 @@ class EventHandler {
         await (0, dt_audit_library_1.publishAudit)(payload);
     }
     async onDeviceDelete(deviceId) {
-        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.DELETED, { deviceId }, this.source);
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Events_1.DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS, { deviceId }, this.source);
         const payload = {
-            eventType: Events_1.DT_EVENT_TYPES.DEVICE.DEVICE.DELETED,
+            eventType: Events_1.DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
             properties: {
                 deviceId,
             },

package/dist/device/local/events/Events.d.ts

@@ -1,9 +1,16 @@
 export declare const DT_EVENT_TYPES: {
     DEVICE: {
-        DEVICE: {
-            CREATED: string;
-            UPDATED: string;
-            DELETED: string;
+        CREATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        UPDATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        DELETE: {
+            SUCCESS: string;
+            FAILED: string;
         };
         STATE: {
             SET: string;
@@ -34,17 +41,31 @@ export declare const DT_EVENT_TYPES: {
         };
     };
     CONNECTION: {
-        CONNECTION: {
-            CREATED: string;
-            UPDATED: string;
-            DELETED: string;
+        CREATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        UPDATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        DELETE: {
+            SUCCESS: string;
+            FAILED: string;
         };
     };
     PROPERTY: {
-        PROPERTY: {
-            CREATED: string;
-            UPDATED: string;
-            DELETED: string;
+        CREATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        UPDATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        DELETE: {
+            SUCCESS: string;
+            FAILED: string;
         };
         PREFERENCES: {
             UPDATED: string;

package/dist/device/local/events/Events.js

@@ -3,10 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DT_EVENT_TYPES = void 0;
 exports.DT_EVENT_TYPES = {
     DEVICE: {
-        DEVICE: {
-            CREATED: "device.device.created",
-            UPDATED: "device.device.updated",
-            DELETED: "device.device.deleted",
+        CREATE: {
+            SUCCESS: "device.create.success",
+            FAILED: "device.create.failed",
+        },
+        UPDATE: {
+            SUCCESS: "device.update.success",
+            FAILED: "device.update.failed",
+        },
+        DELETE: {
+            SUCCESS: "device.delete.success",
+            FAILED: "device.delete.failed",
         },
         STATE: {
             SET: "device.state.set",
@@ -37,17 +44,31 @@ exports.DT_EVENT_TYPES = {
         },
     },
     CONNECTION: {
-        CONNECTION: {
-            CREATED: "connection.connection.created",
-            UPDATED: "connection.connection.updated",
-            DELETED: "connection.connection.deleted",
+        CREATE: {
+            SUCCESS: "connection.create.success",
+            FAILED: "connection.create.failed",
+        },
+        UPDATE: {
+            SUCCESS: "connection.update.success",
+            FAILED: "connection.update.failed",
+        },
+        DELETE: {
+            SUCCESS: "connection.delete.success",
+            FAILED: "connection.delete.failed",
         },
     },
     PROPERTY: {
-        PROPERTY: {
-            CREATED: "property.property.created",
-            UPDATED: "property.property.updated",
-            DELETED: "property.property.deleted",
+        CREATE: {
+            SUCCESS: "property.create.success",
+            FAILED: "property.create.failed",
+        },
+        UPDATE: {
+            SUCCESS: "property.update.success",
+            FAILED: "property.update.failed",
+        },
+        DELETE: {
+            SUCCESS: "property.delete.success",
+            FAILED: "property.delete.failed",
         },
         PREFERENCES: {
             UPDATED: "property.preferences.updated",

package/dist/device/local/repository/Schedule.repository.d.ts

@@ -1,7 +1,6 @@
 import { ISchedule } from "../interfaces/ISchedule";
 export declare class ScheduleRepository {
     private readonly axiosInstance;
-    private readonly logger;
     constructor();
     getSchedule(scheduleId: string): Promise<any>;
     getScheduleByZone(zoneId: string): Promise<any>;

package/dist/device/local/repository/Schedule.repository.js

@@ -40,16 +40,16 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduleRepository = void 0;
 const typedi_1 = require("typedi");
-const config_1 = require("../../../config/config");
 const http_utils_1 = require("../../../utils/http.utils");
+const config_1 = require("../../../config/config");
 let ScheduleRepository = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
     var ScheduleRepository = _classThis = class {
+        // private readonly logger = getLogger();
         constructor() {
-            this.logger = (0, config_1.getLogger)();
             this.axiosInstance = (0, http_utils_1.getDeviceServiceAxiosInstance)();
         }
         async getSchedule(scheduleId) {
@@ -58,7 +58,7 @@ let ScheduleRepository = (() => {
                 return response.data;
             }
             catch (error) {
-                this.logger.error(`Failed to get schedule ${scheduleId}:`, error);
+                (0, config_1.getConfig)().LOGGER.error(`Failed to get schedule ${scheduleId}:`, error);
                 const errorMessage = error.response?.data?.message || error.message || "Unknown error";
                 throw new Error(`Failed to get schedule: ${errorMessage}`);
             }
@@ -69,7 +69,7 @@ let ScheduleRepository = (() => {
                 return response.data;
             }
             catch (error) {
-                this.logger.error(`Failed to get schedule by zone ${zoneId}:`, error);
+                (0, config_1.getConfig)().LOGGER.error(`Failed to get schedule by zone ${zoneId}:`, error);
                 const errorMessage = error.response?.data?.message || error.message || "Unknown error";
                 throw new Error(`Failed to get schedule: ${errorMessage}`);
             }
@@ -80,7 +80,7 @@ let ScheduleRepository = (() => {
                 return response.data;
             }
             catch (error) {
-                this.logger.error(`Failed to update schedule ${scheduleId}:`, error);
+                (0, config_1.getConfig)().LOGGER.error(`Failed to update schedule ${scheduleId}:`, error);
                 const errorMessage = error.response?.data?.message || error.message || "Unknown error";
                 throw new Error(`Failed to update schedule: ${errorMessage}`);
             }
@@ -91,7 +91,7 @@ let ScheduleRepository = (() => {
                 return response.data;
             }
             catch (error) {
-                this.logger.error(`Failed to delete schedule from DB ${scheduleId}:`, error);
+                (0, config_1.getConfig)().LOGGER.error(`Failed to delete schedule from DB ${scheduleId}:`, error);
                 throw new Error(`Failed to delete schedule from DB: ${error.message}`);
             }
         }

package/dist/queue/entities/HybridHttpQueue.d.ts

@@ -1,25 +1,15 @@
 import { HttpCallOption } from "../types/http.types";
 import { IQueueResponse } from "../interfaces";
+import { RequestQueueOptions } from "../types/queue.types";
 export declare class HybridHttpQueue {
+    private readonly rateLimitConfigs;
     private readonly queues;
     private readonly workers;
-    private readonly rateLimitConfigs;
     private readonly jobResults;
     constructor();
-    private handleRateLimitAndQueue;
+    private addToQueue;
     private processHttpRequest;
-    request(options: {
-        method: string;
-        url: string;
-        body?: any;
-        params?: Record<string, any>;
-        headers?: Record<string, string>;
-        queueOptions?: {
-            connectionId: string;
-            connectionProvider: string;
-            microservice: string;
-        };
-    }): Promise<IQueueResponse>;
+    request(options: RequestQueueOptions): Promise<any>;
     handleRequest(url: string, method: string, options: HttpCallOption): Promise<IQueueResponse>;
     shutdown(): Promise<void>;
 }

package/dist/queue/entities/HybridHttpQueue.js

@@ -37,18 +37,13 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HybridHttpQueue = void 0;
-const config_1 = require("../../config/config");
-const axios_1 = __importDefault(require("axios"));
-const dt_audit_library_1 = require("dt-audit-library");
 const typedi_1 = require("typedi");
 const rateLimit_utils_1 = require("../utils/rateLimit.utils");
 const jobUtils_1 = require("../utils/jobUtils");
 const queueUtils_1 = require("../utils/queueUtils");
+const config_1 = require("../../config/config");
 let HybridHttpQueue = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
@@ -56,13 +51,15 @@ let HybridHttpQueue = (() => {
     let _classThis;
     var HybridHttpQueue = _classThis = class {
         constructor() {
+            // BullMQ queues and workers for persistent storage
             this.queues = new Map();
             this.workers = new Map();
             this.jobResults = new Map();
             this.rateLimitConfigs = rateLimit_utils_1.RateLimitUtils.initializeRateLimitConfigs();
         }
-        async handleRateLimitAndQueue(url, method, options) {
-            const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
+        async addToQueue(connectionId, provider, url, method, options) {
+            const queueKey = queueUtils_1.QueueUtils.getQueueKey(options.queueOptions?.microservice, connectionId, provider);
+            // Calculate delay based on rate limit window
             const key = `rate_limit:${provider}:${connectionId}`;
             const config = this.rateLimitConfigs.get(provider);
             const windowMs = config?.windowMs ?? 60000;
@@ -70,11 +67,14 @@ let HybridHttpQueue = (() => {
             const now = Date.now();
             const windowStart = now - windowMs;
             const recentRequests = timestamps.filter((t) => t > windowStart);
-            const nextAvailableTime = recentRequests.length > 0 ? recentRequests[0] + windowMs : now + 1000;
-            const delay = Math.max(nextAvailableTime - now, 1000); // at least 1s delay
+            let delay = 0;
+            if (recentRequests.length >= (config?.maxRequests ?? 5)) {
+                const earliestRequest = recentRequests[0];
+                const nextAvailableTime = earliestRequest + windowMs;
+                delay = Math.max(nextAvailableTime - now, 1000); // At least 1s delay
+            }
             // Create job data
             const jobData = {
-                microservice,
                 connectionId,
                 provider,
                 url,
@@ -82,78 +82,25 @@ let HybridHttpQueue = (() => {
                 options,
                 timestamp: Date.now(),
             };
-            // Add job to queue with delay (background processing)
-            const queueKey = queueUtils_1.QueueUtils.getQueueKey(microservice, connectionId, provider);
-            const queue = queueUtils_1.QueueUtils.getOrCreateQueue(queueKey, this.queues);
+            // Add job to BullMQ queue with delay
+            const jobId = await queueUtils_1.QueueUtils.addJobToQueue(queueKey, jobData, delay, this.queues);
+            // Initialize worker if not exists
             queueUtils_1.QueueUtils.getOrCreateWorker(queueKey, this.workers, this.processHttpRequest.bind(this), this.jobResults);
-            const job = await queue.add("http-request", jobData, {
-                delay,
-                attempts: 1,
-                removeOnComplete: { age: 300, count: 1 },
-                removeOnFail: { age: 300, count: 1 },
-            });
-            await (0, dt_audit_library_1.publishAudit)({
-                eventType: "http.request.rateLimitQueued",
-                properties: {
-                    resource: microservice,
-                    connectionId,
-                    provider,
-                    endpoint: url,
-                    method,
-                    timestamp: Date.now(),
-                    queueId: job.id,
-                    reason: "rate_limit_exceeded_queued",
-                    delay,
-                    estimatedProcessingTime: now + delay,
-                },
-            });
-            // Return immediate response to controller
-            return {
-                success: true,
-                queued: true,
-                estimatedProcessingTime: now + delay,
-                jobId: job.id,
-            };
+            (0, config_1.getConfig)().LOGGER.info(`Request queued: ${method} ${url} -> ${provider} [${connectionId}]. Job ID: ${jobId}, Delay: ${delay}ms`);
+            // Wait for job completion and return result
+            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, this.jobResults);
         }
         async processHttpRequest(job) {
             const { connectionId, provider, url, method, options } = job.data;
+            // Check rate limit before processing
             const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
             if (!allowed) {
-                // This shouldn't happen since we check before queuing, but handle it gracefully
-                (0, config_1.getConfig)().LOGGER.warn(`Job ${job.id} still rate limited after delay, skipping`);
-                return;
-            }
-            await rateLimit_utils_1.RateLimitUtils.recordRequest(connectionId, provider);
-            try {
-                (0, config_1.getConfig)().LOGGER.info(`Executing HTTP request: ${method} ${url} for ${provider}`);
-                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}`);
-                return response.data;
-            }
-            catch (error) {
-                (0, config_1.getConfig)().LOGGER.error(`HTTP request failed ${job.id}: ${error.message}`);
-                await (0, dt_audit_library_1.publishAudit)({
-                    eventType: "http.request.error",
-                    properties: {
-                        connectionId,
-                        provider,
-                        endpoint: url,
-                        method,
-                        timestamp: Date.now(),
-                        queueId: job.id,
-                        reason: "execution_error",
-                        errorMessage: error.message,
-                    },
-                });
-                throw new Error(`HTTP request failed: ${error.message}`);
+                // This shouldn't happen since we calculate delay, but handle it gracefully
+                (0, config_1.getConfig)().LOGGER.warn(`Job ${job.id} still rate limited after delay, waiting for window to expire...`);
+                await queueUtils_1.QueueUtils.waitForRateLimitExpiry(connectionId, provider, this.rateLimitConfigs);
             }
+            // Execute the HTTP request
+            return queueUtils_1.QueueUtils.executeHttpRequest(url, method, options, connectionId, provider);
         }
         async request(options) {
             const { method, url, body, params, headers, queueOptions } = options;
@@ -171,50 +118,15 @@ let HybridHttpQueue = (() => {
             const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
             // Check rate limit first
             const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
-            if (!allowed) {
-                // Rate limited - queue the request and return immediate response
-                return this.handleRateLimitAndQueue(url, method, options);
-            }
-            // Not rate limited - process immediately
-            (0, config_1.getConfig)().LOGGER.info(`Processing immediately: ${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}`);
-                return {
-                    success: true,
-                    data: response.data,
-                    queued: false,
-                };
+            if (allowed) {
+                // Rate limit not exceeded - execute immediately
+                (0, config_1.getConfig)().LOGGER.info(`Rate limit not exceeded: ${method} ${url} -> ${provider} [${connectionId}], executing immediately`);
+                return queueUtils_1.QueueUtils.executeHttpRequest(url, method, options, connectionId, provider);
             }
-            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,
-                    },
-                });
-                return {
-                    success: false,
-                    error: `HTTP request failed: ${error.message}`,
-                    queued: false,
-                };
+            else {
+                // Rate limit exceeded - add to BullMQ queue
+                (0, config_1.getConfig)().LOGGER.info(`Rate limit exceeded: ${method} ${url} -> ${provider} [${connectionId}], adding to BullMQ queue`);
+                return this.addToQueue(connectionId, provider, url, method, options);
             }
         }
         async shutdown() {

package/dist/queue/interfaces/IHybridHttpQueue.d.ts

@@ -1,18 +1,8 @@
 import { HttpCallOption } from "../types/http.types";
 import { IQueueResponse } from "./IJobResult";
+import { RequestQueueOptions } from "../types/queue.types";
 export interface IHybridHttpQueue {
-    request(options: {
-        method: string;
-        url: string;
-        body?: any;
-        params?: Record<string, any>;
-        headers?: Record<string, string>;
-        queueOptions?: {
-            connectionId: string;
-            connectionProvider: string;
-            microservice: string;
-        };
-    }): Promise<IQueueResponse>;
+    request(options: RequestQueueOptions): Promise<IQueueResponse>;
     handleRequest(url: string, method: string, options: HttpCallOption): Promise<IQueueResponse>;
     shutdown(): Promise<void>;
 }

package/dist/queue/interfaces/IJobResult.d.ts

@@ -4,11 +4,4 @@ export interface IJobResult {
     resolved: boolean;
     timestamp: number;
 }
-export interface IQueueResponse {
-    success: boolean;
-    data?: any;
-    error?: string;
-    queued?: boolean;
-    estimatedProcessingTime?: number;
-    jobId?: string;
-}
+export type IQueueResponse = any;

package/dist/queue/interfaces/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./IHybridHttpQueue";
-export * from "./IHttpRequestJob";
 export * from "./IJobResult";
 export * from "./IRateLimitConfig";

package/dist/queue/interfaces/index.js

@@ -15,6 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./IHybridHttpQueue"), exports);
-__exportStar(require("./IHttpRequestJob"), exports);
 __exportStar(require("./IJobResult"), exports);
 __exportStar(require("./IRateLimitConfig"), exports);

package/dist/queue/services/QueueService.d.ts

@@ -1,20 +1,10 @@
 import { IHybridHttpQueue, IQueueResponse } from "../interfaces";
 import { HttpCallOption } from "../types/http.types";
+import { RequestQueueOptions } from "../types/queue.types";
 export declare class QueueService implements IHybridHttpQueue {
     private readonly hybridQueue;
     constructor();
-    request(options: {
-        method: string;
-        url: string;
-        body?: any;
-        params?: Record<string, any>;
-        headers?: Record<string, string>;
-        queueOptions?: {
-            connectionId: string;
-            connectionProvider: string;
-            microservice: string;
-        };
-    }): Promise<IQueueResponse>;
+    request(options: RequestQueueOptions): Promise<IQueueResponse>;
     handleRequest(url: string, method: string, options: HttpCallOption): Promise<IQueueResponse>;
     shutdown(): Promise<void>;
 }