@experts_hub/shared 1.0.516 → 1.0.519

package/dist/index.js

@@ -36,6 +36,7 @@ __export(index_exports, {
   AccountStatus: () => AccountStatus,
   AccountType: () => AccountType,
   AdminCreateJobInformationDto: () => AdminCreateJobInformationDto,
+  AdminJobBasicInformationV2Dto: () => AdminJobBasicInformationV2Dto,
   AdminPermission: () => AdminPermission,
   AdminRole: () => AdminRole,
   AdminRolePermission: () => AdminRolePermission,
@@ -198,6 +199,7 @@ __export(index_exports, {
   JobFreelancerRecommendationV2: () => JobFreelancerRecommendationV2,
   JobIdParamDto: () => JobIdParamDto,
   JobLocation: () => JobLocation,
+  JobLocationAdminDto: () => JobLocationAdminDto,
   JobLocationDto: () => JobLocationDto,
   JobLocationEnum: () => JobLocationEnum2,
   JobLocationEnumDto: () => JobLocationEnumDto,
@@ -3031,6 +3033,7 @@ InterviewInvite = __decorateClass([
 var import_typeorm15 = require("typeorm");
 var AiInterviewStatusEnum = /* @__PURE__ */ ((AiInterviewStatusEnum2) => {
   AiInterviewStatusEnum2["NOT_ATTEMPTED"] = "NOT_ATTEMPTED";
+  AiInterviewStatusEnum2["ATTEMPTED"] = "ATTEMPTED";
   AiInterviewStatusEnum2["ACTIVE"] = "ACTIVE";
   AiInterviewStatusEnum2["COMPELETED"] = "COMPELETED";
   AiInterviewStatusEnum2["PASSED"] = "PASSED";
@@ -6946,6 +6949,8 @@ var ADMIN_JOB_PATTERN = {
   adminFetchJobById: "admin.fetch.job.by.id",
   adminCreateJob: "admin.create.job",
   adminUpdateJob: "admin.update.job",
+  adminCreateJobV2: "admin.create.job.v2",
+  adminUpdateJobV2: "admin.update.job.v2",
   adminDeleteJob: "admin.delete.job",
   adminCountJob: "admin.count.job",
   adminFetchGraphCount: "admin.fetch.graph.count"
@@ -7145,6 +7150,194 @@ __decorateClass([
   (0, import_class_validator63.IsInt)({ message: "Client ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "clientId", 2);
 
+// src/modules/job-admin/dto/admin-job-basic-information-v2.dto.ts
+var import_class_validator64 = require("class-validator");
+var import_class_transformer14 = require("class-transformer");
+var JobLocationAdminEnumDto = /* @__PURE__ */ ((JobLocationAdminEnumDto2) => {
+  JobLocationAdminEnumDto2["ONSITE"] = "ONSITE";
+  JobLocationAdminEnumDto2["REMOTE"] = "REMOTE";
+  JobLocationAdminEnumDto2["HYBRID"] = "HYBRID";
+  return JobLocationAdminEnumDto2;
+})(JobLocationAdminEnumDto || {});
+var EmploymentTypeAdminEnumDto = /* @__PURE__ */ ((EmploymentTypeAdminEnumDto2) => {
+  EmploymentTypeAdminEnumDto2["FULLTIME"] = "FULLTIME";
+  EmploymentTypeAdminEnumDto2["PARTTIME"] = "PARTTIME";
+  EmploymentTypeAdminEnumDto2["BOTH"] = "BOTH";
+  EmploymentTypeAdminEnumDto2["HOURLY"] = "HOURLY";
+  EmploymentTypeAdminEnumDto2["FREELANCE"] = "FREELANCE";
+  EmploymentTypeAdminEnumDto2["FTE"] = "FTE";
+  return EmploymentTypeAdminEnumDto2;
+})(EmploymentTypeAdminEnumDto || {});
+var typeOfExperienceAdminEnumDto = /* @__PURE__ */ ((typeOfExperienceAdminEnumDto2) => {
+  typeOfExperienceAdminEnumDto2["SINGLE"] = "SINGLE";
+  typeOfExperienceAdminEnumDto2["RANGE"] = "RANGE";
+  return typeOfExperienceAdminEnumDto2;
+})(typeOfExperienceAdminEnumDto || {});
+var JobLocationAdminDto = class {
+};
+__decorateClass([
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsNumber)()
+], JobLocationAdminDto.prototype, "countryId", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsNumber)()
+], JobLocationAdminDto.prototype, "stateId", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsNumber)()
+], JobLocationAdminDto.prototype, "cityId", 2);
+var AdminJobBasicInformationV2Dto = class {
+  constructor() {
+    this.isDraft = false;
+  }
+};
+__decorateClass([
+  (0, import_class_validator64.IsInt)({ message: "Client ID must be a valid integer." })
+], AdminJobBasicInformationV2Dto.prototype, "clientId", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_transformer14.Type)(() => Boolean)
+], AdminJobBasicInformationV2Dto.prototype, "isDraft", 2);
+__decorateClass([
+  (0, import_class_validator64.IsNotEmpty)({ message: "Please enter job role" }),
+  (0, import_class_validator64.IsString)({ message: "Job role must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "jobRole", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)()
+], AdminJobBasicInformationV2Dto.prototype, "jobRoleCanonicalName", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsString)({ message: "Project name must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "projectName", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsString)({ message: "Note must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "note", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsArray)({ message: "Skills must be an array" }),
+  (0, import_class_validator64.ArrayNotEmpty)({ message: "Please select at least one skill" }),
+  (0, import_class_validator64.IsString)({ each: true, message: "Each skill must be a string" }),
+  (0, import_class_transformer14.Type)(() => String)
+], AdminJobBasicInformationV2Dto.prototype, "skills", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsArray)({ message: "Good to have skills must be an array" }),
+  (0, import_class_validator64.IsString)({ each: true, message: "Each skill must be a string" }),
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_transformer14.Type)(() => String)
+], AdminJobBasicInformationV2Dto.prototype, "goodToHaveSkills", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsArray)({ message: "locations must be an array" }),
+  (0, import_class_validator64.ArrayNotEmpty)({ message: "Please select at least one location" }),
+  (0, import_class_validator64.ValidateNested)({ each: true }),
+  (0, import_class_transformer14.Type)(() => JobLocationAdminDto),
+  (0, import_class_validator64.IsOptional)()
+], AdminJobBasicInformationV2Dto.prototype, "locations", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsNumber)({}, { message: "Openings must be a number" }),
+  (0, import_class_validator64.Min)(1, { message: "There must be at least 1 opening" }),
+  (0, import_class_transformer14.Type)(() => Number)
+], AdminJobBasicInformationV2Dto.prototype, "openings", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsEnum)(JobLocationAdminEnumDto, {
+    message: `Location must be one of: ${Object.values(JobLocationAdminEnumDto).join(
+      ", "
+    )}`
+  })
+], AdminJobBasicInformationV2Dto.prototype, "location", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsEnum)(EmploymentTypeAdminEnumDto, {
+    message: `Type of employment must be one of: ${Object.values(
+      EmploymentTypeAdminEnumDto
+    ).join(", ")}`
+  })
+], AdminJobBasicInformationV2Dto.prototype, "typeOfEmployment", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsString)({ message: "Currency must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "currency", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsNumber)({}, { message: "Expected salary (from) must be a number" }),
+  (0, import_class_validator64.Min)(0, { message: "Expected salary (from) cannot be negative" }),
+  (0, import_class_transformer14.Type)(() => Number)
+], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryFrom", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)()
+], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryFrom", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsNumber)({}, { message: "Expected salary (to) must be a number" }),
+  (0, import_class_validator64.Min)(0, { message: "Expected salary (to) cannot be negative" }),
+  (0, import_class_transformer14.Type)(() => Number)
+], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryTo", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)()
+], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryTo", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)()
+], AdminJobBasicInformationV2Dto.prototype, "years", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)()
+], AdminJobBasicInformationV2Dto.prototype, "months", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)()
+], AdminJobBasicInformationV2Dto.prototype, "weeks", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)()
+], AdminJobBasicInformationV2Dto.prototype, "days", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsNumber)({}, { message: "Number of hours must be a number" }),
+  (0, import_class_validator64.Min)(0, { message: "Number of hours cannot be negative" }),
+  (0, import_class_validator64.Max)(40, { message: "Number of hours cannot exceed 40" }),
+  (0, import_class_transformer14.Type)(() => Number)
+], AdminJobBasicInformationV2Dto.prototype, "numberOfHours", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsString)({ message: "Candidate communication skills must be a string" }),
+  (0, import_class_validator64.IsOptional)()
+], AdminJobBasicInformationV2Dto.prototype, "candidateCommunicationSkills", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsNotEmpty)({ message: "Please enter the academic qualification" }),
+  (0, import_class_validator64.IsString)({ message: "Academic qualification must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "academicQualification", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsEnum)(typeOfExperienceAdminEnumDto, {
+    message: `Type of experience must be one of: ${Object.values(
+      typeOfExperienceAdminEnumDto
+    ).join(", ")}`
+  })
+], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceType", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsNotEmpty)({ message: "Please enter the years of experience" }),
+  (0, import_class_validator64.IsString)({ message: "Years of experience must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceFrom", 2);
+__decorateClass([
+  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator64.IsNotEmpty)({ message: "Please enter the years of experience upto" }),
+  (0, import_class_validator64.IsString)({ message: "Years of experience must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceTo", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsString)({ message: "Business industry must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "businessIndustry", 2);
+__decorateClass([
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsString)({ message: "Additional comment must be a string" }),
+  (0, import_class_validator64.MaxLength)(500, { message: "Additional comment must not exceed 500 characters" })
+], AdminJobBasicInformationV2Dto.prototype, "additionalComment", 2);
+
 // src/modules/lead/pattern/pattern.ts
 var LEAD_PATTERN = {
   fetchLead: "fetch.lead",
@@ -7152,7 +7345,7 @@ var LEAD_PATTERN = {
 };
 
 // src/modules/lead/dto/create-lead.dto.ts
-var import_class_validator64 = require("class-validator");
+var import_class_validator65 = require("class-validator");
 var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
   CategoryEmumDto2["BUSINESS"] = "BUSINESS";
   CategoryEmumDto2["FREELANCER"] = "FREELANCER";
@@ -7161,23 +7354,23 @@ var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
 var CreateLeadDto = class {
 };
 __decorateClass([
-  (0, import_class_validator64.IsString)({ message: "Name must be a string" })
+  (0, import_class_validator65.IsString)({ message: "Name must be a string" })
 ], CreateLeadDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator64.IsEmail)({}, { message: "Invalid email address" })
+  (0, import_class_validator65.IsEmail)({}, { message: "Invalid email address" })
 ], CreateLeadDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator64.IsString)({ message: "Mobile code must be a string (e.g., +1)" })
+  (0, import_class_validator65.IsString)({ message: "Mobile code must be a string (e.g., +1)" })
 ], CreateLeadDto.prototype, "mobileCode", 2);
 __decorateClass([
-  (0, import_class_validator64.IsString)({ message: "Mobile must be a string (e.g., 1243253534)" })
+  (0, import_class_validator65.IsString)({ message: "Mobile must be a string (e.g., 1243253534)" })
 ], CreateLeadDto.prototype, "mobile", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsString)({ message: "Description must be a string" })
+  (0, import_class_validator65.IsOptional)(),
+  (0, import_class_validator65.IsString)({ message: "Description must be a string" })
 ], CreateLeadDto.prototype, "description", 2);
 __decorateClass([
-  (0, import_class_validator64.IsEnum)(CategoryEmumDto, {
+  (0, import_class_validator65.IsEnum)(CategoryEmumDto, {
     message: `Type of category must be one of: ${Object.values(
       CategoryEmumDto
     ).join(", ")}`
@@ -7197,46 +7390,46 @@ var ADMIN_ROLE_PATTERN = {
 };
 
 // src/modules/admin-role/dto/create-admin-role.dto.ts
-var import_class_validator65 = require("class-validator");
+var import_class_validator66 = require("class-validator");
 var CreateAdminRoleDto = class {
 };
 __decorateClass([
-  (0, import_class_validator65.IsNotEmpty)({ message: "Please enter admin role name." }),
-  (0, import_class_validator65.IsString)({ message: "Role name must be a string." })
+  (0, import_class_validator66.IsNotEmpty)({ message: "Please enter admin role name." }),
+  (0, import_class_validator66.IsString)({ message: "Role name must be a string." })
 ], CreateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  (0, import_class_validator65.IsOptional)(),
-  (0, import_class_validator65.IsString)({ message: "Role description must be a string." })
+  (0, import_class_validator66.IsOptional)(),
+  (0, import_class_validator66.IsString)({ message: "Role description must be a string." })
 ], CreateAdminRoleDto.prototype, "roleDescription", 2);
 
 // src/modules/admin-role/dto/update-admin-role.dto.ts
-var import_class_validator66 = require("class-validator");
+var import_class_validator67 = require("class-validator");
 var UpdateAdminRoleDto = class {
 };
 __decorateClass([
-  (0, import_class_validator66.IsNotEmpty)({ message: "Please enter admin role name." }),
-  (0, import_class_validator66.IsString)({ message: "Role name must be a string." })
+  (0, import_class_validator67.IsNotEmpty)({ message: "Please enter admin role name." }),
+  (0, import_class_validator67.IsString)({ message: "Role name must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  (0, import_class_validator66.IsOptional)(),
-  (0, import_class_validator66.IsString)({ message: "Role description must be a string." })
+  (0, import_class_validator67.IsOptional)(),
+  (0, import_class_validator67.IsString)({ message: "Role description must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleDescription", 2);
 __decorateClass([
-  (0, import_class_validator66.IsOptional)(),
-  (0, import_class_validator66.IsBoolean)({ message: "Is active must be a boolean value." })
+  (0, import_class_validator67.IsOptional)(),
+  (0, import_class_validator67.IsBoolean)({ message: "Is active must be a boolean value." })
 ], UpdateAdminRoleDto.prototype, "isActive", 2);
 
 // src/modules/admin-role/dto/attach-permissions-to-role.dto.ts
-var import_class_validator67 = require("class-validator");
+var import_class_validator68 = require("class-validator");
 var AttachPermissionsToRoleDto = class {
 };
 __decorateClass([
-  (0, import_class_validator67.IsNotEmpty)({ message: "Please enter admin role ID." }),
-  (0, import_class_validator67.IsString)({ message: "Role ID must be a string." })
+  (0, import_class_validator68.IsNotEmpty)({ message: "Please enter admin role ID." }),
+  (0, import_class_validator68.IsString)({ message: "Role ID must be a string." })
 ], AttachPermissionsToRoleDto.prototype, "roleId", 2);
 __decorateClass([
-  (0, import_class_validator67.IsNotEmpty)({ message: "Please enter permission IDs." }),
-  (0, import_class_validator67.IsString)({ message: "Permission IDs must be a comma-separated string." })
+  (0, import_class_validator68.IsNotEmpty)({ message: "Please enter permission IDs." }),
+  (0, import_class_validator68.IsString)({ message: "Permission IDs must be a comma-separated string." })
 ], AttachPermissionsToRoleDto.prototype, "permissionIds", 2);
 
 // src/modules/admin-permission/pattern/pattern.ts
@@ -7262,8 +7455,8 @@ var CALENDLY_PATTERN = {
 };
 
 // src/modules/interview/dto/interview-invite.dto.ts
-var import_class_validator68 = require("class-validator");
-var import_class_transformer14 = require("class-transformer");
+var import_class_validator69 = require("class-validator");
+var import_class_transformer15 = require("class-transformer");
 var CandidateType = /* @__PURE__ */ ((CandidateType2) => {
   CandidateType2["SHORTLISTED"] = "SHORTLISTED";
   CandidateType2["APPLICATNTS"] = "APPLICATNTS";
@@ -7274,107 +7467,107 @@ var CandidateType = /* @__PURE__ */ ((CandidateType2) => {
 var ExistingCandidateDto = class {
 };
 __decorateClass([
-  (0, import_class_validator68.IsUUID)()
+  (0, import_class_validator69.IsUUID)()
 ], ExistingCandidateDto.prototype, "id", 2);
 __decorateClass([
-  (0, import_class_validator68.IsEnum)(CandidateType, {
+  (0, import_class_validator69.IsEnum)(CandidateType, {
     message: "type must be one of SHORTLISTED, APPLICATNTS, or RECOMMENDED"
   })
 ], ExistingCandidateDto.prototype, "type", 2);
 var NewCandidateDto = class {
 };
 __decorateClass([
-  (0, import_class_validator68.IsNotEmpty)({ message: "Please enter the candidate name" }),
-  (0, import_class_validator68.IsString)({ message: "Name must be a string" })
+  (0, import_class_validator69.IsNotEmpty)({ message: "Please enter the candidate name" }),
+  (0, import_class_validator69.IsString)({ message: "Name must be a string" })
 ], NewCandidateDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator68.IsEmail)({}, { message: "Please enter a valid email." })
+  (0, import_class_validator69.IsEmail)({}, { message: "Please enter a valid email." })
 ], NewCandidateDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator68.IsEnum)(CandidateType, {
+  (0, import_class_validator69.IsEnum)(CandidateType, {
     message: "type must be NEW"
   })
 ], NewCandidateDto.prototype, "type", 2);
 var CandidatesDto = class {
 };
 __decorateClass([
-  (0, import_class_validator68.ValidateIf)((o) => o.exixtingCandidates?.length > 0),
-  (0, import_class_validator68.IsArray)({ message: "Existing candidates should be an array." }),
-  (0, import_class_validator68.ArrayNotEmpty)({ message: "Please select at least one candidate." }),
-  (0, import_class_validator68.ValidateNested)({ each: true }),
-  (0, import_class_transformer14.Type)(() => ExistingCandidateDto)
+  (0, import_class_validator69.ValidateIf)((o) => o.exixtingCandidates?.length > 0),
+  (0, import_class_validator69.IsArray)({ message: "Existing candidates should be an array." }),
+  (0, import_class_validator69.ArrayNotEmpty)({ message: "Please select at least one candidate." }),
+  (0, import_class_validator69.ValidateNested)({ each: true }),
+  (0, import_class_transformer15.Type)(() => ExistingCandidateDto)
 ], CandidatesDto.prototype, "exixtingCandidates", 2);
 __decorateClass([
-  (0, import_class_validator68.ValidateIf)((o) => o.newCandidates?.length > 0),
-  (0, import_class_validator68.IsArray)({ message: "New candidates should be an array." }),
-  (0, import_class_validator68.ArrayNotEmpty)({ message: "Please add at least one candidate." }),
-  (0, import_class_validator68.ValidateNested)({ each: true }),
-  (0, import_class_transformer14.Type)(() => NewCandidateDto)
+  (0, import_class_validator69.ValidateIf)((o) => o.newCandidates?.length > 0),
+  (0, import_class_validator69.IsArray)({ message: "New candidates should be an array." }),
+  (0, import_class_validator69.ArrayNotEmpty)({ message: "Please add at least one candidate." }),
+  (0, import_class_validator69.ValidateNested)({ each: true }),
+  (0, import_class_transformer15.Type)(() => NewCandidateDto)
 ], CandidatesDto.prototype, "newCandidates", 2);
 var InterviewInviteDto = class {
 };
 __decorateClass([
-  (0, import_class_validator68.IsUUID)()
+  (0, import_class_validator69.IsUUID)()
 ], InterviewInviteDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator68.ValidateNested)({ each: true }),
-  (0, import_class_transformer14.Type)(() => CandidatesDto)
+  (0, import_class_validator69.ValidateNested)({ each: true }),
+  (0, import_class_transformer15.Type)(() => CandidatesDto)
 ], InterviewInviteDto.prototype, "candidates", 2);
 
 // src/modules/interview/dto/create-f2f-interview.dto.ts
-var import_class_validator69 = require("class-validator");
+var import_class_validator70 = require("class-validator");
 var CreateF2FInterviewDto = class {
 };
 __decorateClass([
-  (0, import_class_validator69.IsEmail)({}, { message: "Please enter a valid email address." }),
-  (0, import_class_validator69.IsNotEmpty)({ message: "Invitee email is required." })
+  (0, import_class_validator70.IsEmail)({}, { message: "Please enter a valid email address." }),
+  (0, import_class_validator70.IsNotEmpty)({ message: "Invitee email is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  (0, import_class_validator69.IsString)({ message: "Invitee name must be a string." }),
-  (0, import_class_validator69.IsNotEmpty)({ message: "Invitee name is required." })
+  (0, import_class_validator70.IsString)({ message: "Invitee name must be a string." }),
+  (0, import_class_validator70.IsNotEmpty)({ message: "Invitee name is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeName", 2);
 __decorateClass([
-  (0, import_class_validator69.IsNumber)({}, { message: "Interview ID must be a number." })
+  (0, import_class_validator70.IsNumber)({}, { message: "Interview ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "interviewId", 2);
 __decorateClass([
-  (0, import_class_validator69.IsNumber)({}, { message: "Candidate ID must be a number." })
+  (0, import_class_validator70.IsNumber)({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-direct.dto.ts
-var import_class_validator70 = require("class-validator");
+var import_class_validator71 = require("class-validator");
 var CreateF2FInterviewDirectDto = class {
 };
 __decorateClass([
-  (0, import_class_validator70.IsEmail)({}, { message: "Please enter a valid email address." }),
-  (0, import_class_validator70.IsNotEmpty)({ message: "Invitee email is required." })
+  (0, import_class_validator71.IsEmail)({}, { message: "Please enter a valid email address." }),
+  (0, import_class_validator71.IsNotEmpty)({ message: "Invitee email is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  (0, import_class_validator70.IsString)({ message: "Invitee name must be a string." }),
-  (0, import_class_validator70.IsNotEmpty)({ message: "Invitee name is required." })
+  (0, import_class_validator71.IsString)({ message: "Invitee name must be a string." }),
+  (0, import_class_validator71.IsNotEmpty)({ message: "Invitee name is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeName", 2);
 __decorateClass([
-  (0, import_class_validator70.IsNumber)({}, { message: "Job ID must be a number." })
+  (0, import_class_validator71.IsNumber)({}, { message: "Job ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator70.IsNumber)({}, { message: "Candidate ID must be a number." })
+  (0, import_class_validator71.IsNumber)({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-reschedule-request.dto.ts
-var import_class_validator71 = require("class-validator");
+var import_class_validator72 = require("class-validator");
 var CreateF2FInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  (0, import_class_validator71.IsNotEmpty)({ message: "F2F Interview ID is required." })
+  (0, import_class_validator72.IsNotEmpty)({ message: "F2F Interview ID is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "f2FInterviewId", 2);
 __decorateClass([
-  (0, import_class_validator71.IsNotEmpty)({ message: "Rescheduled date is required." })
+  (0, import_class_validator72.IsNotEmpty)({ message: "Rescheduled date is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledDate", 2);
 __decorateClass([
-  (0, import_class_validator71.IsString)({ message: "Rescheduled slot must be a string." }),
-  (0, import_class_validator71.IsNotEmpty)({ message: "Rescheduled slot is required." })
+  (0, import_class_validator72.IsString)({ message: "Rescheduled slot must be a string." }),
+  (0, import_class_validator72.IsNotEmpty)({ message: "Rescheduled slot is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledSlot", 2);
 __decorateClass([
-  (0, import_class_validator71.IsString)({ message: "Freelancer reason must be a string." })
+  (0, import_class_validator72.IsString)({ message: "Freelancer reason must be a string." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/contract/pattern/pattern.ts
@@ -7398,43 +7591,43 @@ var CONTRACT_PATTERN = {
 };
 
 // src/modules/contract/dto/sign-contract-for-client.dto.ts
-var import_class_validator72 = require("class-validator");
-var import_class_transformer15 = require("class-transformer");
+var import_class_validator73 = require("class-validator");
+var import_class_transformer16 = require("class-transformer");
 var SignContractForClientDto = class {
 };
 __decorateClass([
-  (0, import_class_validator72.IsNotEmpty)({ message: "Job Id is required." }),
-  (0, import_class_transformer15.Type)(() => Number),
-  (0, import_class_validator72.IsNumber)({}, { message: "Job ID must be a number." })
+  (0, import_class_validator73.IsNotEmpty)({ message: "Job Id is required." }),
+  (0, import_class_transformer16.Type)(() => Number),
+  (0, import_class_validator73.IsNumber)({}, { message: "Job ID must be a number." })
 ], SignContractForClientDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator72.IsNotEmpty)({ message: "Freelancer ID is required." }),
-  (0, import_class_transformer15.Type)(() => Number),
-  (0, import_class_validator72.IsNumber)({}, { message: "Freelancer ID must be a number." })
+  (0, import_class_validator73.IsNotEmpty)({ message: "Freelancer ID is required." }),
+  (0, import_class_transformer16.Type)(() => Number),
+  (0, import_class_validator73.IsNumber)({}, { message: "Freelancer ID must be a number." })
 ], SignContractForClientDto.prototype, "freelancerId", 2);
 __decorateClass([
-  (0, import_class_validator72.IsNotEmpty)({ message: "Contract type is required." }),
-  (0, import_class_validator72.IsEnum)(ContractTypeEnum)
+  (0, import_class_validator73.IsNotEmpty)({ message: "Contract type is required." }),
+  (0, import_class_validator73.IsEnum)(ContractTypeEnum)
 ], SignContractForClientDto.prototype, "contractType", 2);
 
 // src/modules/contract/dto/sign-contract-for-freelancer.dto.ts
-var import_class_validator73 = require("class-validator");
-var import_class_transformer16 = require("class-transformer");
+var import_class_validator74 = require("class-validator");
+var import_class_transformer17 = require("class-transformer");
 var SignContractForFreelancerDto = class {
 };
 __decorateClass([
-  (0, import_class_validator73.IsNotEmpty)({ message: "Job Id is required." }),
-  (0, import_class_transformer16.Type)(() => Number),
-  (0, import_class_validator73.IsNumber)({}, { message: "Job ID must be a number." })
+  (0, import_class_validator74.IsNotEmpty)({ message: "Job Id is required." }),
+  (0, import_class_transformer17.Type)(() => Number),
+  (0, import_class_validator74.IsNumber)({}, { message: "Job ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator73.IsNotEmpty)({ message: "Client ID is required." }),
-  (0, import_class_transformer16.Type)(() => Number),
-  (0, import_class_validator73.IsNumber)({}, { message: "Client ID must be a number." })
+  (0, import_class_validator74.IsNotEmpty)({ message: "Client ID is required." }),
+  (0, import_class_transformer17.Type)(() => Number),
+  (0, import_class_validator74.IsNumber)({}, { message: "Client ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "clientId", 2);
 __decorateClass([
-  (0, import_class_validator73.IsNotEmpty)({ message: "Contract type is required." }),
-  (0, import_class_validator73.IsEnum)(ContractTypeEnum)
+  (0, import_class_validator74.IsNotEmpty)({ message: "Contract type is required." }),
+  (0, import_class_validator74.IsEnum)(ContractTypeEnum)
 ], SignContractForFreelancerDto.prototype, "contractType", 2);
 
 // src/modules/stripe/pattern/pattern.ts
@@ -7452,11 +7645,11 @@ var STRIPE_PATTERN = {
 };
 
 // src/modules/stripe/dto/create-checkout-session.dto.ts
-var import_class_validator74 = require("class-validator");
+var import_class_validator75 = require("class-validator");
 var CreateCheckoutSessionDto = class {
 };
 __decorateClass([
-  (0, import_class_validator74.IsNotEmpty)({ message: "Amount is required" })
+  (0, import_class_validator75.IsNotEmpty)({ message: "Amount is required" })
 ], CreateCheckoutSessionDto.prototype, "amount", 2);
 
 // src/modules/timesheet/pattern/pattern.ts
@@ -7477,99 +7670,99 @@ var TIMESHEET_CLIENT_PATTERN = {
 };
 
 // src/modules/timesheet/dto/create-freelancer-timesheet.dto.ts
-var import_class_validator75 = require("class-validator");
+var import_class_validator76 = require("class-validator");
 var CreateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  (0, import_class_validator75.IsNotEmpty)({ message: "Job id is required" }),
-  (0, import_class_validator75.IsNumber)({}, { message: "Job id must be a number" })
+  (0, import_class_validator76.IsNotEmpty)({ message: "Job id is required" }),
+  (0, import_class_validator76.IsNumber)({}, { message: "Job id must be a number" })
 ], CreateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator75.IsNotEmpty)({ message: "start date is required" }),
-  (0, import_class_validator75.IsDateString)()
+  (0, import_class_validator76.IsNotEmpty)({ message: "start date is required" }),
+  (0, import_class_validator76.IsDateString)()
 ], CreateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  (0, import_class_validator75.IsNotEmpty)({ message: "end date is required" }),
-  (0, import_class_validator75.IsDateString)()
+  (0, import_class_validator76.IsNotEmpty)({ message: "end date is required" }),
+  (0, import_class_validator76.IsDateString)()
 ], CreateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  (0, import_class_validator75.IsNotEmpty)({ message: "start time is required" }),
-  (0, import_class_validator75.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator76.IsNotEmpty)({ message: "start time is required" }),
+  (0, import_class_validator76.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "startTime must be in HH:mm:ss format"
   })
 ], CreateFreelancerTimesheetDto.prototype, "startTime", 2);
 __decorateClass([
-  (0, import_class_validator75.IsNotEmpty)({ message: "end time is required" }),
-  (0, import_class_validator75.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator76.IsNotEmpty)({ message: "end time is required" }),
+  (0, import_class_validator76.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "endTime must be in HH:mm:ss format"
   })
 ], CreateFreelancerTimesheetDto.prototype, "endTime", 2);
 __decorateClass([
-  (0, import_class_validator75.IsOptional)(),
-  (0, import_class_validator75.IsInt)()
+  (0, import_class_validator76.IsOptional)(),
+  (0, import_class_validator76.IsInt)()
 ], CreateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  (0, import_class_validator75.IsOptional)(),
-  (0, import_class_validator75.IsString)()
+  (0, import_class_validator76.IsOptional)(),
+  (0, import_class_validator76.IsString)()
 ], CreateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  (0, import_class_validator75.IsOptional)(),
-  (0, import_class_validator75.IsString)()
+  (0, import_class_validator76.IsOptional)(),
+  (0, import_class_validator76.IsString)()
 ], CreateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  (0, import_class_validator75.IsOptional)(),
-  (0, import_class_validator75.IsString)()
+  (0, import_class_validator76.IsOptional)(),
+  (0, import_class_validator76.IsString)()
 ], CreateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  (0, import_class_validator75.IsNotEmpty)({ message: "Description is required" })
+  (0, import_class_validator76.IsNotEmpty)({ message: "Description is required" })
 ], CreateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/timesheet/dto/update-freelancer-timesheet.dto.ts
-var import_class_validator76 = require("class-validator");
+var import_class_validator77 = require("class-validator");
 var UpdateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  (0, import_class_validator76.IsNotEmpty)({ message: "Job id is required" }),
-  (0, import_class_validator76.IsNumber)({}, { message: "Job id must be a number" })
+  (0, import_class_validator77.IsNotEmpty)({ message: "Job id is required" }),
+  (0, import_class_validator77.IsNumber)({}, { message: "Job id must be a number" })
 ], UpdateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator76.IsNotEmpty)({ message: "start date is required" }),
-  (0, import_class_validator76.IsDateString)()
+  (0, import_class_validator77.IsNotEmpty)({ message: "start date is required" }),
+  (0, import_class_validator77.IsDateString)()
 ], UpdateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  (0, import_class_validator76.IsNotEmpty)({ message: "end date is required" }),
-  (0, import_class_validator76.IsDateString)()
+  (0, import_class_validator77.IsNotEmpty)({ message: "end date is required" }),
+  (0, import_class_validator77.IsDateString)()
 ], UpdateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  (0, import_class_validator76.IsNotEmpty)({ message: "start time is required" }),
-  (0, import_class_validator76.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator77.IsNotEmpty)({ message: "start time is required" }),
+  (0, import_class_validator77.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "startTime must be in HH:mm:ss format"
   })
 ], UpdateFreelancerTimesheetDto.prototype, "startTime", 2);
 __decorateClass([
-  (0, import_class_validator76.IsNotEmpty)({ message: "end time is required" }),
-  (0, import_class_validator76.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator77.IsNotEmpty)({ message: "end time is required" }),
+  (0, import_class_validator77.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "endTime must be in HH:mm:ss format"
   })
 ], UpdateFreelancerTimesheetDto.prototype, "endTime", 2);
 __decorateClass([
-  (0, import_class_validator76.IsOptional)(),
-  (0, import_class_validator76.IsInt)()
+  (0, import_class_validator77.IsOptional)(),
+  (0, import_class_validator77.IsInt)()
 ], UpdateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  (0, import_class_validator76.IsOptional)(),
-  (0, import_class_validator76.IsString)()
+  (0, import_class_validator77.IsOptional)(),
+  (0, import_class_validator77.IsString)()
 ], UpdateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  (0, import_class_validator76.IsOptional)(),
-  (0, import_class_validator76.IsString)()
+  (0, import_class_validator77.IsOptional)(),
+  (0, import_class_validator77.IsString)()
 ], UpdateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  (0, import_class_validator76.IsOptional)(),
-  (0, import_class_validator76.IsString)()
+  (0, import_class_validator77.IsOptional)(),
+  (0, import_class_validator77.IsString)()
 ], UpdateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  (0, import_class_validator76.IsNotEmpty)({ message: "Description is required" })
+  (0, import_class_validator77.IsNotEmpty)({ message: "Description is required" })
 ], UpdateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/invoice/pattern/pattern.ts
@@ -7584,54 +7777,54 @@ var INVOICE_PATTERN = {
 };
 
 // src/modules/invoice/dto/update-invoice-status.dto.ts
-var import_class_validator77 = require("class-validator");
+var import_class_validator78 = require("class-validator");
 var UpdateInvoiceStatusDto = class {
 };
 __decorateClass([
-  (0, import_class_validator77.IsNotEmpty)({ message: "Please provide invoice status." }),
-  (0, import_class_validator77.IsEnum)(InvoiceStatusEnum, {
+  (0, import_class_validator78.IsNotEmpty)({ message: "Please provide invoice status." }),
+  (0, import_class_validator78.IsEnum)(InvoiceStatusEnum, {
     message: "Status must be one of: APPROVED, REJECTED"
   })
 ], UpdateInvoiceStatusDto.prototype, "status", 2);
 
 // src/modules/dispute/dto/create-dispute.dto.ts
-var import_class_validator78 = require("class-validator");
-var import_class_transformer17 = require("class-transformer");
+var import_class_validator79 = require("class-validator");
+var import_class_transformer18 = require("class-transformer");
 var CreateDisputeDto = class {
 };
 __decorateClass([
-  (0, import_class_validator78.ValidateIf)((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
-  (0, import_class_validator78.IsNumber)({}, { message: "Client id must be a number" }),
-  (0, import_class_transformer17.Type)(() => Number)
+  (0, import_class_validator79.ValidateIf)((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
+  (0, import_class_validator79.IsNumber)({}, { message: "Client id must be a number" }),
+  (0, import_class_transformer18.Type)(() => Number)
 ], CreateDisputeDto.prototype, "clientId", 2);
 __decorateClass([
-  (0, import_class_validator78.ValidateIf)((o) => o.initiatorType === "CLIENT" /* CLIENT */),
-  (0, import_class_validator78.IsNumber)({}, { message: "Freelancer id must be a number" }),
-  (0, import_class_transformer17.Type)(() => Number)
+  (0, import_class_validator79.ValidateIf)((o) => o.initiatorType === "CLIENT" /* CLIENT */),
+  (0, import_class_validator79.IsNumber)({}, { message: "Freelancer id must be a number" }),
+  (0, import_class_transformer18.Type)(() => Number)
 ], CreateDisputeDto.prototype, "freelancerId", 2);
 __decorateClass([
-  (0, import_class_validator78.IsNotEmpty)({ message: "Please select dispute type." }),
-  (0, import_class_validator78.IsString)(),
-  (0, import_class_validator78.IsIn)(["JOB", "INVOICE"])
+  (0, import_class_validator79.IsNotEmpty)({ message: "Please select dispute type." }),
+  (0, import_class_validator79.IsString)(),
+  (0, import_class_validator79.IsIn)(["JOB", "INVOICE"])
 ], CreateDisputeDto.prototype, "disputeType", 2);
 __decorateClass([
-  (0, import_class_validator78.IsNotEmpty)({ message: "Please provide initiator type." }),
-  (0, import_class_validator78.IsString)()
+  (0, import_class_validator79.IsNotEmpty)({ message: "Please provide initiator type." }),
+  (0, import_class_validator79.IsString)()
 ], CreateDisputeDto.prototype, "initiatorType", 2);
 __decorateClass([
-  (0, import_class_validator78.IsNotEmpty)({ message: "Please enter description." }),
-  (0, import_class_validator78.IsString)({ message: "Description must be a string" }),
-  (0, import_class_validator78.MaxLength)(500, { message: "Description must not exceed 500 characters" })
+  (0, import_class_validator79.IsNotEmpty)({ message: "Please enter description." }),
+  (0, import_class_validator79.IsString)({ message: "Description must be a string" }),
+  (0, import_class_validator79.MaxLength)(500, { message: "Description must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "description", 2);
 __decorateClass([
-  (0, import_class_validator78.IsOptional)(),
-  (0, import_class_validator78.IsString)({ message: "Comment must be a string" }),
-  (0, import_class_validator78.MaxLength)(500, { message: "Comment must not exceed 500 characters" })
+  (0, import_class_validator79.IsOptional)(),
+  (0, import_class_validator79.IsString)({ message: "Comment must be a string" }),
+  (0, import_class_validator79.MaxLength)(500, { message: "Comment must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "comment", 2);
 __decorateClass([
-  (0, import_class_validator78.IsOptional)(),
-  (0, import_class_validator78.IsObject)({ message: "Dynamic fields must be a valid object" }),
-  (0, import_class_transformer17.Transform)(({ value }) => {
+  (0, import_class_validator79.IsOptional)(),
+  (0, import_class_validator79.IsObject)({ message: "Dynamic fields must be a valid object" }),
+  (0, import_class_transformer18.Transform)(({ value }) => {
     if (typeof value === "string") {
       try {
         return JSON.parse(value);
@@ -7644,14 +7837,14 @@ __decorateClass([
 ], CreateDisputeDto.prototype, "dynamicFields", 2);
 
 // src/modules/senseloaf/dto/ai-interview-question-generate.dto.ts
-var import_class_validator79 = require("class-validator");
+var import_class_validator80 = require("class-validator");
 var AiInterviewQuestionGenerateDto = class {
 };
 __decorateClass([
-  (0, import_class_validator79.IsNotEmpty)({ message: "Please enter job description." })
+  (0, import_class_validator80.IsNotEmpty)({ message: "Please enter job description." })
 ], AiInterviewQuestionGenerateDto.prototype, "jobDescription", 2);
 __decorateClass([
-  (0, import_class_validator79.IsNotEmpty)({ message: "Please enter number of questions." })
+  (0, import_class_validator80.IsNotEmpty)({ message: "Please enter number of questions." })
 ], AiInterviewQuestionGenerateDto.prototype, "numQuestions", 2);
 
 // src/adapters/tcp/user.tcp.adapter.ts
@@ -8654,6 +8847,7 @@ RecommendationWeightageConfig = __decorateClass([
   AccountStatus,
   AccountType,
   AdminCreateJobInformationDto,
+  AdminJobBasicInformationV2Dto,
   AdminPermission,
   AdminRole,
   AdminRolePermission,
@@ -8816,6 +9010,7 @@ RecommendationWeightageConfig = __decorateClass([
   JobFreelancerRecommendationV2,
   JobIdParamDto,
   JobLocation,
+  JobLocationAdminDto,
   JobLocationDto,
   JobLocationEnum,
   JobLocationEnumDto,