dt-common-device 5.1.6 → 6.0.0

package/dist/entities/pms/pms.service.js

@@ -0,0 +1,124 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.PmsService = void 0;
+const typedi_1 = __importStar(require("typedi"));
+const pms_repository_1 = require("./pms.repository");
+let PmsService = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var PmsService = _classThis = class {
+        constructor() {
+            this.pmsRepository = typedi_1.default.get(pms_repository_1.PmsRepository);
+        }
+        async getSchedule(scheduleId) {
+            if (!scheduleId) {
+                throw new Error("Schedule ID is required");
+            }
+            const schedule = await this.pmsRepository.getSchedule(scheduleId);
+            if (!schedule)
+                return null;
+            return schedule;
+        }
+        async getGuest(guestId) {
+            if (!guestId) {
+                throw new Error("Guest ID is required");
+            }
+            const guest = await this.pmsRepository.getGuest(guestId);
+            if (!guest)
+                return null;
+            return guest;
+        }
+        async getGuestId(scheduleId) {
+            if (!scheduleId) {
+                throw new Error("Schedule ID is required");
+            }
+            const guestId = await this.pmsRepository.getGuestId(scheduleId);
+            if (!guestId)
+                return null;
+            return guestId;
+        }
+    };
+    __setFunctionName(_classThis, "PmsService");
+    (() => {
+        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);
+        PmsService = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return PmsService = _classThis;
+})();
+exports.PmsService = PmsService;

package/dist/events/BaseEventHandler.d.ts

