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

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

@@ -0,0 +1,35 @@
+import { IClientApiEntity } from "../../api";
+import { EntityEnum, EnumEntityType } from "../interface/entity.utils.interface";
+import { RelationConfigs } from "../interface/relation-config.interface";
+import { BaseEntityModel } from "./base.entity.model";
+import { ProjectEntityModel } from "./project.entity.model";
+export declare class ClientEntityModel extends BaseEntityModel<EntityEnum.CLIENT> implements IClientApiEntity {
+    createdOn: string;
+    updatedOn: string;
+    id: number;
+    name: string;
+    description?: string;
+    primaryContactName: string;
+    primaryContact: string;
+    primaryEmail: string;
+    secondaryContactName?: string;
+    secondaryEmail?: string;
+    address?: string;
+    secondaryContact?: string;
+    country?: string;
+    industry?: string;
+    zipCode?: string;
+    organizationId: number;
+    reference?: string;
+    createdBy: number;
+    updatedBy: number;
+    projectIds?: number[];
+    billingOverdueDays: number;
+    projects: ProjectEntityModel[];
+    getRelationConfigs(): any;
+    static relationConfigs: RelationConfigs<[
+        EntityEnum.PROJECT
+    ], EnumEntityType<EntityEnum.CLIENT>>;
+    static fromApiEntity(apiEntity: IClientApiEntity): ClientEntityModel;
+    populateProjectIds(projects: ProjectEntityModel[]): ClientEntityModel;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientEntityModel = void 0;
+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 ClientEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.createdOn = "";
+        this.updatedOn = "";
+        this.id = 0;
+        this.name = "";
+        this.primaryContactName = "";
+        this.primaryContact = "";
+        this.primaryEmail = "";
+        this.organizationId = 0;
+        this.createdBy = 0;
+        this.updatedBy = 0;
+        this.billingOverdueDays = 0;
+        this.projects = [];
+    }
+    getRelationConfigs() {
+        // return this.constructor.prototype.relationConfigs || [];
+        return this.constructor.prototype.constructor.relationConfigs;
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new ClientEntityModel(entity_utils_interface_1.EntityEnum.CLIENT);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+    populateProjectIds(projects) {
+        this.projectIds = projects
+            .filter((project) => project.clientId === this.id)
+            .map((project) => project.id);
+        return this;
+    }
+}
+exports.ClientEntityModel = ClientEntityModel;
+ClientEntityModel.relationConfigs = [
+    {
+        name: entity_utils_interface_1.EntityEnum.PROJECT,
+        relation: relation_type_enum_1.RelationType.MANY,
+        key: "projects",
+        mapKeyConfig: {
+            relationKey: "clientId",
+            key: "id",
+        },
+    },
+];

package/dist/src/entities/model/configuration.model.d.ts

