dt-common-device 13.1.3 → 13.1.4

package/dist/issues/IssueBuilder.example.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBasicIssue = createBasicIssue;
+exports.createDeviceIssue = createDeviceIssue;
+exports.createSecurityIssue = createSecurityIssue;
+exports.createEnergyIssue = createEnergyIssue;
+exports.createHubIssue = createHubIssue;
+exports.createUserIssue = createUserIssue;
+exports.createPropertyIssue = createPropertyIssue;
+exports.createMaintenanceIssue = createMaintenanceIssue;
+exports.createUrgentIssue = createUrgentIssue;
+exports.createMultipleIssues = createMultipleIssues;
+exports.createIssueWithDueDate = createIssueWithDueDate;
+exports.createUnassignedIssue = createUnassignedIssue;
+const IssueBuilder_1 = require("./IssueBuilder");
+const issue_types_1 = require("./issue.types");
+/**
+ * Example usage of IssueBuilder
+ * This file demonstrates various ways to use the IssueBuilder pattern
+ */
+// Example 1: Basic issue creation
+function createBasicIssue() {
+    const issueData = 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"))
+        .build();
+    return issueData;
+}
+// Example 2: Using static factory methods
+function createDeviceIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createDeviceIssue("device123", "prop456")
+        .setCategory(issue_types_1.IssuesCategory.READINESS)
+        .setTitle("Device Firmware Update")
+        .setDescription("Device firmware update is available")
+        .setPriority(issue_types_1.IssuePriority.MEDIUM)
+        .setAssignedTo("admin")
+        .setCreatedBy("system")
+        .setDueDate(new Date("2024-01-20"))
+        .build();
+    return issueData;
+}
+// Example 3: Using predefined issue types
+function createSecurityIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createSecurityIssue()
+        .setPropertyId("prop789")
+        .setTitle("Security Breach Detected")
+        .setDescription("Unauthorized access attempt detected")
+        .setEntityId("user123")
+        .setEntityType(issue_types_1.EntityType.USER)
+        .setAssignedTo("security-team")
+        .setCreatedBy("security-system")
+        .setDueDate(new Date("2024-01-10"))
+        .build();
+    return issueData;
+}
+// Example 4: Creating energy issue
+function createEnergyIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createEnergyIssue()
+        .setPropertyId("prop101")
+        .setTitle("High Energy Consumption")
+        .setDescription("Energy usage is 20% above normal levels")
+        .setEntityId("zone456")
+        .setEntityType(issue_types_1.EntityType.COLLECTION)
+        .setAssignedTo("energy-manager")
+        .setCreatedBy("energy-monitor")
+        .setDueDate(new Date("2024-01-25"))
+        .build();
+    return issueData;
+}
+// Example 5: Creating hub issue
+function createHubIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createHubIssue("hub789", "prop202")
+        .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+        .setTitle("Hub Connection Lost")
+        .setDescription("Hub has lost connection to the network")
+        .setPriority(issue_types_1.IssuePriority.CRITICAL)
+        .setAssignedTo("network-admin")
+        .setCreatedBy("network-monitor")
+        .setDueDate(new Date("2024-01-05"))
+        .build();
+    return issueData;
+}
+// Example 6: Creating user-specific issue
+function createUserIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createUserIssue("user456", "prop303")
+        .setCategory(issue_types_1.IssuesCategory.SECURITY)
+        .setTitle("User Access Review Required")
+        .setDescription("User access permissions need review")
+        .setPriority(issue_types_1.IssuePriority.MEDIUM)
+        .setAssignedTo("hr-admin")
+        .setCreatedBy("access-control")
+        .setDueDate(new Date("2024-01-30"))
+        .build();
+    return issueData;
+}
+// Example 7: Creating property-specific issue
+function createPropertyIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createPropertyIssue("prop404")
+        .setCategory(issue_types_1.IssuesCategory.READINESS)
+        .setTitle("Property Maintenance Schedule")
+        .setDescription("Annual property maintenance is due")
+        .setPriority(issue_types_1.IssuePriority.LOW)
+        .setAssignedTo("property-manager")
+        .setCreatedBy("maintenance-system")
+        .setDueDate(new Date("2024-02-15"))
+        .build();
+    return issueData;
+}
+// Example 8: Creating maintenance issue
+function createMaintenanceIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createMaintenanceIssue("prop505", "device789", issue_types_1.EntityType.DEVICE)
+        .setTitle("Scheduled Device Maintenance")
+        .setDescription("Regular maintenance is scheduled for this device")
+        .setAssignedTo("technician")
+        .setCreatedBy("maintenance-scheduler")
+        .setDueDate(new Date("2024-01-12"))
+        .build();
+    return issueData;
+}
+// Example 9: Creating urgent issue
+function createUrgentIssue() {
+    const issueData = IssueBuilder_1.IssueBuilder.createUrgentIssue("prop606", "hub123", issue_types_1.EntityType.HUB)
+        .setTitle("Critical Hub Failure")
+        .setDescription("Hub is experiencing critical failures")
+        .setAssignedTo("emergency-tech")
+        .setCreatedBy("monitoring-system")
+        .setDueDate(new Date("2024-01-03"))
+        .build();
+    return issueData;
+}
+// Example 10: Reusing builder instance
+function createMultipleIssues() {
+    const builder = new IssueBuilder_1.IssueBuilder()
+        .setPropertyId("prop707")
+        .setCreatedBy("batch-processor");
+    const issue1 = builder
+        .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+        .setTitle("Device Temperature High")
+        .setDescription("Device temperature exceeds normal operating range")
+        .setEntityId("device789")
+        .setEntityType(issue_types_1.EntityType.DEVICE)
+        .setPriority(issue_types_1.IssuePriority.HIGH)
+        .setAssignedTo("tech-support")
+        .build();
+    const issue2 = builder
+        .reset()
+        .setPropertyId("prop707")
+        .setCategory(issue_types_1.IssuesCategory.ENERGY)
+        .setTitle("Low Battery Warning")
+        .setDescription("Device battery level is below 20%")
+        .setEntityId("device789")
+        .setEntityType(issue_types_1.EntityType.DEVICE)
+        .setPriority(issue_types_1.IssuePriority.MEDIUM)
+        .setAssignedTo("maintenance-team")
+        .setCreatedBy("batch-processor")
+        .build();
+    return [issue1, issue2];
+}
+// Example 11: Creating issue with due date calculation
+function createIssueWithDueDate() {
+    const dueDate = new Date();
+    dueDate.setDate(dueDate.getDate() + 7); // Due in 7 days
+    const issueData = 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)
+        .build();
+    return issueData;
+}
+// Example 12: Creating issue without assignment
+function createUnassignedIssue() {
+    const issueData = new IssueBuilder_1.IssueBuilder()
+        .setCategory(issue_types_1.IssuesCategory.OTHER)
+        .setPropertyId("prop909")
+        .setTitle("General Inquiry")
+        .setDescription("General inquiry about system functionality")
+        .setEntityType(issue_types_1.EntityType.PROPERTY)
+        .setPriority(issue_types_1.IssuePriority.LOW)
+        .setCreatedBy("user-inquiry")
+        .build();
+    return issueData;
+}