@@ -15,12 +15,12 @@ export declare abstract class BaseEventHandler implements IEventHandler {
     handleEvent(event: DeviceEvent): Promise<void>;
     beforeEvent(event: DeviceEvent): Promise<void>;
     abstract onEvent(event: DeviceEvent): Promise<void>;
-    afterEvent(event: DeviceEvent): Promise<void>;
+    afterEvent(deviceId: string, event: DeviceEvent, auditBody: IAuditProperties, actionPayload: any, eventType?: string): Promise<void>;
     /**
      * Handle multiple events - default implementation processes them sequentially
      */
     handleEvents(events: DeviceEvent[]): Promise<void>;
-    onStateChange(deviceId: string, state: Record<string, any>, event: DeviceEvent, auditProperties: IAuditProperties, eventType?: string): Promise<void>;
+    onStateChange(deviceId: string, state: Record<string, any>, auditProperties: IAuditProperties, eventType?: string): Promise<void>;
     /**
      * Check if this handler can process the given event type
      */

package/dist/events/BaseEventHandler.js

@@ -7,6 +7,9 @@ exports.BaseEventHandler = void 0;
 const config_1 = require("../config/config");
 const Device_service_1 = require("../entities/device/local/services/Device.service");
 const typedi_1 = __importDefault(require("typedi"));
+const IAuditProperties_1 = require("../audit/IAuditProperties");
+const audit_1 = require("../audit");
+const constants_1 = require("../constants");
 class BaseEventHandler {
     constructor(supportedEventTypes, priority = 100) {
         this.supportedEventTypes = supportedEventTypes;
@@ -32,19 +35,29 @@ class BaseEventHandler {
             throw error;
         }
         finally {
-            await this.afterEvent(event);
+            await this.afterEvent(event.deviceId, event, {
+                resource: IAuditProperties_1.Resource.DEVICE,
+                source: constants_1.Source.CLOUD_EVENT,
+                propertyId: event.data.propertyId || "",
+                deviceId: event.deviceId,
+            }, {}, event.eventName);
         }
     }
     async beforeEvent(event) {
         this.logger.info("[DT | CDL]:[BaseEventHandler]: Before event - Handle Before Event");
     }
-    async afterEvent(event) {
-        this.logger.info("[DT | CDL]:[BaseEventHandler]: After event - Event processing completed", {
-            eventName: event.eventName,
-            deviceId: event.deviceId,
-            handler: this.constructor.name,
+    async afterEvent(deviceId, event, auditBody, actionPayload, eventType) {
+        await (0, audit_1.pushAudit)({
+            auditType: eventType || constants_1.DT_EVENT_TYPES.DEVICE.STATE.CHANGED,
+            auditData: {
+                ...event.data,
+                ...auditBody,
+                deviceId,
+                actionPayload,
+                connectionProvider: event.connectionProvider,
+            },
         });
-        //TODO: Implement AUDIT Here!
+        this.logger.info("[DT | CDL]:[BaseEventHandler]: After event - Event processing completed");
     }
     /**
      * Handle multiple events - default implementation processes them sequentially
@@ -65,11 +78,9 @@ class BaseEventHandler {
             this.logger.error(`${this.constructor.name}: handleEvents Error`, error);
         }
     }
-    // TODO: Check AuditBody for this function
-    async onStateChange(deviceId, state, event, auditProperties, eventType) {
+    async onStateChange(deviceId, state, auditProperties, eventType) {
         try {
             await this.localDeviceService.setState(deviceId, state, auditProperties, eventType);
-            await this.afterEvent(event);
         }
         catch (error) {
             this.logger.error(`[DT | CDL]:[BaseEventHandler]: Error during state change: ${error.message || error.toString()}`);

package/dist/issues/Issue.model.d.ts

@@ -1,5 +1,5 @@
 import mongoose, { Model } from "mongoose";
-import { EntityType, IssueStatus, IssuePriority, IssueDocument as IIssueDocument, CreateIssueData, UpdateIssueData, AddCommentData } from "./issue.types";
+import { IssueDocument as IIssueDocument, CreateIssueData, UpdateIssueData, AddCommentData } from "./issue.types";
 interface IIssueMethods {
     addComment(commentData: AddCommentData): void;
     updateComment(commentId: string, content: string, userId: string): boolean;
@@ -10,11 +10,7 @@ interface IIssueMethods {
     unassign(unassignedBy: string): void;
 }
 interface IIssueModel extends Model<IIssueDocument, {}, IIssueMethods> {
-    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
     findByAssignee(assignedTo: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
-    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IIssueDocument[]>;
-    findByStatus(status: IssueStatus, includeDeleted?: boolean): Promise<IIssueDocument[]>;
-    findByPriority(priority: IssuePriority, includeDeleted?: boolean): Promise<IIssueDocument[]>;
     findOverdue(includeDeleted?: boolean): Promise<IIssueDocument[]>;
     findUpcoming(days?: number, includeDeleted?: boolean): Promise<IIssueDocument[]>;
 }

package/dist/issues/Issue.model.js

@@ -188,13 +188,6 @@ IssueSchema.methods.unassign = function (unassignedBy) {
     this.updatedBy = unassignedBy;
 };
 // Static methods
-IssueSchema.statics.findByProperty = function (propertyId, includeDeleted = false) {
-    const query = { propertyId };
-    if (!includeDeleted) {
-        query.isDeleted = false;
-    }
-    return this.find(query).sort({ createdAt: -1 });
-};
 IssueSchema.statics.findByAssignee = function (assignedTo, includeDeleted = false) {
     const query = { assignedTo };
     if (!includeDeleted) {
@@ -202,27 +195,6 @@ IssueSchema.statics.findByAssignee = function (assignedTo, includeDeleted = fals
     }
     return this.find(query).sort({ priority: -1, createdAt: -1 });
 };
-IssueSchema.statics.findByEntity = function (entityId, entityType, includeDeleted = false) {
-    const query = { entityId, entityType };
-    if (!includeDeleted) {
-        query.isDeleted = false;
-    }
-    return this.find(query).sort({ createdAt: -1 });
-};
-IssueSchema.statics.findByStatus = function (status, includeDeleted = false) {
-    const query = { status };
-    if (!includeDeleted) {
-        query.isDeleted = false;
-    }
-    return this.find(query).sort({ priority: -1, createdAt: -1 });
-};
-IssueSchema.statics.findByPriority = function (priority, includeDeleted = false) {
-    const query = { priority };
-    if (!includeDeleted) {
-        query.isDeleted = false;
-    }
-    return this.find(query).sort({ createdAt: -1 });
-};
 IssueSchema.statics.findOverdue = function (includeDeleted = false) {
     const query = {
         dueDate: { $lt: new Date() },

package/dist/issues/Issue.repository.d.ts

@@ -1,6 +1,7 @@
 import { IIssueDocument } from "./Issue.model";
-import { CreateIssueData, UpdateIssueData, IssueStatus, IssuePriority, IssuesCategory, EntityType } from "./issue.types";
+import { CreateIssueData, UpdateIssueData, IssuePriority, IssuesCategory, IIssueQuery } from "./issue.types";
 export declare class IssueRepository {
+    private buildQuery;
     /**
      * Create a new issue
      */
@@ -12,21 +13,7 @@ export declare class IssueRepository {
     /**
      * Find all issues with filters
      */
-    findAll(filters?: {
-        propertyId?: string;
-        assignedTo?: string;
-        status?: IssueStatus;
-        priority?: IssuePriority;
-        category?: IssuesCategory;
-        entityType?: EntityType;
-        entityId?: string;
-        includeDeleted?: boolean;
-        limit?: number;
-        skip?: number;
-        sort?: {
-            [key: string]: 1 | -1;
-        };
-    }): Promise<IIssueDocument[]>;
+    query(filters?: IIssueQuery): Promise<IIssueDocument[]>;
     /**
      * Update an issue
      */
@@ -42,36 +29,11 @@ export declare class IssueRepository {
     /**
      * Count issues with filters
      */
-    count(filters?: {
-        propertyId?: string;
-        assignedTo?: string;
-        status?: IssueStatus;
-        priority?: IssuePriority;
-        category?: IssuesCategory;
-        entityType?: EntityType;
-        entityId?: string;
-        includeDeleted?: boolean;
-    }): Promise<number>;
-    /**
-     * Find issues by property
-     */
-    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    count(filters?: IIssueQuery): Promise<number>;
     /**
      * Find issues by assignee
      */
     findByAssignee(assignedTo: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
-    /**
-     * Find issues by entity
-     */
-    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IIssueDocument[]>;
-    /**
-     * Find issues by status
-     */
-    findByStatus(status: IssueStatus, includeDeleted?: boolean): Promise<IIssueDocument[]>;
-    /**
-     * Find issues by priority
-     */
-    findByPriority(priority: IssuePriority, includeDeleted?: boolean): Promise<IIssueDocument[]>;
     /**
      * Find overdue issues
      */

package/dist/issues/Issue.repository.js

@@ -48,6 +48,32 @@ let IssueRepository = (() => {
     let _classExtraInitializers = [];
     let _classThis;
     var IssueRepository = _classThis = class {
+        async buildQuery(filters) {
+            const query = {};
+            if (filters.propertyId)
+                query.propertyId = filters.propertyId;
+            if (filters.assignedTo)
+                query.assignedTo = filters.assignedTo;
+            if (filters.status)
+                query.status = filters.status;
+            if (filters.priority)
+                query.priority = filters.priority;
+            if (filters.category)
+                query.category = filters.category;
+            if (filters.entityType)
+                query.entityType = filters.entityType;
+            if (filters.entityId)
+                query.entityId = filters.entityId;
+            if (!filters.includeDeleted)
+                query.isDeleted = false;
+            if (filters.sort)
+                query.sort = filters.sort;
+            if (filters.limit)
+                query.limit = filters.limit;
+            if (filters.skip)
+                query.skip = filters.skip;
+            return query;
+        }
         /**
          * Create a new issue
          */
@@ -83,25 +109,9 @@ let IssueRepository = (() => {
         /**
          * Find all issues with filters
          */
-        async findAll(filters = {}) {
+        async query(filters = {}) {
             try {
-                const query = {};
-                if (filters.propertyId)
-                    query.propertyId = filters.propertyId;
-                if (filters.assignedTo)
-                    query.assignedTo = filters.assignedTo;
-                if (filters.status)
-                    query.status = filters.status;
-                if (filters.priority)
-                    query.priority = filters.priority;
-                if (filters.category)
-                    query.category = filters.category;
-                if (filters.entityType)
-                    query.entityType = filters.entityType;
-                if (filters.entityId)
-                    query.entityId = filters.entityId;
-                if (!filters.includeDeleted)
-                    query.isDeleted = false;
+                const query = await this.buildQuery(filters);
                 const queryBuilder = Issue_model_1.IssueModel.find(query);
                 if (filters.sort) {
                     queryBuilder.sort(filters.sort);
@@ -163,40 +173,13 @@ let IssueRepository = (() => {
          */
         async count(filters = {}) {
             try {
-                const query = {};
-                if (filters.propertyId)
-                    query.propertyId = filters.propertyId;
-                if (filters.assignedTo)
-                    query.assignedTo = filters.assignedTo;
-                if (filters.status)
-                    query.status = filters.status;
-                if (filters.priority)
-                    query.priority = filters.priority;
-                if (filters.category)
-                    query.category = filters.category;
-                if (filters.entityType)
-                    query.entityType = filters.entityType;
-                if (filters.entityId)
-                    query.entityId = filters.entityId;
-                if (!filters.includeDeleted)
-                    query.isDeleted = false;
+                const query = await this.buildQuery(filters);
                 return await Issue_model_1.IssueModel.countDocuments(query);
             }
             catch (error) {
                 throw new Error(`Failed to count issues: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
-        /**
-         * Find issues by property
-         */
-        async findByProperty(propertyId, includeDeleted = false) {
-            try {
-                return await Issue_model_1.IssueModel.findByProperty(propertyId, includeDeleted);
-            }
-            catch (error) {
-                throw new Error(`Failed to find issues by property: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
         /**
          * Find issues by assignee
          */
@@ -208,39 +191,6 @@ let IssueRepository = (() => {
                 throw new Error(`Failed to find issues by assignee: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
-        /**
-         * Find issues by entity
-         */
-        async findByEntity(entityId, entityType, includeDeleted = false) {
-            try {
-                return await Issue_model_1.IssueModel.findByEntity(entityId, entityType, includeDeleted);
-            }
-            catch (error) {
-                throw new Error(`Failed to find issues by entity: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-        /**
-         * Find issues by status
-         */
-        async findByStatus(status, includeDeleted = false) {
-            try {
-                return await Issue_model_1.IssueModel.findByStatus(status, includeDeleted);
-            }
-            catch (error) {
-                throw new Error(`Failed to find issues by status: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-        /**
-         * Find issues by priority
-         */
-        async findByPriority(priority, includeDeleted = false) {
-            try {
-                return await Issue_model_1.IssueModel.findByPriority(priority, includeDeleted);
-            }
-            catch (error) {
-                throw new Error(`Failed to find issues by priority: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
         /**
          * Find overdue issues
          */

package/dist/issues/Issue.service.d.ts

@@ -1,40 +1,39 @@
-import { IssueRepository } from "./Issue.repository";
 import { IIssueDocument } from "./Issue.model";
-import { CreateIssueData, UpdateIssueData, AddCommentData, IssueStatus, IssuePriority, IssuesCategory, EntityType } from "./issue.types";
+import { CreateIssueData, UpdateIssueData, AddCommentData, IssuePriority, IssuesCategory, IIssueQuery } from "./issue.types";
 import { IssueBuilder } from "./IssueBuilder";
 import { Source } from "../constants/Service";
 import { IDevice } from "../entities/device/local/interfaces";
 export declare class IssueService {
     private readonly issueRepository;
-    constructor(issueRepository: IssueRepository);
+    constructor();
     /**
      * Create a readiness issue using IssueBuilder
      */
-    createReadinessIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createReadinessIssue(data: CreateIssueData): Promise<IIssueDocument>;
     /**
      * Create an operations issue using IssueBuilder
      */
-    createOperationsIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createOperationsIssue(data: CreateIssueData): Promise<IIssueDocument>;
     /**
      * Create a security issue using IssueBuilder
      */
-    createSecurityIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createSecurityIssue(data: CreateIssueData): Promise<IIssueDocument>;
     /**
      * Create an energy issue using IssueBuilder
      */
-    createEnergyIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createEnergyIssue(data: CreateIssueData): Promise<IIssueDocument>;
     /**
      * Create a device-specific issue using IssueBuilder
      */
-    createDeviceIssue(deviceId: string, propertyId: string, title: string, description: string, source: Source, category?: IssuesCategory, priority?: IssuePriority, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createDeviceIssue(data: CreateIssueData): Promise<IIssueDocument>;
     /**
      * Create a hub-specific issue using IssueBuilder
      */
-    createHubIssue(hubId: string, propertyId: string, title: string, description: string, createdBy: string, category?: IssuesCategory, priority?: IssuePriority, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createHubIssue(data: CreateIssueData): Promise<IIssueDocument>;
     /**
      * Create a user-specific issue using IssueBuilder
      */
-    createUserIssue(userId: string, propertyId: string, title: string, description: string, createdBy: string, category?: IssuesCategory, priority?: IssuePriority, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createUserIssue(data: CreateIssueData): Promise<IIssueDocument>;
     /**
      * Create issue for device going offline longer than baseline
      */
@@ -50,11 +49,11 @@ export declare class IssueService {
     /**
      * Create a maintenance issue using IssueBuilder
      */
-    createMaintenanceIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createMaintenanceIssue(data: CreateIssueData): Promise<IIssueDocument>;
     /**
      * Create an urgent issue using IssueBuilder
      */
-    createUrgentIssue(propertyId: string, title: string, description: string, createdBy: string, entityId?: string, entityType?: EntityType, assignedTo?: string, dueDate?: Date): Promise<IIssueDocument>;
+    createUrgentIssue(data: CreateIssueData): Promise<IIssueDocument>;
     /**
      * Create a new issue with business logic validation
      * Accepts either a CreateIssueData object or an IssueBuilder instance
@@ -67,18 +66,7 @@ export declare class IssueService {
     /**
      * Get all issues with business logic filtering
      */
-    getIssues(filters?: {
-        propertyId?: string;
-        assignedTo?: string;
-        status?: IssueStatus;
-        priority?: IssuePriority;
-        category?: IssuesCategory;
-        entityType?: EntityType;
-        entityId?: string;
-        includeDeleted?: boolean;
-        limit?: number;
-        skip?: number;
-    }): Promise<IIssueDocument[]>;
+    query(filters: IIssueQuery): Promise<IIssueDocument[]>;
     /**
      * Update an issue with business logic validation
      */
@@ -119,26 +107,10 @@ export declare class IssueService {
      * Unassign an issue
      */
     unassignIssue(id: string, unassignedBy: string): Promise<IIssueDocument | null>;
-    /**
-     * Get issues by property with business logic
-     */
-    getIssuesByProperty(propertyId: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
     /**
      * Get issues assigned to a user with business logic
      */
     getIssuesByAssignee(assignedTo: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
-    /**
-     * Get issues by entity
-     */
-    getIssuesByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IIssueDocument[]>;
-    /**
-     * Get issues by status
-     */
-    getIssuesByStatus(status: IssueStatus, includeDeleted?: boolean): Promise<IIssueDocument[]>;
-    /**
-     * Get issues by priority
-     */
-    getIssuesByPriority(priority: IssuePriority, includeDeleted?: boolean): Promise<IIssueDocument[]>;
     /**
      * Get overdue issues with business logic
      */