law-common 10.18.1-beta.8 → 10.18.1-beta.9

package/dist/src/entities/enums/reimbursement.entity.enum.d.ts

@@ -0,0 +1,52 @@
+export declare enum ReimbursementBillingTypeEnum {
+    BILLABLE = "BILLABLE",
+    NON_BILLABLE = "NON_BILLABLE",
+    HYBRID = "HYBRID"
+}
+export declare enum ReimbursementBillingPresentEnum {
+    YES = "YES",
+    NO = "NO"
+}
+export declare enum ReimbursementIncurredByEnum {
+    SELF = "SELF",
+    SELF_OTHERS = "SELF_OTHERS",
+    OTHERS = "OTHERS"
+}
+export declare enum ReimbursementStatusEnum {
+    APPROVAL_PENDING = "APPROVAL_PENDING",
+    APPROVED = "APPROVED",
+    REJECTED = "REJECTED",
+    PARTIALLY_APPROVED = "PARTIALLY_APPROVED",
+    PAYMENT_DISBURSE = "PAYMENT_DISBURSE",
+    DELETED = "DELETED"
+}
+export declare enum ReimbursementExpenseState {
+    PENDING = "pending",
+    APPROVED = "approved",
+    REJECTED = "rejected",
+    DELETED = "deleted"
+}
+export declare enum ReimbursementPaymentStatusEnum {
+    PAID = "PAID",
+    UNPAID = "UNPAID"
+}
+export declare enum ReimbursementActionEnum {
+    VIEW = "view",
+    EDIT = "edit",
+    DELETE = "delete",
+    APPROVE = "approve",
+    REJECT = "reject",
+    UPDATE_PAYMENT = "update_payment"
+}
+export declare enum ReimbursementExpenseActionEnum {
+    PENDING = "pending",
+    APPROVE = "approve",
+    REJECT = "reject",
+    DELETE = "delete"
+}
+export declare namespace ReimbursementActionEnum {
+    function getLabel(action: ReimbursementActionEnum): string;
+}
+export declare namespace ReimbursementExpenseActionEnum {
+    function getLabel(action: ReimbursementExpenseActionEnum): string;
+}

