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

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

@@ -0,0 +1,12 @@
+export declare enum BillingStatusEnum {
+    PENDING_APPROVAL = "PENDING_APPROVAL",
+    REQUEST_CHANGES = "REQUEST_CHANGES",
+    INTERNAL_APPROVED = "INTERNAL_APPROVED",
+    PENDING_CLIENT_REVIEW = "PENDING_CLIENT_REVIEW",
+    CLIENT_REVISION_APPROVAL = "CLIENT_REVISION_APPROVAL",
+    CANCELLED = "CANCELLED",
+    REJECT_CLIENT_REVISION = "REJECT_CLIENT_REVISION",
+    INVOICE_SENT = "INVOICE_SENT",
+    PENDING_PAYMENT = "PENDING_PAYMENT",
+    SETTLED = "SETTLED"
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingStatusEnum = void 0;
+var BillingStatusEnum;
+(function (BillingStatusEnum) {
+    BillingStatusEnum["PENDING_APPROVAL"] = "PENDING_APPROVAL";
+    BillingStatusEnum["REQUEST_CHANGES"] = "REQUEST_CHANGES";
+    BillingStatusEnum["INTERNAL_APPROVED"] = "INTERNAL_APPROVED";
+    BillingStatusEnum["PENDING_CLIENT_REVIEW"] = "PENDING_CLIENT_REVIEW";
+    BillingStatusEnum["CLIENT_REVISION_APPROVAL"] = "CLIENT_REVISION_APPROVAL";
+    BillingStatusEnum["CANCELLED"] = "CANCELLED";
+    BillingStatusEnum["REJECT_CLIENT_REVISION"] = "REJECT_CLIENT_REVISION";
+    BillingStatusEnum["INVOICE_SENT"] = "INVOICE_SENT";
+    BillingStatusEnum["PENDING_PAYMENT"] = "PENDING_PAYMENT";
+    BillingStatusEnum["SETTLED"] = "SETTLED";
+})(BillingStatusEnum || (exports.BillingStatusEnum = BillingStatusEnum = {}));

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

@@ -0,0 +1,5 @@
+export declare enum BillingTimesheetStatusEnum {
+    UNCHANGED = "unchanged",
+    UPDATED = "updated",
+    DELETED = "deleted"
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingTimesheetStatusEnum = void 0;
+var BillingTimesheetStatusEnum;
+(function (BillingTimesheetStatusEnum) {
+    BillingTimesheetStatusEnum["UNCHANGED"] = "unchanged";
+    BillingTimesheetStatusEnum["UPDATED"] = "updated";
+    BillingTimesheetStatusEnum["DELETED"] = "deleted";
+})(BillingTimesheetStatusEnum || (exports.BillingTimesheetStatusEnum = BillingTimesheetStatusEnum = {}));

package/dist/src/entities/enums/billing.transaction.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum BillingTransactionType {
+    TDS = "TDS",
+    WRITE_OFF = "WRITE_OFF",
+    CREDIT_NOTE = "CREDIT_NOTE",
+    PAYMENT = "PAYMENT"
+}
+export declare namespace BillingTransactionType {
+    function getNames(): string[];
+    function parse(value: string): BillingTransactionType;
+}

package/dist/src/entities/enums/billing.transaction.enum.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingTransactionType = void 0;
+const error_key_enum_1 = require("../../enums/error.key.enum");
+const exceptions_1 = require("../../exceptions");
+var BillingTransactionType;
+(function (BillingTransactionType) {
+    BillingTransactionType["TDS"] = "TDS";
+    BillingTransactionType["WRITE_OFF"] = "WRITE_OFF";
+    BillingTransactionType["CREDIT_NOTE"] = "CREDIT_NOTE";
+    BillingTransactionType["PAYMENT"] = "PAYMENT";
+})(BillingTransactionType || (exports.BillingTransactionType = BillingTransactionType = {}));
+(function (BillingTransactionType) {
+    function getNames() {
+        return Object.values(BillingTransactionType).filter((value) => typeof value === "string");
+    }
+    BillingTransactionType.getNames = getNames;
+    function parse(value) {
+        if (Object.values(BillingTransactionType).includes(value)) {
+            return value;
+        }
+        throw new exceptions_1.AppBadRequestException({
+            key: error_key_enum_1.ErrorKeyEnum.BILLING_TRANSACTION_TYPE,
+            message: ["Invalid Billing Transaction Type"],
+        });
+    }
+    BillingTransactionType.parse = parse;
+})(BillingTransactionType || (exports.BillingTransactionType = BillingTransactionType = {}));

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

@@ -0,0 +1,4 @@
+export declare enum BillingInvoiceTypeEnum {
+    CLIENT = "client",
+    CLIENT_AFFILIATE = "client_affiliate"
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingInvoiceTypeEnum = void 0;
+var BillingInvoiceTypeEnum;
+(function (BillingInvoiceTypeEnum) {
+    BillingInvoiceTypeEnum["CLIENT"] = "client";
+    BillingInvoiceTypeEnum["CLIENT_AFFILIATE"] = "client_affiliate";
+})(BillingInvoiceTypeEnum || (exports.BillingInvoiceTypeEnum = BillingInvoiceTypeEnum = {}));

package/dist/src/entities/enums/configuration-key.enum.d.ts

@@ -0,0 +1,8 @@
+import { CronJobNames } from "./cron-jobs-name.enum";
+export declare enum ConfigurationKeyEnum {
+    PENDING_APPROVAL_TIMESHEET_REMINDER = "pendingApprovalTimesheetReminder"
+}
+export declare namespace ConfigurationKeyEnum {
+    function IsCronJobConfigurationKey(key: ConfigurationKeyEnum): boolean;
+    function getCronJobName(configurationKey: ConfigurationKeyEnum): CronJobNames;
+}

package/dist/src/entities/enums/configuration-key.enum.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationKeyEnum = void 0;
+const cron_jobs_name_enum_1 = require("./cron-jobs-name.enum");
+var ConfigurationKeyEnum;
+(function (ConfigurationKeyEnum) {
+    ConfigurationKeyEnum["PENDING_APPROVAL_TIMESHEET_REMINDER"] = "pendingApprovalTimesheetReminder";
+})(ConfigurationKeyEnum || (exports.ConfigurationKeyEnum = ConfigurationKeyEnum = {}));
+(function (ConfigurationKeyEnum) {
+    function IsCronJobConfigurationKey(key) {
+        if (getCronJobName(key))
+            return true;
+        return false;
+    }
+    ConfigurationKeyEnum.IsCronJobConfigurationKey = IsCronJobConfigurationKey;
+    function getCronJobName(configurationKey) {
+        const cronJobConfigurationKeyMapping = {
+            [ConfigurationKeyEnum.PENDING_APPROVAL_TIMESHEET_REMINDER]: cron_jobs_name_enum_1.CronJobNames.PENDING_APPROVAL_TIMESHEET_REMINDER,
+        };
+        return cronJobConfigurationKeyMapping[configurationKey];
+    }
+    ConfigurationKeyEnum.getCronJobName = getCronJobName;
+})(ConfigurationKeyEnum || (exports.ConfigurationKeyEnum = ConfigurationKeyEnum = {}));

package/dist/src/entities/enums/configuration.type.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum ConfigurationTypeEnum {
+    INTEGER = "integer",
+    INTEGER_POSITIVE = "integer_positive",
+    INTEGER_NEGATIVE = "integer_negative",
+    STRING = "string",
+    CRONJOB_EXPRESSION = "cronjob_expression"
+}

package/dist/src/entities/enums/configuration.type.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationTypeEnum = void 0;
+var ConfigurationTypeEnum;
+(function (ConfigurationTypeEnum) {
+    ConfigurationTypeEnum["INTEGER"] = "integer";
+    ConfigurationTypeEnum["INTEGER_POSITIVE"] = "integer_positive";
+    ConfigurationTypeEnum["INTEGER_NEGATIVE"] = "integer_negative";
+    ConfigurationTypeEnum["STRING"] = "string";
+    ConfigurationTypeEnum["CRONJOB_EXPRESSION"] = "cronjob_expression";
+})(ConfigurationTypeEnum || (exports.ConfigurationTypeEnum = ConfigurationTypeEnum = {}));

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

@@ -0,0 +1,42 @@
+"use strict";
+// export enum CountryEnum {
+//   India = "India",
+//   USA = "USA",
+//   UK = "UK",
+//   Singapore = "Singapore",
+//   Japan = "Japan",
+//   Israel = "Israel",
+//   France = "France",
+//   Mauritius = "Mauritius",
+//   China = "China",
+//   South_Korea = "South Korea",
+// }
+// export namespace CountryEnum {
+//   export function values() {
+//     return Object.keys(CountryEnum).filter(
+//       (type) => isNaN(<any>type) && type !== "values"
+//     );
+//   }
+//   export function keys() {
+//     return Object.keys(CountryEnum).filter(
+//       (type) => isNaN(<any>type) && type !== "values"
+//     );
+//   }
+//   export function getCountryTimezone(country: CountryEnum): string {
+//     switch (country) {
+//       case CountryEnum.India:
+//         return "Asia/Kolkata";
+//       case CountryEnum.USA:
+//         return "America/New_York";
+//       case CountryEnum.UK:
+//         return "Europe/London";
+//       default:
+//         return "UTC";
+//     }
+//   }
+//   export function getNames(): string[] {
+//     return Object.values(CountryEnum).filter(
+//       (value) => typeof value === "string"
+//     ) as string[];
+//   }
+// }

package/dist/src/entities/enums/cron-jobs-name.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum CronJobNames {
+    PENDING_APPROVAL_TIMESHEET_REMINDER = "pending_approval_timesheet_reminder"
+}

package/dist/src/entities/enums/cron-jobs-name.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronJobNames = void 0;
+var CronJobNames;
+(function (CronJobNames) {
+    CronJobNames["PENDING_APPROVAL_TIMESHEET_REMINDER"] = "pending_approval_timesheet_reminder";
+})(CronJobNames || (exports.CronJobNames = CronJobNames = {}));

package/dist/src/entities/enums/cron-jobs-status.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum CronJobStatus {
+    RUNNING = "running",
+    FAILED = "failed",
+    SUCCESS = "success"
+}

package/dist/src/entities/enums/cron-jobs-status.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronJobStatus = void 0;
+var CronJobStatus;
+(function (CronJobStatus) {
+    CronJobStatus["RUNNING"] = "running";
+    CronJobStatus["FAILED"] = "failed";
+    CronJobStatus["SUCCESS"] = "success";
+})(CronJobStatus || (exports.CronJobStatus = CronJobStatus = {}));

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

@@ -0,0 +1,16 @@
+export declare enum DurationTypeEnum {
+    FIRST = "first",
+    SECOND = "second",
+    FULL = "full",
+    FULL_FIRST = "full_first",
+    SECOND_FULL = "second_full",
+    SECOND_FIRST = "second_first"
+}
+export declare namespace DurationTypeEnum {
+    function getDropdownLabel(action: DurationTypeEnum): string;
+    function getLeaveTypeFromStartEnd(from: DurationTypeEnum, to?: DurationTypeEnum): DurationTypeEnum;
+    function getStartEndFromLeaveType(type: DurationTypeEnum): {
+        fromType: DurationTypeEnum;
+        toType: DurationTypeEnum;
+    };
+}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurationTypeEnum = void 0;
+const error_key_enum_1 = require("../../enums/error.key.enum");
+const exceptions_1 = require("../../exceptions");
+var DurationTypeEnum;
+(function (DurationTypeEnum) {
+    DurationTypeEnum["FIRST"] = "first";
+    DurationTypeEnum["SECOND"] = "second";
+    DurationTypeEnum["FULL"] = "full";
+    DurationTypeEnum["FULL_FIRST"] = "full_first";
+    DurationTypeEnum["SECOND_FULL"] = "second_full";
+    DurationTypeEnum["SECOND_FIRST"] = "second_first";
+})(DurationTypeEnum || (exports.DurationTypeEnum = DurationTypeEnum = {}));
+(function (DurationTypeEnum) {
+    const typeLabelMap = {
+        [DurationTypeEnum.FIRST]: "First Half",
+        [DurationTypeEnum.SECOND]: "Second Half",
+        [DurationTypeEnum.FULL]: "Full Day",
+    };
+    function getDropdownLabel(action) {
+        if (!Object.values(DurationTypeEnum).includes(action)) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.LEAVE_TYPE,
+                message: ["Invalid type value"],
+            });
+        }
+        const label = typeLabelMap[action];
+        if (!label) {
+            throw new exceptions_1.AppBadRequestException({
+                key: error_key_enum_1.ErrorKeyEnum.LEAVE_TYPE,
+                message: ["Invalid type value"],
+            });
+        }
+        return label;
+    }
+    DurationTypeEnum.getDropdownLabel = getDropdownLabel;
+    function getLeaveTypeFromStartEnd(from, to) {
+        if (!to || from === to)
+            return from;
+        if (from === DurationTypeEnum.FULL && to === DurationTypeEnum.FIRST)
+            return DurationTypeEnum.FULL_FIRST;
+        if (from === DurationTypeEnum.SECOND && to === DurationTypeEnum.FULL)
+            return DurationTypeEnum.SECOND_FULL;
+        if (from === DurationTypeEnum.SECOND && to === DurationTypeEnum.FIRST)
+            return DurationTypeEnum.SECOND_FIRST;
+        throw new Error(`Invalid leave type: ${from} + ${to}`);
+    }
+    DurationTypeEnum.getLeaveTypeFromStartEnd = getLeaveTypeFromStartEnd;
+    function getStartEndFromLeaveType(type) {
+        switch (type) {
+            case DurationTypeEnum.FIRST:
+                return {
+                    fromType: DurationTypeEnum.FIRST,
+                    toType: DurationTypeEnum.FIRST,
+                };
+            case DurationTypeEnum.SECOND:
+                return {
+                    fromType: DurationTypeEnum.SECOND,
+                    toType: DurationTypeEnum.SECOND,
+                };
+            case DurationTypeEnum.FULL:
+                return {
+                    fromType: DurationTypeEnum.FULL,
+                    toType: DurationTypeEnum.FULL,
+                };
+            case DurationTypeEnum.FULL_FIRST:
+                return {
+                    fromType: DurationTypeEnum.FULL,
+                    toType: DurationTypeEnum.FIRST,
+                };
+            case DurationTypeEnum.SECOND_FULL:
+                return {
+                    fromType: DurationTypeEnum.SECOND,
+                    toType: DurationTypeEnum.FULL,
+                };
+            case DurationTypeEnum.SECOND_FIRST:
+                return {
+                    fromType: DurationTypeEnum.SECOND,
+                    toType: DurationTypeEnum.FIRST,
+                };
+            default:
+                throw new Error(`Invalid DurationTypeEnum: ${type}`);
+        }
+    }
+    DurationTypeEnum.getStartEndFromLeaveType = getStartEndFromLeaveType;
+})(DurationTypeEnum || (exports.DurationTypeEnum = DurationTypeEnum = {}));

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

