dt-common-device 5.1.7 → 6.1.0

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
      */

package/dist/issues/Issue.service.js

@@ -1,4 +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 __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";
@@ -33,13 +49,31 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     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.IssueService = void 0;
-const typedi_1 = require("typedi");
+const typedi_1 = __importStar(require("typedi"));
+const Issue_repository_1 = require("./Issue.repository");
 const Issue_model_1 = require("./Issue.model");
 const issue_types_1 = require("./issue.types");
 const IssueBuilder_1 = require("./IssueBuilder");
@@ -49,183 +83,210 @@ let IssueService = (() => {
     let _classExtraInitializers = [];
     let _classThis;
     var IssueService = _classThis = class {
-        constructor(issueRepository) {
-            this.issueRepository = issueRepository;
+        constructor() {
+            this.issueRepository = typedi_1.default.get(Issue_repository_1.IssueRepository);
         }
         /**
          * Create a readiness issue using IssueBuilder
          */
-        async createReadinessIssue(propertyId, title, description, createdBy, entityId, entityType, assignedTo, dueDate) {
+        async createReadinessIssue(data) {
             const issueBuilder = IssueBuilder_1.IssueBuilder.createReadinessIssue()
-                .setPropertyId(propertyId)
-                .setTitle(title)
-                .setDescription(description)
-                .setCreatedBy(createdBy);
-            if (entityId)
-                issueBuilder.setEntityId(entityId);
-            if (entityType)
-                issueBuilder.setEntityType(entityType);
-            if (assignedTo)
-                issueBuilder.setAssignedTo(assignedTo);
-            if (dueDate)
-                issueBuilder.setDueDate(dueDate);
+                .setPropertyId(data.propertyId)
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setCreatedBy(data.createdBy);
+            if (data.entityId)
+                issueBuilder.setEntityId(data.entityId);
+            if (data.entityType)
+                issueBuilder.setEntityType(data.entityType);
+            if (data.assignedTo)
+                issueBuilder.setAssignedTo(data.assignedTo);
+            if (data.dueDate)
+                issueBuilder.setDueDate(data.dueDate);
             return await this.createIssue(issueBuilder);
         }
         /**
          * Create an operations issue using IssueBuilder
          */
-        async createOperationsIssue(propertyId, title, description, createdBy, entityId, entityType, assignedTo, dueDate) {
+        async createOperationsIssue(data) {
             const issueBuilder = IssueBuilder_1.IssueBuilder.createOperationsIssue()
-                .setPropertyId(propertyId)
-                .setTitle(title)
-                .setDescription(description)
-                .setCreatedBy(createdBy);
-            if (entityId)
-                issueBuilder.setEntityId(entityId);
-            if (entityType)
-                issueBuilder.setEntityType(entityType);
-            if (assignedTo)
-                issueBuilder.setAssignedTo(assignedTo);
-            if (dueDate)
-                issueBuilder.setDueDate(dueDate);
+                .setPropertyId(data.propertyId)
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setCreatedBy(data.createdBy);
+            if (data.entityId)
+                issueBuilder.setEntityId(data.entityId);
+            if (data.entityType)
+                issueBuilder.setEntityType(data.entityType);
+            if (data.assignedTo)
+                issueBuilder.setAssignedTo(data.assignedTo);
+            if (data.dueDate)
+                issueBuilder.setDueDate(data.dueDate);
             return await this.createIssue(issueBuilder);
         }
         /**
          * Create a security issue using IssueBuilder
          */
-        async createSecurityIssue(propertyId, title, description, createdBy, entityId, entityType, assignedTo, dueDate) {
+        async createSecurityIssue(data) {
             const issueBuilder = IssueBuilder_1.IssueBuilder.createSecurityIssue()
-                .setPropertyId(propertyId)
-                .setTitle(title)
-                .setDescription(description)
-                .setCreatedBy(createdBy);
-            if (entityId)
-                issueBuilder.setEntityId(entityId);
-            if (entityType)
-                issueBuilder.setEntityType(entityType);
-            if (assignedTo)
-                issueBuilder.setAssignedTo(assignedTo);
-            if (dueDate)
-                issueBuilder.setDueDate(dueDate);
+                .setPropertyId(data.propertyId)
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setCreatedBy(data.createdBy);
+            if (data.entityId)
+                issueBuilder.setEntityId(data.entityId);
+            if (data.entityType)
+                issueBuilder.setEntityType(data.entityType);
+            if (data.assignedTo)
+                issueBuilder.setAssignedTo(data.assignedTo);
+            if (data.dueDate)
+                issueBuilder.setDueDate(data.dueDate);
             return await this.createIssue(issueBuilder);
         }
         /**
          * Create an energy issue using IssueBuilder
          */
-        async createEnergyIssue(propertyId, title, description, createdBy, entityId, entityType, assignedTo, dueDate) {
+        async createEnergyIssue(data) {
             const issueBuilder = IssueBuilder_1.IssueBuilder.createEnergyIssue()
-                .setPropertyId(propertyId)
-                .setTitle(title)
-                .setDescription(description)
-                .setCreatedBy(createdBy);
-            if (entityId)
-                issueBuilder.setEntityId(entityId);
-            if (entityType)
-                issueBuilder.setEntityType(entityType);
-            if (assignedTo)
-                issueBuilder.setAssignedTo(assignedTo);
-            if (dueDate)
-                issueBuilder.setDueDate(dueDate);
+                .setPropertyId(data.propertyId)
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setCreatedBy(data.createdBy);
+            if (data.entityId)
+                issueBuilder.setEntityId(data.entityId);
+            if (data.entityType)
+                issueBuilder.setEntityType(data.entityType);
+            if (data.assignedTo)
+                issueBuilder.setAssignedTo(data.assignedTo);
+            if (data.dueDate)
+                issueBuilder.setDueDate(data.dueDate);
             return await this.createIssue(issueBuilder);
         }
         /**
          * Create a device-specific issue using IssueBuilder
          */
-        async createDeviceIssue(deviceId, propertyId, title, description, source, category, priority, assignedTo, dueDate) {
-            const issueBuilder = IssueBuilder_1.IssueBuilder.createDeviceIssue(deviceId, propertyId)
-                .setTitle(title)
-                .setDescription(description)
-                .setCreatedBy(source);
-            if (category)
-                issueBuilder.setCategory(category);
-            if (priority)
-                issueBuilder.setPriority(priority);
-            if (assignedTo)
-                issueBuilder.setAssignedTo(assignedTo);
-            if (dueDate)
-                issueBuilder.setDueDate(dueDate);
+        async createDeviceIssue(data) {
+            const issueBuilder = IssueBuilder_1.IssueBuilder.createDeviceIssue(data.entityId, data.propertyId)
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setCreatedBy(data.createdBy);
+            if (data.category)
+                issueBuilder.setCategory(data.category);
+            if (data.priority)
+                issueBuilder.setPriority(data.priority);
+            if (data.assignedTo)
+                issueBuilder.setAssignedTo(data.assignedTo);
+            if (data.dueDate)
+                issueBuilder.setDueDate(data.dueDate);
             return await this.createIssue(issueBuilder);
         }
         /**
          * Create a hub-specific issue using IssueBuilder
          */
-        async createHubIssue(hubId, propertyId, title, description, createdBy, category, priority, assignedTo, dueDate) {
-            const issueBuilder = IssueBuilder_1.IssueBuilder.createHubIssue(hubId, propertyId)
-                .setTitle(title)
-                .setDescription(description)
-                .setCreatedBy(createdBy);
-            if (category)
-                issueBuilder.setCategory(category);
-            if (priority)
-                issueBuilder.setPriority(priority);
-            if (assignedTo)
-                issueBuilder.setAssignedTo(assignedTo);
-            if (dueDate)
-                issueBuilder.setDueDate(dueDate);
+        async createHubIssue(data) {
+            const issueBuilder = IssueBuilder_1.IssueBuilder.createHubIssue(data.entityId, data.propertyId)
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setCreatedBy(data.createdBy);
+            if (data.category)
+                issueBuilder.setCategory(data.category);
+            if (data.priority)
+                issueBuilder.setPriority(data.priority);
+            if (data.assignedTo)
+                issueBuilder.setAssignedTo(data.assignedTo);
+            if (data.dueDate)
+                issueBuilder.setDueDate(data.dueDate);
             return await this.createIssue(issueBuilder);
         }
         /**
          * Create a user-specific issue using IssueBuilder
          */
-        async createUserIssue(userId, propertyId, title, description, createdBy, category, priority, assignedTo, dueDate) {
-            const issueBuilder = IssueBuilder_1.IssueBuilder.createUserIssue(userId, propertyId)
-                .setTitle(title)
-                .setDescription(description)
-                .setCreatedBy(createdBy);
-            if (category)
-                issueBuilder.setCategory(category);
-            if (priority)
-                issueBuilder.setPriority(priority);
-            if (assignedTo)
-                issueBuilder.setAssignedTo(assignedTo);
-            if (dueDate)
-                issueBuilder.setDueDate(dueDate);
+        async createUserIssue(data) {
+            const issueBuilder = IssueBuilder_1.IssueBuilder.createUserIssue(data.entityId, data.propertyId)
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setCreatedBy(data.createdBy);
+            if (data.category)
+                issueBuilder.setCategory(data.category);
+            if (data.priority)
+                issueBuilder.setPriority(data.priority);
+            if (data.assignedTo)
+                issueBuilder.setAssignedTo(data.assignedTo);
+            if (data.dueDate)
+                issueBuilder.setDueDate(data.dueDate);
             return await this.createIssue(issueBuilder);
         }
         /**
          * Create issue for device going offline longer than baseline
          */
         async createDeviceOfflineIssue(device, source, reason) {
-            return await this.createDeviceIssue(device.deviceId, device.propertyId, "Device Offline - Requires Attention", `Device ${device.name} (${device.deviceId}) has been offline for longer than the baseline time. ${reason ? `Reason: ${reason}` : ""} This requires immediate attention to restore device functionality.`, source, issue_types_1.IssuesCategory.OPERATIONS, issue_types_1.IssuePriority.HIGH);
+            return await this.createDeviceIssue({
+                entityId: device.deviceId,
+                entityType: issue_types_1.EntityType.DEVICE,
+                propertyId: device.propertyId,
+                title: "Device Offline - Requires Attention",
+                description: `Device ${device.name} (${device.deviceId}) has been offline for longer than the baseline time. ${reason ? `Reason: ${reason}` : ""} This requires immediate attention to restore device functionality.`,
+                createdBy: source,
+                category: issue_types_1.IssuesCategory.OPERATIONS,
+                priority: issue_types_1.IssuePriority.HIGH,
+            });
         }
         /**
          * Create issue for device battery level below threshold (READINESS + OPERATIONAL + ENERGY)
          */
         async createDeviceBatteryIssue(device, batteryLevel, threshold, source) {
-            return await this.createDeviceIssue(device.deviceId, device.propertyId, "Device Battery Low - Requires Attention", `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%. This requires immediate attention to replace or charge the device battery.`, source, issue_types_1.IssuesCategory.ENERGY, issue_types_1.IssuePriority.MEDIUM);
+            return await this.createDeviceIssue({
+                entityId: device.deviceId,
+                entityType: issue_types_1.EntityType.DEVICE,
+                propertyId: device.propertyId,
+                title: "Device Battery Low - Requires Attention",
+                description: `Device ${device.name} (${device.deviceId}) battery level is ${batteryLevel}%, which is below the property threshold of ${threshold}%. This requires immediate attention to replace or charge the device battery.`,
+                createdBy: source,
+                category: issue_types_1.IssuesCategory.ENERGY,
+                priority: issue_types_1.IssuePriority.MEDIUM,
+            });
         }
         /**
          * Create issue for device malfunction (jammed or not accepting codes) (READINESS + OPERATIONAL)
          */
         async createDeviceMalfunctionIssue(device, issueType, source, reason) {
-            return await this.createDeviceIssue(device.deviceId, device.propertyId, `Device Malfunction - ${issueType} - Requires Attention`, `Device ${device.name} (${device.deviceId}) has a malfunction: ${issueType}. ${reason ? `Reason: ${reason}` : ""} This requires immediate attention to resolve the device malfunction.`, source, issue_types_1.IssuesCategory.OPERATIONS, issue_types_1.IssuePriority.HIGH);
+            return await this.createDeviceIssue({
+                entityId: device.deviceId,
+                entityType: issue_types_1.EntityType.DEVICE,
+                propertyId: device.propertyId,
+                title: `Device Malfunction - ${issueType} - Requires Attention`,
+                description: `Device ${device.name} (${device.deviceId}) has a malfunction: ${issueType}. ${reason ? `Reason: ${reason}` : ""} This requires immediate attention to resolve the device malfunction.`,
+                createdBy: source,
+                category: issue_types_1.IssuesCategory.OPERATIONS,
+                priority: issue_types_1.IssuePriority.HIGH,
+            });
         }
         /**
          * Create a maintenance issue using IssueBuilder
          */
-        async createMaintenanceIssue(propertyId, title, description, createdBy, entityId, entityType, assignedTo, dueDate) {
-            const issueBuilder = IssueBuilder_1.IssueBuilder.createMaintenanceIssue(propertyId, entityId, entityType)
-                .setTitle(title)
-                .setDescription(description)
-                .setCreatedBy(createdBy);
-            if (assignedTo)
-                issueBuilder.setAssignedTo(assignedTo);
-            if (dueDate)
-                issueBuilder.setDueDate(dueDate);
+        async createMaintenanceIssue(data) {
+            const issueBuilder = IssueBuilder_1.IssueBuilder.createMaintenanceIssue(data.propertyId, data.entityId, data.entityType)
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setCreatedBy(data.createdBy);
+            if (data.assignedTo)
+                issueBuilder.setAssignedTo(data.assignedTo);
+            if (data.dueDate)
+                issueBuilder.setDueDate(data.dueDate);
             return await this.createIssue(issueBuilder);
         }
         /**
          * Create an urgent issue using IssueBuilder
          */
-        async createUrgentIssue(propertyId, title, description, createdBy, entityId, entityType, assignedTo, dueDate) {
-            const issueBuilder = IssueBuilder_1.IssueBuilder.createUrgentIssue(propertyId, entityId, entityType)
-                .setTitle(title)
-                .setDescription(description)
-                .setCreatedBy(createdBy);
-            if (assignedTo)
-                issueBuilder.setAssignedTo(assignedTo);
-            if (dueDate)
-                issueBuilder.setDueDate(dueDate);
+        async createUrgentIssue(data) {
+            const issueBuilder = IssueBuilder_1.IssueBuilder.createUrgentIssue(data.propertyId, data.entityId, data.entityType)
+                .setTitle(data.title)
+                .setDescription(data.description)
+                .setCreatedBy(data.createdBy);
+            if (data.assignedTo)
+                issueBuilder.setAssignedTo(data.assignedTo);
+            if (data.dueDate)
+                issueBuilder.setDueDate(data.dueDate);
             return await this.createIssue(issueBuilder);
         }
         /**
@@ -274,12 +335,12 @@ let IssueService = (() => {
         /**
          * Get all issues with business logic filtering
          */
-        async getIssues(filters = {}) {
+        async query(filters) {
             // Business logic: Validate filters
             this.validateFilters(filters);
             // Business logic: Apply business rules to filters
             const enhancedFilters = this.applyBusinessRules(filters);
-            return await this.issueRepository.findAll(enhancedFilters);
+            return await this.issueRepository.query(enhancedFilters);
         }
         /**
          * Update an issue with business logic validation
@@ -353,7 +414,7 @@ let IssueService = (() => {
                 });
             }
             // Add comment using the model instance methods
-            const issueModel = await Issue_model_1.IssueModel.findById(issueId);
+            const issueModel = await Issue_model_1.IssueModel.findById({ _id: issueId });
             if (issueModel) {
                 issueModel.addComment(commentData);
                 return await issueModel.save();
@@ -465,15 +526,6 @@ let IssueService = (() => {
             issueModel.unassign(unassignedBy);
             return await issueModel.save();
         }
-        /**
-         * Get issues by property with business logic
-         */
-        async getIssuesByProperty(propertyId, includeDeleted = false) {
-            if (!propertyId) {
-                throw new Error("Property ID is required");
-            }
-            return await this.issueRepository.findByProperty(propertyId, includeDeleted);
-        }
         /**
          * Get issues assigned to a user with business logic
          */
@@ -483,24 +535,6 @@ let IssueService = (() => {
             }
             return await this.issueRepository.findByAssignee(assignedTo, includeDeleted);
         }
-        /**
-         * Get issues by entity
-         */
-        async getIssuesByEntity(entityId, entityType, includeDeleted = false) {
-            return await this.issueRepository.findByEntity(entityId, entityType, includeDeleted);
-        }
-        /**
-         * Get issues by status
-         */
-        async getIssuesByStatus(status, includeDeleted = false) {
-            return await this.issueRepository.findByStatus(status, includeDeleted);
-        }
-        /**
-         * Get issues by priority
-         */
-        async getIssuesByPriority(priority, includeDeleted = false) {
-            return await this.issueRepository.findByPriority(priority, includeDeleted);
-        }
         /**
          * Get overdue issues with business logic
          */

package/dist/issues/IssueBuilder.d.ts

@@ -25,43 +25,43 @@ export declare class IssueBuilder {
     /**
      * Sets the issue category
      */
-    setCategory(category: IssuesCategory): IssueBuilder;
+    setCategory(category: IssuesCategory): this;
     /**
      * Sets the property ID
      */
-    setPropertyId(propertyId: string): IssueBuilder;
+    setPropertyId(propertyId: string): this;
     /**
      * Sets the issue title
      */
-    setTitle(title: string): IssueBuilder;
+    setTitle(title: string): this;
     /**
      * Sets the issue description
      */
-    setDescription(description: string): IssueBuilder;
+    setDescription(description: string): this;
     /**
      * Sets the entity ID (optional)
      */
-    setEntityId(entityId?: string): IssueBuilder;
+    setEntityId(entityId?: string): this;
     /**
      * Sets the entity type
      */
-    setEntityType(entityType: EntityType): IssueBuilder;
+    setEntityType(entityType: EntityType): this;
     /**
      * Sets the issue priority (optional, defaults to MEDIUM)
      */
-    setPriority(priority?: IssuePriority): IssueBuilder;
+    setPriority(priority?: IssuePriority): this;
     /**
      * Sets the user assigned to the issue (optional)
      */
-    setAssignedTo(assignedTo?: string): IssueBuilder;
+    setAssignedTo(assignedTo?: string): this;
     /**
      * Sets the user who created the issue (required)
      */
-    setCreatedBy(createdBy: string): IssueBuilder;
+    setCreatedBy(createdBy: string): this;
     /**
      * Sets the due date (optional)
      */
-    setDueDate(dueDate?: Date): IssueBuilder;
+    setDueDate(dueDate?: Date): this;
     /**
      * Validates that all required fields are present
      */
@@ -74,7 +74,7 @@ export declare class IssueBuilder {
     /**
      * Resets the builder to its initial state
      */
-    reset(): IssueBuilder;
+    reset(): this;
     /**
      * Creates a new builder instance with predefined values for common issue types
      */

package/dist/issues/IssueBuilder.js

@@ -121,8 +121,16 @@ class IssueBuilder {
      * Validates that all required fields are present
      */
     validate() {
-        const requiredFields = ["category", "propertyId", "title", "description", "entityType", "createdBy"];
-        const missingFields = requiredFields.filter(field => !this.data[field]);
+        const requiredFields = [
+            "category",
+            "propertyId",
+            "title",
+            "description",
+            "entityId",
+            "entityType",
+            "createdBy",
+        ];
+        const missingFields = requiredFields.filter((field) => !this.data[field]);
         if (missingFields.length > 0) {
             throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
         }