package/dist/src/entities/enums/reimbursement.entity.enum.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReimbursementExpenseActionEnum = exports.ReimbursementActionEnum = exports.ReimbursementPaymentStatusEnum = exports.ReimbursementExpenseState = exports.ReimbursementStatusEnum = exports.ReimbursementIncurredByEnum = exports.ReimbursementBillingPresentEnum = exports.ReimbursementBillingTypeEnum = void 0;
+const error_key_enum_1 = require("../../enums/error.key.enum");
+const exceptions_1 = require("../../exceptions");
+var ReimbursementBillingTypeEnum;
+(function (ReimbursementBillingTypeEnum) {
+    ReimbursementBillingTypeEnum["BILLABLE"] = "BILLABLE";
+    ReimbursementBillingTypeEnum["NON_BILLABLE"] = "NON_BILLABLE";
+    ReimbursementBillingTypeEnum["HYBRID"] = "HYBRID";
+})(ReimbursementBillingTypeEnum || (exports.ReimbursementBillingTypeEnum = ReimbursementBillingTypeEnum = {}));
+var ReimbursementBillingPresentEnum;
+(function (ReimbursementBillingPresentEnum) {
+    ReimbursementBillingPresentEnum["YES"] = "YES";
+    ReimbursementBillingPresentEnum["NO"] = "NO";
+})(ReimbursementBillingPresentEnum || (exports.ReimbursementBillingPresentEnum = ReimbursementBillingPresentEnum = {}));
+var ReimbursementIncurredByEnum;
+(function (ReimbursementIncurredByEnum) {
+    ReimbursementIncurredByEnum["SELF"] = "SELF";
+    ReimbursementIncurredByEnum["SELF_OTHERS"] = "SELF_OTHERS";
+    ReimbursementIncurredByEnum["OTHERS"] = "OTHERS";
+})(ReimbursementIncurredByEnum || (exports.ReimbursementIncurredByEnum = ReimbursementIncurredByEnum = {}));
+var ReimbursementStatusEnum;
+(function (ReimbursementStatusEnum) {
+    ReimbursementStatusEnum["APPROVAL_PENDING"] = "APPROVAL_PENDING";
+    ReimbursementStatusEnum["APPROVED"] = "APPROVED";
+    ReimbursementStatusEnum["REJECTED"] = "REJECTED";
+    ReimbursementStatusEnum["PARTIALLY_APPROVED"] = "PARTIALLY_APPROVED";
+    ReimbursementStatusEnum["PAYMENT_DISBURSE"] = "PAYMENT_DISBURSE";
+    ReimbursementStatusEnum["DELETED"] = "DELETED";
+})(ReimbursementStatusEnum || (exports.ReimbursementStatusEnum = ReimbursementStatusEnum = {}));
+var ReimbursementExpenseState;
+(function (ReimbursementExpenseState) {
+    ReimbursementExpenseState["PENDING"] = "pending";
+    ReimbursementExpenseState["APPROVED"] = "approved";
+    ReimbursementExpenseState["REJECTED"] = "rejected";
+    ReimbursementExpenseState["DELETED"] = "deleted";
+})(ReimbursementExpenseState || (exports.ReimbursementExpenseState = ReimbursementExpenseState = {}));
+var ReimbursementPaymentStatusEnum;
+(function (ReimbursementPaymentStatusEnum) {
+    ReimbursementPaymentStatusEnum["PAID"] = "PAID";
+    ReimbursementPaymentStatusEnum["UNPAID"] = "UNPAID";
+})(ReimbursementPaymentStatusEnum || (exports.ReimbursementPaymentStatusEnum = ReimbursementPaymentStatusEnum = {}));
+var ReimbursementActionEnum;
+(function (ReimbursementActionEnum) {
+    ReimbursementActionEnum["VIEW"] = "view";
+    ReimbursementActionEnum["EDIT"] = "edit";
+    ReimbursementActionEnum["DELETE"] = "delete";
+    ReimbursementActionEnum["APPROVE"] = "approve";
+    ReimbursementActionEnum["REJECT"] = "reject";
+    ReimbursementActionEnum["UPDATE_PAYMENT"] = "update_payment";
+})(ReimbursementActionEnum || (exports.ReimbursementActionEnum = ReimbursementActionEnum = {}));
+var ReimbursementExpenseActionEnum;
+(function (ReimbursementExpenseActionEnum) {
+    ReimbursementExpenseActionEnum["PENDING"] = "pending";
+    ReimbursementExpenseActionEnum["APPROVE"] = "approve";
+    ReimbursementExpenseActionEnum["REJECT"] = "reject";
+    ReimbursementExpenseActionEnum["DELETE"] = "delete";
+})(ReimbursementExpenseActionEnum || (exports.ReimbursementExpenseActionEnum = ReimbursementExpenseActionEnum = {}));
+(function (ReimbursementActionEnum) {
+    const actionLabelMap = {
+        [ReimbursementActionEnum.VIEW]: "View",
+        [ReimbursementActionEnum.EDIT]: "Edit",
+        [ReimbursementActionEnum.DELETE]: "Delete",
+        [ReimbursementActionEnum.APPROVE]: "Approve",
+        [ReimbursementActionEnum.REJECT]: "Reject",
+        [ReimbursementActionEnum.UPDATE_PAYMENT]: "Update Payment",
+    };
+    function getLabel(action) {
+        if (!Object.values(ReimbursementActionEnum).includes(action)) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.REIMBURSEMENT_FLOW_ACTION,
+                message: ["Invalid action value"],
+            });
+        }
+        const label = actionLabelMap[action];
+        if (!label) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.REIMBURSEMENT_FLOW_ACTION,
+                message: ["Invalid action value"],
+            });
+        }
+        return label;
+    }
+    ReimbursementActionEnum.getLabel = getLabel;
+})(ReimbursementActionEnum || (exports.ReimbursementActionEnum = ReimbursementActionEnum = {}));
+(function (ReimbursementExpenseActionEnum) {
+    const actionLabelMap = {
+        [ReimbursementExpenseActionEnum.PENDING]: "Pending",
+        [ReimbursementExpenseActionEnum.APPROVE]: "Approve",
+        [ReimbursementExpenseActionEnum.REJECT]: "Reject",
+        [ReimbursementExpenseActionEnum.DELETE]: "delete",
+    };
+    function getLabel(action) {
+        if (!Object.values(ReimbursementExpenseActionEnum).includes(action)) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.REIMBURSEMENT_EXPENSE_FLOW_ACTION,
+                message: ["Invalid action value"],
+            });
+        }
+        const label = actionLabelMap[action];
+        if (!label) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.REIMBURSEMENT_EXPENSE_FLOW_ACTION,
+                message: ["Invalid action value"],
+            });
+        }
+        return label;
+    }
+    ReimbursementExpenseActionEnum.getLabel = getLabel;
+})(ReimbursementExpenseActionEnum || (exports.ReimbursementExpenseActionEnum = ReimbursementExpenseActionEnum = {}));