@@ -0,0 +1,3 @@
+export declare enum EntitySearchConstraintTypeEnum {
+    COLUMN_DEPTH = "column_depth"
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitySearchConstraintTypeEnum = void 0;
+var EntitySearchConstraintTypeEnum;
+(function (EntitySearchConstraintTypeEnum) {
+    EntitySearchConstraintTypeEnum["COLUMN_DEPTH"] = "column_depth";
+})(EntitySearchConstraintTypeEnum || (exports.EntitySearchConstraintTypeEnum = EntitySearchConstraintTypeEnum = {}));

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

@@ -0,0 +1,4 @@
+export declare enum ExpenseTypeEnum {
+    BILLABLE = "billable",
+    NON_BILLABLE = "non_billable"
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpenseTypeEnum = void 0;
+var ExpenseTypeEnum;
+(function (ExpenseTypeEnum) {
+    ExpenseTypeEnum["BILLABLE"] = "billable";
+    ExpenseTypeEnum["NON_BILLABLE"] = "non_billable";
+})(ExpenseTypeEnum || (exports.ExpenseTypeEnum = ExpenseTypeEnum = {}));

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

@@ -0,0 +1,9 @@
+export declare enum HistoryOperationEnum {
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete"
+}
+export declare namespace HistoryOperationEnum {
+    function getNames(): string[];
+    function parse(value: string): HistoryOperationEnum;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryOperationEnum = void 0;
+const error_key_enum_1 = require("../../enums/error.key.enum");
+const exceptions_1 = require("../../exceptions");
+var HistoryOperationEnum;
+(function (HistoryOperationEnum) {
+    HistoryOperationEnum["CREATE"] = "create";
+    HistoryOperationEnum["UPDATE"] = "update";
+    HistoryOperationEnum["DELETE"] = "delete";
+})(HistoryOperationEnum || (exports.HistoryOperationEnum = HistoryOperationEnum = {}));
+(function (HistoryOperationEnum) {
+    function getNames() {
+        return Object.values(HistoryOperationEnum).filter((value) => typeof value === "string");
+    }
+    HistoryOperationEnum.getNames = getNames;
+    function parse(value) {
+        if (Object.values(HistoryOperationEnum).includes(value)) {
+            return value;
+        }
+        throw new exceptions_1.AppBadRequestException({
+            key: error_key_enum_1.ErrorKeyEnum.HISTORY_OPERATION,
+            message: ["Invalid History operation"],
+        });
+    }
+    HistoryOperationEnum.parse = parse;
+})(HistoryOperationEnum || (exports.HistoryOperationEnum = HistoryOperationEnum = {}));

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

@@ -0,0 +1,8 @@
+export declare enum LeaveTypeEnum {
+    LEISURE = "leisure",
+    ILLNESS = "illness",
+    BEREAVEMENT = "bereavement",
+    SICK = "sick",
+    UNPAID = "unpaid",
+    BIRTHDAY = "birthday"
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveTypeEnum = void 0;
+var LeaveTypeEnum;
+(function (LeaveTypeEnum) {
+    LeaveTypeEnum["LEISURE"] = "leisure";
+    LeaveTypeEnum["ILLNESS"] = "illness";
+    LeaveTypeEnum["BEREAVEMENT"] = "bereavement";
+    LeaveTypeEnum["SICK"] = "sick";
+    LeaveTypeEnum["UNPAID"] = "unpaid";
+    LeaveTypeEnum["BIRTHDAY"] = "birthday";
+})(LeaveTypeEnum || (exports.LeaveTypeEnum = LeaveTypeEnum = {}));

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

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

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

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

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

@@ -0,0 +1,13 @@
+export declare enum LeaveStatusEnum {
+    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 LeaveStatusEnum {
+    function getNames(): string[];
+    function parse(value: string): LeaveStatusEnum;
+}

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

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

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

@@ -0,0 +1,4 @@
+export declare enum OrganizationStatusEnum {
+    active = "active",
+    deactive = "deactive"
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationStatusEnum = void 0;
+var OrganizationStatusEnum;
+(function (OrganizationStatusEnum) {
+    OrganizationStatusEnum["active"] = "active";
+    OrganizationStatusEnum["deactive"] = "deactive";
+})(OrganizationStatusEnum || (exports.OrganizationStatusEnum = OrganizationStatusEnum = {}));

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

@@ -0,0 +1,4 @@
+export declare enum PaymentStatusEnum {
+    PENDING = "pending",
+    SETTLED = "settled"
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentStatusEnum = void 0;
+var PaymentStatusEnum;
+(function (PaymentStatusEnum) {
+    PaymentStatusEnum["PENDING"] = "pending";
+    PaymentStatusEnum["SETTLED"] = "settled";
+})(PaymentStatusEnum || (exports.PaymentStatusEnum = PaymentStatusEnum = {}));

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

@@ -0,0 +1,15 @@
+export declare enum ProjectBillingTypeEnum {
+    HOURLY = "HOURLY",
+    FIXED = "FIXED",
+    ADHOC = "ADHOC"
+}
+export declare enum ProjectStatusEnum {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    DELETED = "DELETED",
+    COMPLETED = "COMPLETED",
+    ON_HOLD = "ON_HOLD",
+    SUSPENDED = "SUSPENDED",
+    CANCELLED = "CANCELLED",
+    ARCHIVED = "ARCHIVED"
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectStatusEnum = exports.ProjectBillingTypeEnum = void 0;
+var ProjectBillingTypeEnum;
+(function (ProjectBillingTypeEnum) {
+    ProjectBillingTypeEnum["HOURLY"] = "HOURLY";
+    ProjectBillingTypeEnum["FIXED"] = "FIXED";
+    ProjectBillingTypeEnum["ADHOC"] = "ADHOC";
+})(ProjectBillingTypeEnum || (exports.ProjectBillingTypeEnum = ProjectBillingTypeEnum = {}));
+var ProjectStatusEnum;
+(function (ProjectStatusEnum) {
+    ProjectStatusEnum["ACTIVE"] = "ACTIVE";
+    ProjectStatusEnum["INACTIVE"] = "INACTIVE";
+    ProjectStatusEnum["DELETED"] = "DELETED";
+    ProjectStatusEnum["COMPLETED"] = "COMPLETED";
+    ProjectStatusEnum["ON_HOLD"] = "ON_HOLD";
+    ProjectStatusEnum["SUSPENDED"] = "SUSPENDED";
+    ProjectStatusEnum["CANCELLED"] = "CANCELLED";
+    ProjectStatusEnum["ARCHIVED"] = "ARCHIVED";
+})(ProjectStatusEnum || (exports.ProjectStatusEnum = ProjectStatusEnum = {}));

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

@@ -0,0 +1,4 @@
+export declare enum ProjectUserStatusEnum {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectUserStatusEnum = void 0;
+var ProjectUserStatusEnum;
+(function (ProjectUserStatusEnum) {
+    ProjectUserStatusEnum["ACTIVE"] = "ACTIVE";
+    ProjectUserStatusEnum["INACTIVE"] = "INACTIVE";
+})(ProjectUserStatusEnum || (exports.ProjectUserStatusEnum = ProjectUserStatusEnum = {}));