law-common 10.26.1-beta.1 → 10.26.1-beta.11

package/dist/src/entities/model/leave.entity.model.js

@@ -2,33 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LeaveEntityModel = void 0;
 const utils_1 = require("../../utils");
+const string_util_1 = require("../../utils/string.util");
 const duration_type_enum_1 = require("../enums/duration-type.enum");
+const leave_type_enum_1 = require("../enums/leave-type.enum");
 const leave_status_enum_1 = require("../enums/leave.status.enum");
-class LeaveEntityModel {
-    constructor(data) {
-        this.createdOn = "";
-        this.updatedOn = "";
-        this.id = data.id;
-        this.employeeId = data.employeeId;
-        this.fromDate = data.fromDate;
-        this.toDate = data.toDate;
-        this.reason = data.reason;
-        this.durationType = data.durationType;
-        this.status = data.status;
-        this.remark = data.remark;
-        this.type = data.type;
-        this.createdOn = data.createdOn;
-        this.updatedOn = data.updatedOn;
-        this.createdBy = data.createdBy;
-        this.updatedBy = data.updatedBy;
+const relation_type_enum_1 = require("../enums/relation-type.enum");
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class LeaveEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.employeeId = 0;
+        this.fromDate = "";
+        this.toDate = "";
+        this.reason = "";
+        this.durationType = duration_type_enum_1.DurationTypeEnum.FULL;
+        this.status = leave_status_enum_1.LeaveStatusEnum.DELETED;
+        this.type = leave_type_enum_1.LeaveTypeEnum.SICK;
+        this.createdOn = 0;
+        this.updatedOn = 0;
+        this.createdBy = 0;
+        this.updatedBy = 0;
     }
     static fromEntity(data) {
-        return new LeaveEntityModel(data);
-    }
-    isMoreThanOneDayLeave() {
-        const fromDate = new utils_1.DateCodeModel(this.fromDate);
-        const toDate = new utils_1.DateCodeModel(this.toDate);
-        return fromDate.diffInDays(toDate) > 1;
+        const entity = new LeaveEntityModel(entity_utils_interface_1.EntityEnum.LEAVE);
+        Object.assign(entity, data);
+        return entity;
     }
     getLeaveDuration(excludeWeekdays = [], excludeDates = []) {
         if (!this.isMoreThanOneDayLeave()) {
@@ -80,5 +80,153 @@ class LeaveEntityModel {
         return leaves.filter((leave) => includePredicates.every((predicate) => predicate(leave)) &&
             excludePredicates.every((predicate) => !predicate(leave)));
     }
+    static orderByFromDateAsc(leaves) {
+        return leaves.sort((a, b) => {
+            const dateA = new Date(a.fromDate);
+            const dateB = new Date(b.fromDate);
+            return dateA.getTime() - dateB.getTime();
+        });
+    }
+    isWeekendSucceeds() {
+        const toDate = new utils_1.DateCodeModel(this.toDate);
+        const nextDate = toDate.getByOffset(1);
+        return nextDate.isDayPresent([utils_1.Weekday.Saturday, utils_1.Weekday.Sunday]);
+    }
+    isWeekendPrecedes() {
+        const fromDate = new utils_1.DateCodeModel(this.fromDate);
+        const prevDate = fromDate.getByOffset(-1);
+        return prevDate.isDayPresent([utils_1.Weekday.Saturday, utils_1.Weekday.Sunday]);
+    }
+    isHolidaySucceeds(holidays) {
+        const toDate = new utils_1.DateCodeModel(this.toDate);
+        const nextDate = toDate.getByOffset(1);
+        return holidays.some((holiday) => holiday.isSame(nextDate));
+    }
+    isHolidayPrecedes(holidays) {
+        const fromDate = new utils_1.DateCodeModel(this.fromDate);
+        const prevDate = fromDate.getByOffset(-1);
+        return holidays.some((holiday) => holiday.isSame(prevDate));
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs;
+    }
+    static fromApiEntity(apiEntity) {
+        return LeaveEntityModel.fromEntity(apiEntity);
+    }
+    static getPendingApprovalStatuses() {
+        return [
+            leave_status_enum_1.LeaveStatusEnum.PENDING_APPROVAL,
+            leave_status_enum_1.LeaveStatusEnum.DELETE_APPROVAL,
+            leave_status_enum_1.LeaveStatusEnum.EDIT_APPROVAL,
+        ];
+    }
+    getStatusLabel() {
+        const pendingStatuses = LeaveEntityModel.getPendingApprovalStatuses();
+        let statusLabel = "";
+        if (pendingStatuses.includes(this.status)) {
+            statusLabel = "PENDING_APPROVAL";
+        }
+        else if (this.status === leave_status_enum_1.LeaveStatusEnum.RESOLVE_REJECTED) {
+            statusLabel = "CHANGES_REJECTED";
+        }
+        else {
+            statusLabel = this.status.toString();
+        }
+        return (0, string_util_1.formatString)(statusLabel);
+    }
+    getTypeLabel() {
+        return (0, string_util_1.formatString)(this.type.toString());
+    }
+    getLeaveCount() {
+        var _a;
+        return ((_a = this.leaveCount) === null || _a === void 0 ? void 0 : _a.count) || 0;
+    }
+    static getLeaveCount(leaveEntities) {
+        return leaveEntities.reduce((acc, leave) => acc + leave.getLeaveCount(), 0);
+    }
+    isMoreThanOneDayLeave() {
+        const fromDate = new utils_1.DateCodeModel(this.fromDate);
+        const toDate = new utils_1.DateCodeModel(this.toDate);
+        return fromDate.diffInDays(toDate) > 1;
+    }
+    getFromDateLabel() {
+        const statues = [
+            duration_type_enum_1.DurationTypeEnum.SECOND,
+            duration_type_enum_1.DurationTypeEnum.SECOND_FULL,
+            duration_type_enum_1.DurationTypeEnum.SECOND_FIRST,
+        ];
+        if (statues.includes(this.durationType)) {
+            return "Second Half";
+        }
+        return "Full Day";
+    }
+    getToDateLabel() {
+        const statues = [
+            duration_type_enum_1.DurationTypeEnum.FIRST,
+            duration_type_enum_1.DurationTypeEnum.FULL_FIRST,
+            duration_type_enum_1.DurationTypeEnum.SECOND_FIRST,
+        ];
+        if (statues.includes(this.durationType)) {
+            return "First Half";
+        }
+        return "Full Day";
+    }
+    getDateDurationLabel() {
+        if (!this.isMoreThanOneDayLeave()) {
+            return `${new utils_1.DateCodeModel(this.fromDate).getFormattedDateWithMonthName()} ${this.durationType === duration_type_enum_1.DurationTypeEnum.FULL
+                ? "(Full Day)"
+                : this.durationType === duration_type_enum_1.DurationTypeEnum.FIRST
+                    ? "(First Half)"
+                    : "(Second Half)"}`;
+        }
+        return `${new utils_1.DateCodeModel(this.fromDate).getFormattedDateWithMonthName()} (${this.getFromDateLabel()}) - ${new utils_1.DateCodeModel(this.toDate).getFormattedDateWithMonthName()} (${this.getToDateLabel()})`;
+    }
+    static getLeaveStatusPriority() {
+        return {
+            [leave_status_enum_1.LeaveStatusEnum.PENDING_APPROVAL]: 1,
+            [leave_status_enum_1.LeaveStatusEnum.EDIT_APPROVAL]: 2,
+            [leave_status_enum_1.LeaveStatusEnum.DELETE_APPROVAL]: 3,
+            [leave_status_enum_1.LeaveStatusEnum.APPROVED]: 4,
+            [leave_status_enum_1.LeaveStatusEnum.REJECTED]: 5,
+        };
+    }
 }
 exports.LeaveEntityModel = LeaveEntityModel;
+LeaveEntityModel.relationConfigs = [
+    {
+        name: entity_utils_interface_1.VirtualEntityEnum.LEAVE_COUNT,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "leaveCount",
+        mapKeyConfig: {
+            relationKey: "leaveId",
+            key: "id",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.USER,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "createdByUser",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "createdBy",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.USER,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "updatedByUser",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "updatedBy",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.USER,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "user",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "employeeId",
+        },
+    },
+];

package/dist/src/entities/model/leave_count.entity.model.d.ts

@@ -0,0 +1,19 @@
+import { DateCodeModel } from "../../utils";
+import { VirtualEntityEnum } from "../interface/entity.utils.interface";
+import { ILeaveCountVirtualEntity } from "../interface/leave.entity.interface";
+import { BaseEntityModel } from "./base.entity.model";
+import { LeaveEntityModel } from "./leave.entity.model";
+export declare class LeaveCountVirtualEntityModel extends BaseEntityModel<VirtualEntityEnum.LEAVE_COUNT> implements ILeaveCountVirtualEntity {
+    id: number;
+    period: string;
+    leaveId?: number;
+    count: number;
+    createdBy: number;
+    updatedBy: number;
+    createdOn: number;
+    updatedOn: number;
+    static fromEntity(entity: ILeaveCountVirtualEntity): LeaveCountVirtualEntityModel;
+    getRelationConfigs(): any[];
+    static relationConfigs: never[];
+    static fromLeaveHoliday(leaveModel: LeaveEntityModel, holidayDateCodes: DateCodeModel[]): LeaveCountVirtualEntityModel;
+}

package/dist/src/entities/model/leave_count.entity.model.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveCountVirtualEntityModel = void 0;
+const utils_1 = require("../../utils");
+const leave_type_enum_1 = require("../enums/leave-type.enum");
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class LeaveCountVirtualEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.period = "";
+        this.count = 0;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.createdOn = 0;
+        this.updatedOn = 0;
+    }
+    static fromEntity(entity) {
+        const result = new LeaveCountVirtualEntityModel(entity_utils_interface_1.VirtualEntityEnum.LEAVE_COUNT);
+        Object.assign(result, entity);
+        return result;
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs;
+    }
+    static fromLeaveHoliday(leaveModel, holidayDateCodes) {
+        const leaveCountVirtualEntity = {
+            leaveId: leaveModel.id,
+            count: leaveModel.getLeaveDuration([utils_1.Weekday.Sunday, utils_1.Weekday.Saturday], holidayDateCodes) +
+                (leaveModel.type === leave_type_enum_1.LeaveTypeEnum.SICK &&
+                    (leaveModel.isWeekendPrecedes() ||
+                        leaveModel.isWeekendSucceeds() ||
+                        leaveModel.isHolidayPrecedes(holidayDateCodes) ||
+                        leaveModel.isHolidaySucceeds(holidayDateCodes))
+                    ? 2
+                    : 0),
+            createdBy: leaveModel.createdBy,
+            updatedBy: leaveModel.updatedBy,
+            createdOn: leaveModel.createdOn,
+            updatedOn: leaveModel.updatedOn,
+            id: leaveModel.id,
+            period: leaveModel.fromDate + leaveModel.toDate + leaveModel.durationType,
+        };
+        return LeaveCountVirtualEntityModel.fromEntity(leaveCountVirtualEntity);
+    }
+}
+exports.LeaveCountVirtualEntityModel = LeaveCountVirtualEntityModel;
+// static relationConfigs = [
+//             {
+//                 name: EntityEnum.LEAVE,
+//                 relation: RelationType.ONE,
+//                 key: 'leaveCount',
+//                 mapKeyConfig: {
+//                     relationKey: 'id',
+//                     key: 'leaveId',
+//                 },
+//             },
+//         ];
+LeaveCountVirtualEntityModel.relationConfigs = [];