package/dist/src/entities/enums/relation-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum RelationType {
+    ONE = "one",
+    MANY = "many"
+}

package/dist/src/entities/enums/relation-type.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationType = void 0;
+var RelationType;
+(function (RelationType) {
+    RelationType["ONE"] = "one";
+    RelationType["MANY"] = "many";
+})(RelationType || (exports.RelationType = RelationType = {}));

package/dist/src/entities/enums/task.entity.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum TaskStatusEnum {
+    active = "active",
+    deactive = "deactive",
+    deleted = "deleted"
+}
+export declare enum TaskTypeEnum {
+    billable = "billable",
+    non_billable = "non_billable"
+}

package/dist/src/entities/enums/task.entity.enum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskTypeEnum = exports.TaskStatusEnum = void 0;
+var TaskStatusEnum;
+(function (TaskStatusEnum) {
+    TaskStatusEnum["active"] = "active";
+    TaskStatusEnum["deactive"] = "deactive";
+    TaskStatusEnum["deleted"] = "deleted";
+})(TaskStatusEnum || (exports.TaskStatusEnum = TaskStatusEnum = {}));
+var TaskTypeEnum;
+(function (TaskTypeEnum) {
+    TaskTypeEnum["billable"] = "billable";
+    TaskTypeEnum["non_billable"] = "non_billable";
+})(TaskTypeEnum || (exports.TaskTypeEnum = TaskTypeEnum = {}));

package/dist/src/entities/enums/timesheet.action.enum.d.ts

@@ -0,0 +1,13 @@
+export declare enum TimesheetActionEnum {
+    VIEW = "view",
+    EDIT = "edit",
+    DELETE = "delete",
+    CREATE = "create",
+    APPROVE = "approve",
+    REJECT = "reject",
+    RECALL = "recall",
+    BILLING_UPDATE = "billing_update"
+}
+export declare namespace TimesheetActionEnum {
+    function getLabel(action: TimesheetActionEnum): string;
+}

