dt-common-device 7.6.6 → 7.6.9

package/dist/pms/webhookQueue/services/WebhookQueueService.js

@@ -0,0 +1,274 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookQueueService = void 0;
+const bullmq_1 = require("bullmq");
+const ioredis_1 = require("ioredis");
+const typedi_1 = require("typedi");
+const WebhookWorker_1 = require("./WebhookWorker");
+let WebhookQueueService = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var WebhookQueueService = _classThis = class {
+        constructor(config) {
+            this.webhookQueues = new Map();
+            this.workers = new Map();
+            this.config = {
+                maxRetries: 3,
+                backoffDelay: 2000,
+                jobTimeout: 300000, // 5 minutes
+                removeOnComplete: { age: 3600000, count: 100 }, // 1 hour, max 100
+                removeOnFail: { age: 7200000, count: 50 }, // 2 hours, max 50
+                ...config,
+            };
+            this.redisConnection = new ioredis_1.Redis({
+                host: this.config.redisHost,
+                port: this.config.redisPort,
+                maxRetriesPerRequest: null,
+                enableReadyCheck: false,
+            });
+        }
+        async addWebhookToQueue(propertyId, pmsType, webhookData, options = {}) {
+            const queueName = this.getQueueName(propertyId, pmsType);
+            const queue = await this.getOrCreateQueue(queueName);
+            const jobData = {
+                propertyId,
+                pmsType,
+                webhookData,
+                timestamp: new Date().toISOString(),
+                retryCount: 0,
+            };
+            const jobOptions = {
+                priority: options.priority || 1,
+                delay: options.delay || 0,
+                attempts: options.attempts || this.config.maxRetries,
+                backoff: options.backoff || {
+                    type: "exponential",
+                    delay: this.config.backoffDelay,
+                },
+                removeOnComplete: this.config.removeOnComplete,
+                removeOnFail: this.config.removeOnFail,
+                timeout: this.config.jobTimeout,
+            };
+            const job = await queue.add("process_webhook", jobData, jobOptions);
+            return job.id;
+        }
+        async getQueueStatus(propertyId, pmsType) {
+            const queueName = this.getQueueName(propertyId, pmsType);
+            const queue = this.webhookQueues.get(queueName);
+            if (!queue) {
+                return {
+                    waiting: 0,
+                    active: 0,
+                    completed: 0,
+                    failed: 0,
+                    delayed: 0,
+                };
+            }
+            const [waiting, active, completed, failed, delayed] = await Promise.all([
+                queue.getWaiting(),
+                queue.getActive(),
+                queue.getCompleted(),
+                queue.getFailed(),
+                queue.getDelayed(),
+            ]);
+            return {
+                waiting: waiting.length,
+                active: active.length,
+                completed: completed.length,
+                failed: failed.length,
+                delayed: delayed.length,
+            };
+        }
+        async getAllPropertyQueueStatuses(propertyId) {
+            const pmsTypes = ["CLOUDBEDS", "HOTELKEY", "STAYNTOUCH"];
+            const statuses = {};
+            for (const pmsType of pmsTypes) {
+                statuses[pmsType] = await this.getQueueStatus(propertyId, pmsType);
+            }
+            return statuses;
+        }
+        async getQueueMetrics(propertyId, pmsType) {
+            const queueName = this.getQueueName(propertyId, pmsType);
+            const queue = this.webhookQueues.get(queueName);
+            if (!queue) {
+                return {
+                    totalProcessed: 0,
+                    totalFailed: 0,
+                    averageProcessingTime: 0,
+                    queueName,
+                };
+            }
+            const [completed, failed] = await Promise.all([
+                queue.getCompleted(),
+                queue.getFailed(),
+            ]);
+            const totalProcessed = completed.length;
+            const totalFailed = failed.length;
+            // Calculate average processing time from completed jobs
+            let totalProcessingTime = 0;
+            let processedWithTime = 0;
+            for (const job of completed) {
+                if (job.processedOn && job.timestamp) {
+                    totalProcessingTime += job.processedOn - job.timestamp;
+                    processedWithTime++;
+                }
+            }
+            const averageProcessingTime = processedWithTime > 0 ? totalProcessingTime / processedWithTime : 0;
+            const lastProcessedAt = completed.length > 0
+                ? new Date(completed[0].processedOn || 0).toISOString()
+                : undefined;
+            return {
+                totalProcessed,
+                totalFailed,
+                averageProcessingTime,
+                lastProcessedAt,
+                queueName,
+            };
+        }
+        async cleanupQueue(propertyId, pmsType) {
+            const queueName = this.getQueueName(propertyId, pmsType);
+            const queue = this.webhookQueues.get(queueName);
+            if (queue) {
+                // BullMQ v5: clean(grace, limit, type)
+                await queue.clean(3600000, 1000, "completed"); // Clean completed jobs older than 1 hour
+                await queue.clean(7200000, 1000, "failed"); // Clean failed jobs older than 2 hours
+            }
+        }
+        async pauseQueue(propertyId, pmsType) {
+            const queueName = this.getQueueName(propertyId, pmsType);
+            const queue = this.webhookQueues.get(queueName);
+            if (queue) {
+                await queue.pause();
+            }
+        }
+        async resumeQueue(propertyId, pmsType) {
+            const queueName = this.getQueueName(propertyId, pmsType);
+            const queue = this.webhookQueues.get(queueName);
+            if (queue) {
+                await queue.resume();
+            }
+        }
+        async getActiveQueues() {
+            return Array.from(this.webhookQueues.keys());
+        }
+        async shutdown() {
+            // Stop all workers
+            for (const worker of this.workers.values()) {
+                await worker.stopProcessing();
+            }
+            // Close all queues
+            for (const queue of this.webhookQueues.values()) {
+                await queue.close();
+            }
+            // Close Redis connection
+            await this.redisConnection.quit();
+            this.webhookQueues.clear();
+            this.workers.clear();
+        }
+        async queueExists(propertyId, pmsType) {
+            const queueName = this.getQueueName(propertyId, pmsType);
+            return this.webhookQueues.has(queueName);
+        }
+        async getQueueConfig(propertyId, pmsType) {
+            const queueName = this.getQueueName(propertyId, pmsType);
+            const queue = this.webhookQueues.get(queueName);
+            if (!queue) {
+                return null;
+            }
+            return {
+                name: queue.name,
+                client: queue.client,
+                opts: queue.opts,
+            };
+        }
+        async updateQueueConfig(propertyId, pmsType, config) {
+            // Note: BullMQ doesn't support runtime config updates
+            // This would require recreating the queue
+            throw new Error("Queue configuration updates not supported at runtime");
+        }
+        /**
+         * Set webhook processor function for a specific queue
+         */
+        async setWebhookProcessor(propertyId, pmsType, processor) {
+            const queueName = this.getQueueName(propertyId, pmsType);
+            let worker = this.workers.get(queueName);
+            if (!worker) {
+                worker = new WebhookWorker_1.WebhookWorker(this.redisConnection);
+                this.workers.set(queueName, worker);
+            }
+            worker.setWebhookProcessor(processor);
+            await worker.startProcessing(queueName);
+        }
+        getQueueName(propertyId, pmsType) {
+            return `${propertyId}_${pmsType}_webhook`;
+        }
+        async getOrCreateQueue(queueName) {
+            if (!this.webhookQueues.has(queueName)) {
+                const queue = new bullmq_1.Queue(queueName, {
+                    connection: this.redisConnection,
+                    defaultJobOptions: {
+                        removeOnComplete: this.config.removeOnComplete,
+                        removeOnFail: this.config.removeOnFail,
+                        attempts: this.config.maxRetries,
+                        backoff: {
+                            type: "exponential",
+                            delay: this.config.backoffDelay,
+                        },
+                    },
+                });
+                this.webhookQueues.set(queueName, queue);
+            }
+            return this.webhookQueues.get(queueName);
+        }
+    };
+    __setFunctionName(_classThis, "WebhookQueueService");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        WebhookQueueService = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return WebhookQueueService = _classThis;
+})();
+exports.WebhookQueueService = WebhookQueueService;