package/dist/src/entities/model/reimbursement-expense.entity.model.d.ts

@@ -1,10 +1,10 @@
-import { IReimbursementExpenseApiEntity } from "../../api";
 import { ReimbursementExpenseState } from "../enums/reimbursement.entity.enum";
 import { EntityEnum, EnumEntityType } from "../interface/entity.utils.interface";
+import { IReimbursementExpenseEntity } from "../interface/reimbursement_expense.entity.interface";
 import { RelationConfigs } from "../interface/relation-config.interface";
 import { BaseEntityModel } from "./base.entity.model";
 import { ReimbursementEntityModel } from "./reimbursement.entity.model";
-export declare class ReimbursementExpenseEntityModel extends BaseEntityModel<EntityEnum.REIMBURSEMENT_EXPENSE> implements IReimbursementExpenseApiEntity {
+export declare class ReimbursementExpenseEntityModel extends BaseEntityModel<EntityEnum.REIMBURSEMENT_EXPENSE> implements IReimbursementExpenseEntity {
     id: number;
     reimbursementId: number;
     userId: number;
@@ -16,10 +16,10 @@ export declare class ReimbursementExpenseEntityModel extends BaseEntityModel<Ent
     sanctionedBy?: number;
     createdBy: number;
     updatedBy: number;
-    createdOn: string;
-    updatedOn: string;
+    createdOn: number;
+    updatedOn: number;
     reimbursement?: ReimbursementEntityModel;
-    static fromApiEntity(apiEntity: IReimbursementExpenseApiEntity): ReimbursementExpenseEntityModel;
+    static fromEntity(apiEntity: IReimbursementExpenseEntity): ReimbursementExpenseEntityModel;
     static relationConfigs: RelationConfigs<[
         EntityEnum.REIMBURSEMENT
     ], EnumEntityType<EntityEnum.REIMBURSEMENT_EXPENSE>>;

package/dist/src/entities/model/reimbursement-expense.entity.model.js

@@ -17,10 +17,10 @@ class ReimbursementExpenseEntityModel extends base_entity_model_1.BaseEntityMode
         this.state = reimbursement_entity_enum_1.ReimbursementExpenseState.PENDING;
         this.createdBy = 0;
         this.updatedBy = 0;
-        this.createdOn = "";
-        this.updatedOn = "";
+        this.createdOn = 0;
+        this.updatedOn = 0;
     }
-    static fromApiEntity(apiEntity) {
+    static fromEntity(apiEntity) {
         const entity = new ReimbursementExpenseEntityModel(entity_utils_interface_1.EntityEnum.REIMBURSEMENT_EXPENSE);
         Object.assign(entity, apiEntity);
         return entity;

package/dist/src/entities/model/reimbursement.entity.model.d.ts

@@ -1,8 +1,8 @@
-import { IReimbursementApiEntity } from "../../api";
 import { ReimbursementBillingPresentEnum, ReimbursementBillingTypeEnum, ReimbursementIncurredByEnum, ReimbursementPaymentStatusEnum, ReimbursementStatusEnum } from "../enums/reimbursement.entity.enum";
 import { EntityEnum } from "../interface/entity.utils.interface";
+import { IReimbursementEntity } from "../interface/reimbursement.entity.interface";
 import { BaseEntityModel } from "./base.entity.model";
-export declare class ReimbursementEntityModel extends BaseEntityModel<EntityEnum.REIMBURSEMENT> implements IReimbursementApiEntity {
+export declare class ReimbursementEntityModel extends BaseEntityModel<EntityEnum.REIMBURSEMENT> implements IReimbursementEntity {
     id: number;
     billingType: ReimbursementBillingTypeEnum;
     billDate: string;
@@ -24,9 +24,9 @@ export declare class ReimbursementEntityModel extends BaseEntityModel<EntityEnum
     bankId?: number;
     createdBy: number;
     updatedBy: number;
-    createdOn: string;
-    updatedOn: string;
+    createdOn: number;
+    updatedOn: number;
     static relationConfigs: never[];
     getRelationConfigs(): any[];
-    static fromApiEntity(apiEntity: IReimbursementApiEntity): ReimbursementEntityModel;
+    static fromEntity(entity: IReimbursementEntity): ReimbursementEntityModel;
 }

package/dist/src/entities/model/reimbursement.entity.model.js

@@ -18,16 +18,16 @@ class ReimbursementEntityModel extends base_entity_model_1.BaseEntityModel {
         this.paymentStatus = reimbursement_entity_enum_1.ReimbursementPaymentStatusEnum.UNPAID;
         this.createdBy = 0;
         this.updatedBy = 0;
-        this.createdOn = "";
-        this.updatedOn = "";
+        this.createdOn = 0;
+        this.updatedOn = 0;
     }
     getRelationConfigs() {
         return this.constructor.prototype.constructor.relationConfigs || [];
     }
-    static fromApiEntity(apiEntity) {
-        const entity = new ReimbursementEntityModel(entity_utils_interface_1.EntityEnum.REIMBURSEMENT);
-        Object.assign(entity, apiEntity);
-        return entity;
+    static fromEntity(entity) {
+        const result = new ReimbursementEntityModel(entity_utils_interface_1.EntityEnum.REIMBURSEMENT);
+        Object.assign(result, entity);
+        return result;
     }
 }
 exports.ReimbursementEntityModel = ReimbursementEntityModel;

package/dist/src/utils/entity.flow.util.d.ts

@@ -0,0 +1,32 @@
+import { LeaveActionEnum, LeaveStatusEnum } from "../entities";
+export type LeaveStatusActionPair = {
+    status: LeaveStatusEnum;
+    action: LeaveActionEnum;
+};
+/**
+ * Gets available actions for a leave based on current status and user permissions
+ * @param entityFlowConfig - The flow configuration for the entity
+ * @param currentStatus - The current status of the leave
+ * @param userPermissions - Array of permissions the user has
+ * @param combineActions - Array of action values to combine into a single action
+ * @param actionLabels - Object mapping actions to custom labels
+ * @param data - Optional function to provide additional visibility conditions
+ * @returns Array of available actions with labels and values
+ */
+export declare function getPermittedActions<T extends LeaveStatusActionPair, E>(entityFlowConfig: {
+    [key in T["status"]]?: {
+        actions: {
+            [key in T["action"]]?: {
+                permissions: string[];
+                next: () => T["status"];
+            };
+        };
+    };
+}, currentStatus: T["status"] | null, userPermissions: string[], combineActions?: T["action"][], actionLabels?: {
+    [key in T["action"]]?: string;
+}, data?: (a: E) => {
+    [key: string]: () => boolean;
+}): {
+    label: string;
+    value: T["action"] | string;
+}[];

package/dist/src/utils/entity.flow.util.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermittedActions = getPermittedActions;
+/**
+ * Converts an action or combined action to a value-label pair
+ * @param action - The action or combined action key
+ * @param actionLabels - Object mapping actions to custom labels
+ * @returns Object with label and value
+ */
+function convertToValueLabel(action, actionLabels) {
+    return {
+        label: actionLabels[action] || action,
+        value: action,
+    };
+}
+/**
+ * Filters actions based on user permissions and visibility conditions
+ * @param actionConfig - The actions configuration for the current status
+ * @param userPermissions - Array of permissions the user has
+ * @param data - Optional function to provide additional visibility conditions
+ * @returns Array of permitted action keys
+ * @throws Error if multiple permissions are found for a single action
+ */
+function _getPermittedActions(actionConfig, userPermissions, data) {
+    return Object.entries(actionConfig)
+        .filter(([actionKey, config]) => {
+        var _a;
+        const actionRequiredPermissions = (_a = config === null || config === void 0 ? void 0 : config.permissions) !== null && _a !== void 0 ? _a : [];
+        const matchingPermissions = actionRequiredPermissions.filter((permission) => userPermissions.includes(permission));
+        if (matchingPermissions.length > 1) {
+            throw new Error(`Multiple permissions found for action ${actionKey}: ${matchingPermissions.join(", ")}`);
+        }
+        return (matchingPermissions.length > 0 &&
+            (!data ||
+                !data({})[matchingPermissions[0]] ||
+                data({})[matchingPermissions[0]]()));
+    })
+        .map(([actionKey, _]) => actionKey);
+}
+/**
+ * Combines specified actions into a single action if all are present
+ * @param permittedActions - Array of permitted action keys
+ * @param combineActions - Array of actions to combine
+ * @returns Array of action keys, with combined action if applicable
+ */
+function combinePermittedActions(permittedActions, combineActions) {
+    if (combineActions.length === 0) {
+        return permittedActions;
+    }
+    const isCombinedActionPresent = combineActions.every((action) => permittedActions.includes(action));
+    if (isCombinedActionPresent) {
+        const combinedValue = combineActions.join("_");
+        return [
+            ...permittedActions.filter((action) => !combineActions.includes(action)),
+            combinedValue,
+        ];
+    }
+    return permittedActions;
+}
+/**
+ * Gets available actions for a leave based on current status and user permissions
+ * @param entityFlowConfig - The flow configuration for the entity
+ * @param currentStatus - The current status of the leave
+ * @param userPermissions - Array of permissions the user has
+ * @param combineActions - Array of action values to combine into a single action
+ * @param actionLabels - Object mapping actions to custom labels
+ * @param data - Optional function to provide additional visibility conditions
+ * @returns Array of available actions with labels and values
+ */
+function getPermittedActions(entityFlowConfig, currentStatus, userPermissions, combineActions = [], actionLabels = {}, data = (_) => ({})) {
+    var _a;
+    // Handle invalid inputs
+    if (!currentStatus || !entityFlowConfig[currentStatus]) {
+        return [];
+    }
+    const actionConfig = ((_a = entityFlowConfig[currentStatus]) === null || _a === void 0 ? void 0 : _a.actions) || {};
+    // Get permitted actions
+    const permittedActions = _getPermittedActions(actionConfig, userPermissions, data);
+    // Combine actions if specified
+    const finalActions = combinePermittedActions(permittedActions, combineActions);
+    // Convert to value-label pairs
+    return finalActions.map((action) => convertToValueLabel(action, actionLabels));
+}

package/dist/src/utils/helper.fn.util.d.ts

@@ -1,4 +1,4 @@
-import { EntityEnum, EnumEntityType, IBaseEntityServiceResponse, IEntityFilterData } from "../entities";
+import { EntityEnum, EnumEntityType, IBaseEntityServiceResponse, IEntityFilterData, IEntityServiceResponse } from "../entities";
 import { Modify } from "../misc";
 export declare function groupByFunction<T, K>(list: T[], keyGetter: (input: T) => K): Map<K, T[]>;
 export declare function groupByOneToOneFunction<T, K>(list: T[], keyGetter: (input: T) => K): Map<K, T>;
@@ -176,6 +176,42 @@ export declare function transformDate<T extends {
 export declare function capitalizeFirstWord(str: string): string;
 export declare function getEntitiesFromSearchV2Response<E extends EntityEnum, // Enum key like EntityEnum.USER, EntityEnum.PROJECT, etc.
 T extends EnumEntityType<E>>(searchResponseV2: IBaseEntityServiceResponse<EnumEntityType<EntityEnum>>, entityEnumKey: E, EntityClass: new () => T): T[];
+/**
+ * Recursively searches for entities of a specific type within a nested `relatedEntities` structure.
+ *
+ * This function traverses the `relatedEntities` tree, looking for a target entity key.
+ * When found, it collects all `baseEntities` for that key and instantiates them
+ * as instances of the provided `EntityClass`. The function continues to traverse
+ * all nested `relatedEntities` recursively, accumulating all matches.
+ *
+ * @template E - The enum type representing the target entity key (`EntityEnum`).
+ * @template T - The corresponding entity type for the target key (`EnumEntityType<E>`).
+ *
+ * @param relatedEntities - The nested `relatedEntities` structure, typically from a
+ *   `IBaseEntityServiceResponse`. Can be undefined, in which case an empty array is returned.
+ * @param targetKey - The entity key (`EntityEnum`) to search for in the nested structure.
+ * @param EntityClass - A constructor function for the entity type `T`. Used to
+ *   instantiate new objects from the raw base entity data.
+ *
+ * @returns An array of entities of type `T` found at any level of the nested structure.
+ *   If no entities are found, an empty array is returned.
+ *
+ * @example
+ * ```ts
+ * const billingEntities = findEntitiesAtAnyLevel(
+ *   projectUserMappingsOfCurrentUser.relatedEntities,
+ *   EntityEnum.BILLING,
+ *   BillingEntity
+ * );
+ *
+ * console.log(billingEntities); // [BillingEntity {...}, BillingEntity {...}]
+ * ```
+ *
+ * @note
+ * - This function preserves the type of entities by mapping the raw objects to the provided `EntityClass`.
+ * - It can handle deeply nested `relatedEntities` structures.
+ */
+export declare function findEntitiesFromSearchV2RelatedEntities<E extends EntityEnum, T extends EnumEntityType<E>>(relatedEntities: IEntityServiceResponse | undefined, targetKey: EntityEnum, EntityClass: new () => T): T[];
 /**
  * Checks if two decimal numbers are approximately equal within a given tolerance.
  *

package/dist/src/utils/helper.fn.util.js

@@ -33,6 +33,7 @@ exports.createKeyLabelMap = createKeyLabelMap;
 exports.transformDate = transformDate;
 exports.capitalizeFirstWord = capitalizeFirstWord;
 exports.getEntitiesFromSearchV2Response = getEntitiesFromSearchV2Response;
+exports.findEntitiesFromSearchV2RelatedEntities = findEntitiesFromSearchV2RelatedEntities;
 exports.areDecimalNumbersEqual = areDecimalNumbersEqual;
 exports.formatIndianNumber = formatIndianNumber;
 exports.findDuplicateIds = findDuplicateIds;
@@ -403,6 +404,58 @@ function getEntitiesFromSearchV2Response(searchResponseV2, entityEnumKey, Entity
     }
     return (((_a = searchResponseV2.relatedEntities[entityEnumKey]) === null || _a === void 0 ? void 0 : _a.baseEntities) || []).map((entity) => Object.assign(new EntityClass(), entity));
 }
+/**
+ * Recursively searches for entities of a specific type within a nested `relatedEntities` structure.
+ *
+ * This function traverses the `relatedEntities` tree, looking for a target entity key.
+ * When found, it collects all `baseEntities` for that key and instantiates them
+ * as instances of the provided `EntityClass`. The function continues to traverse
+ * all nested `relatedEntities` recursively, accumulating all matches.
+ *
+ * @template E - The enum type representing the target entity key (`EntityEnum`).
+ * @template T - The corresponding entity type for the target key (`EnumEntityType<E>`).
+ *
+ * @param relatedEntities - The nested `relatedEntities` structure, typically from a
+ *   `IBaseEntityServiceResponse`. Can be undefined, in which case an empty array is returned.
+ * @param targetKey - The entity key (`EntityEnum`) to search for in the nested structure.
+ * @param EntityClass - A constructor function for the entity type `T`. Used to
+ *   instantiate new objects from the raw base entity data.
+ *
+ * @returns An array of entities of type `T` found at any level of the nested structure.
+ *   If no entities are found, an empty array is returned.
+ *
+ * @example
+ * ```ts
+ * const billingEntities = findEntitiesAtAnyLevel(
+ *   projectUserMappingsOfCurrentUser.relatedEntities,
+ *   EntityEnum.BILLING,
+ *   BillingEntity
+ * );
+ *
+ * console.log(billingEntities); // [BillingEntity {...}, BillingEntity {...}]
+ * ```
+ *
+ * @note
+ * - This function preserves the type of entities by mapping the raw objects to the provided `EntityClass`.
+ * - It can handle deeply nested `relatedEntities` structures.
+ */
+function findEntitiesFromSearchV2RelatedEntities(relatedEntities, targetKey, EntityClass) {
+    if (!relatedEntities)
+        return [];
+    let result = [];
+    for (const key of Object.keys(relatedEntities)) {
+        const value = relatedEntities[key];
+        // If this key is the target and has baseEntities
+        if (key === targetKey && (value === null || value === void 0 ? void 0 : value.baseEntities)) {
+            result.push(...value.baseEntities.map((entity) => Object.assign(new EntityClass(), entity)));
+        }
+        // If value has relatedEntities, recurse
+        if (value === null || value === void 0 ? void 0 : value.relatedEntities) {
+            result.push(...findEntitiesFromSearchV2RelatedEntities(value.relatedEntities, targetKey, EntityClass));
+        }
+    }
+    return result;
+}
 /**
  * Checks if two decimal numbers are approximately equal within a given tolerance.
  *

package/dist/src/utils/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./date.util";
 export * from "./helper.fn.util";
 export * from "./models/date-code.model.util";
+export * from "./string.util";
+export * from "./entity.flow.util";

package/dist/src/utils/index.js

@@ -17,3 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./date.util"), exports);
 __exportStar(require("./helper.fn.util"), exports);
 __exportStar(require("./models/date-code.model.util"), exports);
+__exportStar(require("./string.util"), exports);
+__exportStar(require("./entity.flow.util"), exports);

package/dist/src/utils/string.util.d.ts

@@ -0,0 +1 @@
+export declare function formatString(input: string): string;

package/dist/src/utils/string.util.js

@@ -1 +1,15 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatString = formatString;
+function formatString(input) {
+    if (input.includes('_')) {
+        return input
+            .split('_')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join(' ');
+    }
+    else {
+        // For single-word strings, capitalize the first letter
+        return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "law-common",
- "version": "10.26.1-beta.1",
+ "version": "10.26.1-beta.11",
  "description": "",
  "main": "dist/index.js",
  "files": [

package/dist/src/api/interface/bank_history.api.d.ts

@@ -1,3 +0,0 @@
-import { IApiEntity, IBankHistoryEntity } from "../../entities";
-export type IBankHistoryApiEntity = IApiEntity<IBankHistoryEntity>;
-export type IBankHistoryApiEntityArray = IBankHistoryApiEntity[];