package/dist/src/entities/enums/timesheet.action.enum.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimesheetActionEnum = void 0;
+const error_key_enum_1 = require("../../enums/error.key.enum");
+const exceptions_1 = require("../../exceptions");
+var TimesheetActionEnum;
+(function (TimesheetActionEnum) {
+    TimesheetActionEnum["VIEW"] = "view";
+    TimesheetActionEnum["EDIT"] = "edit";
+    TimesheetActionEnum["DELETE"] = "delete";
+    TimesheetActionEnum["CREATE"] = "create";
+    TimesheetActionEnum["APPROVE"] = "approve";
+    TimesheetActionEnum["REJECT"] = "reject";
+    TimesheetActionEnum["RECALL"] = "recall";
+    TimesheetActionEnum["BILLING_UPDATE"] = "billing_update";
+})(TimesheetActionEnum || (exports.TimesheetActionEnum = TimesheetActionEnum = {}));
+(function (TimesheetActionEnum) {
+    const actionLabelMap = {
+        [TimesheetActionEnum.APPROVE]: "Approve",
+        [TimesheetActionEnum.VIEW]: "View",
+        [TimesheetActionEnum.EDIT]: "Edit",
+        [TimesheetActionEnum.DELETE]: "Delete",
+        [TimesheetActionEnum.CREATE]: "Create",
+        [TimesheetActionEnum.REJECT]: "Reject",
+        [TimesheetActionEnum.RECALL]: "Recall",
+        [TimesheetActionEnum.BILLING_UPDATE]: "Billing Update",
+    };
+    function getLabel(action) {
+        if (!Object.values(TimesheetActionEnum).includes(action)) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.TIMESHEET_FLOW_ACTION,
+                message: ["Invalid action value"],
+            });
+        }
+        const label = actionLabelMap[action];
+        if (!label) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.TIMESHEET_FLOW_ACTION,
+                message: ["Invalid action value"],
+            });
+        }
+        return label;
+    }
+    TimesheetActionEnum.getLabel = getLabel;
+})(TimesheetActionEnum || (exports.TimesheetActionEnum = TimesheetActionEnum = {}));

package/dist/src/entities/enums/timesheet.status.enum.d.ts

@@ -0,0 +1,14 @@
+export declare enum TimesheetStatusEnum {
+    ONTIME = "ontime",
+    CREATE_APPROVAL = "create_approval",
+    EDIT_APPROVAL = "edit_approval",
+    DELETE_APPROVAL = "delete_approval",
+    RESOLVED_REJECTED = "resolved_rejected",
+    REJECTED = "rejected",
+    APPROVED = "approved",
+    DELETED = "deleted"
+}
+export declare namespace TimesheetStatusEnum {
+    function getNames(): string[];
+    function parse(value: string): TimesheetStatusEnum;
+}

package/dist/src/entities/enums/timesheet.status.enum.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimesheetStatusEnum = void 0;
+const error_key_enum_1 = require("../../enums/error.key.enum");
+const exceptions_1 = require("../../exceptions");
+var TimesheetStatusEnum;
+(function (TimesheetStatusEnum) {
+    TimesheetStatusEnum["ONTIME"] = "ontime";
+    TimesheetStatusEnum["CREATE_APPROVAL"] = "create_approval";
+    TimesheetStatusEnum["EDIT_APPROVAL"] = "edit_approval";
+    TimesheetStatusEnum["DELETE_APPROVAL"] = "delete_approval";
+    TimesheetStatusEnum["RESOLVED_REJECTED"] = "resolved_rejected";
+    TimesheetStatusEnum["REJECTED"] = "rejected";
+    TimesheetStatusEnum["APPROVED"] = "approved";
+    TimesheetStatusEnum["DELETED"] = "deleted";
+})(TimesheetStatusEnum || (exports.TimesheetStatusEnum = TimesheetStatusEnum = {}));
+(function (TimesheetStatusEnum) {
+    function getNames() {
+        return Object.values(TimesheetStatusEnum).filter((value) => typeof value === "string");
+    }
+    TimesheetStatusEnum.getNames = getNames;
+    function parse(value) {
+        if (Object.values(TimesheetStatusEnum).includes(value)) {
+            return value;
+        }
+        throw new exceptions_1.AppBadRequestException({
+            key: error_key_enum_1.ErrorKeyEnum.TIMESHEET_STATUS,
+            message: ["Invalid timesheet status"],
+        });
+    }
+    TimesheetStatusEnum.parse = parse;
+})(TimesheetStatusEnum || (exports.TimesheetStatusEnum = TimesheetStatusEnum = {}));