package/dist/pms/webhookQueue/services/WebhookWorker.d.ts

@@ -0,0 +1,37 @@
+import { Worker } from "bullmq";
+import { Redis } from "ioredis";
+import { IWebhookWorker } from "../interfaces";
+import { IWebhookJobData, IWebhookProcessingResult } from "../types/webhook.types";
+export declare class WebhookWorker implements IWebhookWorker {
+    private worker;
+    private webhookProcessor;
+    private redisConnection;
+    private isRunning;
+    private processedJobs;
+    private failedJobs;
+    private lastProcessedAt?;
+    constructor(redisConnection: Redis);
+    startProcessing(queueName: string): Promise<void>;
+    stopProcessing(): Promise<void>;
+    processWebhookJob(jobData: IWebhookJobData): Promise<IWebhookProcessingResult>;
+    handleError(error: Error, jobData: IWebhookJobData): Promise<void>;
+    getWorkerStatus(): Promise<{
+        isRunning: boolean;
+        processedJobs: number;
+        failedJobs: number;
+        lastProcessedAt?: string;
+    }>;
+    setWebhookProcessor(processor: (webhookData: any, pmsType: string) => Promise<any>): void;
+    /**
+     * Get the underlying BullMQ worker instance
+     */
+    getWorker(): Worker | null;
+    /**
+     * Check if the worker is currently processing
+     */
+    isWorkerRunning(): boolean;
+    /**
+     * Reset worker statistics
+     */
+    resetStats(): void;
+}