@@ -1,20 +1,19 @@
-import { ConfigurationKeyEnum, ConfigurationTypeEnum, IConfigurationEntity } from "..";
-export interface IConfigurationsModel extends IConfigurationEntity {
-    isCronJobKey(): boolean;
-}
-export declare class ConfigurationsModel implements IConfigurationsModel {
+import { ConfigurationKeyEnum, ConfigurationTypeEnum } from "..";
+import { IConfigurationApiEntity } from "../../api";
+export declare class ConfigurationEntityModel implements IConfigurationApiEntity {
     id: number;
     key: ConfigurationKeyEnum;
     value: string;
     description: string;
     label: string;
     type: ConfigurationTypeEnum;
-    createdOn: Date;
-    updatedOn: Date;
+    createdOn: string;
+    updatedOn: string;
     createdBy: number;
     updatedBy: number;
     organizationId: number;
-    constructor(data: IConfigurationEntity);
+    constructor(data: IConfigurationApiEntity);
     isCronJobKey(): boolean;
-    static findByKey(configurationEntities: IConfigurationEntity[], key: ConfigurationKeyEnum): IConfigurationEntity | undefined;
+    static findByKey(configurationEntities: IConfigurationApiEntity[], key: ConfigurationKeyEnum): IConfigurationApiEntity | undefined;
+    static fromApiEntity(apiEntity: IConfigurationApiEntity): ConfigurationEntityModel;
 }

package/dist/src/entities/model/configuration.model.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigurationsModel = void 0;
+exports.ConfigurationEntityModel = void 0;
 const __1 = require("..");
-class ConfigurationsModel {
+class ConfigurationEntityModel {
     constructor(data) {
         this.id = 0;
         this.key = __1.ConfigurationKeyEnum.PENDING_APPROVAL_TIMESHEET_REMINDER;
@@ -10,8 +10,8 @@ class ConfigurationsModel {
         this.description = "";
         this.label = "";
         this.type = __1.ConfigurationTypeEnum.CRONJOB_EXPRESSION;
-        this.createdOn = new Date();
-        this.updatedOn = new Date();
+        this.createdOn = "";
+        this.updatedOn = "";
         this.createdBy = 0;
         this.updatedBy = 0;
         this.organizationId = 0;
@@ -23,5 +23,10 @@ class ConfigurationsModel {
     static findByKey(configurationEntities, key) {
         return configurationEntities.find((configurationEntity) => configurationEntity.key === key);
     }
+    static fromApiEntity(apiEntity) {
+        const entity = new ConfigurationEntityModel(apiEntity);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
 }
-exports.ConfigurationsModel = ConfigurationsModel;
+exports.ConfigurationEntityModel = ConfigurationEntityModel;

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

@@ -1,11 +1,14 @@
-import { IDesignationEntity } from "../interface/designation.entity.interface";
-export declare class DesignationEntityModel implements IDesignationEntity {
+import { IDesignationApiEntity } from "../interface/designation.entity.interface";
+import { EntityEnum } from "../interface/entity.utils.interface";
+import { BaseEntityModel } from "./base.entity.model";
+export declare class DesignationEntityModel extends BaseEntityModel<EntityEnum.DESIGNATION> implements IDesignationApiEntity {
     id: number;
     name: string;
     description?: string;
     createdBy: number;
-    createdOn: Date;
+    createdOn: string;
     updatedBy: number;
-    updatedOn: Date;
-    constructor(data: IDesignationEntity);
+    updatedOn: string;
+    static fromApiEntity(apiEntity: IDesignationApiEntity): DesignationEntityModel;
+    getRelationConfigs(): any[];
 }

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

@@ -1,15 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DesignationEntityModel = void 0;
-class DesignationEntityModel {
-    constructor(data) {
-        this.id = data.id;
-        this.name = data.name;
-        this.description = data.description;
-        this.createdBy = data.createdBy;
-        this.createdOn = data.createdOn;
-        this.updatedBy = data.updatedBy;
-        this.updatedOn = data.updatedOn;
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+class DesignationEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.name = "";
+        this.createdBy = 0;
+        this.createdOn = "";
+        this.updatedBy = 0;
+        this.updatedOn = "";
+    }
+    //   constructor(data: IDesignationApiEntity) {
+    // this.id = data.id;
+    // this.name = data.name;
+    // this.description = data.description;
+    // this.createdBy = data.createdBy;
+    // this.createdOn = data.createdOn;
+    // this.updatedBy = data.updatedBy;
+    // this.updatedOn = data.updatedOn;
+    //   }
+    static fromApiEntity(apiEntity) {
+        const entity = new DesignationEntityModel(entity_utils_interface_1.EntityEnum.DESIGNATION);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+    getRelationConfigs() {
+        return this.constructor.prototype.constructor.relationConfigs || [];
     }
 }
 exports.DesignationEntityModel = DesignationEntityModel;

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

@@ -0,0 +1,8 @@
+import { EntityEnum, EntityIndexMap, EntityMap, EnumEntityType, IBaseEntityApiResponse } from "../interface/entity.utils.interface";
+export declare function mapToIndex(entityMap: EntityMap): EntityIndexMap;
+export declare function getEntityIndexMap<T extends EntityEnum>(data: IBaseEntityApiResponse<EnumEntityType<T>>, baseEntity: T, reusedConfig?: {
+    existingEntityIndexMap: EntityIndexMap;
+    enumEntities: EntityEnum[];
+}): EntityIndexMap;
+export declare function populateRelationsFor(entityIndexMap: EntityIndexMap, enumEntities: EntityEnum[]): void;
+export declare function parseEntities<T extends EnumEntityType<EntityEnum>>(json: IBaseEntityApiResponse<T>, baseEntity: EntityEnum, entityMap: EntityMap): EntityMap;

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToIndex = mapToIndex;
+exports.getEntityIndexMap = getEntityIndexMap;
+exports.populateRelationsFor = populateRelationsFor;
+exports.parseEntities = parseEntities;
+const entity_utils_interface_1 = require("../interface/entity.utils.interface");
+const base_entity_model_1 = require("./base.entity.model");
+const billing_reimbursement_expense_entity_model_1 = require("./billing-reimbursement-expense.entity.model");
+const billing_entity_model_1 = require("./billing.entity.model");
+const client_entity_model_1 = require("./client.entity.model");
+const project_user_mapping_entity_model_1 = require("./project-user-mapping.entity.model");
+const project_entity_model_1 = require("./project.entity.model");
+const reimbursement_expense_entity_model_1 = require("./reimbursement-expense.entity.model");
+const reimbursement_entity_model_1 = require("./reimbursement.entity.model");
+const user_entity_model_1 = require("./user.entity.model");
+function mapToIndex(entityMap) {
+    return Object.keys(entityMap).reduce((acc, key) => {
+        // @ts-ignore
+        acc[key] = entityMap[key].reduce((innerAcc, entity) => {
+            innerAcc[entity.id] = entity;
+            return innerAcc;
+        }, {});
+        return acc;
+    }, {});
+}
+function getEntityIndexMap(data, baseEntity, reusedConfig) {
+    const entityMap = {};
+    parseEntities(data, baseEntity, entityMap);
+    const entityIndexMap = mapToIndex(entityMap);
+    if (reusedConfig) {
+        for (const entity of reusedConfig.enumEntities) {
+            // @ts-ignore
+            entityIndexMap[entity] = reusedConfig.existingEntityIndexMap[entity];
+        }
+    }
+    return entityIndexMap;
+}
+function populateRelationsFor(entityIndexMap, enumEntities) {
+    enumEntities.forEach((entity) => {
+        base_entity_model_1.BaseEntityModel.populateRelationsForEntities(entityIndexMap, entity);
+    });
+}
+function parseEntities(json, baseEntity, entityMap) {
+    var _a;
+    const entityFromJsonMappings = {
+        [entity_utils_interface_1.EntityEnum.PROJECT]: project_entity_model_1.ProjectEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.CLIENT]: client_entity_model_1.ClientEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING]: billing_entity_model_1.BillingEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.USER]: user_entity_model_1.UserEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.PROJECT_USER_MAPPING]: project_user_mapping_entity_model_1.ProjectUserMappingEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.REIMBURSEMENT]: reimbursement_entity_model_1.ReimbursementEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.REIMBURSEMENT_EXPENSE]: reimbursement_expense_entity_model_1.ReimbursementExpenseEntityModel.fromApiEntity,
+        [entity_utils_interface_1.EntityEnum.BILLING_REIMBURSEMENT_EXPENSE]: billing_reimbursement_expense_entity_model_1.BillingReimbursementExpneseEntityModel.fromApiEntity,
+    };
+    if (!(baseEntity in entityFromJsonMappings)) {
+        throw new Error(`Unknown entity: ${baseEntity}`);
+    }
+    entityMap[baseEntity] = ((_a = json["baseEntities"]) !== null && _a !== void 0 ? _a : []).map((e) => entityFromJsonMappings[baseEntity](e));
+    if (json["relatedEntities"]) {
+        const relatedEntities = json["relatedEntities"];
+        for (const entityName in relatedEntities) {
+            parseEntities(
+            // @ts-ignore
+            relatedEntities[entityName], entityName, entityMap);
+        }
+    }
+    return entityMap;
+}

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

@@ -1,19 +1 @@
-import { DateCodeModel } from "../../utils";
-import { IAuditColumnEntity } from "../interface/audit-column.entity.interface";
-import { IHolidayEntity } from "../interface/holiday.entity.interface";
-export declare class BaseEntityModel<T extends IAuditColumnEntity> {
-    createdOn: Date;
-    updatedOn: Date;
-    createdBy: number;
-    updatedBy: number;
-    constructor(data: T);
-}
-export declare class HolidayEntityModel extends BaseEntityModel<IHolidayEntity> implements IHolidayEntity {
-    id: number;
-    holidayListId: number;
-    dateCode: string;
-    private constructor();
-    getDateCodeModel(): DateCodeModel;
-    static fromEntity(data: IHolidayEntity): HolidayEntityModel;
-    static getDateCodeModelFromDate(models: HolidayEntityModel[]): DateCodeModel[];
-}
+export declare const toBeDeleted = "holiday";

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

@@ -1,31 +1,44 @@
 "use strict";
+// import { DateCodeModel } from "../../utils";
+// import { IAuditColumnEntity } from "../interface/audit-column.entity.interface";
+// import { IHolidayEntity } from "../interface/holiday.entity.interface";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HolidayEntityModel = exports.BaseEntityModel = void 0;
-const utils_1 = require("../../utils");
-class BaseEntityModel {
-    constructor(data) {
-        this.createdOn = data.createdOn;
-        this.updatedOn = data.updatedOn;
-        this.createdBy = data.createdBy;
-        this.updatedBy = data.updatedBy;
-    }
-}
-exports.BaseEntityModel = BaseEntityModel;
-class HolidayEntityModel extends BaseEntityModel {
-    constructor(data) {
-        super(data);
-        this.id = data.id;
-        this.holidayListId = data.holidayListId;
-        this.dateCode = data.dateCode;
-    }
-    getDateCodeModel() {
-        return new utils_1.DateCodeModel(this.dateCode);
-    }
-    static fromEntity(data) {
-        return new HolidayEntityModel(data);
-    }
-    static getDateCodeModelFromDate(models) {
-        return models.map((model) => model.getDateCodeModel());
-    }
-}
-exports.HolidayEntityModel = HolidayEntityModel;
+exports.toBeDeleted = void 0;
+// export class BaseEntityModelV1<T extends IAuditColumnEntity> {
+//   createdOn: Date;
+//   updatedOn: Date;
+//   createdBy: number;
+//   updatedBy: number;
+//   constructor(data: T) {
+//     this.createdOn = data.createdOn;
+//     this.updatedOn = data.updatedOn;
+//     this.createdBy = data.createdBy;
+//     this.updatedBy = data.updatedBy;
+//   }
+// }
+// export class HolidayEntityModel
+//   extends BaseEntityModelV1<IHolidayEntity>
+//   implements IHolidayEntity
+// {
+//   id: number;
+//   holidayListId: number;
+//   dateCode: string;
+//   private constructor(data: IHolidayEntity) {
+//     super(data);
+//     this.id = data.id;
+//     this.holidayListId = data.holidayListId;
+//     this.dateCode = data.dateCode;
+//   }
+//   getDateCodeModel(): DateCodeModel {
+//     return new DateCodeModel(this.dateCode);
+//   }
+//   static fromEntity(data: IHolidayEntity): HolidayEntityModel {
+//     return new HolidayEntityModel(data);
+//   }
+//   static getDateCodeModelFromDate(
+//     models: HolidayEntityModel[]
+//   ): DateCodeModel[] {
+//     return models.map((model) => model.getDateCodeModel());
+//   }
+// }
+exports.toBeDeleted = "holiday";

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

@@ -1,9 +1,9 @@
+import { ILeaveApiEntity } from "../../api";
 import { DateCodeModel, Weekday } from "../../utils";
 import { DurationTypeEnum } from "../enums/duration-type.enum";
 import { LeaveTypeEnum } from "../enums/leave-type.enum";
 import { LeaveStatusEnum } from "../enums/leave.status.enum";
-import { ILeaveEntity } from "../interface/leave.entity.interface";
-export declare class LeaveEntityModel implements ILeaveEntity {
+export declare class LeaveEntityModel implements ILeaveApiEntity {
     id: number;
     employeeId: number;
     fromDate: string;
@@ -13,12 +13,12 @@ export declare class LeaveEntityModel implements ILeaveEntity {
     status: LeaveStatusEnum;
     remark?: string;
     type: LeaveTypeEnum;
-    createdOn: Date;
-    updatedOn: Date;
+    createdOn: string;
+    updatedOn: string;
     createdBy: number;
     updatedBy: number;
     private constructor();
-    static fromEntity(data: ILeaveEntity): LeaveEntityModel;
+    static fromEntity(data: ILeaveApiEntity): LeaveEntityModel;
     isMoreThanOneDayLeave(): boolean;
     getLeaveDuration(excludeWeekdays?: Weekday[], excludeDates?: DateCodeModel[]): number;
     static getLeaveDuration(leaves: LeaveEntityModel[], excludeWeekdays?: Weekday[], excludeDates?: DateCodeModel[], leaveStatusEnum?: LeaveStatusEnum[]): number;

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

@@ -6,6 +6,8 @@ const duration_type_enum_1 = require("../enums/duration-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;
@@ -41,7 +43,8 @@ class LeaveEntityModel {
         if (this.durationType === duration_type_enum_1.DurationTypeEnum.SECOND_FIRST) {
             return count - 1;
         }
-        if (this.durationType === duration_type_enum_1.DurationTypeEnum.FULL_FIRST || this.durationType === duration_type_enum_1.DurationTypeEnum.SECOND_FULL) {
+        if (this.durationType === duration_type_enum_1.DurationTypeEnum.FULL_FIRST ||
+            this.durationType === duration_type_enum_1.DurationTypeEnum.SECOND_FULL) {
             return count - 0.5;
         }
         return count;

package/dist/src/entities/model/project-user-mapping.entity.model.d.ts

@@ -0,0 +1,26 @@
+import { IProjectUserMappingApiEntity } from "../../api";
+import { ProjectUserStatusEnum } from "../enums/project_user_status.enum";
+import { EntityEnum, EnumEntityType, IEntityApiResponse } from "../interface/entity.utils.interface";
+import { IProjectUserMappingEntity } from "../interface/project.entity.interface";
+import { RelationConfigs } from "../interface/relation-config.interface";
+import { BaseEntityModel } from "./base.entity.model";
+import { ProjectEntityModel } from "./project.entity.model";
+import { UserEntityModel } from "./user.entity.model";
+export declare class ProjectUserMappingEntityModel extends BaseEntityModel<EntityEnum.PROJECT_USER_MAPPING> implements IProjectUserMappingApiEntity {
+    id: number;
+    projectId: number;
+    userId: number;
+    status: ProjectUserStatusEnum;
+    createdOn: string;
+    updatedOn: string;
+    createdBy: number;
+    updatedBy: number;
+    user?: UserEntityModel;
+    project?: ProjectEntityModel;
+    static fromApiEntity(apiEntity: IEntityApiResponse<IProjectUserMappingEntity>): ProjectUserMappingEntityModel;
+    static relationConfigs: RelationConfigs<[
+        EntityEnum.USER,
+        EntityEnum.PROJECT
+    ], EnumEntityType<EntityEnum.PROJECT_USER_MAPPING>>;
+    getRelationConfigs(): [import("../interface/relation-config.interface").IRelationConfig<EntityEnum.USER, EnumEntityType<EntityEnum.PROJECT_USER_MAPPING>>, import("../interface/relation-config.interface").IRelationConfig<EntityEnum.PROJECT, EnumEntityType<EntityEnum.PROJECT_USER_MAPPING>>];
+}

package/dist/src/entities/model/project-user-mapping.entity.model.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectUserMappingEntityModel = void 0;
+const project_user_status_enum_1 = require("../enums/project_user_status.enum");
+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 ProjectUserMappingEntityModel extends base_entity_model_1.BaseEntityModel {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+        this.projectId = 0;
+        this.userId = 0;
+        this.status = project_user_status_enum_1.ProjectUserStatusEnum.ACTIVE;
+        this.createdOn = "";
+        this.updatedOn = "";
+        this.createdBy = 0;
+        this.updatedBy = 0;
+    }
+    static fromApiEntity(apiEntity) {
+        const entity = new ProjectUserMappingEntityModel(entity_utils_interface_1.EntityEnum.PROJECT_USER_MAPPING);
+        Object.assign(entity, apiEntity);
+        return entity;
+    }
+    getRelationConfigs() {
+        return ProjectUserMappingEntityModel.relationConfigs;
+    }
+}
+exports.ProjectUserMappingEntityModel = ProjectUserMappingEntityModel;
+ProjectUserMappingEntityModel.relationConfigs = [
+    {
+        name: entity_utils_interface_1.EntityEnum.USER,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "user",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "userId",
+        },
+    },
+    {
+        name: entity_utils_interface_1.EntityEnum.PROJECT,
+        relation: relation_type_enum_1.RelationType.ONE,
+        key: "project",
+        mapKeyConfig: {
+            relationKey: "id",
+            key: "projectId",
+        },
+    },
+];

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

@@ -0,0 +1,40 @@
+import { IProjectApiEntity } from "../../api";
+import { CurrencyEnum } from "../../enums";
+import { ProjectBillingTypeEnum, ProjectStatusEnum } from "../enums/project.entity.enum";
+import { EntityEnum, EnumEntityType } from "../interface/entity.utils.interface";
+import { IProjectUserDto } from "../interface/project.entity.interface";
+import { RelationConfigs } from "../interface/relation-config.interface";
+import { BaseEntityModel } from "./base.entity.model";
+import { ClientEntityModel } from "./client.entity.model";
+import { ProjectUserMappingEntityModel } from "./project-user-mapping.entity.model";
+import { UserEntityModel } from "./user.entity.model";
+export declare class ProjectEntityModel extends BaseEntityModel<EntityEnum.PROJECT> implements IProjectApiEntity {
+    id: number;
+    name: string;
+    clientId: number;
+    startDate: string;
+    currency: CurrencyEnum;
+    billingType: ProjectBillingTypeEnum;
+    billingRate: string;
+    status: ProjectStatusEnum;
+    organizationId: number;
+    description?: string;
+    expectedEndDate?: string;
+    actualEndDate?: string;
+    createdBy: number;
+    updatedBy: number;
+    createdOn: string;
+    updatedOn: string;
+    users?: IProjectUserDto[];
+    billingOverdueDays?: number;
+    userMappings?: (UserEntityModel & ProjectUserMappingEntityModel)[];
+    projectUserMappings?: ProjectUserMappingEntityModel[];
+    client: ClientEntityModel;
+    static fromApiEntity(apiEntity: IProjectApiEntity): ProjectEntityModel;
+    static relationConfigs: RelationConfigs<[
+        EntityEnum.PROJECT_USER_MAPPING,
+        EntityEnum.CLIENT
+    ], EnumEntityType<EntityEnum.PROJECT>>;
+    populateUsers(users: UserEntityModel[], projectUserMapping: ProjectUserMappingEntityModel[]): void;
+    getRelationConfigs(): [import("../interface/relation-config.interface").IRelationConfig<EntityEnum.PROJECT_USER_MAPPING, EnumEntityType<EntityEnum.PROJECT>>, import("../interface/relation-config.interface").IRelationConfig<EntityEnum.CLIENT, EnumEntityType<EntityEnum.PROJECT>>];
+}