package/dist/src/entities/enums/timezone.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum Timezone {
+    ASIA_KOLKATA = "Asia/Kolkata"
+}

package/dist/src/entities/enums/timezone.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timezone = void 0;
+var Timezone;
+(function (Timezone) {
+    Timezone["ASIA_KOLKATA"] = "Asia/Kolkata";
+})(Timezone || (exports.Timezone = Timezone = {}));

package/dist/src/entities/enums/user.entity.enum.d.ts

@@ -0,0 +1,28 @@
+export declare enum UserStatusEnum {
+    active = "active",
+    deactive = "deactive",
+    suspended = "suspended",
+    pending = "pending",
+    notice_period = "notice_period"
+}
+export declare enum UserRoleEnum {
+    admin = "admin",
+    employee = "employee",
+    partner = "partner",
+    accountant = "accountant",
+    owner = "owner",
+    secretary = "secretary",
+    hr = "hr"
+}
+export declare enum UserGenderEnum {
+    male = "male",
+    female = "female",
+    prefer_not_to_say = "prefer_not_to_say"
+}
+export declare namespace UserRoleEnum {
+    function getNames(): string[];
+    function parse(value: string): UserRoleEnum;
+}
+export declare namespace UserStatusEnum {
+    function getNames(): string[];
+}

package/dist/src/entities/enums/user.entity.enum.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserGenderEnum = exports.UserRoleEnum = exports.UserStatusEnum = void 0;
+const error_key_enum_1 = require("../../enums/error.key.enum");
+const exceptions_1 = require("../../exceptions");
+var UserStatusEnum;
+(function (UserStatusEnum) {
+    UserStatusEnum["active"] = "active";
+    UserStatusEnum["deactive"] = "deactive";
+    UserStatusEnum["suspended"] = "suspended";
+    UserStatusEnum["pending"] = "pending";
+    UserStatusEnum["notice_period"] = "notice_period";
+})(UserStatusEnum || (exports.UserStatusEnum = UserStatusEnum = {}));
+var UserRoleEnum;
+(function (UserRoleEnum) {
+    UserRoleEnum["admin"] = "admin";
+    UserRoleEnum["employee"] = "employee";
+    UserRoleEnum["partner"] = "partner";
+    UserRoleEnum["accountant"] = "accountant";
+    UserRoleEnum["owner"] = "owner";
+    UserRoleEnum["secretary"] = "secretary";
+    UserRoleEnum["hr"] = "hr";
+})(UserRoleEnum || (exports.UserRoleEnum = UserRoleEnum = {}));
+var UserGenderEnum;
+(function (UserGenderEnum) {
+    UserGenderEnum["male"] = "male";
+    UserGenderEnum["female"] = "female";
+    UserGenderEnum["prefer_not_to_say"] = "prefer_not_to_say";
+})(UserGenderEnum || (exports.UserGenderEnum = UserGenderEnum = {}));
+(function (UserRoleEnum) {
+    function getNames() {
+        return Object.values(UserRoleEnum).filter((value) => typeof value === "string");
+    }
+    UserRoleEnum.getNames = getNames;
+    function parse(value) {
+        if (Object.values(UserRoleEnum).includes(value)) {
+            return value;
+        }
+        throw new exceptions_1.AppBadRequestException({
+            key: error_key_enum_1.ErrorKeyEnum.USER_ROLE,
+            message: ["Invalid user role"],
+        });
+    }
+    UserRoleEnum.parse = parse;
+})(UserRoleEnum || (exports.UserRoleEnum = UserRoleEnum = {}));
+(function (UserStatusEnum) {
+    function getNames() {
+        return Object.values(UserStatusEnum).filter((value) => typeof value === "string");
+    }
+    UserStatusEnum.getNames = getNames;
+})(UserStatusEnum || (exports.UserStatusEnum = UserStatusEnum = {}));