package/dist/pms/webhookQueue/services/WebhookWorker.js

@@ -0,0 +1,201 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookWorker = void 0;
+const bullmq_1 = require("bullmq");
+const typedi_1 = require("typedi");
+let WebhookWorker = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var WebhookWorker = _classThis = class {
+        constructor(redisConnection) {
+            this.worker = null;
+            this.webhookProcessor = null;
+            this.isRunning = false;
+            this.processedJobs = 0;
+            this.failedJobs = 0;
+            this.redisConnection = redisConnection;
+        }
+        async startProcessing(queueName) {
+            if (this.isRunning) {
+                return;
+            }
+            this.worker = new bullmq_1.Worker(queueName, async (job) => {
+                try {
+                    const startTime = Date.now();
+                    const result = await this.processWebhookJob(job.data);
+                    const processingTime = Date.now() - startTime;
+                    this.processedJobs++;
+                    this.lastProcessedAt = new Date().toISOString();
+                    return {
+                        ...result,
+                        processingTime,
+                    };
+                }
+                catch (error) {
+                    this.failedJobs++;
+                    await this.handleError(error, job.data);
+                    throw error;
+                }
+            }, {
+                connection: this.redisConnection,
+                lockDuration: 300000, // 5 minutes lock duration
+                stalledInterval: 60000, // 1 minute stall check interval
+                concurrency: 1, // Process one webhook at a time per queue
+            });
+            // Set up event handlers
+            this.worker.on("completed", (job) => {
+                console.log(`[Webhook Worker] Job ${job.id} completed successfully for queue ${queueName}`);
+            });
+            this.worker.on("failed", (job, err) => {
+                if (job) {
+                    console.error(`[Webhook Worker] Job ${job.id} failed for queue ${queueName} with error: ${err.message}`);
+                }
+                else {
+                    console.error(`[Webhook Worker] Unknown job failed for queue ${queueName} with error: ${err.message}`);
+                }
+            });
+            this.worker.on("error", (err) => {
+                console.error(`[Webhook Worker] Worker error for queue ${queueName}:`, err);
+            });
+            this.worker.on("stalled", (jobId) => {
+                console.warn(`[Webhook Worker] Job ${jobId} stalled in queue ${queueName}`);
+            });
+            this.isRunning = true;
+            console.log(`[Webhook Worker] Started processing queue: ${queueName}`);
+        }
+        async stopProcessing() {
+            if (!this.isRunning || !this.worker) {
+                return;
+            }
+            await this.worker.close();
+            this.worker = null;
+            this.isRunning = false;
+            console.log("[Webhook Worker] Stopped processing");
+        }
+        async processWebhookJob(jobData) {
+            if (!this.webhookProcessor) {
+                throw new Error("Webhook processor not set");
+            }
+            try {
+                const startTime = Date.now();
+                // Process the webhook using the provided processor function
+                await this.webhookProcessor(jobData.webhookData, jobData.pmsType);
+                const processingTime = Date.now() - startTime;
+                return {
+                    success: true,
+                    propertyId: jobData.propertyId,
+                    pmsType: jobData.pmsType,
+                    timestamp: jobData.timestamp,
+                    processingTime,
+                };
+            }
+            catch (error) {
+                const processingTime = Date.now() - Date.parse(jobData.timestamp);
+                return {
+                    success: false,
+                    propertyId: jobData.propertyId,
+                    pmsType: jobData.pmsType,
+                    timestamp: jobData.timestamp,
+                    error: error.message,
+                    processingTime,
+                };
+            }
+        }
+        async handleError(error, jobData) {
+            console.error(`[Webhook Worker] Error processing webhook for property: ${jobData.propertyId}, PMS: ${jobData.pmsType}:`, error);
+            // Log additional context
+            console.error(`[Webhook Worker] Job data:`, {
+                propertyId: jobData.propertyId,
+                pmsType: jobData.pmsType,
+                timestamp: jobData.timestamp,
+                retryCount: jobData.retryCount,
+            });
+            // You can add additional error handling here:
+            // - Send to error monitoring service
+            // - Create error tickets
+            // - Notify administrators
+            // - Log to external logging service
+        }
+        async getWorkerStatus() {
+            return {
+                isRunning: this.isRunning,
+                processedJobs: this.processedJobs,
+                failedJobs: this.failedJobs,
+                lastProcessedAt: this.lastProcessedAt,
+            };
+        }
+        setWebhookProcessor(processor) {
+            this.webhookProcessor = processor;
+        }
+        /**
+         * Get the underlying BullMQ worker instance
+         */
+        getWorker() {
+            return this.worker;
+        }
+        /**
+         * Check if the worker is currently processing
+         */
+        isWorkerRunning() {
+            return this.isRunning && this.worker !== null;
+        }
+        /**
+         * Reset worker statistics
+         */
+        resetStats() {
+            this.processedJobs = 0;
+            this.failedJobs = 0;
+            this.lastProcessedAt = undefined;
+        }
+    };
+    __setFunctionName(_classThis, "WebhookWorker");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        WebhookWorker = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return WebhookWorker = _classThis;
+})();
+exports.WebhookWorker = WebhookWorker;

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