package/dist/issues/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("./issue.types").IssueDocument>;
+    /**
+     * Example 2: Using convenience methods for specific issue types
+     */
+    createSpecificIssues(): Promise<{
+        readinessIssue: import("./issue.types").IssueDocument;
+        operationsIssue: import("./issue.types").IssueDocument;
+        securityIssue: import("./issue.types").IssueDocument;
+        energyIssue: import("./issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 3: Using device-specific issue methods
+     */
+    createDeviceIssues(): Promise<{
+        deviceIssue1: import("./issue.types").IssueDocument;
+        deviceIssue2: import("./issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 4: Using hub-specific issue methods
+     */
+    createHubIssues(): Promise<{
+        hubIssue1: import("./issue.types").IssueDocument;
+        hubIssue2: import("./issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 5: Using user-specific issue methods
+     */
+    createUserIssues(): Promise<{
+        userIssue: import("./issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 6: Using maintenance and urgent issue methods
+     */
+    createMaintenanceAndUrgentIssues(): Promise<{
+        maintenanceIssue: import("./issue.types").IssueDocument;
+        urgentIssue: import("./issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 7: Using static factory methods with IssueBuilder
+     */
+    createIssuesWithStaticMethods(): Promise<{
+        issue1: import("./issue.types").IssueDocument;
+        issue2: import("./issue.types").IssueDocument;
+    }>;
+    /**
+     * Example 8: Creating multiple issues efficiently
+     */
+    createMultipleIssues(): Promise<import("./issue.types").IssueDocument[]>;
+    /**
+     * Example 9: Creating issue with due date calculation
+     */
+    createIssueWithDueDate(): Promise<import("./issue.types").IssueDocument>;
+    /**
+     * Example 10: Backward compatibility - still works with CreateIssueData
+     */
+    createIssueWithLegacyData(): Promise<import("./issue.types").IssueDocument>;
+}

package/dist/issues/IssueService.example.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueServiceExample = void 0;
+const constants_1 = require("../constants");
+const IssueBuilder_1 = require("./IssueBuilder");
+const issue_types_1 = require("./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({
+            propertyId: "prop123",
+            title: "System Maintenance Required",
+            description: "System maintenance is scheduled for tonight",
+            createdBy: "admin",
+            entityId: "system456",
+            entityType: issue_types_1.EntityType.PROPERTY,
+            assignedTo: "maintenance-team",
+            dueDate: new Date("2024-01-20"),
+            category: issue_types_1.IssuesCategory.READINESS,
+        });
+        // Create an operations issue
+        const operationsIssue = await this.issueService.createOperationsIssue({
+            propertyId: "prop123",
+            title: "Device Temperature High",
+            description: "Device temperature exceeds normal operating range",
+            createdBy: "monitor",
+            entityId: "device789",
+            entityType: issue_types_1.EntityType.DEVICE,
+            assignedTo: "tech-support",
+            dueDate: new Date("2024-01-10"),
+            category: issue_types_1.IssuesCategory.OPERATIONS,
+        });
+        // Create a security issue
+        const securityIssue = await this.issueService.createSecurityIssue({
+            propertyId: "prop123",
+            title: "Unauthorized Access Attempt",
+            description: "Multiple failed login attempts detected",
+            createdBy: "security-system",
+            entityId: "user123",
+            entityType: issue_types_1.EntityType.USER,
+            assignedTo: "security-team",
+            dueDate: new Date("2024-01-05"),
+            category: issue_types_1.IssuesCategory.SECURITY,
+        });
+        // Create an energy issue
+        const energyIssue = await this.issueService.createEnergyIssue({
+            propertyId: "prop123",
+            title: "High Energy Consumption",
+            description: "Energy usage is 20% above normal levels",
+            createdBy: "energy-monitor",
+            entityId: "zone456",
+            entityType: issue_types_1.EntityType.COLLECTION,
+            assignedTo: "energy-manager",
+            dueDate: new Date("2024-01-25"),
+            category: issue_types_1.IssuesCategory.ENERGY,
+        });
+        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({
+            entityId: "device123",
+            propertyId: "prop456",
+            title: "Device Battery Low",
+            description: "Device battery level is below 20%",
+            createdBy: constants_1.Source.CLOUD_EVENT,
+            category: issue_types_1.IssuesCategory.READINESS,
+            priority: issue_types_1.IssuePriority.MEDIUM,
+            assignedTo: "maintenance-team",
+            dueDate: new Date("2024-01-12"),
+            entityType: issue_types_1.EntityType.DEVICE,
+        });
+        // Create a device issue with custom category and priority
+        const deviceIssue2 = await this.issueService.createDeviceIssue({
+            entityId: "device789",
+            propertyId: "prop456",
+            title: "Device Firmware Update Available",
+            description: "New firmware version is available for installation",
+            createdBy: constants_1.Source.CLOUD_EVENT,
+            category: issue_types_1.IssuesCategory.READINESS,
+            priority: issue_types_1.IssuePriority.MEDIUM,
+            assignedTo: "admin",
+            dueDate: new Date("2024-01-20"),
+            entityType: issue_types_1.EntityType.DEVICE,
+        });
+        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({
+            entityId: "hub123",
+            propertyId: "prop456",
+            title: "Hub Connection Lost",
+            description: "Hub has lost connection to the network",
+            createdBy: "network-monitor",
+            category: issue_types_1.IssuesCategory.READINESS,
+            priority: issue_types_1.IssuePriority.MEDIUM,
+            assignedTo: "network-admin",
+            dueDate: new Date("2024-01-05"),
+            entityType: issue_types_1.EntityType.HUB,
+        });
+        // Create a hub issue with custom settings
+        const hubIssue2 = await this.issueService.createHubIssue({
+            entityId: "hub789",
+            propertyId: "prop456",
+            title: "Hub Maintenance Required",
+            description: "Hub requires scheduled maintenance",
+            createdBy: "maintenance-system",
+            category: issue_types_1.IssuesCategory.READINESS,
+            priority: issue_types_1.IssuePriority.LOW,
+            assignedTo: "technician",
+            dueDate: new Date("2024-01-15"),
+            entityType: issue_types_1.EntityType.HUB,
+        });
+        return { hubIssue1, hubIssue2 };
+    }
+    /**
+     * Example 5: Using user-specific issue methods
+     */
+    async createUserIssues() {
+        // Create a user issue
+        const userIssue = await this.issueService.createUserIssue({
+            entityId: "user456",
+            propertyId: "prop303",
+            title: "User Access Review Required",
+            description: "User access permissions need review",
+            createdBy: "access-control",
+            category: issue_types_1.IssuesCategory.SECURITY,
+            priority: issue_types_1.IssuePriority.MEDIUM,
+            assignedTo: "hr-admin",
+            dueDate: new Date("2024-01-30"),
+            entityType: issue_types_1.EntityType.USER,
+        });
+        return { userIssue };
+    }
+    /**
+     * Example 6: Using maintenance and urgent issue methods
+     */
+    async createMaintenanceAndUrgentIssues() {
+        // Create a maintenance issue
+        const maintenanceIssue = await this.issueService.createMaintenanceIssue({
+            propertyId: "prop505",
+            title: "Scheduled Device Maintenance",
+            description: "Regular maintenance is scheduled for this device",
+            createdBy: "maintenance-scheduler",
+            entityId: "device789",
+            entityType: issue_types_1.EntityType.DEVICE,
+            assignedTo: "technician",
+            dueDate: new Date("2024-01-12"),
+            category: issue_types_1.IssuesCategory.READINESS,
+            priority: issue_types_1.IssuePriority.MEDIUM,
+        });
+        // Create an urgent issue
+        const urgentIssue = await this.issueService.createUrgentIssue({
+            propertyId: "prop606",
+            title: "Critical Hub Failure",
+            description: "Hub is experiencing critical failures",
+            createdBy: "monitoring-system",
+            entityId: "hub123",
+            entityType: issue_types_1.EntityType.HUB,
+            assignedTo: "emergency-tech",
+            dueDate: new Date("2024-01-03"),
+            category: issue_types_1.IssuesCategory.READINESS,
+            priority: issue_types_1.IssuePriority.CRITICAL,
+        });
+        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"),
+            source: constants_1.Source.CLOUD_EVENT,
+        };
+        // This still works with the updated createIssue method
+        const issue = await this.issueService.createIssue(issueData);
+        return issue;
+    }
+}
+exports.IssueServiceExample = IssueServiceExample;

package/dist/pms/IPms.d.ts

@@ -0,0 +1,6 @@
+export declare enum PmsProvider {
+    Cloudbeds = "Cloudbeds",
+    StayNTouch = "StayNTouch",
+    HotelKey = "HotelKey",
+    Yanolja = "Yanolja"
+}

package/dist/pms/index.d.ts

@@ -0,0 +1 @@
+export * from "./webhookQueue";

package/dist/pms/webhookQueue/examples/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./pms-integration";
+export * from "./usage";

package/dist/pms/webhookQueue/examples/pms-integration.d.ts

@@ -0,0 +1,65 @@
+export declare class ExamplePmsServiceWithQueue {
+    private webhookQueueIntegration;
+    constructor();
+    /**
+     * Initialize the webhook queue system
+     */
+    initializeWebhookQueue(): Promise<void>;
+    /**
+     * Your existing webhook processing method
+     * This will be called by the queue worker
+     */
+    processWebhook(webhookData: any, pmsType: string): Promise<any>;
+    /**
+     * Modified webhook handler that queues webhooks instead of processing directly
+     */
+    handleWebhookWithQueue(webhookData: any, pmsType: string, propertyId: string): Promise<string>;
+    /**
+     * Get webhook queue status for monitoring
+     */
+    getWebhookQueueStatus(propertyId: string, pmsType: string): Promise<import("../types/webhook.types").IWebhookQueueStatus>;
+    /**
+     * Get all webhook queue statuses for a property
+     */
+    getAllWebhookQueueStatuses(propertyId: string): Promise<Record<string, import("../types/webhook.types").IWebhookQueueStatus>>;
+    /**
+     * Clean up old webhook jobs
+     */
+    cleanupWebhookQueues(propertyId: string): Promise<void>;
+    /**
+     * Shutdown webhook queue system
+     */
+    shutdownWebhookQueue(): Promise<void>;
+    private extractPropertyIdFromWebhook;
+    private simulateWebhookProcessing;
+}
+export declare class ExamplePmsController {
+    private pmsService;
+    constructor();
+    /**
+     * Initialize the service (call this when your app starts)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Modified webhook endpoint that uses the queue
+     */
+    handleWebhook(payload: any, pmsType: string): Promise<any>;
+    /**
+     * Get webhook queue status
+     */
+    getWebhookQueueStatus(propertyId: string, pmsType: string): Promise<import("../types/webhook.types").IWebhookQueueStatus>;
+    /**
+     * Get all webhook queue statuses for a property
+     */
+    getAllWebhookQueueStatuses(propertyId: string): Promise<Record<string, import("../types/webhook.types").IWebhookQueueStatus>>;
+    /**
+     * Cleanup webhook queues
+     */
+    cleanupWebhookQueues(propertyId: string): Promise<void>;
+    /**
+     * Shutdown the service
+     */
+    shutdown(): Promise<void>;
+    private extractPropertyIdFromPayload;
+}
+export declare function exampleUsage(): Promise<void>;