package/dist/src/entities/enums/work.from.home.action.enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum WorkFromHomeActionEnum {
+    READ = "read",
+    EDIT = "edit",
+    APPROVE = "approve",
+    REJECT = "reject",
+    DELETE = "delete",
+    RECALL = "recall"
+}
+export declare namespace WorkFromHomeActionEnum {
+    function getLabel(action: WorkFromHomeActionEnum): string;
+}

package/dist/src/entities/enums/work.from.home.action.enum.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkFromHomeActionEnum = void 0;
+const error_key_enum_1 = require("../../enums/error.key.enum");
+const exceptions_1 = require("../../exceptions");
+var WorkFromHomeActionEnum;
+(function (WorkFromHomeActionEnum) {
+    WorkFromHomeActionEnum["READ"] = "read";
+    WorkFromHomeActionEnum["EDIT"] = "edit";
+    WorkFromHomeActionEnum["APPROVE"] = "approve";
+    WorkFromHomeActionEnum["REJECT"] = "reject";
+    WorkFromHomeActionEnum["DELETE"] = "delete";
+    WorkFromHomeActionEnum["RECALL"] = "recall";
+})(WorkFromHomeActionEnum || (exports.WorkFromHomeActionEnum = WorkFromHomeActionEnum = {}));
+(function (WorkFromHomeActionEnum) {
+    const actionLabelMap = {
+        [WorkFromHomeActionEnum.READ]: "Read",
+        [WorkFromHomeActionEnum.EDIT]: "Edit",
+        [WorkFromHomeActionEnum.APPROVE]: "Approve",
+        [WorkFromHomeActionEnum.REJECT]: "Reject",
+        [WorkFromHomeActionEnum.DELETE]: "Delete",
+        [WorkFromHomeActionEnum.RECALL]: "Recall",
+    };
+    function getLabel(action) {
+        if (!Object.values(WorkFromHomeActionEnum).includes(action)) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.WORK_FROM_HOME_FLOW_ACTION,
+                message: ["Invalid action value"],
+            });
+        }
+        const label = actionLabelMap[action];
+        if (!label) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.BANK_FLOW_ACTION,
+                message: ["Invalid action value"],
+            });
+        }
+        return label;
+    }
+    WorkFromHomeActionEnum.getLabel = getLabel;
+})(WorkFromHomeActionEnum || (exports.WorkFromHomeActionEnum = WorkFromHomeActionEnum = {}));

package/dist/src/entities/enums/work.from.home.status.enum.d.ts

@@ -0,0 +1,13 @@
+export declare enum WorkFromHomeStatusEnum {
+    PENDING_APPROVAL = "pending_approval",
+    EDIT_APPROVAL = "edit_approval",
+    DELETE_APPROVAL = "delete_approval",
+    RESOLVE_REJECTED = "resolve_rejected",
+    APPROVED = "approved",
+    REJECTED = "rejected",
+    DELETED = "deleted"
+}
+export declare namespace WorkFromHomeStatusEnum {
+    function getNames(): string[];
+    function parse(value: string): WorkFromHomeStatusEnum;
+}