@@ -0,0 +1,4 @@
+export * from "./WebhookQueueFactory";
+export * from "./WebhookQueueIntegration";
+export * from "./WebhookQueueService";
+export * from "./WebhookWorker";

package/dist/pms/webhookQueue/services/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./WebhookQueueFactory"), exports);
+__exportStar(require("./WebhookQueueIntegration"), exports);
+__exportStar(require("./WebhookQueueService"), exports);
+__exportStar(require("./WebhookWorker"), exports);

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

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

package/dist/pms/webhookQueue/types/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./webhook.types"), exports);

package/dist/pms/webhookQueue/types/webhook.types.d.ts

@@ -0,0 +1,60 @@
+export interface IWebhookJobData {
+    propertyId: string;
+    pmsType: string;
+    webhookData: any;
+    timestamp: string;
+    retryCount?: number;
+}
+export interface IWebhookQueueConfig {
+    redisHost: string;
+    redisPort: number;
+    maxRetries?: number;
+    backoffDelay?: number;
+    jobTimeout?: number;
+    removeOnComplete?: {
+        age: number;
+        count: number;
+    };
+    removeOnFail?: {
+        age: number;
+        count: number;
+    };
+}
+export interface IWebhookQueueStatus {
+    waiting: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed?: number;
+}
+export interface IWebhookQueueOptions {
+    priority?: number;
+    delay?: number;
+    attempts?: number;
+    backoff?: {
+        type: "exponential" | "fixed";
+        delay: number;
+    };
+}
+export interface IWebhookProcessingResult {
+    success: boolean;
+    propertyId: string;
+    pmsType: string;
+    timestamp: string;
+    error?: string;
+    processingTime?: number;
+}
+export interface IWebhookQueueMetrics {
+    totalProcessed: number;
+    totalFailed: number;
+    averageProcessingTime: number;
+    lastProcessedAt?: string;
+    queueName: string;
+}
+export type PMS_TYPE = "CLOUDBEDS" | "HOTELKEY" | "STAYNTOUCH";
+export interface IWebhookPayload {
+    eventType?: string;
+    propertyId?: string;
+    reservationId?: string;
+    [key: string]: any;
+}

package/dist/pms/webhookQueue/types/webhook.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/property/IProperty.d.ts

@@ -0,0 +1,29 @@
+export interface IProperty {
+    id: string;
+    name: string;
+    apartment: string;
+    city: string;
+    country: string;
+    state: string;
+    street: string;
+    zipCode: string;
+    createdBy?: string;
+    isDeleted: boolean;
+    imageURL: string;
+    timezone: string;
+    officialName?: string;
+    sameAsOfficialName?: boolean;
+    phoneNumber?: string;
+    phoneNumberCountryCode?: string;
+    propertyKey?: string;
+    hubNetworkId?: string;
+    isTimeZoneOverridden: boolean;
+    createdAt: string;
+    updatedAt: string;
+    propertyBillingId?: string;
+}
+export interface IPropertySettings {
+    id: string;
+    propertyId: string;
+    settings: Record<string, any>;
+}

package/dist/property/IProperty.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/property/Property.repository.d.ts

@@ -0,0 +1,8 @@
+import { IProperty, IPropertySettings } from "./IProperty";
+export declare class PropertyRepository {
+    private readonly postgres;
+    constructor();
+    getPropertyPreferences(propertyId: string, keys?: string[]): Promise<IPropertySettings | null>;
+    getProperty(propertyId: string): Promise<IProperty | null>;
+    getAllProperties(): Promise<any[]>;
+}