package/dist/src/entities/enums/work.from.home.status.enum.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkFromHomeStatusEnum = void 0;
+const error_key_enum_1 = require("../../enums/error.key.enum");
+const exceptions_1 = require("../../exceptions");
+var WorkFromHomeStatusEnum;
+(function (WorkFromHomeStatusEnum) {
+    WorkFromHomeStatusEnum["PENDING_APPROVAL"] = "pending_approval";
+    WorkFromHomeStatusEnum["EDIT_APPROVAL"] = "edit_approval";
+    WorkFromHomeStatusEnum["DELETE_APPROVAL"] = "delete_approval";
+    WorkFromHomeStatusEnum["RESOLVE_REJECTED"] = "resolve_rejected";
+    WorkFromHomeStatusEnum["APPROVED"] = "approved";
+    WorkFromHomeStatusEnum["REJECTED"] = "rejected";
+    WorkFromHomeStatusEnum["DELETED"] = "deleted";
+})(WorkFromHomeStatusEnum || (exports.WorkFromHomeStatusEnum = WorkFromHomeStatusEnum = {}));
+(function (WorkFromHomeStatusEnum) {
+    function getNames() {
+        return Object.values(WorkFromHomeStatusEnum).filter((value) => typeof value === "string");
+    }
+    WorkFromHomeStatusEnum.getNames = getNames;
+    function parse(value) {
+        if (Object.values(WorkFromHomeStatusEnum).includes(value)) {
+            return value;
+        }
+        throw new exceptions_1.AppBadRequestException({
+            key: error_key_enum_1.ErrorKeyEnum.WORK_FROM_HOME_STATUS,
+            message: ["Invalid work from home status"],
+        });
+    }
+    WorkFromHomeStatusEnum.parse = parse;
+})(WorkFromHomeStatusEnum || (exports.WorkFromHomeStatusEnum = WorkFromHomeStatusEnum = {}));

package/dist/src/entities/func/convert-to-common-entity.func.d.ts

@@ -0,0 +1,15 @@
+import { Modify } from "../../misc/interface/modify.interface";
+export declare function ConvertToCommonEntity<T extends {
+    createdOn: Date;
+    updatedOn: Date;
+}, R extends Modify<T, {
+    createdOn: string;
+    updatedOn: string;
+}>>(obj: T): R;
+export declare function ConvertApiToEntity<T extends {
+    createdOn: string;
+    updatedOn: string;
+}, R extends Modify<T, {
+    createdOn: Date;
+    updatedOn: Date;
+}>>(obj: T): R;

package/dist/src/entities/func/convert-to-common-entity.func.js

@@ -0,0 +1,24 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvertToCommonEntity = ConvertToCommonEntity;
+exports.ConvertApiToEntity = ConvertApiToEntity;
+function ConvertToCommonEntity(obj) {
+    var _a, _b;
+    const { createdOn: _, updatedOn: __ } = obj, objectToAssign = __rest(obj, ["createdOn", "updatedOn"]);
+    return Object.assign({ createdOn: (_a = obj.createdOn) === null || _a === void 0 ? void 0 : _a.toISOString(), updatedOn: (_b = obj.updatedOn) === null || _b === void 0 ? void 0 : _b.toISOString() }, objectToAssign);
+}
+function ConvertApiToEntity(obj) {
+    const { createdOn: _, updatedOn: __ } = obj, objectToAssign = __rest(obj, ["createdOn", "updatedOn"]);
+    return Object.assign({ createdOn: new Date(obj.createdOn), updatedOn: new Date(obj.updatedOn) }, objectToAssign);
+}

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

@@ -0,0 +1,97 @@
+export * from "./enums/task.entity.enum";
+export * from "./enums/user.entity.enum";
+export * from "./enums/organization.entity.enum";
+export * from "./func/convert-to-common-entity.func";
+export * from "./interface/audit-column.entity.interface";
+export * from "./interface/entity.utils.interface";
+export * from "./interface/organization.entity.interface";
+export * from "./interface/task.entity.interface";
+export * from "./interface/user.entity.interface";
+export * from "./interface/designation.entity.interface";
+export * from "./interface/industry.entity.interface";
+export * from "./interface/configuration.entity.interface";
+export * from "./interface/rate.entity.interface";
+export * from "./interface/client.entity.interface";
+export * from "./interface/project.entity.interface";
+export * from "./interface/timesheet.entity.interface";
+export * from "./enums/reimbursement.entity.enum";
+export * from "./interface/reimbursement.entity.interface";
+export * from "./enums/expense_type.entity.enum";
+export * from "./interface/expense_type.entity.interface";
+export * from "./enums/billing.impact.enum";
+export * from "./enums/payment_status.enum";
+export * from "./interface/billing.entity.interface";
+export * from "./enums/billing.status.enum";
+export * from "./enums/billing.timesheet.change.status.enum";
+export * from "./interface/office.location.entity";
+export * from "./interface/bank.entity.interface";
+export * from "./enums/billing.payment.type.enum";
+export * from "./interface/billing_payment.entity.interface";
+export * from "./interface/client_affiliate_entity.interface";
+export * from "./interface/permission.entity.interface";
+export * from "./interface/role.entity.interface";
+export * from "./interface/role.permission.mapping.entity.interface";
+export * from "./enums/billing.transaction.enum";
+export * from "./interface/billing_transaction.entity.interface";
+export * from "./interface/timesheet_history.entity.interface";
+export * from "./enums/history_operation.enum";
+export * from "./interface/billing_history.entity.interface";
+export * from "./interface/billing_timesheet_history.entity.interface";
+export * from "./enums/history_operation.enum";
+export * from "./enums/timesheet.action.enum";
+export * from "./enums/timesheet.status.enum";
+export * from "./enums/billing.action.enum";
+export * from "./enums/configuration.type.enum";
+export * from "./enums/project_user_status.enum";
+export * from "./interface/reimbursement_expense.entity.interface";
+export * from "./interface/reimbursement_history.entity.interface";
+export * from "./enums/entity_search_constraint_type.enum";
+export * from "./enums/bank_action.enum";
+export * from "./enums/bank_status.enum";
+export * from "./interface/bank_history.entity.interface";
+export * from "./enums/leave.action.enum";
+export * from "./enums/leave.status.enum";
+export * from "./interface/leave.entity.interface";
+export * from "./interface/leave_history.entity.interface";
+export * from "./enums/duration-type.enum";
+export * from "./enums/leave-type.enum";
+export * from "./enums/work.from.home.action.enum";
+export * from "./enums/work.from.home.status.enum";
+export * from "./interface/work_from_home.entity.interface";
+export * from "./interface/work_from_home_history.entity.interface";
+export * from "./interface/country.entity.interface";
+export * from "./enums/billing_invoice_type.enum";
+export * from "./interface/billing_timesheet.entity.interface";
+export * from "./interface/intermediary_bank.entity.interface";
+export * from "./interface/holiday-list.entity.interface";
+export * from "./interface/holiday.entity.interface";
+export * from "./model/leave.entity.model";
+export * from "./model/holiday.entity.model";
+export * from "./enums/cron-jobs-name.enum";
+export * from "./enums/cron-jobs-status.enum";
+export * from "./enums/configuration-key.enum";
+export * from "./enums/timezone.enum";
+export * from "./interface/cron-job.entity.interface";
+export * from "./model/configuration.model";
+export * from "./interface/to-do.entity.interface";
+export * from "./enums/billing-type.enum";
+export * from "./interface/billing-reimbursement-expense.entity.interface";
+export * from "./enums/billing-reimbursement-expense-change-status.enum";
+export * from "./interface/billing-reimbursement-expense-history.entity.interface";
+export * from "./enums/billing-reimburement-expense-impact.enum";
+export * from "./model/bank.entity.model";
+export * from "./model/base.entity.model";
+export * from "./model/billing-reimbursement-expense.entity.model";
+export * from "./model/billing.entity.model";
+export * from "./model/entity.model.interface";
+export * from "./model/project-user-mapping.entity.model";
+export * from "./model/project.entity.model";
+export * from "./model/reimbursement-expense.entity.model";
+export * from "./model/reimbursement.entity.model";
+export * from "./model/task.entity.model";
+export * from "./model/user.entity.model";
+export * from "./model/client.entity.model";
+export * from "./model/configuration.model";
+export * from "./model/designation.entity.model";
+export * from "./model/timesheet.entity.model";
+export * from "./model/user.entity.model";