@experts_hub/shared 1.0.648 → 1.0.649

package/dist/index.mjs

@@ -4307,6 +4307,9 @@ __decorateClass([
 __decorateClass([
   Column35({ name: "is_interview_created", type: "boolean", default: false })
 ], Job.prototype, "isInterviewCreated", 2);
+__decorateClass([
+  Column35({ name: "is_job_created_via_ai", type: "boolean", default: false })
+], Job.prototype, "isJobCreatedViaAI", 2);
 __decorateClass([
   OneToMany14(() => InterviewInvite, (interviewInvite) => interviewInvite.job, { cascade: true })
 ], Job.prototype, "interviewInvites", 2);
@@ -6373,6 +6376,7 @@ var JOB_PATTERN = {
   updateJobAdditionalComments: "update.job.additional.comments",
   fetchJobDescription: "fetch.job.description",
   updateJobDescription: "update.job.description",
+  createJobViaAI: "create.job.via.ai",
   updateJobStatus: "update.job.status",
   closeJob: "close.job",
   searchJobsByRoleAndSkills: "search.jobs.by.role.and.skills",
@@ -6607,70 +6611,40 @@ __decorateClass([
   MaxLength8(5e3, { message: "Description must not exceed 5000 characters" })
 ], JobDescriptionDto.prototype, "description", 2);
 
-// src/modules/job/dto/job-status.dto.ts
-import { IsEnum as IsEnum16, IsNotEmpty as IsNotEmpty43 } from "class-validator";
-var JobStatus = /* @__PURE__ */ ((JobStatus2) => {
-  JobStatus2["ACTIVE"] = "ACTIVE";
-  JobStatus2["OPEN"] = "OPEN";
-  JobStatus2["DRAFT"] = "DRAFT";
-  JobStatus2["ONHOLD"] = "ONHOLD";
-  JobStatus2["CLOSED"] = "CLOSED";
-  JobStatus2["COMPLETED"] = "COMPLETED";
-  return JobStatus2;
-})(JobStatus || {});
-var JobStatusDto = class {
-};
-__decorateClass([
-  IsNotEmpty43({ message: "Please provide a job status" }),
-  IsEnum16(JobStatus, {
-    message: `Status must be one of: ${Object.values(JobStatus).join(", ")}`
-  })
-], JobStatusDto.prototype, "status", 2);
-
-// src/modules/job/dto/job-id-param.dto.ts
-import { IsUUID as IsUUID16 } from "class-validator";
-var JobIdParamDto = class {
-};
-__decorateClass([
-  IsUUID16("4", {
-    message: "Invalid job ID. It must be a valid UUID version 4."
-  })
-], JobIdParamDto.prototype, "id", 2);
-
-// src/modules/job/dto/job-basic-information-v2.dto.ts
+// src/modules/job/dto/create-job-via-ai.dto..ts
 import {
   IsString as IsString23,
-  IsNotEmpty as IsNotEmpty44,
+  IsNotEmpty as IsNotEmpty43,
   IsArray as IsArray3,
   ArrayNotEmpty as ArrayNotEmpty2,
   IsNumber as IsNumber4,
   IsOptional as IsOptional22,
-  IsEnum as IsEnum17,
+  IsEnum as IsEnum16,
   Min as Min2,
   ValidateIf as ValidateIf4,
   MaxLength as MaxLength9,
   Max as Max2
 } from "class-validator";
 import { Type as Type3 } from "class-transformer";
-var JobLocationEnumV2 = /* @__PURE__ */ ((JobLocationEnumV22) => {
-  JobLocationEnumV22["ONSITE"] = "ONSITE";
-  JobLocationEnumV22["REMOTE"] = "REMOTE";
-  JobLocationEnumV22["HYBRID"] = "HYBRID";
-  return JobLocationEnumV22;
+var JobLocationEnumV2 = /* @__PURE__ */ ((JobLocationEnumV23) => {
+  JobLocationEnumV23["ONSITE"] = "ONSITE";
+  JobLocationEnumV23["REMOTE"] = "REMOTE";
+  JobLocationEnumV23["HYBRID"] = "HYBRID";
+  return JobLocationEnumV23;
 })(JobLocationEnumV2 || {});
-var EmploymentTypeV2 = /* @__PURE__ */ ((EmploymentTypeV22) => {
-  EmploymentTypeV22["FULLTIME"] = "FULLTIME";
-  EmploymentTypeV22["PARTTIME"] = "PARTTIME";
-  EmploymentTypeV22["BOTH"] = "BOTH";
-  EmploymentTypeV22["HOURLY"] = "HOURLY";
-  EmploymentTypeV22["FREELANCE"] = "FREELANCE";
-  EmploymentTypeV22["FTE"] = "FTE";
-  return EmploymentTypeV22;
+var EmploymentTypeV2 = /* @__PURE__ */ ((EmploymentTypeV23) => {
+  EmploymentTypeV23["FULLTIME"] = "FULLTIME";
+  EmploymentTypeV23["PARTTIME"] = "PARTTIME";
+  EmploymentTypeV23["BOTH"] = "BOTH";
+  EmploymentTypeV23["HOURLY"] = "HOURLY";
+  EmploymentTypeV23["FREELANCE"] = "FREELANCE";
+  EmploymentTypeV23["FTE"] = "FTE";
+  return EmploymentTypeV23;
 })(EmploymentTypeV2 || {});
-var StepCompletedEnumV2 = /* @__PURE__ */ ((StepCompletedEnumV22) => {
-  StepCompletedEnumV22["BASIC_INFORMATION"] = "BASIC_INFORMATION";
-  StepCompletedEnumV22["JOB_DESCRIPTION"] = "JOB_DESCRIPTION";
-  return StepCompletedEnumV22;
+var StepCompletedEnumV2 = /* @__PURE__ */ ((StepCompletedEnumV23) => {
+  StepCompletedEnumV23["BASIC_INFORMATION"] = "BASIC_INFORMATION";
+  StepCompletedEnumV23["JOB_DESCRIPTION"] = "JOB_DESCRIPTION";
+  return StepCompletedEnumV23;
 })(StepCompletedEnumV2 || {});
 var JobLocationDto = class {
 };
@@ -6701,7 +6675,7 @@ __decorateClass([
   IsString23({ message: "City name must be a string" }),
   MaxLength9(255, { message: "City name must not exceed 255 characters" })
 ], JobLocationDto.prototype, "cityName", 2);
-var JobBasicInformationV2Dto = class {
+var CreateJobViaAIDto = class {
   constructor() {
     this.isDraft = false;
   }
@@ -6709,22 +6683,22 @@ var JobBasicInformationV2Dto = class {
 __decorateClass([
   IsOptional22(),
   Type3(() => Boolean)
-], JobBasicInformationV2Dto.prototype, "isDraft", 2);
+], CreateJobViaAIDto.prototype, "isDraft", 2);
 __decorateClass([
-  IsNotEmpty44({ message: "Please enter job role" }),
+  IsNotEmpty43({ message: "Please enter job role" }),
   IsString23({ message: "Job role must be a string" })
-], JobBasicInformationV2Dto.prototype, "jobRole", 2);
+], CreateJobViaAIDto.prototype, "jobRole", 2);
 __decorateClass([
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "jobRoleCanonicalName", 2);
+], CreateJobViaAIDto.prototype, "jobRoleCanonicalName", 2);
 __decorateClass([
   IsOptional22(),
   IsString23({ message: "Project name must be a string" })
-], JobBasicInformationV2Dto.prototype, "projectName", 2);
+], CreateJobViaAIDto.prototype, "projectName", 2);
 __decorateClass([
   IsOptional22(),
   IsString23({ message: "Note must be a string" })
-], JobBasicInformationV2Dto.prototype, "note", 2);
+], CreateJobViaAIDto.prototype, "note", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
   IsOptional22(),
@@ -6732,160 +6706,420 @@ __decorateClass([
   ArrayNotEmpty2({ message: "Please select at least one skill" }),
   IsString23({ each: true, message: "Each skill must be a string" }),
   Type3(() => String)
-], JobBasicInformationV2Dto.prototype, "skills", 2);
+], CreateJobViaAIDto.prototype, "skills", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
   IsArray3({ message: "Good to have skills must be an array" }),
   IsString23({ each: true, message: "Each skill must be a string" }),
   IsOptional22(),
   Type3(() => String)
-], JobBasicInformationV2Dto.prototype, "goodToHaveSkills", 2);
+], CreateJobViaAIDto.prototype, "goodToHaveSkills", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
   IsNumber4({}, { message: "Openings must be a number" }),
   Min2(1, { message: "There must be at least 1 opening" }),
   Type3(() => Number)
-], JobBasicInformationV2Dto.prototype, "openings", 2);
+], CreateJobViaAIDto.prototype, "openings", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsEnum17(JobLocationEnumV2, {
+  IsEnum16(JobLocationEnumV2, {
     message: `Location must be one of: ${Object.values(JobLocationEnumV2).join(
       ", "
     )}`
   })
-], JobBasicInformationV2Dto.prototype, "locationMode", 2);
+], CreateJobViaAIDto.prototype, "locationMode", 2);
 __decorateClass([
   IsOptional22(),
   Type3(() => JobLocationDto)
-], JobBasicInformationV2Dto.prototype, "locations", 2);
+], CreateJobViaAIDto.prototype, "locations", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsEnum17(EmploymentTypeV2, {
+  IsEnum16(EmploymentTypeV2, {
     message: `Type of employment must be one of: ${Object.values(
       EmploymentTypeV2
     ).join(", ")}`
   })
-], JobBasicInformationV2Dto.prototype, "typeOfEmployment", 2);
+], CreateJobViaAIDto.prototype, "typeOfEmployment", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
   IsString23({ message: "Currency must be a string" })
-], JobBasicInformationV2Dto.prototype, "currency", 2);
+], CreateJobViaAIDto.prototype, "currency", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
   IsNumber4({}, { message: "Expected salary (from) must be a number" }),
   Min2(0, { message: "Expected salary (from) cannot be negative" }),
   Type3(() => Number)
-], JobBasicInformationV2Dto.prototype, "expectedSalaryFrom", 2);
+], CreateJobViaAIDto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "hideExpectedSalaryFrom", 2);
+], CreateJobViaAIDto.prototype, "hideExpectedSalaryFrom", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
   IsNumber4({}, { message: "Expected salary (to) must be a number" }),
   Min2(0, { message: "Expected salary (to) cannot be negative" }),
   Type3(() => Number)
-], JobBasicInformationV2Dto.prototype, "expectedSalaryTo", 2);
+], CreateJobViaAIDto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "hideExpectedSalaryTo", 2);
+], CreateJobViaAIDto.prototype, "hideExpectedSalaryTo", 2);
 __decorateClass([
   IsOptional22(),
   IsNumber4({}, { message: "Expected annual budget (from) must be a number" }),
   Min2(0, { message: "Expected annual budget (from) cannot be negative" }),
   Type3(() => Number)
-], JobBasicInformationV2Dto.prototype, "expectedAnnualBudgetFrom", 2);
+], CreateJobViaAIDto.prototype, "expectedAnnualBudgetFrom", 2);
 __decorateClass([
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetFrom", 2);
+], CreateJobViaAIDto.prototype, "hideExpectedAnnualBudgetFrom", 2);
 __decorateClass([
   IsOptional22(),
   IsNumber4({}, { message: "Expected annual budget (to) must be a number" }),
   Min2(0, { message: "Expected annual budget (to) cannot be negative" }),
   Type3(() => Number)
-], JobBasicInformationV2Dto.prototype, "expectedAnnualBudgetTo", 2);
+], CreateJobViaAIDto.prototype, "expectedAnnualBudgetTo", 2);
 __decorateClass([
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetTo", 2);
+], CreateJobViaAIDto.prototype, "hideExpectedAnnualBudgetTo", 2);
 __decorateClass([
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "years", 2);
+], CreateJobViaAIDto.prototype, "years", 2);
 __decorateClass([
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "months", 2);
+], CreateJobViaAIDto.prototype, "months", 2);
 __decorateClass([
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "weeks", 2);
+], CreateJobViaAIDto.prototype, "weeks", 2);
 __decorateClass([
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "days", 2);
+], CreateJobViaAIDto.prototype, "days", 2);
 __decorateClass([
   IsOptional22(),
   IsNumber4({}, { message: "Number of hours must be a number" }),
   Min2(0, { message: "Number of hours cannot be negative" }),
   Max2(40, { message: "Number of hours cannot exceed 40" }),
   Type3(() => Number)
-], JobBasicInformationV2Dto.prototype, "numberOfHours", 2);
+], CreateJobViaAIDto.prototype, "numberOfHours", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
   IsString23({ message: "Candidate communication skills must be a string" }),
   IsOptional22()
-], JobBasicInformationV2Dto.prototype, "candidateCommunicationSkills", 2);
+], CreateJobViaAIDto.prototype, "candidateCommunicationSkills", 2);
 __decorateClass([
   IsOptional22(),
   IsString23({ message: "Academic qualification must be a string" })
-], JobBasicInformationV2Dto.prototype, "academicQualification", 2);
+], CreateJobViaAIDto.prototype, "academicQualification", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsNotEmpty44({ message: "Please enter the years of experience" }),
+  IsNotEmpty43({ message: "Please enter the years of experience" }),
   IsString23({ message: "Years of experience must be a string" })
-], JobBasicInformationV2Dto.prototype, "yearsOfExperienceFrom", 2);
+], CreateJobViaAIDto.prototype, "yearsOfExperienceFrom", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsNotEmpty44({ message: "Please enter the years of experience upto" }),
+  IsNotEmpty43({ message: "Please enter the years of experience upto" }),
   IsString23({ message: "Years of experience must be a string" })
-], JobBasicInformationV2Dto.prototype, "yearsOfExperienceTo", 2);
+], CreateJobViaAIDto.prototype, "yearsOfExperienceTo", 2);
 __decorateClass([
   IsOptional22(),
   IsString23({ message: "Business industry must be a string" })
-], JobBasicInformationV2Dto.prototype, "businessIndustry", 2);
+], CreateJobViaAIDto.prototype, "businessIndustry", 2);
 __decorateClass([
   IsOptional22(),
-  IsEnum17(StepCompletedEnumV2, {
+  IsEnum16(StepCompletedEnumV2, {
     message: `Type of stepCompleted must be one of: ${Object.values(
       StepCompletedEnumV2
     ).join(", ")}`
   })
-], JobBasicInformationV2Dto.prototype, "stepCompleted", 2);
+], CreateJobViaAIDto.prototype, "stepCompleted", 2);
 __decorateClass([
   IsOptional22(),
   IsString23({ message: "Additional comment must be a string" }),
   MaxLength9(500, { message: "Additional comment must not exceed 500 characters" })
+], CreateJobViaAIDto.prototype, "additionalComment", 2);
+__decorateClass([
+  IsNotEmpty43({ message: "Please enter job description" }),
+  IsString23({ message: "Description must be a string" }),
+  MaxLength9(5e3, { message: "Description must not exceed 5000 characters" })
+], CreateJobViaAIDto.prototype, "description", 2);
+
+// src/modules/job/dto/job-status.dto.ts
+import { IsEnum as IsEnum17, IsNotEmpty as IsNotEmpty44 } from "class-validator";
+var JobStatus = /* @__PURE__ */ ((JobStatus2) => {
+  JobStatus2["ACTIVE"] = "ACTIVE";
+  JobStatus2["OPEN"] = "OPEN";
+  JobStatus2["DRAFT"] = "DRAFT";
+  JobStatus2["ONHOLD"] = "ONHOLD";
+  JobStatus2["CLOSED"] = "CLOSED";
+  JobStatus2["COMPLETED"] = "COMPLETED";
+  return JobStatus2;
+})(JobStatus || {});
+var JobStatusDto = class {
+};
+__decorateClass([
+  IsNotEmpty44({ message: "Please provide a job status" }),
+  IsEnum17(JobStatus, {
+    message: `Status must be one of: ${Object.values(JobStatus).join(", ")}`
+  })
+], JobStatusDto.prototype, "status", 2);
+
+// src/modules/job/dto/job-id-param.dto.ts
+import { IsUUID as IsUUID16 } from "class-validator";
+var JobIdParamDto = class {
+};
+__decorateClass([
+  IsUUID16("4", {
+    message: "Invalid job ID. It must be a valid UUID version 4."
+  })
+], JobIdParamDto.prototype, "id", 2);
+
+// src/modules/job/dto/job-basic-information-v2.dto.ts
+import {
+  IsString as IsString24,
+  IsNotEmpty as IsNotEmpty45,
+  IsArray as IsArray4,
+  ArrayNotEmpty as ArrayNotEmpty3,
+  IsNumber as IsNumber5,
+  IsOptional as IsOptional23,
+  IsEnum as IsEnum18,
+  Min as Min3,
+  ValidateIf as ValidateIf5,
+  MaxLength as MaxLength10,
+  Max as Max3
+} from "class-validator";
+import { Type as Type4 } from "class-transformer";
+var JobLocationEnumV22 = /* @__PURE__ */ ((JobLocationEnumV23) => {
+  JobLocationEnumV23["ONSITE"] = "ONSITE";
+  JobLocationEnumV23["REMOTE"] = "REMOTE";
+  JobLocationEnumV23["HYBRID"] = "HYBRID";
+  return JobLocationEnumV23;
+})(JobLocationEnumV22 || {});
+var EmploymentTypeV22 = /* @__PURE__ */ ((EmploymentTypeV23) => {
+  EmploymentTypeV23["FULLTIME"] = "FULLTIME";
+  EmploymentTypeV23["PARTTIME"] = "PARTTIME";
+  EmploymentTypeV23["BOTH"] = "BOTH";
+  EmploymentTypeV23["HOURLY"] = "HOURLY";
+  EmploymentTypeV23["FREELANCE"] = "FREELANCE";
+  EmploymentTypeV23["FTE"] = "FTE";
+  return EmploymentTypeV23;
+})(EmploymentTypeV22 || {});
+var StepCompletedEnumV22 = /* @__PURE__ */ ((StepCompletedEnumV23) => {
+  StepCompletedEnumV23["BASIC_INFORMATION"] = "BASIC_INFORMATION";
+  StepCompletedEnumV23["JOB_DESCRIPTION"] = "JOB_DESCRIPTION";
+  return StepCompletedEnumV23;
+})(StepCompletedEnumV22 || {});
+var JobLocationDto2 = class {
+};
+__decorateClass([
+  IsOptional23(),
+  Type4(() => Number)
+], JobLocationDto2.prototype, "countryId", 2);
+__decorateClass([
+  IsOptional23(),
+  Type4(() => Number)
+], JobLocationDto2.prototype, "stateId", 2);
+__decorateClass([
+  IsOptional23(),
+  Type4(() => Number)
+], JobLocationDto2.prototype, "cityId", 2);
+__decorateClass([
+  IsOptional23(),
+  IsString24({ message: "Country name must be a string" }),
+  MaxLength10(255, { message: "Country name must not exceed 255 characters" })
+], JobLocationDto2.prototype, "countryName", 2);
+__decorateClass([
+  IsOptional23(),
+  IsString24({ message: "State name must be a string" }),
+  MaxLength10(255, { message: "State name must not exceed 255 characters" })
+], JobLocationDto2.prototype, "stateName", 2);
+__decorateClass([
+  IsOptional23(),
+  IsString24({ message: "City name must be a string" }),
+  MaxLength10(255, { message: "City name must not exceed 255 characters" })
+], JobLocationDto2.prototype, "cityName", 2);
+var JobBasicInformationV2Dto = class {
+  constructor() {
+    this.isDraft = false;
+  }
+};
+__decorateClass([
+  IsOptional23(),
+  Type4(() => Boolean)
+], JobBasicInformationV2Dto.prototype, "isDraft", 2);
+__decorateClass([
+  IsNotEmpty45({ message: "Please enter job role" }),
+  IsString24({ message: "Job role must be a string" })
+], JobBasicInformationV2Dto.prototype, "jobRole", 2);
+__decorateClass([
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "jobRoleCanonicalName", 2);
+__decorateClass([
+  IsOptional23(),
+  IsString24({ message: "Project name must be a string" })
+], JobBasicInformationV2Dto.prototype, "projectName", 2);
+__decorateClass([
+  IsOptional23(),
+  IsString24({ message: "Note must be a string" })
+], JobBasicInformationV2Dto.prototype, "note", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsOptional23(),
+  IsArray4({ message: "Skills must be an array" }),
+  ArrayNotEmpty3({ message: "Please select at least one skill" }),
+  IsString24({ each: true, message: "Each skill must be a string" }),
+  Type4(() => String)
+], JobBasicInformationV2Dto.prototype, "skills", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsArray4({ message: "Good to have skills must be an array" }),
+  IsString24({ each: true, message: "Each skill must be a string" }),
+  IsOptional23(),
+  Type4(() => String)
+], JobBasicInformationV2Dto.prototype, "goodToHaveSkills", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsNumber5({}, { message: "Openings must be a number" }),
+  Min3(1, { message: "There must be at least 1 opening" }),
+  Type4(() => Number)
+], JobBasicInformationV2Dto.prototype, "openings", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsEnum18(JobLocationEnumV22, {
+    message: `Location must be one of: ${Object.values(JobLocationEnumV22).join(
+      ", "
+    )}`
+  })
+], JobBasicInformationV2Dto.prototype, "locationMode", 2);
+__decorateClass([
+  IsOptional23(),
+  Type4(() => JobLocationDto2)
+], JobBasicInformationV2Dto.prototype, "locations", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsEnum18(EmploymentTypeV22, {
+    message: `Type of employment must be one of: ${Object.values(
+      EmploymentTypeV22
+    ).join(", ")}`
+  })
+], JobBasicInformationV2Dto.prototype, "typeOfEmployment", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsString24({ message: "Currency must be a string" })
+], JobBasicInformationV2Dto.prototype, "currency", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsNumber5({}, { message: "Expected salary (from) must be a number" }),
+  Min3(0, { message: "Expected salary (from) cannot be negative" }),
+  Type4(() => Number)
+], JobBasicInformationV2Dto.prototype, "expectedSalaryFrom", 2);
+__decorateClass([
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "hideExpectedSalaryFrom", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsNumber5({}, { message: "Expected salary (to) must be a number" }),
+  Min3(0, { message: "Expected salary (to) cannot be negative" }),
+  Type4(() => Number)
+], JobBasicInformationV2Dto.prototype, "expectedSalaryTo", 2);
+__decorateClass([
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "hideExpectedSalaryTo", 2);
+__decorateClass([
+  IsOptional23(),
+  IsNumber5({}, { message: "Expected annual budget (from) must be a number" }),
+  Min3(0, { message: "Expected annual budget (from) cannot be negative" }),
+  Type4(() => Number)
+], JobBasicInformationV2Dto.prototype, "expectedAnnualBudgetFrom", 2);
+__decorateClass([
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetFrom", 2);
+__decorateClass([
+  IsOptional23(),
+  IsNumber5({}, { message: "Expected annual budget (to) must be a number" }),
+  Min3(0, { message: "Expected annual budget (to) cannot be negative" }),
+  Type4(() => Number)
+], JobBasicInformationV2Dto.prototype, "expectedAnnualBudgetTo", 2);
+__decorateClass([
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetTo", 2);
+__decorateClass([
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "years", 2);
+__decorateClass([
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "months", 2);
+__decorateClass([
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "weeks", 2);
+__decorateClass([
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "days", 2);
+__decorateClass([
+  IsOptional23(),
+  IsNumber5({}, { message: "Number of hours must be a number" }),
+  Min3(0, { message: "Number of hours cannot be negative" }),
+  Max3(40, { message: "Number of hours cannot exceed 40" }),
+  Type4(() => Number)
+], JobBasicInformationV2Dto.prototype, "numberOfHours", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsString24({ message: "Candidate communication skills must be a string" }),
+  IsOptional23()
+], JobBasicInformationV2Dto.prototype, "candidateCommunicationSkills", 2);
+__decorateClass([
+  IsOptional23(),
+  IsString24({ message: "Academic qualification must be a string" })
+], JobBasicInformationV2Dto.prototype, "academicQualification", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsNotEmpty45({ message: "Please enter the years of experience" }),
+  IsString24({ message: "Years of experience must be a string" })
+], JobBasicInformationV2Dto.prototype, "yearsOfExperienceFrom", 2);
+__decorateClass([
+  ValidateIf5((o) => !o.isDraft),
+  IsNotEmpty45({ message: "Please enter the years of experience upto" }),
+  IsString24({ message: "Years of experience must be a string" })
+], JobBasicInformationV2Dto.prototype, "yearsOfExperienceTo", 2);
+__decorateClass([
+  IsOptional23(),
+  IsString24({ message: "Business industry must be a string" })
+], JobBasicInformationV2Dto.prototype, "businessIndustry", 2);
+__decorateClass([
+  IsOptional23(),
+  IsEnum18(StepCompletedEnumV22, {
+    message: `Type of stepCompleted must be one of: ${Object.values(
+      StepCompletedEnumV22
+    ).join(", ")}`
+  })
+], JobBasicInformationV2Dto.prototype, "stepCompleted", 2);
+__decorateClass([
+  IsOptional23(),
+  IsString24({ message: "Additional comment must be a string" }),
+  MaxLength10(500, { message: "Additional comment must not exceed 500 characters" })
 ], JobBasicInformationV2Dto.prototype, "additionalComment", 2);
 
 // src/modules/job/dto/close-job.dto.ts
-import { IsOptional as IsOptional23, IsString as IsString24 } from "class-validator";
+import { IsOptional as IsOptional24, IsString as IsString25 } from "class-validator";
 var CloseJobDto = class {
 };
 __decorateClass([
-  IsOptional23(),
-  IsString24()
+  IsOptional24(),
+  IsString25()
 ], CloseJobDto.prototype, "reason", 2);
 
 // src/modules/job/dto/create-job-application.dto.ts
-import { IsBoolean as IsBoolean3, IsNotEmpty as IsNotEmpty45, IsOptional as IsOptional24, IsString as IsString25 } from "class-validator";
+import { IsBoolean as IsBoolean3, IsNotEmpty as IsNotEmpty46, IsOptional as IsOptional25, IsString as IsString26 } from "class-validator";
 var CreateJobApplicationDto = class {
 };
 __decorateClass([
-  IsNotEmpty45({ message: "Job ID is required" }),
-  IsString25({ message: "Job ID must be a string" })
+  IsNotEmpty46({ message: "Job ID is required" }),
+  IsString26({ message: "Job ID must be a string" })
 ], CreateJobApplicationDto.prototype, "jobId", 2);
 __decorateClass([
-  IsOptional24(),
+  IsOptional25(),
   IsBoolean3({ message: "isCta must be a boolean" })
 ], CreateJobApplicationDto.prototype, "isCta", 2);
 
 // src/modules/job/dto/change-job-application-status.dto.ts
-import { IsEnum as IsEnum18, IsNotEmpty as IsNotEmpty46 } from "class-validator";
+import { IsEnum as IsEnum19, IsNotEmpty as IsNotEmpty47 } from "class-validator";
 var JobApplicationStatus = /* @__PURE__ */ ((JobApplicationStatus2) => {
   JobApplicationStatus2["PENDING"] = "PENDING";
   JobApplicationStatus2["SHORTLISTED"] = "SHORTLISTED";
@@ -6897,24 +7131,24 @@ var JobApplicationStatus = /* @__PURE__ */ ((JobApplicationStatus2) => {
 var ChangeJobApplicationStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty46({ message: "Status is required" }),
-  IsEnum18(JobApplicationStatus, {
+  IsNotEmpty47({ message: "Status is required" }),
+  IsEnum19(JobApplicationStatus, {
     message: `Status must be one of: ${Object.values(JobApplicationStatus).join(", ")}`
   })
 ], ChangeJobApplicationStatusDto.prototype, "status", 2);
 
 // src/modules/job/dto/change-job-application-status-bulk.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty3, IsArray as IsArray4, IsEnum as IsEnum19, IsNotEmpty as IsNotEmpty47, IsNumber as IsNumber5 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty4, IsArray as IsArray5, IsEnum as IsEnum20, IsNotEmpty as IsNotEmpty48, IsNumber as IsNumber6 } from "class-validator";
 var ChangeJobApplicationStatusBulkDto = class {
 };
 __decorateClass([
-  IsArray4({ message: "Job application IDs must be an array" }),
-  ArrayNotEmpty3({ message: "At least one job application ID is required" }),
-  IsNumber5({}, { each: true, message: "Each job application ID must be a number" })
+  IsArray5({ message: "Job application IDs must be an array" }),
+  ArrayNotEmpty4({ message: "At least one job application ID is required" }),
+  IsNumber6({}, { each: true, message: "Each job application ID must be a number" })
 ], ChangeJobApplicationStatusBulkDto.prototype, "jobApplicationIds", 2);
 __decorateClass([
-  IsNotEmpty47({ message: "Status is required" }),
-  IsEnum19(JobApplicationStatus, {
+  IsNotEmpty48({ message: "Status is required" }),
+  IsEnum20(JobApplicationStatus, {
     message: `Status must be one of: ${Object.values(JobApplicationStatus).join(", ")}`
   })
 ], ChangeJobApplicationStatusBulkDto.prototype, "status", 2);
@@ -6962,23 +7196,23 @@ var FREELANCER_ASSESSMENT_REQUEST_PATTERN = {
 
 // src/modules/user/freelancer-profile/dto/freelancer-change-password.dto.ts
 import {
-  IsString as IsString26,
-  IsNotEmpty as IsNotEmpty48,
-  MaxLength as MaxLength10,
+  IsString as IsString27,
+  IsNotEmpty as IsNotEmpty49,
+  MaxLength as MaxLength11,
   MinLength as MinLength8,
   Matches as Matches8
 } from "class-validator";
 var FreelancerChangePasswordDto = class {
 };
 __decorateClass([
-  IsNotEmpty48({ message: "Please enter Old Password." }),
-  IsString26()
+  IsNotEmpty49({ message: "Please enter Old Password." }),
+  IsString27()
 ], FreelancerChangePasswordDto.prototype, "oldPassword", 2);
 __decorateClass([
-  IsNotEmpty48({ message: "Please enter New Password." }),
-  IsString26(),
+  IsNotEmpty49({ message: "Please enter New Password." }),
+  IsString27(),
   MinLength8(6),
-  MaxLength10(32),
+  MaxLength11(32),
   Matches8(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "New Password must include letters, numbers and symbols."
   })
@@ -6986,13 +7220,13 @@ __decorateClass([
 
 // src/modules/user/freelancer-profile/dto/update-freelancer-profile.dto.ts
 import {
-  IsOptional as IsOptional25,
-  IsString as IsString27,
+  IsOptional as IsOptional26,
+  IsString as IsString28,
   IsEmail as IsEmail7,
-  IsNumber as IsNumber6,
-  IsEnum as IsEnum20,
-  IsNotEmpty as IsNotEmpty49,
-  ValidateIf as ValidateIf5,
+  IsNumber as IsNumber7,
+  IsEnum as IsEnum21,
+  IsNotEmpty as IsNotEmpty50,
+  ValidateIf as ValidateIf6,
   IsInt
 } from "class-validator";
 var NatureOfWorkDto = /* @__PURE__ */ ((NatureOfWorkDto2) => {
@@ -7010,150 +7244,150 @@ var ModeOfWorkDto = /* @__PURE__ */ ((ModeOfWorkDto2) => {
 var UpdateFreelancerProfileDto = class {
 };
 __decorateClass([
-  IsNotEmpty49({ message: "Please enter first name." }),
-  IsString27({ message: "Please enter valid first name." })
+  IsNotEmpty50({ message: "Please enter first name." }),
+  IsString28({ message: "Please enter valid first name." })
 ], UpdateFreelancerProfileDto.prototype, "firstName", 2);
 __decorateClass([
-  IsOptional25(),
-  IsNotEmpty49({ message: "Please enter last name." }),
-  IsString27({ message: "Please enter valid last name." })
+  IsOptional26(),
+  IsNotEmpty50({ message: "Please enter last name." }),
+  IsString28({ message: "Please enter valid last name." })
 ], UpdateFreelancerProfileDto.prototype, "lastName", 2);
 __decorateClass([
-  IsNotEmpty49({ message: "Please enter designation." }),
-  IsString27({ message: "Please enter valid designation." })
+  IsNotEmpty50({ message: "Please enter designation." }),
+  IsString28({ message: "Please enter valid designation." })
 ], UpdateFreelancerProfileDto.prototype, "designation", 2);
 __decorateClass([
-  IsNotEmpty49({ message: "Please enter experience." }),
-  IsString27({ message: "Please enter valid experience." })
+  IsNotEmpty50({ message: "Please enter experience." }),
+  IsString28({ message: "Please enter valid experience." })
 ], UpdateFreelancerProfileDto.prototype, "experience", 2);
 __decorateClass([
-  IsNotEmpty49({ message: "Please enter email id." }),
+  IsNotEmpty50({ message: "Please enter email id." }),
   IsEmail7()
 ], UpdateFreelancerProfileDto.prototype, "email", 2);
 __decorateClass([
-  IsNotEmpty49({ message: "Please enter mobile code." }),
-  IsString27({ message: "Please enter valid mobile code." })
+  IsNotEmpty50({ message: "Please enter mobile code." }),
+  IsString28({ message: "Please enter valid mobile code." })
 ], UpdateFreelancerProfileDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsNotEmpty49({ message: "Please enter mobile number." }),
-  IsString27({ message: "Please enter valid mobile number." })
+  IsNotEmpty50({ message: "Please enter mobile number." }),
+  IsString28({ message: "Please enter valid mobile number." })
 ], UpdateFreelancerProfileDto.prototype, "mobile", 2);
 __decorateClass([
-  IsOptional25(),
-  IsNumber6()
+  IsOptional26(),
+  IsNumber7()
 ], UpdateFreelancerProfileDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional25(),
-  IsNumber6()
+  IsOptional26(),
+  IsNumber7()
 ], UpdateFreelancerProfileDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional25(),
-  IsNumber6()
+  IsOptional26(),
+  IsNumber7()
 ], UpdateFreelancerProfileDto.prototype, "cityId", 2);
 //@IsString({ message: "Please enter valid expected hourly compensation." })
 __decorateClass([
-  ValidateIf5((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */ || dto.NatureOfWorkDto === "BOTH" /* BOTH */),
-  IsNotEmpty49({ message: "Please enter expected hourly compensation." })
+  ValidateIf6((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */ || dto.NatureOfWorkDto === "BOTH" /* BOTH */),
+  IsNotEmpty50({ message: "Please enter expected hourly compensation." })
 ], UpdateFreelancerProfileDto.prototype, "expectedHourlyCompensation", 2);
 __decorateClass([
-  ValidateIf5((dto) => dto.NatureOfWorkDto === "FTE" /* FTE */ || dto.NatureOfWorkDto === "BOTH" /* BOTH */),
-  IsNotEmpty49({ message: "Please enter expected annual compensation." })
+  ValidateIf6((dto) => dto.NatureOfWorkDto === "FTE" /* FTE */ || dto.NatureOfWorkDto === "BOTH" /* BOTH */),
+  IsNotEmpty50({ message: "Please enter expected annual compensation." })
 ], UpdateFreelancerProfileDto.prototype, "expectedAnnualCompensation", 2);
 __decorateClass([
-  ValidateIf5((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
+  ValidateIf6((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
   IsInt({ message: "Please enter valid weekly availability hours (integer)." }),
-  IsNotEmpty49({ message: "Please enter weekly availability hours" })
+  IsNotEmpty50({ message: "Please enter weekly availability hours" })
 ], UpdateFreelancerProfileDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  IsNotEmpty49({ message: "Please select engagement type." }),
-  IsEnum20(NatureOfWorkDto, {
+  IsNotEmpty50({ message: "Please select engagement type." }),
+  IsEnum21(NatureOfWorkDto, {
     message: `Engagement Type must be one of: ${Object.values(
       NatureOfWorkDto
     ).join(", ")}`
   })
 ], UpdateFreelancerProfileDto.prototype, "natureOfWork", 2);
 __decorateClass([
-  IsNotEmpty49({ message: "Please select mode of work." }),
-  IsEnum20(ModeOfWorkDto, {
+  IsNotEmpty50({ message: "Please select mode of work." }),
+  IsEnum21(ModeOfWorkDto, {
     message: `Mode of work must be one of: ${Object.values(ModeOfWorkDto).join(
       ", "
     )}`
   })
 ], UpdateFreelancerProfileDto.prototype, "modeOfWork", 2);
 __decorateClass([
-  IsOptional25(),
-  IsString27()
+  IsOptional26(),
+  IsString28()
 ], UpdateFreelancerProfileDto.prototype, "portfolioLink", 2);
 __decorateClass([
-  IsNotEmpty49({ message: "Please enter address." }),
-  IsString27()
+  IsNotEmpty50({ message: "Please enter address." }),
+  IsString28()
 ], UpdateFreelancerProfileDto.prototype, "address", 2);
 __decorateClass([
-  IsOptional25(),
-  IsString27()
+  IsOptional26(),
+  IsString28()
 ], UpdateFreelancerProfileDto.prototype, "addressLine", 2);
 __decorateClass([
-  IsNotEmpty49({ message: "Please enter postalCode." }),
-  IsString27()
+  IsNotEmpty50({ message: "Please enter postalCode." }),
+  IsString28()
 ], UpdateFreelancerProfileDto.prototype, "postalCode", 2);
 __decorateClass([
-  IsOptional25(),
-  IsString27()
+  IsOptional26(),
+  IsString28()
 ], UpdateFreelancerProfileDto.prototype, "about", 2);
 __decorateClass([
-  IsOptional25(),
-  IsString27()
+  IsOptional26(),
+  IsString28()
 ], UpdateFreelancerProfileDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  IsOptional25(),
-  IsString27()
+  IsOptional26(),
+  IsString28()
 ], UpdateFreelancerProfileDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  IsOptional25(),
-  IsString27()
+  IsOptional26(),
+  IsString28()
 ], UpdateFreelancerProfileDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  IsOptional25(),
-  IsString27()
-], UpdateFreelancerProfileDto.prototype, "stackOverflowProfileLink", 2);
+  IsOptional26(),
+  IsString28()
+], UpdateFreelancerProfileDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  IsOptional25(),
-  IsString27()
+  IsOptional26(),
+  IsString28()
 ], UpdateFreelancerProfileDto.prototype, "resumeUrl", 2);
 
 // src/modules/user/freelancer-profile/dto/freelancer-e-signature.dto.ts
-import { IsNotEmpty as IsNotEmpty50, IsUUID as IsUUID17 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty51, IsUUID as IsUUID17 } from "class-validator";
 var FreelancerESignatureDto = class {
 };
 __decorateClass([
   IsUUID17("4", { message: "Freelancer UUID must be a valid UUID." }),
-  IsNotEmpty50({ message: "Freelancer UUID is required." })
+  IsNotEmpty51({ message: "Freelancer UUID is required." })
 ], FreelancerESignatureDto.prototype, "uuid", 2);
 
 // src/modules/user/freelancer-profile/dto/fetch-client-info-for-chat.dto.ts
-import { IsNotEmpty as IsNotEmpty51, IsNumber as IsNumber7 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty52, IsNumber as IsNumber8 } from "class-validator";
 var FetchClientInfoForChatDto = class {
 };
 __decorateClass([
-  IsNotEmpty51({ message: "Client ID is required" }),
-  IsNumber7({}, { message: "Client ID must be a number" })
+  IsNotEmpty52({ message: "Client ID is required" }),
+  IsNumber8({}, { message: "Client ID must be a number" })
 ], FetchClientInfoForChatDto.prototype, "clientId", 2);
 
 // src/modules/user/freelancer-profile/dto/capture-ai-assessment-result.dto.ts
-import { IsNotEmpty as IsNotEmpty52, IsString as IsString28, IsOptional as IsOptional26, IsObject as IsObject4 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty53, IsString as IsString29, IsOptional as IsOptional27, IsObject as IsObject4 } from "class-validator";
 var CaptureAiAssessmentResultDto = class {
 };
 __decorateClass([
-  IsNotEmpty52({ message: "AI Assessment UUID is required" }),
-  IsString28({ message: "AI Assessment UUID must be a string" })
+  IsNotEmpty53({ message: "AI Assessment UUID is required" }),
+  IsString29({ message: "AI Assessment UUID must be a string" })
 ], CaptureAiAssessmentResultDto.prototype, "aiAssessmentUuid", 2);
 __decorateClass([
-  IsOptional26(),
+  IsOptional27(),
   IsObject4()
 ], CaptureAiAssessmentResultDto.prototype, "result", 2);
 __decorateClass([
-  IsOptional26(),
-  IsString28()
+  IsOptional27(),
+  IsString29()
 ], CaptureAiAssessmentResultDto.prototype, "status", 2);
 
 // src/modules/bank/pattern/pattern.ts
@@ -7168,11 +7402,11 @@ var BANK_PATTERN = {
 
 // src/modules/bank/dto/freelancer-bank-details.dto.ts
 import {
-  IsEnum as IsEnum21,
-  IsNotEmpty as IsNotEmpty53,
-  IsOptional as IsOptional27,
-  IsString as IsString29,
-  ValidateIf as ValidateIf6
+  IsEnum as IsEnum22,
+  IsNotEmpty as IsNotEmpty54,
+  IsOptional as IsOptional28,
+  IsString as IsString30,
+  ValidateIf as ValidateIf7
 } from "class-validator";
 var BankAccountScope = /* @__PURE__ */ ((BankAccountScope2) => {
   BankAccountScope2["DOMESTIC"] = "DOMESTIC";
@@ -7182,51 +7416,51 @@ var BankAccountScope = /* @__PURE__ */ ((BankAccountScope2) => {
 var FreelancerBankDetailsDto = class {
 };
 __decorateClass([
-  IsNotEmpty53({ message: "Please enter Account Holder Name." })
+  IsNotEmpty54({ message: "Please enter Account Holder Name." })
 ], FreelancerBankDetailsDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty53({ message: "Please enter Mobile Code." })
+  IsNotEmpty54({ message: "Please enter Mobile Code." })
 ], FreelancerBankDetailsDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsNotEmpty53({ message: "Please enter Mobile Number." })
+  IsNotEmpty54({ message: "Please enter Mobile Number." })
 ], FreelancerBankDetailsDto.prototype, "mobile", 2);
 __decorateClass([
-  IsNotEmpty53({ message: "Please enter Email." })
+  IsNotEmpty54({ message: "Please enter Email." })
 ], FreelancerBankDetailsDto.prototype, "email", 2);
 __decorateClass([
-  IsOptional27()
+  IsOptional28()
 ], FreelancerBankDetailsDto.prototype, "address", 2);
 __decorateClass([
-  IsNotEmpty53({ message: "Please enter Account Number." })
+  IsNotEmpty54({ message: "Please enter Account Number." })
 ], FreelancerBankDetailsDto.prototype, "accountNumber", 2);
 __decorateClass([
-  IsNotEmpty53({ message: "Please enter Bank Name." })
+  IsNotEmpty54({ message: "Please enter Bank Name." })
 ], FreelancerBankDetailsDto.prototype, "bankName", 2);
 __decorateClass([
-  IsOptional27(),
-  IsString29()
+  IsOptional28(),
+  IsString30()
 ], FreelancerBankDetailsDto.prototype, "branchName", 2);
 __decorateClass([
-  ValidateIf6((dto) => dto.accountScope === "DOMESTIC"),
-  IsNotEmpty53({ message: "IFSC Code is required for DOMESTIC accounts." })
+  ValidateIf7((dto) => dto.accountScope === "DOMESTIC"),
+  IsNotEmpty54({ message: "IFSC Code is required for DOMESTIC accounts." })
 ], FreelancerBankDetailsDto.prototype, "ifscCode", 2);
 __decorateClass([
-  ValidateIf6((dto) => dto.accountScope === "INTERNATIONAL"),
-  IsNotEmpty53({ message: "Routing Number/Sort Code is required for INTERNATIONAL accounts." })
+  ValidateIf7((dto) => dto.accountScope === "INTERNATIONAL"),
+  IsNotEmpty54({ message: "Routing Number/Sort Code is required for INTERNATIONAL accounts." })
 ], FreelancerBankDetailsDto.prototype, "routingNo", 2);
 __decorateClass([
-  ValidateIf6((dto) => dto.accountScope === "INTERNATIONAL"),
-  IsNotEmpty53({ message: "ABA Number is required for INTERNATIONAL accounts." })
+  ValidateIf7((dto) => dto.accountScope === "INTERNATIONAL"),
+  IsNotEmpty54({ message: "ABA Number is required for INTERNATIONAL accounts." })
 ], FreelancerBankDetailsDto.prototype, "abaNumber", 2);
 __decorateClass([
-  ValidateIf6((dto) => dto.accountScope === "INTERNATIONAL"),
-  IsNotEmpty53({ message: "IBAN is required for INTERNATIONAL accounts." })
+  ValidateIf7((dto) => dto.accountScope === "INTERNATIONAL"),
+  IsNotEmpty54({ message: "IBAN is required for INTERNATIONAL accounts." })
 ], FreelancerBankDetailsDto.prototype, "iban", 2);
 __decorateClass([
-  IsOptional27()
+  IsOptional28()
 ], FreelancerBankDetailsDto.prototype, "accountType", 2);
 __decorateClass([
-  IsEnum21(BankAccountScope, {
+  IsEnum22(BankAccountScope, {
     message: `Type of Account Scope must be one of: ${Object.values(
       BankAccountScope
     ).join(", ")}`
@@ -7248,7 +7482,7 @@ var SYSTEM_PREFERENCES_PATTERN = {
 // src/modules/system-preference/dto/system-preference.dto.ts
 import {
   IsBoolean as IsBoolean4,
-  IsEnum as IsEnum22
+  IsEnum as IsEnum23
 } from "class-validator";
 var SystemPreferenceKey = /* @__PURE__ */ ((SystemPreferenceKey2) => {
   SystemPreferenceKey2["EMAIL_NOTIFICATION"] = "EMAIL_NOTIFICATION";
@@ -7261,7 +7495,7 @@ __decorateClass([
   IsBoolean4()
 ], SystemPreferenceDto.prototype, "value", 2);
 __decorateClass([
-  IsEnum22(SystemPreferenceKey, {
+  IsEnum23(SystemPreferenceKey, {
     message: `key must be one of: ${Object.values(
       SystemPreferenceKey
     ).join(", ")}`
@@ -7276,40 +7510,40 @@ var GLOBAL_SETTING_PATTERN = {
 
 // src/modules/global-setting/dto/add-global-setting.dto.ts
 import {
-  IsString as IsString30,
-  IsNotEmpty as IsNotEmpty54,
-  MaxLength as MaxLength11
+  IsString as IsString31,
+  IsNotEmpty as IsNotEmpty55,
+  MaxLength as MaxLength12
 } from "class-validator";
 var AddGlobalSettingDto = class {
 };
 __decorateClass([
-  IsNotEmpty54({ message: "Key is required" }),
-  IsString30({ message: "Key must be a string" }),
-  MaxLength11(255, { message: "Key must not exceed 255 characters" })
+  IsNotEmpty55({ message: "Key is required" }),
+  IsString31({ message: "Key must be a string" }),
+  MaxLength12(255, { message: "Key must not exceed 255 characters" })
 ], AddGlobalSettingDto.prototype, "key", 2);
 __decorateClass([
-  IsNotEmpty54({ message: "Value is required" }),
-  IsString30({ message: "Value must be a string" })
+  IsNotEmpty55({ message: "Value is required" }),
+  IsString31({ message: "Value must be a string" })
 ], AddGlobalSettingDto.prototype, "value", 2);
 
 // src/modules/global-setting/dto/remove-global-setting.dto.ts
 import {
-  IsString as IsString31,
-  IsNotEmpty as IsNotEmpty55,
+  IsString as IsString32,
+  IsNotEmpty as IsNotEmpty56,
   IsUUID as IsUUID18,
-  ValidateIf as ValidateIf7
+  ValidateIf as ValidateIf8
 } from "class-validator";
 var RemoveGlobalSettingDto = class {
 };
 __decorateClass([
-  ValidateIf7((o) => !o.key),
-  IsNotEmpty55({ message: "Either uuid or key is required" }),
+  ValidateIf8((o) => !o.key),
+  IsNotEmpty56({ message: "Either uuid or key is required" }),
   IsUUID18("4", { message: "UUID must be a valid UUID" })
 ], RemoveGlobalSettingDto.prototype, "uuid", 2);
 __decorateClass([
-  ValidateIf7((o) => !o.uuid),
-  IsNotEmpty55({ message: "Either uuid or key is required" }),
-  IsString31({ message: "Key must be a string" })
+  ValidateIf8((o) => !o.uuid),
+  IsNotEmpty56({ message: "Either uuid or key is required" }),
+  IsString32({ message: "Key must be a string" })
 ], RemoveGlobalSettingDto.prototype, "key", 2);
 
 // src/modules/notification/pattern/pattern.ts
@@ -7354,28 +7588,28 @@ var EMAIL_PATTERN = {
 };
 
 // src/modules/notification/dto/test-notification.dto.ts
-import { IsOptional as IsOptional28, IsString as IsString32, IsObject as IsObject5, IsEmail as IsEmail8, IsPhoneNumber } from "class-validator";
+import { IsOptional as IsOptional29, IsString as IsString33, IsObject as IsObject5, IsEmail as IsEmail8, IsPhoneNumber } from "class-validator";
 var TestNotificationDto = class {
 };
 __decorateClass([
-  IsOptional28(),
+  IsOptional29(),
   IsEmail8({}, { message: "Email must be valid" })
 ], TestNotificationDto.prototype, "email", 2);
 __decorateClass([
-  IsOptional28(),
+  IsOptional29(),
   IsPhoneNumber()
 ], TestNotificationDto.prototype, "phone", 2);
 __decorateClass([
-  IsOptional28(),
-  IsString32()
+  IsOptional29(),
+  IsString33()
 ], TestNotificationDto.prototype, "message", 2);
 __decorateClass([
-  IsOptional28(),
+  IsOptional29(),
   IsObject5()
 ], TestNotificationDto.prototype, "data", 2);
 __decorateClass([
-  IsOptional28(),
-  IsString32()
+  IsOptional29(),
+  IsString33()
 ], TestNotificationDto.prototype, "type", 2);
 
 // src/modules/rating/pattern/pattern.ts
@@ -7387,103 +7621,103 @@ var RATING_PATTERN = {
 
 // src/modules/rating/dto/add.rating.dto.ts
 import {
-  IsEnum as IsEnum23,
+  IsEnum as IsEnum24,
   IsInt as IsInt2,
-  IsNotEmpty as IsNotEmpty56,
-  IsOptional as IsOptional29,
-  IsString as IsString33,
-  IsNumber as IsNumber8,
-  Min as Min3,
-  Max as Max3
+  IsNotEmpty as IsNotEmpty57,
+  IsOptional as IsOptional30,
+  IsString as IsString34,
+  IsNumber as IsNumber9,
+  Min as Min4,
+  Max as Max4
 } from "class-validator";
 var CreateRatingDto = class {
 };
 __decorateClass([
-  IsOptional29(),
+  IsOptional30(),
   IsInt2({ message: "Reviewee ID must be a valid integer" })
 ], CreateRatingDto.prototype, "revieweeId", 2);
 __decorateClass([
-  IsOptional29(),
+  IsOptional30(),
   IsInt2({ message: "Reviewer ID must be a valid integer" })
 ], CreateRatingDto.prototype, "reviewerId", 2);
 __decorateClass([
   IsInt2({ message: "Job ID must be a valid integer" }),
-  IsNotEmpty56({ message: "Job ID is required" })
+  IsNotEmpty57({ message: "Job ID is required" })
 ], CreateRatingDto.prototype, "jobId", 2);
 __decorateClass([
-  IsEnum23(RatingTypeEnum, {
+  IsEnum24(RatingTypeEnum, {
     message: `Rating type must be one of: ${Object.values(RatingTypeEnum).join(", ")}`
   })
 ], CreateRatingDto.prototype, "ratingType", 2);
 __decorateClass([
-  IsOptional29(),
-  IsString33({ message: "Reviewer comment must be a string" })
+  IsOptional30(),
+  IsString34({ message: "Reviewer comment must be a string" })
 ], CreateRatingDto.prototype, "reviewerComment", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "overallExperience", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "workQuality", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "oneTimeDelivery", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "understaning", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "communication", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "skillUtilized", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "communicationClarity", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "requirementsClarity", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "responsiveness", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "paymentPromptness", 2);
 __decorateClass([
-  IsOptional29(),
-  IsNumber8(),
-  Min3(0),
-  Max3(5)
+  IsOptional30(),
+  IsNumber9(),
+  Min4(0),
+  Max4(5)
 ], CreateRatingDto.prototype, "responsibilitiesAndExpectations", 2);
 
 // src/modules/company-role/pattern/pattern.ts
@@ -7499,48 +7733,48 @@ var COMPANY_ROLES_PATTERNS = {
 };
 
 // src/modules/company-role/dto/create-company-role.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty4, IsArray as IsArray5, IsBoolean as IsBoolean5, IsInt as IsInt3, IsNotEmpty as IsNotEmpty57, IsOptional as IsOptional30 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty5, IsArray as IsArray6, IsBoolean as IsBoolean5, IsInt as IsInt3, IsNotEmpty as IsNotEmpty58, IsOptional as IsOptional31 } from "class-validator";
 var CreateCompanyRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty57({ message: "Please enter company role name." })
+  IsNotEmpty58({ message: "Please enter company role name." })
 ], CreateCompanyRoleDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty57({ message: "Please enter company role slug" })
+  IsNotEmpty58({ message: "Please enter company role slug" })
 ], CreateCompanyRoleDto.prototype, "slug", 2);
 __decorateClass([
-  IsNotEmpty57({ message: "Please enter description" })
+  IsNotEmpty58({ message: "Please enter description" })
 ], CreateCompanyRoleDto.prototype, "description", 2);
 __decorateClass([
-  IsArray5({ message: "Permission IDs must be an array." }),
-  ArrayNotEmpty4({ message: "Please select at least one permission." }),
+  IsArray6({ message: "Permission IDs must be an array." }),
+  ArrayNotEmpty5({ message: "Please select at least one permission." }),
   IsInt3({ each: true, message: "Each permission ID must be an integer." })
 ], CreateCompanyRoleDto.prototype, "permissionIds", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional31(),
   IsBoolean5({ message: "Is active must be a boolean value" })
 ], CreateCompanyRoleDto.prototype, "isActive", 2);
 
 // src/modules/company-role/dto/update-company-role.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty5, IsArray as IsArray6, IsBoolean as IsBoolean6, IsInt as IsInt4, IsNotEmpty as IsNotEmpty58, IsOptional as IsOptional31 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty6, IsArray as IsArray7, IsBoolean as IsBoolean6, IsInt as IsInt4, IsNotEmpty as IsNotEmpty59, IsOptional as IsOptional32 } from "class-validator";
 var UpdateCompanyRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty58({ message: "Please enter company name." })
+  IsNotEmpty59({ message: "Please enter company name." })
 ], UpdateCompanyRoleDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty58({ message: "Please enter slug" })
+  IsNotEmpty59({ message: "Please enter slug" })
 ], UpdateCompanyRoleDto.prototype, "slug", 2);
 __decorateClass([
-  IsNotEmpty58({ message: "Please enter description" })
+  IsNotEmpty59({ message: "Please enter description" })
 ], UpdateCompanyRoleDto.prototype, "description", 2);
 __decorateClass([
-  IsArray6({ message: "Permission IDs must be an array." }),
-  ArrayNotEmpty5({ message: "Please select at least one permission." }),
+  IsArray7({ message: "Permission IDs must be an array." }),
+  ArrayNotEmpty6({ message: "Please select at least one permission." }),
   IsInt4({ each: true, message: "Each permission ID must be an integer." })
 ], UpdateCompanyRoleDto.prototype, "permissionIds", 2);
 __decorateClass([
-  IsOptional31(),
+  IsOptional32(),
   IsBoolean6({ message: "Is active must be a boolean value" })
 ], UpdateCompanyRoleDto.prototype, "isActive", 2);
 
@@ -7561,41 +7795,41 @@ var FREELANCER_EXPERIENCE_PATTERN = {
 // src/modules/user/freelancer-experience/dto/freelancer-experience.dto.ts
 import {
   ArrayMinSize,
-  IsNotEmpty as IsNotEmpty59,
-  IsOptional as IsOptional32,
-  IsString as IsString36,
-  MaxLength as MaxLength13,
-  ValidateNested as ValidateNested2
+  IsNotEmpty as IsNotEmpty60,
+  IsOptional as IsOptional33,
+  IsString as IsString37,
+  MaxLength as MaxLength14,
+  ValidateNested as ValidateNested3
 } from "class-validator";
-import { Type as Type4 } from "class-transformer";
+import { Type as Type5 } from "class-transformer";
 var ExperienceDto = class {
 };
 __decorateClass([
-  IsOptional32()
+  IsOptional33()
 ], ExperienceDto.prototype, "uuid", 2);
 __decorateClass([
-  IsNotEmpty59(),
-  IsString36()
+  IsNotEmpty60(),
+  IsString37()
 ], ExperienceDto.prototype, "companyName", 2);
 __decorateClass([
-  IsNotEmpty59(),
-  IsString36()
+  IsNotEmpty60(),
+  IsString37()
 ], ExperienceDto.prototype, "designation", 2);
 __decorateClass([
-  IsNotEmpty59(),
-  IsString36()
+  IsNotEmpty60(),
+  IsString37()
 ], ExperienceDto.prototype, "jobDuration", 2);
 __decorateClass([
-  IsOptional32(),
-  IsString36(),
-  MaxLength13(5e3, { message: "Description must not exceed 5000 characters" })
+  IsOptional33(),
+  IsString37(),
+  MaxLength14(5e3, { message: "Description must not exceed 5000 characters" })
 ], ExperienceDto.prototype, "description", 2);
 var FreelancerExperienceDto = class {
 };
 __decorateClass([
-  ValidateNested2({ each: true }),
+  ValidateNested3({ each: true }),
   ArrayMinSize(1, { message: "At least one experience is required." }),
-  Type4(() => ExperienceDto)
+  Type5(() => ExperienceDto)
 ], FreelancerExperienceDto.prototype, "experiences", 2);
 
 // src/modules/company-member/pattern/pattern.ts
@@ -7611,34 +7845,34 @@ var COMPANY_MEMBERS_PATTERNS = {
 };
 
 // src/modules/company-member/dto/create-company-member.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty6, IsArray as IsArray7, IsInt as IsInt5, IsNotEmpty as IsNotEmpty60 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty7, IsArray as IsArray8, IsInt as IsInt5, IsNotEmpty as IsNotEmpty61 } from "class-validator";
 var CreateCompanyMemberDto = class {
 };
 __decorateClass([
-  IsNotEmpty60({ message: "Please enter name." })
+  IsNotEmpty61({ message: "Please enter name." })
 ], CreateCompanyMemberDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty60({ message: "Please enter email" })
+  IsNotEmpty61({ message: "Please enter email" })
 ], CreateCompanyMemberDto.prototype, "email", 2);
 __decorateClass([
-  IsArray7({ message: "Role IDs must be an array." }),
-  ArrayNotEmpty6({ message: "Please select at least one role." }),
+  IsArray8({ message: "Role IDs must be an array." }),
+  ArrayNotEmpty7({ message: "Please select at least one role." }),
   IsInt5({ each: true, message: "Each role ID must be an integer." })
 ], CreateCompanyMemberDto.prototype, "roleIds", 2);
 
 // src/modules/company-member/dto/update-company-member.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty7, IsArray as IsArray8, IsInt as IsInt6, IsNotEmpty as IsNotEmpty61 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty8, IsArray as IsArray9, IsInt as IsInt6, IsNotEmpty as IsNotEmpty62 } from "class-validator";
 var UpdateCompanyMemberDto = class {
 };
 __decorateClass([
-  IsNotEmpty61({ message: "Please enter name." })
+  IsNotEmpty62({ message: "Please enter name." })
 ], UpdateCompanyMemberDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty61({ message: "Please enter email" })
+  IsNotEmpty62({ message: "Please enter email" })
 ], UpdateCompanyMemberDto.prototype, "email", 2);
 __decorateClass([
-  IsArray8({ message: "Role IDs must be an array." }),
-  ArrayNotEmpty7({ message: "Please select at least one role." }),
+  IsArray9({ message: "Role IDs must be an array." }),
+  ArrayNotEmpty8({ message: "Please select at least one role." }),
   IsInt6({ each: true, message: "Each role ID must be an integer." })
 ], UpdateCompanyMemberDto.prototype, "roleIds", 2);
 
@@ -7657,32 +7891,32 @@ var FREELANCER_EDUCATION_PATTERN = {
 };
 
 // src/modules/user/freelancer-education/dto/freelancer-education.dto.ts
-import { IsArray as IsArray9, ValidateNested as ValidateNested3, IsString as IsString39, IsNotEmpty as IsNotEmpty62, IsOptional as IsOptional35, ArrayMinSize as ArrayMinSize2 } from "class-validator";
-import { Type as Type5 } from "class-transformer";
+import { IsArray as IsArray10, ValidateNested as ValidateNested4, IsString as IsString40, IsNotEmpty as IsNotEmpty63, IsOptional as IsOptional36, ArrayMinSize as ArrayMinSize2 } from "class-validator";
+import { Type as Type6 } from "class-transformer";
 var EducationDto = class {
 };
 __decorateClass([
-  IsOptional35()
+  IsOptional36()
 ], EducationDto.prototype, "uuid", 2);
 __decorateClass([
-  IsString39(),
-  IsNotEmpty62({ message: "Please Enter Degree " })
+  IsString40(),
+  IsNotEmpty63({ message: "Please Enter Degree " })
 ], EducationDto.prototype, "degree", 2);
 __decorateClass([
-  IsString39(),
-  IsNotEmpty62({ message: "Please Enter University " })
+  IsString40(),
+  IsNotEmpty63({ message: "Please Enter University " })
 ], EducationDto.prototype, "university", 2);
 __decorateClass([
-  IsString39(),
-  IsNotEmpty62({ message: "Please Enter Year of Graduation " })
+  IsString40(),
+  IsNotEmpty63({ message: "Please Enter Year of Graduation " })
 ], EducationDto.prototype, "yearOfGraduation", 2);
 var FreelancerEducationDto = class {
 };
 __decorateClass([
-  IsArray9(),
+  IsArray10(),
   ArrayMinSize2(1, { message: "At least one education is required." }),
-  ValidateNested3({ each: true }),
-  Type5(() => EducationDto)
+  ValidateNested4({ each: true }),
+  Type6(() => EducationDto)
 ], FreelancerEducationDto.prototype, "educations", 2);
 
 // src/modules/user/freelancer-project/pattern/pattern.ts
@@ -7692,68 +7926,68 @@ var FREELANCER_PROJECT_PATTERN = {
 };
 
 // src/modules/user/freelancer-project/dto/freelancer-project.dto.ts
-import { IsArray as IsArray10, ValidateNested as ValidateNested4, IsString as IsString40, IsNotEmpty as IsNotEmpty63, IsOptional as IsOptional36, IsDateString, MaxLength as MaxLength15, ArrayMinSize as ArrayMinSize3 } from "class-validator";
-import { Type as Type6 } from "class-transformer";
+import { IsArray as IsArray11, ValidateNested as ValidateNested5, IsString as IsString41, IsNotEmpty as IsNotEmpty64, IsOptional as IsOptional37, IsDateString, MaxLength as MaxLength16, ArrayMinSize as ArrayMinSize3 } from "class-validator";
+import { Type as Type7 } from "class-transformer";
 var ProjectDto = class {
 };
 __decorateClass([
-  IsOptional36()
+  IsOptional37()
 ], ProjectDto.prototype, "uuid", 2);
 __decorateClass([
-  IsString40(),
-  IsNotEmpty63({ message: "Please Enter Project Name " })
+  IsString41(),
+  IsNotEmpty64({ message: "Please Enter Project Name " })
 ], ProjectDto.prototype, "projectName", 2);
 __decorateClass([
   IsDateString(),
-  IsNotEmpty63({ message: "Please Enter Start Date " })
+  IsNotEmpty64({ message: "Please Enter Start Date " })
 ], ProjectDto.prototype, "startDate", 2);
 __decorateClass([
   IsDateString(),
-  IsNotEmpty63({ message: "Please Enter End Date " })
+  IsNotEmpty64({ message: "Please Enter End Date " })
 ], ProjectDto.prototype, "endDate", 2);
 __decorateClass([
-  IsOptional36(),
-  IsString40()
+  IsOptional37(),
+  IsString41()
 ], ProjectDto.prototype, "clientName", 2);
 __decorateClass([
-  IsOptional36(),
-  IsString40()
+  IsOptional37(),
+  IsString41()
 ], ProjectDto.prototype, "gitLink", 2);
 __decorateClass([
-  IsOptional36(),
-  IsString40(),
-  MaxLength15(5e3, { message: "Description must not exceed 5000 characters" })
+  IsOptional37(),
+  IsString41(),
+  MaxLength16(5e3, { message: "Description must not exceed 5000 characters" })
 ], ProjectDto.prototype, "description", 2);
 var CaseStudyDto = class {
 };
 __decorateClass([
-  IsOptional36()
+  IsOptional37()
 ], CaseStudyDto.prototype, "uuid", 2);
 __decorateClass([
-  IsString40(),
-  IsNotEmpty63({ message: "Please Enter Project Name " })
+  IsString41(),
+  IsNotEmpty64({ message: "Please Enter Project Name " })
 ], CaseStudyDto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional36(),
-  IsString40()
+  IsOptional37(),
+  IsString41()
 ], CaseStudyDto.prototype, "caseStudyLink", 2);
 __decorateClass([
-  IsOptional36(),
-  IsString40(),
-  MaxLength15(5e3, { message: "Description must not exceed 5000 characters" })
+  IsOptional37(),
+  IsString41(),
+  MaxLength16(5e3, { message: "Description must not exceed 5000 characters" })
 ], CaseStudyDto.prototype, "description", 2);
 var FreelancerProjectDto = class {
 };
 __decorateClass([
-  IsArray10(),
+  IsArray11(),
   ArrayMinSize3(1, { message: "At least one project is required." }),
-  ValidateNested4({ each: true }),
-  Type6(() => ProjectDto)
+  ValidateNested5({ each: true }),
+  Type7(() => ProjectDto)
 ], FreelancerProjectDto.prototype, "projects", 2);
 __decorateClass([
-  IsArray10(),
-  ValidateNested4({ each: true }),
-  Type6(() => CaseStudyDto)
+  IsArray11(),
+  ValidateNested5({ each: true }),
+  Type7(() => CaseStudyDto)
 ], FreelancerProjectDto.prototype, "casestudies", 2);
 
 // src/modules/permission/pattern/pattern.ts
@@ -7769,8 +8003,8 @@ var FREELANCER_SKILL_PATTERN = {
 };
 
 // src/modules/user/freelancer-skill/dto/freelancer-skill.dto.ts
-import { IsArray as IsArray11, IsString as IsString41, IsOptional as IsOptional37 } from "class-validator";
-import { Type as Type7 } from "class-transformer";
+import { IsArray as IsArray12, IsString as IsString42, IsOptional as IsOptional38 } from "class-validator";
+import { Type as Type8 } from "class-transformer";
 var FreelancerSkillDto = class {
   constructor() {
     this.coreSkills = [];
@@ -7780,28 +8014,28 @@ var FreelancerSkillDto = class {
   }
 };
 __decorateClass([
-  IsOptional37(),
-  IsArray11(),
-  Type7(() => String),
-  IsString41({ each: true })
+  IsOptional38(),
+  IsArray12(),
+  Type8(() => String),
+  IsString42({ each: true })
 ], FreelancerSkillDto.prototype, "coreSkills", 2);
 __decorateClass([
-  IsOptional37(),
-  IsArray11(),
-  Type7(() => String),
-  IsString41({ each: true })
+  IsOptional38(),
+  IsArray12(),
+  Type8(() => String),
+  IsString42({ each: true })
 ], FreelancerSkillDto.prototype, "secondarySkills", 2);
 __decorateClass([
-  IsOptional37(),
-  IsArray11(),
-  Type7(() => String),
-  IsString41({ each: true })
+  IsOptional38(),
+  IsArray12(),
+  Type8(() => String),
+  IsString42({ each: true })
 ], FreelancerSkillDto.prototype, "tools", 2);
 __decorateClass([
-  IsOptional37(),
-  IsArray11(),
-  Type7(() => String),
-  IsString41({ each: true })
+  IsOptional38(),
+  IsArray12(),
+  Type8(() => String),
+  IsString42({ each: true })
 ], FreelancerSkillDto.prototype, "frameworks", 2);
 
 // src/modules/freelancer-admin/pattern/pattern.ts
@@ -7835,18 +8069,18 @@ var ADMIN_FREELANCER_PATTERN = {
 
 // src/modules/freelancer-admin/dto/create-freelancer.dto.ts
 import {
-  IsString as IsString42,
+  IsString as IsString43,
   IsEmail as IsEmail13,
   IsBoolean as IsBoolean11,
-  IsOptional as IsOptional38,
-  IsEnum as IsEnum24,
-  IsNumber as IsNumber9,
+  IsOptional as IsOptional39,
+  IsEnum as IsEnum25,
+  IsNumber as IsNumber10,
   IsUrl as IsUrl3,
-  MaxLength as MaxLength17,
+  MaxLength as MaxLength18,
   MinLength as MinLength13,
   Matches as Matches9,
-  IsNotEmpty as IsNotEmpty65,
-  ValidateIf as ValidateIf8,
+  IsNotEmpty as IsNotEmpty66,
+  ValidateIf as ValidateIf9,
   IsInt as IsInt7
 } from "class-validator";
 import { Transform as Transform2 } from "class-transformer";
@@ -7865,16 +8099,16 @@ var ModeOfWorkEnum = /* @__PURE__ */ ((ModeOfWorkEnum3) => {
 var CreateFreelancerDto = class {
 };
 __decorateClass([
-  IsOptional38(),
-  IsString42({ message: "Full name must be a string" }),
-  MaxLength17(100, { message: "Full name must not exceed 100 characters" }),
+  IsOptional39(),
+  IsString43({ message: "Full name must be a string" }),
+  MaxLength18(100, { message: "Full name must not exceed 100 characters" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) return value[0]?.trim();
     return typeof value === "string" ? value.trim() : value;
   })
 ], CreateFreelancerDto.prototype, "fullName", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   IsEmail13({}, { message: "Invalid email address" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) return value[0]?.trim();
@@ -7882,24 +8116,24 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "email", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString42({ message: "Mobile code must be a string (e.g., +1)" }),
+  IsOptional39(),
+  IsString43({ message: "Mobile code must be a string (e.g., +1)" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) return value[0]?.trim();
     return typeof value === "string" ? value.trim() : value;
   })
 ], CreateFreelancerDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString42({ message: "Mobile must be a string (e.g., 1243253534)" }),
+  IsOptional39(),
+  IsString43({ message: "Mobile must be a string (e.g., 1243253534)" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) return value[0]?.trim();
     return typeof value === "string" ? value.trim() : value;
   })
 ], CreateFreelancerDto.prototype, "mobile", 2);
 __decorateClass([
-  IsNotEmpty65({ message: "Please enter address." }),
-  IsString42({ message: "address must be a string" }),
+  IsNotEmpty66({ message: "Please enter address." }),
+  IsString43({ message: "address must be a string" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -7909,8 +8143,8 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "address", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString42({ message: "addressLine must be a string" }),
+  IsOptional39(),
+  IsString43({ message: "addressLine must be a string" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -7922,7 +8156,7 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "addressLine", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   IsInt7({ message: "countryId must be an integer" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
@@ -7931,7 +8165,7 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   IsInt7({ message: "stateId must be an integer" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
@@ -7940,7 +8174,7 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   IsInt7({ message: "cityId must be an integer" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
@@ -7949,8 +8183,8 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "cityId", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString42({ message: "postalCode must be a string" }),
+  IsOptional39(),
+  IsString43({ message: "postalCode must be a string" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -7962,8 +8196,8 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "postalCode", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString42({ message: "about must be a string" }),
+  IsOptional39(),
+  IsString43({ message: "about must be a string" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -7975,8 +8209,8 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "about", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString42({ message: "designation must be a string" }),
+  IsOptional39(),
+  IsString43({ message: "designation must be a string" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -7988,8 +8222,8 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "designation", 2);
 __decorateClass([
-  IsOptional38(),
-  IsNumber9({}, { message: "experience must be a number" }),
+  IsOptional39(),
+  IsNumber10({}, { message: "experience must be a number" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     const num = Number(value);
@@ -7997,19 +8231,19 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "experience", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     return value === null || value === "" ? void 0 : value;
   }),
   MinLength13(6, { message: "Password must be at least 6 characters." }),
-  MaxLength17(32, { message: "Password must not exceed 32 characters." }),
+  MaxLength18(32, { message: "Password must not exceed 32 characters." }),
   Matches9(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "Password must include letters, numbers and symbols."
   })
 ], CreateFreelancerDto.prototype, "password", 2);
 __decorateClass([
-  IsNotEmpty65({ message: "Please enter confirm password." }),
+  IsNotEmpty66({ message: "Please enter confirm password." }),
   Match("confirmPassword", { message: "Passwords do not match" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
@@ -8020,7 +8254,7 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "confirmPassword", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     if (value === "true" || value === true) return true;
@@ -8030,19 +8264,19 @@ __decorateClass([
   IsBoolean11({ message: "Developer flag must be true or false" })
 ], CreateFreelancerDto.prototype, "developer", 2);
 __decorateClass([
-  IsOptional38(),
-  IsEnum24(NatureOfWorkEnum, {
+  IsOptional39(),
+  IsEnum25(NatureOfWorkEnum, {
     message: `Nature of work must be one of: ${Object.values(
       NatureOfWorkEnum
     ).join(", ")}`
   })
 ], CreateFreelancerDto.prototype, "natureOfWork", 2);
 __decorateClass([
-  ValidateIf8(
+  ValidateIf9(
     (dto) => dto.natureOfWork === "FREELANCE" /* FREELANCE */ || dto.natureOfWork === "BOTH" /* BOTH */
   ),
-  IsOptional38(),
-  IsNumber9({}, { message: "Expected hourly compensation must be a number" }),
+  IsOptional39(),
+  IsNumber10({}, { message: "Expected hourly compensation must be a number" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     const num = Number(value);
@@ -8050,11 +8284,11 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "expectedHourlyCompensation", 2);
 __decorateClass([
-  ValidateIf8(
+  ValidateIf9(
     (dto) => dto.natureOfWork === "FTE" /* FTE */ || dto.natureOfWork === "BOTH" /* BOTH */
   ),
-  IsOptional38(),
-  IsNumber9({}, { message: "Expected annual compensation must be a number" }),
+  IsOptional39(),
+  IsNumber10({}, { message: "Expected annual compensation must be a number" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     const num = Number(value);
@@ -8062,10 +8296,10 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "expectedAnnualCompensation", 2);
 __decorateClass([
-  ValidateIf8(
+  ValidateIf9(
     (dto) => dto.natureOfWork === "FREELANCE" /* FREELANCE */ || dto.natureOfWork === "BOTH" /* BOTH */
   ),
-  IsOptional38(),
+  IsOptional39(),
   IsInt7({ message: "Please enter valid weekly availability hours (integer)." }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
@@ -8074,15 +8308,15 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  IsOptional38(),
-  IsEnum24(ModeOfWorkEnum, {
+  IsOptional39(),
+  IsEnum25(ModeOfWorkEnum, {
     message: `Mode of work must be one of: ${Object.values(ModeOfWorkEnum).join(
       ", "
     )}`
   })
 ], CreateFreelancerDto.prototype, "modeOfWork", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   Transform2(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     if (value === "true" || value === true) return true;
@@ -8092,9 +8326,9 @@ __decorateClass([
   IsBoolean11({ message: "isImmediateJoiner must be true or false" })
 ], CreateFreelancerDto.prototype, "isImmediateJoiner", 2);
 __decorateClass([
-  ValidateIf8((o) => o.isImmediateJoiner === false),
-  IsOptional38(),
-  IsString42({ message: "availabilityToJoin must be a string" }),
+  ValidateIf9((o) => o.isImmediateJoiner === false),
+  IsOptional39(),
+  IsString43({ message: "availabilityToJoin must be a string" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -8106,7 +8340,7 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "availabilityToJoin", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   IsUrl3({}, { message: "LinkedIn profile link must be a valid URL" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
@@ -8119,8 +8353,8 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString42({ message: "Kaggle profile link must be a string" }),
+  IsOptional39(),
+  IsString43({ message: "Kaggle profile link must be a string" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -8132,7 +8366,7 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   IsUrl3({}, { message: "GitHub profile link must be a valid URL" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
@@ -8145,7 +8379,7 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   IsUrl3({}, { message: "StackOverflow profile link must be a valid URL" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
@@ -8158,7 +8392,7 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   IsUrl3({}, { message: "Portfolio link must be a valid URL" }),
   Transform2(({ value }) => {
     if (Array.isArray(value)) {
@@ -8171,23 +8405,23 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "portfolioLink", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional39()
 ], CreateFreelancerDto.prototype, "file", 2);
 
 // src/modules/freelancer-admin/dto/update-freelancer.dto.ts
 import {
-  IsString as IsString43,
+  IsString as IsString44,
   IsEmail as IsEmail14,
   IsBoolean as IsBoolean12,
-  IsOptional as IsOptional39,
-  IsEnum as IsEnum25,
-  IsNumber as IsNumber10,
+  IsOptional as IsOptional40,
+  IsEnum as IsEnum26,
+  IsNumber as IsNumber11,
   IsUrl as IsUrl4,
-  MaxLength as MaxLength18,
+  MaxLength as MaxLength19,
   MinLength as MinLength14,
   Matches as Matches10,
-  IsNotEmpty as IsNotEmpty66,
-  ValidateIf as ValidateIf9,
+  IsNotEmpty as IsNotEmpty67,
+  ValidateIf as ValidateIf10,
   IsInt as IsInt8
 } from "class-validator";
 import { Transform as Transform3 } from "class-transformer";
@@ -8206,16 +8440,16 @@ var ModeOfWorkEnum2 = /* @__PURE__ */ ((ModeOfWorkEnum3) => {
 var UpdateFreelancerDto = class {
 };
 __decorateClass([
-  IsOptional39(),
-  IsString43({ message: "Full name must be a string" }),
-  MaxLength18(100, { message: "Full name must not exceed 100 characters" }),
+  IsOptional40(),
+  IsString44({ message: "Full name must be a string" }),
+  MaxLength19(100, { message: "Full name must not exceed 100 characters" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) return value[0]?.trim();
     return typeof value === "string" ? value.trim() : value;
   })
 ], UpdateFreelancerDto.prototype, "fullName", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   IsEmail14({}, { message: "Invalid email address" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) return value[0]?.trim();
@@ -8223,24 +8457,24 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "email", 2);
 __decorateClass([
-  IsOptional39(),
-  IsString43({ message: "Mobile code must be a string (e.g., +1)" }),
+  IsOptional40(),
+  IsString44({ message: "Mobile code must be a string (e.g., +1)" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) return value[0]?.trim();
     return typeof value === "string" ? value.trim() : value;
   })
 ], UpdateFreelancerDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsOptional39(),
-  IsString43({ message: "Mobile must be a string (e.g., 1243253534)" }),
+  IsOptional40(),
+  IsString44({ message: "Mobile must be a string (e.g., 1243253534)" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) return value[0]?.trim();
     return typeof value === "string" ? value.trim() : value;
   })
 ], UpdateFreelancerDto.prototype, "mobile", 2);
 __decorateClass([
-  IsNotEmpty66({ message: "Please enter address." }),
-  IsString43({ message: "address must be a string" }),
+  IsNotEmpty67({ message: "Please enter address." }),
+  IsString44({ message: "address must be a string" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -8250,8 +8484,8 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "address", 2);
 __decorateClass([
-  IsOptional39(),
-  IsString43({ message: "addressLine must be a string" }),
+  IsOptional40(),
+  IsString44({ message: "addressLine must be a string" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -8263,7 +8497,7 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "addressLine", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   IsInt8({ message: "countryId must be an integer" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
@@ -8272,7 +8506,7 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   IsInt8({ message: "stateId must be an integer" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
@@ -8281,7 +8515,7 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   IsInt8({ message: "cityId must be an integer" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
@@ -8290,8 +8524,8 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "cityId", 2);
 __decorateClass([
-  IsOptional39(),
-  IsString43({ message: "postalCode must be a string" }),
+  IsOptional40(),
+  IsString44({ message: "postalCode must be a string" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -8303,8 +8537,8 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "postalCode", 2);
 __decorateClass([
-  IsOptional39(),
-  IsString43({ message: "about must be a string" }),
+  IsOptional40(),
+  IsString44({ message: "about must be a string" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -8316,8 +8550,8 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "about", 2);
 __decorateClass([
-  IsOptional39(),
-  IsString43({ message: "designation must be a string" }),
+  IsOptional40(),
+  IsString44({ message: "designation must be a string" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -8329,8 +8563,8 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "designation", 2);
 __decorateClass([
-  IsOptional39(),
-  IsNumber10({}, { message: "experience must be a number" }),
+  IsOptional40(),
+  IsNumber11({}, { message: "experience must be a number" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     const num = Number(value);
@@ -8338,19 +8572,19 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "experience", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     return value === null || value === "" ? void 0 : value;
   }),
   MinLength14(6, { message: "Password must be at least 6 characters." }),
-  MaxLength18(32, { message: "Password must not exceed 32 characters." }),
+  MaxLength19(32, { message: "Password must not exceed 32 characters." }),
   Matches10(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "Password must include letters, numbers and symbols."
   })
 ], UpdateFreelancerDto.prototype, "password", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     if (value === "true" || value === true) return true;
@@ -8360,19 +8594,19 @@ __decorateClass([
   IsBoolean12({ message: "Developer flag must be true or false" })
 ], UpdateFreelancerDto.prototype, "developer", 2);
 __decorateClass([
-  IsOptional39(),
-  IsEnum25(NatureOfWorkEnum2, {
+  IsOptional40(),
+  IsEnum26(NatureOfWorkEnum2, {
     message: `Nature of work must be one of: ${Object.values(
       NatureOfWorkEnum2
     ).join(", ")}`
   })
 ], UpdateFreelancerDto.prototype, "natureOfWork", 2);
 __decorateClass([
-  ValidateIf9(
+  ValidateIf10(
     (dto) => dto.natureOfWork === "FREELANCE" /* FREELANCE */ || dto.natureOfWork === "BOTH" /* BOTH */
   ),
-  IsOptional39(),
-  IsNumber10({}, { message: "Expected hourly compensation must be a number" }),
+  IsOptional40(),
+  IsNumber11({}, { message: "Expected hourly compensation must be a number" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     const num = Number(value);
@@ -8380,11 +8614,11 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "expectedHourlyCompensation", 2);
 __decorateClass([
-  ValidateIf9(
+  ValidateIf10(
     (dto) => dto.natureOfWork === "FTE" /* FTE */ || dto.natureOfWork === "BOTH" /* BOTH */
   ),
-  IsOptional39(),
-  IsNumber10({}, { message: "Expected annual compensation must be a number" }),
+  IsOptional40(),
+  IsNumber11({}, { message: "Expected annual compensation must be a number" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     const num = Number(value);
@@ -8392,10 +8626,10 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "expectedAnnualCompensation", 2);
 __decorateClass([
-  ValidateIf9(
+  ValidateIf10(
     (dto) => dto.natureOfWork === "FREELANCE" /* FREELANCE */ || dto.natureOfWork === "BOTH" /* BOTH */
   ),
-  IsOptional39(),
+  IsOptional40(),
   IsInt8({ message: "Please enter valid weekly availability hours (integer)." }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
@@ -8404,15 +8638,15 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  IsOptional39(),
-  IsEnum25(ModeOfWorkEnum2, {
+  IsOptional40(),
+  IsEnum26(ModeOfWorkEnum2, {
     message: `Mode of work must be one of: ${Object.values(ModeOfWorkEnum2).join(
       ", "
     )}`
   })
 ], UpdateFreelancerDto.prototype, "modeOfWork", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   Transform3(({ value }) => {
     if (Array.isArray(value)) value = value[0];
     if (value === "true" || value === true) return true;
@@ -8422,9 +8656,9 @@ __decorateClass([
   IsBoolean12({ message: "isImmediateJoiner must be true or false" })
 ], UpdateFreelancerDto.prototype, "isImmediateJoiner", 2);
 __decorateClass([
-  ValidateIf9((o) => o.isImmediateJoiner === false),
-  IsOptional39(),
-  IsString43({ message: "availabilityToJoin must be a string" }),
+  ValidateIf10((o) => o.isImmediateJoiner === false),
+  IsOptional40(),
+  IsString44({ message: "availabilityToJoin must be a string" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -8436,7 +8670,7 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "availabilityToJoin", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   IsUrl4({}, { message: "LinkedIn profile link must be a valid URL" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
@@ -8449,8 +8683,8 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  IsOptional39(),
-  IsString43({ message: "Kaggle profile link must be a string" }),
+  IsOptional40(),
+  IsString44({ message: "Kaggle profile link must be a string" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
       const val = value[0];
@@ -8462,7 +8696,7 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   IsUrl4({}, { message: "GitHub profile link must be a valid URL" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
@@ -8475,7 +8709,7 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   IsUrl4({}, { message: "StackOverflow profile link must be a valid URL" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
@@ -8488,7 +8722,7 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  IsOptional39(),
+  IsOptional40(),
   IsUrl4({}, { message: "Portfolio link must be a valid URL" }),
   Transform3(({ value }) => {
     if (Array.isArray(value)) {
@@ -8501,20 +8735,20 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "portfolioLink", 2);
 __decorateClass([
-  IsOptional39()
+  IsOptional40()
 ], UpdateFreelancerDto.prototype, "file", 2);
 
 // src/modules/freelancer-admin/dto/send-ai-assessment-link.dto.ts
-import { IsNotEmpty as IsNotEmpty67, IsUUID as IsUUID19 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty68, IsUUID as IsUUID19 } from "class-validator";
 var SendAiAssessmentLinkDto = class {
 };
 __decorateClass([
   IsUUID19("4", { message: "Freelancer UUID must be a valid UUID." }),
-  IsNotEmpty67({ message: "Freelancer UUID is required." })
+  IsNotEmpty68({ message: "Freelancer UUID is required." })
 ], SendAiAssessmentLinkDto.prototype, "uuid", 2);
 
 // src/modules/freelancer-admin/dto/update-assessment-request-status.dto.ts
-import { IsEnum as IsEnum26, IsOptional as IsOptional40, IsString as IsString44 } from "class-validator";
+import { IsEnum as IsEnum27, IsOptional as IsOptional41, IsString as IsString45 } from "class-validator";
 var AssessmentRequestStatus = /* @__PURE__ */ ((AssessmentRequestStatus2) => {
   AssessmentRequestStatus2["PENDING"] = "PENDING";
   AssessmentRequestStatus2["APPROVED"] = "APPROVED";
@@ -8525,35 +8759,35 @@ var AssessmentRequestStatus = /* @__PURE__ */ ((AssessmentRequestStatus2) => {
 var UpdateAssessmentRequestStatusDto = class {
 };
 __decorateClass([
-  IsEnum26(AssessmentRequestStatus, {
+  IsEnum27(AssessmentRequestStatus, {
     message: `Status must be one of: ${Object.values(AssessmentRequestStatus).join(", ")}`
   })
 ], UpdateAssessmentRequestStatusDto.prototype, "status", 2);
 __decorateClass([
-  IsOptional40(),
-  IsString44()
+  IsOptional41(),
+  IsString45()
 ], UpdateAssessmentRequestStatusDto.prototype, "remarks", 2);
 
 // src/modules/freelancer-admin/dto/admin-export-freelancerV2-optimised.dto.ts
-import { IsOptional as IsOptional41, IsArray as IsArray12, IsEmail as IsEmail15 } from "class-validator";
+import { IsOptional as IsOptional42, IsArray as IsArray13, IsEmail as IsEmail15 } from "class-validator";
 import { Transform as Transform4 } from "class-transformer";
 var AdminExportFreelancerV2OptimisedDto = class {
 };
 __decorateClass([
-  IsOptional41(),
+  IsOptional42(),
   Transform4(
     ({ value }) => typeof value === "string" ? value.split(",").map((email) => email.trim().toLowerCase()).filter(Boolean) : []
   ),
-  IsArray12({ message: "customEmails must be an array" }),
+  IsArray13({ message: "customEmails must be an array" }),
   IsEmail15({}, { each: true, message: "Each email must be a valid email address" })
 ], AdminExportFreelancerV2OptimisedDto.prototype, "customEmails", 2);
 
 // src/modules/freelancer-admin/dto/update-admin-freelancer-account-status.dto.ts
-import { IsEnum as IsEnum27 } from "class-validator";
+import { IsEnum as IsEnum28 } from "class-validator";
 var UpdateAdminFreelancerAccountStatusDto = class {
 };
 __decorateClass([
-  IsEnum27(AccountStatus, {
+  IsEnum28(AccountStatus, {
     message: `accountStatus must be one of: ${Object.values(AccountStatus).join(", ")}`
   })
 ], UpdateAdminFreelancerAccountStatusDto.prototype, "accountStatus", 2);
@@ -8577,235 +8811,235 @@ var CLIENT_ADMIN_PATTERNS = {
 
 // src/modules/client-admin/dto/create-client.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty68,
+  IsNotEmpty as IsNotEmpty69,
   IsEmail as IsEmail16,
-  IsOptional as IsOptional42,
-  IsString as IsString45,
+  IsOptional as IsOptional43,
+  IsString as IsString46,
   MinLength as MinLength15,
-  MaxLength as MaxLength19,
+  MaxLength as MaxLength20,
   Matches as Matches11,
   IsInt as IsInt9,
   IsUrl as IsUrl5
 } from "class-validator";
-import { Type as Type8 } from "class-transformer";
+import { Type as Type9 } from "class-transformer";
 var CreateClientDto = class {
 };
 __decorateClass([
-  IsNotEmpty68({ message: "Please enter first name." }),
-  IsString45()
+  IsNotEmpty69({ message: "Please enter first name." }),
+  IsString46()
 ], CreateClientDto.prototype, "firstName", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please enter last name." }),
-  IsString45()
+  IsNotEmpty69({ message: "Please enter last name." }),
+  IsString46()
 ], CreateClientDto.prototype, "lastName", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please enter email." }),
+  IsNotEmpty69({ message: "Please enter email." }),
   IsEmail16()
 ], CreateClientDto.prototype, "email", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please enter mobile code." }),
-  IsString45({ message: "Mobile code must be a string." })
+  IsNotEmpty69({ message: "Please enter mobile code." }),
+  IsString46({ message: "Mobile code must be a string." })
 ], CreateClientDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please enter phone number." }),
-  IsString45({ message: "Phone number must be a string." })
+  IsNotEmpty69({ message: "Please enter phone number." }),
+  IsString46({ message: "Phone number must be a string." })
 ], CreateClientDto.prototype, "phoneNumber", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please enter password." }),
+  IsNotEmpty69({ message: "Please enter password." }),
   MinLength15(6),
-  MaxLength19(32),
+  MaxLength20(32),
   Matches11(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "Password must include letters, numbers and symbols."
   })
 ], CreateClientDto.prototype, "password", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please enter confirm password." }),
+  IsNotEmpty69({ message: "Please enter confirm password." }),
   Match("confirmPassword", { message: "Passwords do not match" })
 ], CreateClientDto.prototype, "confirmPassword", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please enter company name." }),
-  IsString45()
+  IsNotEmpty69({ message: "Please enter company name." }),
+  IsString46()
 ], CreateClientDto.prototype, "companyName", 2);
 __decorateClass([
-  IsOptional42(),
-  IsString45()
+  IsOptional43(),
+  IsString46()
 ], CreateClientDto.prototype, "foundUsOn", 2);
 __decorateClass([
-  IsOptional42(),
-  IsString45()
+  IsOptional43(),
+  IsString46()
 ], CreateClientDto.prototype, "foundUsOnDetail", 2);
 __decorateClass([
-  IsOptional42(),
-  IsString45({ message: "About company must be a string." })
+  IsOptional43(),
+  IsString46({ message: "About company must be a string." })
 ], CreateClientDto.prototype, "about", 2);
 __decorateClass([
-  IsOptional42(),
+  IsOptional43(),
   IsUrl5({}, { message: "Website must be a valid URL." })
 ], CreateClientDto.prototype, "webSite", 2);
 __decorateClass([
-  IsOptional42(),
-  IsString45({ message: "Company address must be a string." })
+  IsOptional43(),
+  IsString46({ message: "Company address must be a string." })
 ], CreateClientDto.prototype, "companyAddress", 2);
 __decorateClass([
-  IsOptional42(),
-  IsString45({ message: "Address line must be a string." })
+  IsOptional43(),
+  IsString46({ message: "Address line must be a string." })
 ], CreateClientDto.prototype, "addressLine", 2);
 __decorateClass([
-  IsOptional42(),
-  IsString45({ message: "Postal code must be a string." })
+  IsOptional43(),
+  IsString46({ message: "Postal code must be a string." })
 ], CreateClientDto.prototype, "postalCode", 2);
 __decorateClass([
-  IsOptional42(),
+  IsOptional43(),
   IsInt9({ message: "Country ID must be an integer." }),
-  Type8(() => Number)
+  Type9(() => Number)
 ], CreateClientDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional42(),
+  IsOptional43(),
   IsInt9({ message: "State ID must be an integer." }),
-  Type8(() => Number)
+  Type9(() => Number)
 ], CreateClientDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional42(),
+  IsOptional43(),
   IsInt9({ message: "City ID must be an integer." }),
-  Type8(() => Number)
+  Type9(() => Number)
 ], CreateClientDto.prototype, "cityId", 2);
 
 // src/modules/client-admin/dto/update-client-status.dto.ts
-import { IsEnum as IsEnum29 } from "class-validator";
+import { IsEnum as IsEnum30 } from "class-validator";
 var UpdateClientAccountStatusDto = class {
 };
 __decorateClass([
-  IsEnum29(AccountStatus, {
+  IsEnum30(AccountStatus, {
     message: `accountStatus must be one of: ${Object.values(AccountStatus).join(", ")}`
   })
 ], UpdateClientAccountStatusDto.prototype, "accountStatus", 2);
 
 // src/modules/client-admin/dto/update-client.dto.ts
-import { Transform as Transform5, Type as Type9 } from "class-transformer";
+import { Transform as Transform5, Type as Type10 } from "class-transformer";
 import {
-  IsNotEmpty as IsNotEmpty69,
+  IsNotEmpty as IsNotEmpty70,
   IsEmail as IsEmail17,
-  IsOptional as IsOptional43,
-  IsString as IsString46,
+  IsOptional as IsOptional44,
+  IsString as IsString47,
   MinLength as MinLength16,
-  MaxLength as MaxLength20,
+  MaxLength as MaxLength21,
   Matches as Matches12
 } from "class-validator";
 var UpdateClientDto = class {
 };
 __decorateClass([
-  IsNotEmpty69({ message: "Please enter first name." }),
-  IsString46()
+  IsNotEmpty70({ message: "Please enter first name." }),
+  IsString47()
 ], UpdateClientDto.prototype, "firstName", 2);
 __decorateClass([
-  IsNotEmpty69({ message: "Please enter last name." }),
-  IsString46()
+  IsNotEmpty70({ message: "Please enter last name." }),
+  IsString47()
 ], UpdateClientDto.prototype, "lastName", 2);
 __decorateClass([
-  IsNotEmpty69({ message: "Please enter email." }),
+  IsNotEmpty70({ message: "Please enter email." }),
   IsEmail17()
 ], UpdateClientDto.prototype, "email", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46({ message: "Mobile code must be a string." })
+  IsOptional44(),
+  IsString47({ message: "Mobile code must be a string." })
 ], UpdateClientDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46({ message: "Phone number must be a string." })
+  IsOptional44(),
+  IsString47({ message: "Phone number must be a string." })
 ], UpdateClientDto.prototype, "phoneNumber", 2);
 __decorateClass([
-  IsOptional43(),
+  IsOptional44(),
   Transform5(({ value }) => value === null || value === "" ? void 0 : value),
   MinLength16(6, { message: "Password must be at least 6 characters." }),
-  MaxLength20(32, { message: "Password must not exceed 32 characters." }),
+  MaxLength21(32, { message: "Password must not exceed 32 characters." }),
   Matches12(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "Password must include letters, numbers and symbols."
   })
 ], UpdateClientDto.prototype, "password", 2);
 __decorateClass([
-  IsNotEmpty69({ message: "Please enter company name." }),
-  IsString46()
+  IsNotEmpty70({ message: "Please enter company name." }),
+  IsString47()
 ], UpdateClientDto.prototype, "companyName", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46()
+  IsOptional44(),
+  IsString47()
 ], UpdateClientDto.prototype, "foundUsOn", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46()
+  IsOptional44(),
+  IsString47()
 ], UpdateClientDto.prototype, "foundUsOnDetail", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46({ message: "About company must be a string." })
+  IsOptional44(),
+  IsString47({ message: "About company must be a string." })
 ], UpdateClientDto.prototype, "about", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46({ message: "Website must be a string." })
+  IsOptional44(),
+  IsString47({ message: "Website must be a string." })
 ], UpdateClientDto.prototype, "webSite", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46({ message: "Company address must be a string." })
+  IsOptional44(),
+  IsString47({ message: "Company address must be a string." })
 ], UpdateClientDto.prototype, "companyAddress", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46({ message: "Address line must be a string." })
+  IsOptional44(),
+  IsString47({ message: "Address line must be a string." })
 ], UpdateClientDto.prototype, "addressLine", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46({ message: "Postal code must be a string." })
+  IsOptional44(),
+  IsString47({ message: "Postal code must be a string." })
 ], UpdateClientDto.prototype, "postalCode", 2);
 __decorateClass([
-  IsOptional43(),
-  Type9(() => Number)
+  IsOptional44(),
+  Type10(() => Number)
 ], UpdateClientDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional43(),
-  Type9(() => Number)
+  IsOptional44(),
+  Type10(() => Number)
 ], UpdateClientDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional43(),
-  Type9(() => Number)
+  IsOptional44(),
+  Type10(() => Number)
 ], UpdateClientDto.prototype, "cityId", 2);
 
 // src/modules/client-admin/dto/admin-export-clientV2-optimised.dto.ts
-import { IsOptional as IsOptional44, IsArray as IsArray15, IsEmail as IsEmail18 } from "class-validator";
+import { IsOptional as IsOptional45, IsArray as IsArray16, IsEmail as IsEmail18 } from "class-validator";
 import { Transform as Transform6 } from "class-transformer";
 var AdminExportClientV2OptimisedDto = class {
 };
 __decorateClass([
-  IsOptional44(),
+  IsOptional45(),
   Transform6(
     ({ value }) => typeof value === "string" ? value.split(",").map((email) => email.trim().toLowerCase()).filter(Boolean) : []
   ),
-  IsArray15({ message: "customEmails must be an array" }),
+  IsArray16({ message: "customEmails must be an array" }),
   IsEmail18({}, { each: true, message: "Each email must be a valid email address" })
 ], AdminExportClientV2OptimisedDto.prototype, "customEmails", 2);
 
 // src/modules/client-admin/dto/update-admin-client-account-status.dto.ts
-import { IsEnum as IsEnum31 } from "class-validator";
+import { IsEnum as IsEnum32 } from "class-validator";
 var UpdateAdminClientAccountStatusDto = class {
 };
 __decorateClass([
-  IsEnum31(AccountStatus, {
+  IsEnum32(AccountStatus, {
     message: `accountStatus must be one of: ${Object.values(AccountStatus).join(", ")}`
   })
 ], UpdateAdminClientAccountStatusDto.prototype, "accountStatus", 2);
 
 // src/modules/client-admin/dto/update-admin-client-job-posting-restriction.dto.ts
-import { IsBoolean as IsBoolean13, IsNotEmpty as IsNotEmpty70 } from "class-validator";
+import { IsBoolean as IsBoolean13, IsNotEmpty as IsNotEmpty71 } from "class-validator";
 var UpdateAdminClientJobPostingRestrictionDto = class {
 };
 __decorateClass([
-  IsNotEmpty70({ message: "Job posting restriction status is required." }),
+  IsNotEmpty71({ message: "Job posting restriction status is required." }),
   IsBoolean13({ message: "Job posting restriction status must be a boolean value." })
 ], UpdateAdminClientJobPostingRestrictionDto.prototype, "isJobPostingRestricted", 2);
 
 // src/modules/client-admin/dto/skip-service-agreement-flow.dto.ts
-import { IsBoolean as IsBoolean14, IsNotEmpty as IsNotEmpty71 } from "class-validator";
+import { IsBoolean as IsBoolean14, IsNotEmpty as IsNotEmpty72 } from "class-validator";
 var SkipServiceAgreementFlowDto = class {
 };
 __decorateClass([
-  IsNotEmpty71({ message: "Skip service agreement flag is required." }),
+  IsNotEmpty72({ message: "Skip service agreement flag is required." }),
   IsBoolean14({ message: "Skip service agreement must be a boolean value." })
 ], SkipServiceAgreementFlowDto.prototype, "skipServiceAgreement", 2);
 
@@ -8816,7 +9050,7 @@ var FREELANCER_DECLARATION_PATTERN = {
 };
 
 // src/modules/user/freelancer-declaration/dto/freelancer-declaration.dto.ts
-import { IsOptional as IsOptional45, IsEnum as IsEnum32, IsString as IsString47, IsNotEmpty as IsNotEmpty72, IsIn as IsIn3 } from "class-validator";
+import { IsOptional as IsOptional46, IsEnum as IsEnum33, IsString as IsString48, IsNotEmpty as IsNotEmpty73, IsIn as IsIn3 } from "class-validator";
 var DocumentTypeEnum = /* @__PURE__ */ ((DocumentTypeEnum2) => {
   DocumentTypeEnum2["AADHAAR"] = "AADHAAR_CARD";
   DocumentTypeEnum2["PASSPORT"] = "PASSPORT";
@@ -8827,15 +9061,15 @@ var DocumentTypeEnum = /* @__PURE__ */ ((DocumentTypeEnum2) => {
 var FreelancerDeclarationDto = class {
 };
 __decorateClass([
-  IsOptional45(),
-  IsString47({ message: "UUID must be a string" })
+  IsOptional46(),
+  IsString48({ message: "UUID must be a string" })
 ], FreelancerDeclarationDto.prototype, "uuid", 2);
 __decorateClass([
-  IsEnum32(DocumentTypeEnum, { message: "Document type must be one of AADHAAR_CARD, PASSPORT, DRIVING_LICENSE, PAN_CARD" })
+  IsEnum33(DocumentTypeEnum, { message: "Document type must be one of AADHAAR_CARD, PASSPORT, DRIVING_LICENSE, PAN_CARD" })
 ], FreelancerDeclarationDto.prototype, "documentType", 2);
 __decorateClass([
-  IsNotEmpty72({ message: "Please accept the declaration " }),
-  IsString47(),
+  IsNotEmpty73({ message: "Please accept the declaration " }),
+  IsString48(),
   IsIn3([
     "true"
   ])
@@ -8851,36 +9085,36 @@ var CLIENT_CANDIDATE_PREFERENCE_PATTERN = {
 };
 
 // src/modules/user/client-candidate-preference/dto/mark-candidate-status.dto.ts
-import { IsNotEmpty as IsNotEmpty73, IsNumber as IsNumber11, IsOptional as IsOptional46 } from "class-validator";
-import { Type as Type10 } from "class-transformer";
+import { IsNotEmpty as IsNotEmpty74, IsNumber as IsNumber12, IsOptional as IsOptional47 } from "class-validator";
+import { Type as Type11 } from "class-transformer";
 var MarkCandidateStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty73({ message: "Candidate ID is required." }),
-  IsNumber11({}, { message: "Candidate ID must be a number." }),
-  Type10(() => Number)
+  IsNotEmpty74({ message: "Candidate ID is required." }),
+  IsNumber12({}, { message: "Candidate ID must be a number." }),
+  Type11(() => Number)
 ], MarkCandidateStatusDto.prototype, "candidateId", 2);
 __decorateClass([
-  IsOptional46(),
-  IsNumber11({}, { message: "Job ID must be a number." }),
-  Type10(() => Number)
+  IsOptional47(),
+  IsNumber12({}, { message: "Job ID must be a number." }),
+  Type11(() => Number)
 ], MarkCandidateStatusDto.prototype, "jobId", 2);
 
 // src/modules/user/client-candidate-preference/dto/mark-candidate-status-bulk.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty8, IsArray as IsArray16, IsNumber as IsNumber12, IsOptional as IsOptional47 } from "class-validator";
-import { Type as Type11 } from "class-transformer";
+import { ArrayNotEmpty as ArrayNotEmpty9, IsArray as IsArray17, IsNumber as IsNumber13, IsOptional as IsOptional48 } from "class-validator";
+import { Type as Type12 } from "class-transformer";
 var MarkCandidateStatusBulkDto = class {
 };
 __decorateClass([
-  IsArray16({ message: "Candidate IDs must be an array." }),
-  ArrayNotEmpty8({ message: "At least one candidate ID is required." }),
-  IsNumber12({}, { each: true, message: "Each candidate ID must be a number." }),
-  Type11(() => Number)
+  IsArray17({ message: "Candidate IDs must be an array." }),
+  ArrayNotEmpty9({ message: "At least one candidate ID is required." }),
+  IsNumber13({}, { each: true, message: "Each candidate ID must be a number." }),
+  Type12(() => Number)
 ], MarkCandidateStatusBulkDto.prototype, "candidateIds", 2);
 __decorateClass([
-  IsOptional47(),
-  IsNumber12({}, { message: "Job ID must be a number." }),
-  Type11(() => Number)
+  IsOptional48(),
+  IsNumber13({}, { message: "Job ID must be a number." }),
+  Type12(() => Number)
 ], MarkCandidateStatusBulkDto.prototype, "jobId", 2);
 
 // src/modules/cms/pattern/pattern.ts
@@ -8894,44 +9128,44 @@ var CMS_PATTERNS = {
 };
 
 // src/modules/cms/dto/create-cms.dto.ts
-import { IsBoolean as IsBoolean15, IsNotEmpty as IsNotEmpty74, IsOptional as IsOptional48 } from "class-validator";
+import { IsBoolean as IsBoolean15, IsNotEmpty as IsNotEmpty75, IsOptional as IsOptional49 } from "class-validator";
 var CreateCmsDto = class {
 };
 __decorateClass([
-  IsNotEmpty74({ message: "Please enter name." })
+  IsNotEmpty75({ message: "Please enter name." })
 ], CreateCmsDto.prototype, "title", 2);
 __decorateClass([
-  IsOptional48()
+  IsOptional49()
 ], CreateCmsDto.prototype, "content", 2);
 __decorateClass([
-  IsOptional48(),
+  IsOptional49(),
   IsBoolean15({ message: "Is active must be a boolean value" })
 ], CreateCmsDto.prototype, "isActive", 2);
 
 // src/modules/cms/dto/update-cms-status.dto.ts
-import { IsBoolean as IsBoolean16, IsNotEmpty as IsNotEmpty75 } from "class-validator";
+import { IsBoolean as IsBoolean16, IsNotEmpty as IsNotEmpty76 } from "class-validator";
 var UpdateCmsStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty75({ message: "Please specify cms status." }),
+  IsNotEmpty76({ message: "Please specify cms status." }),
   IsBoolean16({ message: "Is active must be a boolean value" })
 ], UpdateCmsStatusDto.prototype, "isActive", 2);
 
 // src/modules/cms/dto/update-cms.dto.ts
-import { IsBoolean as IsBoolean17, IsNotEmpty as IsNotEmpty76, IsOptional as IsOptional49 } from "class-validator";
+import { IsBoolean as IsBoolean17, IsNotEmpty as IsNotEmpty77, IsOptional as IsOptional50 } from "class-validator";
 var UpdateCmsDto = class {
 };
 __decorateClass([
-  IsOptional49()
+  IsOptional50()
 ], UpdateCmsDto.prototype, "uuid", 2);
 __decorateClass([
-  IsNotEmpty76({ message: "Please enter name." })
+  IsNotEmpty77({ message: "Please enter name." })
 ], UpdateCmsDto.prototype, "title", 2);
 __decorateClass([
-  IsOptional49()
+  IsOptional50()
 ], UpdateCmsDto.prototype, "content", 2);
 __decorateClass([
-  IsOptional49(),
+  IsOptional50(),
   IsBoolean17({ message: "Is active must be a boolean value" })
 ], UpdateCmsDto.prototype, "isActive", 2);
 
@@ -8966,18 +9200,18 @@ var ADMIN_JOB_PATTERN = {
 };
 
 // src/modules/job-admin/dto/admin-create-job-information.dto.ts
-import { Type as Type12 } from "class-transformer";
+import { Type as Type13 } from "class-transformer";
 import {
-  IsString as IsString48,
-  IsEnum as IsEnum33,
+  IsString as IsString49,
+  IsEnum as IsEnum34,
   IsInt as IsInt10,
-  IsOptional as IsOptional50,
-  IsArray as IsArray17,
+  IsOptional as IsOptional51,
+  IsArray as IsArray18,
   IsDateString as IsDateString3,
-  IsNotEmpty as IsNotEmpty77,
-  ArrayNotEmpty as ArrayNotEmpty9,
-  Min as Min6,
-  IsNumber as IsNumber13
+  IsNotEmpty as IsNotEmpty78,
+  ArrayNotEmpty as ArrayNotEmpty10,
+  Min as Min7,
+  IsNumber as IsNumber14
 } from "class-validator";
 var JobLocationEnumDto = /* @__PURE__ */ ((JobLocationEnumDto2) => {
   JobLocationEnumDto2["ONSITE"] = "ONSITE";
@@ -8994,55 +9228,55 @@ var TypeOfEmploymentEnumDto = /* @__PURE__ */ ((TypeOfEmploymentEnumDto2) => {
 var AdminCreateJobInformationDto = class {
 };
 __decorateClass([
-  IsString48({ message: "Job role must be a string." }),
-  IsNotEmpty77({ message: "Job role is required." })
+  IsString49({ message: "Job role must be a string." }),
+  IsNotEmpty78({ message: "Job role is required." })
 ], AdminCreateJobInformationDto.prototype, "jobRole", 2);
 __decorateClass([
-  IsOptional50(),
-  IsString48({ message: "Note must be a string." })
+  IsOptional51(),
+  IsString49({ message: "Note must be a string." })
 ], AdminCreateJobInformationDto.prototype, "note", 2);
 __decorateClass([
-  IsArray17({ message: "Skills must be an array of skill names." }),
-  ArrayNotEmpty9({ message: "At least one skill must be provided." }),
-  IsString48({ each: true, message: "Each skill must be a valid string." })
+  IsArray18({ message: "Skills must be an array of skill names." }),
+  ArrayNotEmpty10({ message: "At least one skill must be provided." }),
+  IsString49({ each: true, message: "Each skill must be a valid string." })
 ], AdminCreateJobInformationDto.prototype, "skills", 2);
 __decorateClass([
   IsInt10({ message: "Openings must be a valid integer." }),
-  Min6(1, { message: "There must be at least one opening." })
+  Min7(1, { message: "There must be at least one opening." })
 ], AdminCreateJobInformationDto.prototype, "openings", 2);
 __decorateClass([
-  IsEnum33(JobLocationEnumDto, {
+  IsEnum34(JobLocationEnumDto, {
     message: `Location must be one of: ${Object.values(JobLocationEnumDto).join(
       ", "
     )}.`
   })
 ], AdminCreateJobInformationDto.prototype, "location", 2);
 __decorateClass([
-  IsEnum33(TypeOfEmploymentEnumDto, {
+  IsEnum34(TypeOfEmploymentEnumDto, {
     message: `Type of employment must be one of: ${Object.values(
       TypeOfEmploymentEnumDto
     ).join(", ")}.`
   })
 ], AdminCreateJobInformationDto.prototype, "typeOfEmployment", 2);
 __decorateClass([
-  IsString48({ message: "Onboarding Days must be a string." }),
-  IsNotEmpty77({ message: "Onboarding Days is required." })
+  IsString49({ message: "Onboarding Days must be a string." }),
+  IsNotEmpty78({ message: "Onboarding Days is required." })
 ], AdminCreateJobInformationDto.prototype, "onboardingTat", 2);
 __decorateClass([
-  IsString48({ message: "Communication skills must be a string." }),
-  IsNotEmpty77({ message: "Communication skills are required." })
+  IsString49({ message: "Communication skills must be a string." }),
+  IsNotEmpty78({ message: "Communication skills are required." })
 ], AdminCreateJobInformationDto.prototype, "candidateCommunicationSkills", 2);
 __decorateClass([
-  IsString48({ message: "Currency must be a string." }),
-  IsNotEmpty77({ message: "Currency is required." })
+  IsString49({ message: "Currency must be a string." }),
+  IsNotEmpty78({ message: "Currency is required." })
 ], AdminCreateJobInformationDto.prototype, "currency", 2);
 __decorateClass([
-  Type12(() => Number),
-  IsNumber13({}, { message: "Expected salary from must be a number." })
+  Type13(() => Number),
+  IsNumber14({}, { message: "Expected salary from must be a number." })
 ], AdminCreateJobInformationDto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
-  Type12(() => Number),
-  IsNumber13({}, { message: "Expected salary to must be a number." })
+  Type13(() => Number),
+  IsNumber14({}, { message: "Expected salary to must be a number." })
 ], AdminCreateJobInformationDto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
   IsDateString3(
@@ -9057,19 +9291,19 @@ __decorateClass([
   )
 ], AdminCreateJobInformationDto.prototype, "tentativeEndDate", 2);
 __decorateClass([
-  IsOptional50(),
-  IsString48({ message: "Additional comment must be a string." })
+  IsOptional51(),
+  IsString49({ message: "Additional comment must be a string." })
 ], AdminCreateJobInformationDto.prototype, "additionalComment", 2);
 __decorateClass([
-  IsOptional50(),
+  IsOptional51(),
   IsInt10({ message: "Country ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional50(),
+  IsOptional51(),
   IsInt10({ message: "State ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional50(),
+  IsOptional51(),
   IsInt10({ message: "City ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "cityId", 2);
 __decorateClass([
@@ -9077,18 +9311,18 @@ __decorateClass([
 ], AdminCreateJobInformationDto.prototype, "clientId", 2);
 
 // src/modules/job-admin/dto/admin-update-job-information.dto.ts
-import { Type as Type13 } from "class-transformer";
+import { Type as Type14 } from "class-transformer";
 import {
-  IsString as IsString49,
-  IsEnum as IsEnum34,
+  IsString as IsString50,
+  IsEnum as IsEnum35,
   IsInt as IsInt11,
-  IsOptional as IsOptional51,
-  IsArray as IsArray18,
+  IsOptional as IsOptional52,
+  IsArray as IsArray19,
   IsDateString as IsDateString4,
-  IsNotEmpty as IsNotEmpty78,
-  ArrayNotEmpty as ArrayNotEmpty10,
-  Min as Min7,
-  IsNumber as IsNumber14
+  IsNotEmpty as IsNotEmpty79,
+  ArrayNotEmpty as ArrayNotEmpty11,
+  Min as Min8,
+  IsNumber as IsNumber15
 } from "class-validator";
 var JobLocationEnums = /* @__PURE__ */ ((JobLocationEnums2) => {
   JobLocationEnums2["ONSITE"] = "ONSITE";
@@ -9105,55 +9339,55 @@ var TypeOfEmploymentEnums = /* @__PURE__ */ ((TypeOfEmploymentEnums2) => {
 var AdminUpdateJobInformationDto = class {
 };
 __decorateClass([
-  IsString49({ message: "Job role must be a string." }),
-  IsNotEmpty78({ message: "Job role is required." })
+  IsString50({ message: "Job role must be a string." }),
+  IsNotEmpty79({ message: "Job role is required." })
 ], AdminUpdateJobInformationDto.prototype, "jobRole", 2);
 __decorateClass([
-  IsOptional51(),
-  IsString49({ message: "Note must be a string." })
+  IsOptional52(),
+  IsString50({ message: "Note must be a string." })
 ], AdminUpdateJobInformationDto.prototype, "note", 2);
 __decorateClass([
-  IsArray18({ message: "Skills must be an array of skill names." }),
-  ArrayNotEmpty10({ message: "At least one skill must be provided." }),
-  IsString49({ each: true, message: "Each skill must be a valid string." })
+  IsArray19({ message: "Skills must be an array of skill names." }),
+  ArrayNotEmpty11({ message: "At least one skill must be provided." }),
+  IsString50({ each: true, message: "Each skill must be a valid string." })
 ], AdminUpdateJobInformationDto.prototype, "skills", 2);
 __decorateClass([
   IsInt11({ message: "Openings must be a valid integer." }),
-  Min7(1, { message: "There must be at least one opening." })
+  Min8(1, { message: "There must be at least one opening." })
 ], AdminUpdateJobInformationDto.prototype, "openings", 2);
 __decorateClass([
-  IsEnum34(JobLocationEnums, {
+  IsEnum35(JobLocationEnums, {
     message: `Location must be one of: ${Object.values(JobLocationEnums).join(
       ", "
     )}.`
   })
 ], AdminUpdateJobInformationDto.prototype, "location", 2);
 __decorateClass([
-  IsEnum34(TypeOfEmploymentEnums, {
+  IsEnum35(TypeOfEmploymentEnums, {
     message: `Type of employment must be one of: ${Object.values(
       TypeOfEmploymentEnums
     ).join(", ")}.`
   })
 ], AdminUpdateJobInformationDto.prototype, "typeOfEmployment", 2);
 __decorateClass([
-  IsString49({ message: "Onboarding Days must be a string." }),
-  IsNotEmpty78({ message: "Onboarding Days is required." })
+  IsString50({ message: "Onboarding Days must be a string." }),
+  IsNotEmpty79({ message: "Onboarding Days is required." })
 ], AdminUpdateJobInformationDto.prototype, "onboardingTat", 2);
 __decorateClass([
-  IsString49({ message: "Communication skills must be a string." }),
-  IsNotEmpty78({ message: "Communication skills are required." })
+  IsString50({ message: "Communication skills must be a string." }),
+  IsNotEmpty79({ message: "Communication skills are required." })
 ], AdminUpdateJobInformationDto.prototype, "candidateCommunicationSkills", 2);
 __decorateClass([
-  IsString49({ message: "Currency must be a string." }),
-  IsNotEmpty78({ message: "Currency is required." })
+  IsString50({ message: "Currency must be a string." }),
+  IsNotEmpty79({ message: "Currency is required." })
 ], AdminUpdateJobInformationDto.prototype, "currency", 2);
 __decorateClass([
-  Type13(() => Number),
-  IsNumber14({}, { message: "Expected salary from must be a number." })
+  Type14(() => Number),
+  IsNumber15({}, { message: "Expected salary from must be a number." })
 ], AdminUpdateJobInformationDto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
-  Type13(() => Number),
-  IsNumber14({}, { message: "Expected salary to must be a number." })
+  Type14(() => Number),
+  IsNumber15({}, { message: "Expected salary to must be a number." })
 ], AdminUpdateJobInformationDto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
   IsDateString4(
@@ -9168,19 +9402,19 @@ __decorateClass([
   )
 ], AdminUpdateJobInformationDto.prototype, "tentativeEndDate", 2);
 __decorateClass([
-  IsOptional51(),
-  IsString49({ message: "Additional comment must be a string." })
+  IsOptional52(),
+  IsString50({ message: "Additional comment must be a string." })
 ], AdminUpdateJobInformationDto.prototype, "additionalComment", 2);
 __decorateClass([
-  IsOptional51(),
+  IsOptional52(),
   IsInt11({ message: "Country ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional51(),
+  IsOptional52(),
   IsInt11({ message: "State ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional51(),
+  IsOptional52(),
   IsInt11({ message: "City ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "cityId", 2);
 __decorateClass([
@@ -9189,20 +9423,20 @@ __decorateClass([
 
 // src/modules/job-admin/dto/admin-job-basic-information-v2.dto.ts
 import {
-  IsString as IsString50,
-  IsNotEmpty as IsNotEmpty79,
-  IsArray as IsArray19,
-  ArrayNotEmpty as ArrayNotEmpty11,
-  IsNumber as IsNumber15,
-  IsOptional as IsOptional52,
-  IsEnum as IsEnum35,
-  Min as Min8,
-  ValidateIf as ValidateIf10,
-  MaxLength as MaxLength21,
-  Max as Max4,
+  IsString as IsString51,
+  IsNotEmpty as IsNotEmpty80,
+  IsArray as IsArray20,
+  ArrayNotEmpty as ArrayNotEmpty12,
+  IsNumber as IsNumber16,
+  IsOptional as IsOptional53,
+  IsEnum as IsEnum36,
+  Min as Min9,
+  ValidateIf as ValidateIf11,
+  MaxLength as MaxLength22,
+  Max as Max5,
   IsInt as IsInt12
 } from "class-validator";
-import { Type as Type14 } from "class-transformer";
+import { Type as Type15 } from "class-transformer";
 var JobLocationAdminEnumDto = /* @__PURE__ */ ((JobLocationAdminEnumDto2) => {
   JobLocationAdminEnumDto2["ONSITE"] = "ONSITE";
   JobLocationAdminEnumDto2["REMOTE"] = "REMOTE";
@@ -9231,16 +9465,16 @@ var AdminStepCompletedEnumV2 = /* @__PURE__ */ ((AdminStepCompletedEnumV22) => {
 var JobLocationAdminDto = class {
 };
 __decorateClass([
-  IsOptional52(),
-  IsNumber15()
+  IsOptional53(),
+  IsNumber16()
 ], JobLocationAdminDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional52(),
-  IsNumber15()
+  IsOptional53(),
+  IsNumber16()
 ], JobLocationAdminDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional52(),
-  IsNumber15()
+  IsOptional53(),
+  IsNumber16()
 ], JobLocationAdminDto.prototype, "cityId", 2);
 var AdminJobBasicInformationV2Dto = class {
   constructor() {
@@ -9248,157 +9482,157 @@ var AdminJobBasicInformationV2Dto = class {
   }
 };
 __decorateClass([
-  IsOptional52(),
-  Type14(() => Boolean)
+  IsOptional53(),
+  Type15(() => Boolean)
 ], AdminJobBasicInformationV2Dto.prototype, "isDraft", 2);
 __decorateClass([
   IsInt12({ message: "Client ID must be a valid integer." })
 ], AdminJobBasicInformationV2Dto.prototype, "clientId", 2);
 __decorateClass([
-  IsNotEmpty79({ message: "Please enter job role" }),
-  IsString50({ message: "Job role must be a string" })
+  IsNotEmpty80({ message: "Please enter job role" }),
+  IsString51({ message: "Job role must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "jobRole", 2);
 __decorateClass([
-  IsOptional52(),
-  IsString50({ message: "Note must be a string" })
+  IsOptional53(),
+  IsString51({ message: "Note must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "note", 2);
 __decorateClass([
-  ValidateIf10((o) => !o.isDraft),
-  IsOptional52(),
-  IsArray19({ message: "Skills must be an array" }),
-  ArrayNotEmpty11({ message: "Please select at least one skill" }),
-  IsString50({ each: true, message: "Each skill must be a string" }),
-  Type14(() => String)
+  ValidateIf11((o) => !o.isDraft),
+  IsOptional53(),
+  IsArray20({ message: "Skills must be an array" }),
+  ArrayNotEmpty12({ message: "Please select at least one skill" }),
+  IsString51({ each: true, message: "Each skill must be a string" }),
+  Type15(() => String)
 ], AdminJobBasicInformationV2Dto.prototype, "skills", 2);
 __decorateClass([
-  ValidateIf10((o) => !o.isDraft),
-  IsNumber15({}, { message: "Openings must be a number" }),
-  Min8(1, { message: "There must be at least 1 opening" }),
-  Type14(() => Number)
+  ValidateIf11((o) => !o.isDraft),
+  IsNumber16({}, { message: "Openings must be a number" }),
+  Min9(1, { message: "There must be at least 1 opening" }),
+  Type15(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "openings", 2);
 __decorateClass([
-  ValidateIf10((o) => !o.isDraft),
-  IsEnum35(JobLocationAdminEnumDto, {
+  ValidateIf11((o) => !o.isDraft),
+  IsEnum36(JobLocationAdminEnumDto, {
     message: `Location must be one of: ${Object.values(JobLocationAdminEnumDto).join(
       ", "
     )}`
   })
 ], AdminJobBasicInformationV2Dto.prototype, "location", 2);
 __decorateClass([
-  ValidateIf10((o) => !o.isDraft),
-  IsEnum35(EmploymentTypeAdminEnumDto, {
+  ValidateIf11((o) => !o.isDraft),
+  IsEnum36(EmploymentTypeAdminEnumDto, {
     message: `Type of employment must be one of: ${Object.values(
       EmploymentTypeAdminEnumDto
     ).join(", ")}`
   })
 ], AdminJobBasicInformationV2Dto.prototype, "typeOfEmployment", 2);
 __decorateClass([
-  IsOptional52(),
-  IsNumber15({}, { message: "Expected salary (from) must be a number" }),
-  Min8(0, { message: "Expected salary (from) cannot be negative" }),
-  Type14(() => Number)
+  IsOptional53(),
+  IsNumber16({}, { message: "Expected salary (from) must be a number" }),
+  Min9(0, { message: "Expected salary (from) cannot be negative" }),
+  Type15(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
-  IsOptional52(),
-  IsNumber15({}, { message: "Expected salary (to) must be a number" }),
-  Min8(0, { message: "Expected salary (to) cannot be negative" }),
-  Type14(() => Number)
+  IsOptional53(),
+  IsNumber16({}, { message: "Expected salary (to) must be a number" }),
+  Min9(0, { message: "Expected salary (to) cannot be negative" }),
+  Type15(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
-  IsOptional52(),
-  Type14(() => JobLocationAdminDto)
+  IsOptional53(),
+  Type15(() => JobLocationAdminDto)
 ], AdminJobBasicInformationV2Dto.prototype, "locations", 2);
 __decorateClass([
-  IsOptional52(),
-  IsString50({ message: "Academic qualification must be a string" })
+  IsOptional53(),
+  IsString51({ message: "Academic qualification must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "academicQualification", 2);
 __decorateClass([
-  ValidateIf10((o) => !o.isDraft),
-  IsEnum35(typeOfExperienceAdminEnumDto, {
+  ValidateIf11((o) => !o.isDraft),
+  IsEnum36(typeOfExperienceAdminEnumDto, {
     message: `Type of experience must be one of: ${Object.values(
       typeOfExperienceAdminEnumDto
     ).join(", ")}`
   })
 ], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceType", 2);
 __decorateClass([
-  ValidateIf10((o) => !o.isDraft),
-  IsNotEmpty79({ message: "Please enter the years of experience" }),
-  IsString50({ message: "Years of experience must be a string" })
+  ValidateIf11((o) => !o.isDraft),
+  IsNotEmpty80({ message: "Please enter the years of experience" }),
+  IsString51({ message: "Years of experience must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceFrom", 2);
 __decorateClass([
-  ValidateIf10((o) => !o.isDraft),
-  IsNotEmpty79({ message: "Please enter the years of experience upto" }),
-  IsString50({ message: "Years of experience must be a string" })
+  ValidateIf11((o) => !o.isDraft),
+  IsNotEmpty80({ message: "Please enter the years of experience upto" }),
+  IsString51({ message: "Years of experience must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceTo", 2);
 __decorateClass([
-  IsOptional52(),
-  IsString50({ message: "Business industry must be a string" })
+  IsOptional53(),
+  IsString51({ message: "Business industry must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "businessIndustry", 2);
 __decorateClass([
-  IsOptional52(),
-  IsString50({ message: "Project name must be a string" })
+  IsOptional53(),
+  IsString51({ message: "Project name must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional52()
+  IsOptional53()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryFrom", 2);
 __decorateClass([
-  IsOptional52()
+  IsOptional53()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryTo", 2);
 __decorateClass([
-  IsOptional52(),
-  IsNumber15({}, { message: "Expected annual budget (from) must be a number" }),
-  Min8(0, { message: "Expected annual budget (from) cannot be negative" }),
-  Type14(() => Number)
+  IsOptional53(),
+  IsNumber16({}, { message: "Expected annual budget (from) must be a number" }),
+  Min9(0, { message: "Expected annual budget (from) cannot be negative" }),
+  Type15(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedAnnualBudgetFrom", 2);
 __decorateClass([
-  IsOptional52()
+  IsOptional53()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetFrom", 2);
 __decorateClass([
-  IsOptional52(),
-  IsNumber15({}, { message: "Expected annual budget (to) must be a number" }),
-  Min8(0, { message: "Expected annual budget (to) cannot be negative" }),
-  Type14(() => Number)
+  IsOptional53(),
+  IsNumber16({}, { message: "Expected annual budget (to) must be a number" }),
+  Min9(0, { message: "Expected annual budget (to) cannot be negative" }),
+  Type15(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedAnnualBudgetTo", 2);
 __decorateClass([
-  IsOptional52()
+  IsOptional53()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetTo", 2);
 __decorateClass([
-  IsOptional52(),
-  IsNumber15({}, { message: "Number of hours must be a number" }),
-  Min8(0, { message: "Number of hours cannot be negative" }),
-  Max4(40, { message: "Number of hours cannot exceed 40" }),
-  Type14(() => Number)
+  IsOptional53(),
+  IsNumber16({}, { message: "Number of hours must be a number" }),
+  Min9(0, { message: "Number of hours cannot be negative" }),
+  Max5(40, { message: "Number of hours cannot exceed 40" }),
+  Type15(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "numberOfHours", 2);
 __decorateClass([
-  IsOptional52()
+  IsOptional53()
 ], AdminJobBasicInformationV2Dto.prototype, "years", 2);
 __decorateClass([
-  IsOptional52()
+  IsOptional53()
 ], AdminJobBasicInformationV2Dto.prototype, "months", 2);
 __decorateClass([
-  IsOptional52()
+  IsOptional53()
 ], AdminJobBasicInformationV2Dto.prototype, "weeks", 2);
 __decorateClass([
-  IsOptional52()
+  IsOptional53()
 ], AdminJobBasicInformationV2Dto.prototype, "days", 2);
 __decorateClass([
-  IsOptional52(),
-  IsString50({ message: "Additional comment must be a string" }),
-  MaxLength21(500, { message: "Additional comment must not exceed 500 characters" })
+  IsOptional53(),
+  IsString51({ message: "Additional comment must be a string" }),
+  MaxLength22(500, { message: "Additional comment must not exceed 500 characters" })
 ], AdminJobBasicInformationV2Dto.prototype, "additionalComment", 2);
 __decorateClass([
-  ValidateIf10((o) => !o.isDraft),
-  IsArray19({ message: "Good to have skills must be an array" }),
-  IsString50({ each: true, message: "Each skill must be a string" }),
-  IsOptional52(),
-  Type14(() => String)
+  ValidateIf11((o) => !o.isDraft),
+  IsArray20({ message: "Good to have skills must be an array" }),
+  IsString51({ each: true, message: "Each skill must be a string" }),
+  IsOptional53(),
+  Type15(() => String)
 ], AdminJobBasicInformationV2Dto.prototype, "goodToHaveSkills", 2);
 __decorateClass([
-  IsOptional52()
+  IsOptional53()
 ], AdminJobBasicInformationV2Dto.prototype, "jobRoleCanonicalName", 2);
 __decorateClass([
-  IsOptional52(),
-  IsEnum35(AdminStepCompletedEnumV2, {
+  IsOptional53(),
+  IsEnum36(AdminStepCompletedEnumV2, {
     message: `Type of stepCompleted must be one of: ${Object.values(
       AdminStepCompletedEnumV2
     ).join(", ")}`
@@ -9412,7 +9646,7 @@ var LEAD_PATTERN = {
 };
 
 // src/modules/lead/dto/create-lead.dto.ts
-import { IsString as IsString51, IsEmail as IsEmail19, IsOptional as IsOptional53, IsEnum as IsEnum36 } from "class-validator";
+import { IsString as IsString52, IsEmail as IsEmail19, IsOptional as IsOptional54, IsEnum as IsEnum37 } from "class-validator";
 var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
   CategoryEmumDto2["BUSINESS"] = "BUSINESS";
   CategoryEmumDto2["FREELANCER"] = "FREELANCER";
@@ -9421,23 +9655,23 @@ var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
 var CreateLeadDto = class {
 };
 __decorateClass([
-  IsString51({ message: "Name must be a string" })
+  IsString52({ message: "Name must be a string" })
 ], CreateLeadDto.prototype, "name", 2);
 __decorateClass([
   IsEmail19({}, { message: "Invalid email address" })
 ], CreateLeadDto.prototype, "email", 2);
 __decorateClass([
-  IsString51({ message: "Mobile code must be a string (e.g., +1)" })
+  IsString52({ message: "Mobile code must be a string (e.g., +1)" })
 ], CreateLeadDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsString51({ message: "Mobile must be a string (e.g., 1243253534)" })
+  IsString52({ message: "Mobile must be a string (e.g., 1243253534)" })
 ], CreateLeadDto.prototype, "mobile", 2);
 __decorateClass([
-  IsOptional53(),
-  IsString51({ message: "Description must be a string" })
+  IsOptional54(),
+  IsString52({ message: "Description must be a string" })
 ], CreateLeadDto.prototype, "description", 2);
 __decorateClass([
-  IsEnum36(CategoryEmumDto, {
+  IsEnum37(CategoryEmumDto, {
     message: `Type of category must be one of: ${Object.values(
       CategoryEmumDto
     ).join(", ")}`
@@ -9459,58 +9693,58 @@ var ADMIN_ROLE_PATTERN = {
 };
 
 // src/modules/admin-role/dto/create-admin-role.dto.ts
-import { IsBoolean as IsBoolean18, IsNotEmpty as IsNotEmpty80, IsOptional as IsOptional54, IsString as IsString52 } from "class-validator";
+import { IsBoolean as IsBoolean18, IsNotEmpty as IsNotEmpty81, IsOptional as IsOptional55, IsString as IsString53 } from "class-validator";
 var CreateAdminRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty80({ message: "Please enter admin role name." }),
-  IsString52({ message: "Role name must be a string." })
+  IsNotEmpty81({ message: "Please enter admin role name." }),
+  IsString53({ message: "Role name must be a string." })
 ], CreateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  IsOptional54(),
-  IsString52({ message: "Role description must be a string." })
+  IsOptional55(),
+  IsString53({ message: "Role description must be a string." })
 ], CreateAdminRoleDto.prototype, "roleDescription", 2);
 __decorateClass([
-  IsOptional54(),
+  IsOptional55(),
   IsBoolean18({ message: "Is active must be a boolean value" })
 ], CreateAdminRoleDto.prototype, "isActive", 2);
 
 // src/modules/admin-role/dto/update-admin-role.dto.ts
-import { IsBoolean as IsBoolean19, IsNotEmpty as IsNotEmpty81, IsOptional as IsOptional55, IsString as IsString53 } from "class-validator";
+import { IsBoolean as IsBoolean19, IsNotEmpty as IsNotEmpty82, IsOptional as IsOptional56, IsString as IsString54 } from "class-validator";
 var UpdateAdminRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty81({ message: "Please enter admin role name." }),
-  IsString53({ message: "Role name must be a string." })
+  IsNotEmpty82({ message: "Please enter admin role name." }),
+  IsString54({ message: "Role name must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  IsOptional55(),
-  IsString53({ message: "Role description must be a string." })
+  IsOptional56(),
+  IsString54({ message: "Role description must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleDescription", 2);
 __decorateClass([
-  IsOptional55(),
+  IsOptional56(),
   IsBoolean19({ message: "Is active must be a boolean value." })
 ], UpdateAdminRoleDto.prototype, "isActive", 2);
 
 // src/modules/admin-role/dto/attach-permissions-to-role.dto.ts
-import { IsNotEmpty as IsNotEmpty82, IsString as IsString54 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty83, IsString as IsString55 } from "class-validator";
 var AttachPermissionsToRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty82({ message: "Please enter admin role ID." }),
-  IsString54({ message: "Role ID must be a string." })
+  IsNotEmpty83({ message: "Please enter admin role ID." }),
+  IsString55({ message: "Role ID must be a string." })
 ], AttachPermissionsToRoleDto.prototype, "roleId", 2);
 __decorateClass([
-  IsNotEmpty82({ message: "Please enter permission IDs." }),
-  IsString54({ message: "Permission IDs must be a comma-separated string." })
+  IsNotEmpty83({ message: "Please enter permission IDs." }),
+  IsString55({ message: "Permission IDs must be a comma-separated string." })
 ], AttachPermissionsToRoleDto.prototype, "permissionIds", 2);
 
 // src/modules/admin-role/dto/update-admin-role-status.dto.ts
-import { IsBoolean as IsBoolean20, IsNotEmpty as IsNotEmpty83 } from "class-validator";
+import { IsBoolean as IsBoolean20, IsNotEmpty as IsNotEmpty84 } from "class-validator";
 var UpdateAdminRoleStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty83({ message: "Please specify admin role status." }),
+  IsNotEmpty84({ message: "Please specify admin role status." }),
   IsBoolean20({ message: "Is active must be a boolean value" })
 ], UpdateAdminRoleStatusDto.prototype, "isActive", 2);
 
@@ -9593,17 +9827,17 @@ var INTERVIEW_PATTERN = {
 
 // src/modules/interview/dto/interview-invite.dto.ts
 import {
-  IsString as IsString55,
-  IsNotEmpty as IsNotEmpty84,
-  IsArray as IsArray20,
-  ArrayNotEmpty as ArrayNotEmpty12,
+  IsString as IsString56,
+  IsNotEmpty as IsNotEmpty85,
+  IsArray as IsArray21,
+  ArrayNotEmpty as ArrayNotEmpty13,
   IsEmail as IsEmail20,
   IsUUID as IsUUID20,
-  IsEnum as IsEnum37,
-  ValidateIf as ValidateIf11,
-  ValidateNested as ValidateNested7
+  IsEnum as IsEnum38,
+  ValidateIf as ValidateIf12,
+  ValidateNested as ValidateNested8
 } from "class-validator";
-import { Type as Type15 } from "class-transformer";
+import { Type as Type16 } from "class-transformer";
 var CandidateType = /* @__PURE__ */ ((CandidateType2) => {
   CandidateType2["SHORTLISTED"] = "SHORTLISTED";
   CandidateType2["APPLICATNTS"] = "APPLICATNTS";
@@ -9617,39 +9851,39 @@ __decorateClass([
   IsUUID20()
 ], ExistingCandidateDto.prototype, "id", 2);
 __decorateClass([
-  IsEnum37(CandidateType, {
+  IsEnum38(CandidateType, {
     message: "type must be one of SHORTLISTED, APPLICATNTS, or RECOMMENDED"
   })
 ], ExistingCandidateDto.prototype, "type", 2);
 var NewCandidateDto = class {
 };
 __decorateClass([
-  IsNotEmpty84({ message: "Please enter the candidate name" }),
-  IsString55({ message: "Name must be a string" })
+  IsNotEmpty85({ message: "Please enter the candidate name" }),
+  IsString56({ message: "Name must be a string" })
 ], NewCandidateDto.prototype, "name", 2);
 __decorateClass([
   IsEmail20({}, { message: "Please enter a valid email." })
 ], NewCandidateDto.prototype, "email", 2);
 __decorateClass([
-  IsEnum37(CandidateType, {
+  IsEnum38(CandidateType, {
     message: "type must be NEW"
   })
 ], NewCandidateDto.prototype, "type", 2);
 var CandidatesDto = class {
 };
 __decorateClass([
-  ValidateIf11((o) => o.exixtingCandidates?.length > 0),
-  IsArray20({ message: "Existing candidates should be an array." }),
-  ArrayNotEmpty12({ message: "Please select at least one candidate." }),
-  ValidateNested7({ each: true }),
-  Type15(() => ExistingCandidateDto)
+  ValidateIf12((o) => o.exixtingCandidates?.length > 0),
+  IsArray21({ message: "Existing candidates should be an array." }),
+  ArrayNotEmpty13({ message: "Please select at least one candidate." }),
+  ValidateNested8({ each: true }),
+  Type16(() => ExistingCandidateDto)
 ], CandidatesDto.prototype, "exixtingCandidates", 2);
 __decorateClass([
-  ValidateIf11((o) => o.newCandidates?.length > 0),
-  IsArray20({ message: "New candidates should be an array." }),
-  ArrayNotEmpty12({ message: "Please add at least one candidate." }),
-  ValidateNested7({ each: true }),
-  Type15(() => NewCandidateDto)
+  ValidateIf12((o) => o.newCandidates?.length > 0),
+  IsArray21({ message: "New candidates should be an array." }),
+  ArrayNotEmpty13({ message: "Please add at least one candidate." }),
+  ValidateNested8({ each: true }),
+  Type16(() => NewCandidateDto)
 ], CandidatesDto.prototype, "newCandidates", 2);
 var InterviewInviteDto = class {
 };
@@ -9657,22 +9891,22 @@ __decorateClass([
   IsUUID20()
 ], InterviewInviteDto.prototype, "jobId", 2);
 __decorateClass([
-  ValidateNested7({ each: true }),
-  Type15(() => CandidatesDto)
+  ValidateNested8({ each: true }),
+  Type16(() => CandidatesDto)
 ], InterviewInviteDto.prototype, "candidates", 2);
 
 // src/modules/interview/dto/send-interview-invite.dto.ts
 import {
-  IsString as IsString56,
-  IsNotEmpty as IsNotEmpty85,
-  IsArray as IsArray21,
+  IsString as IsString57,
+  IsNotEmpty as IsNotEmpty86,
+  IsArray as IsArray22,
   IsUUID as IsUUID21,
-  IsEnum as IsEnum38,
+  IsEnum as IsEnum39,
   IsEmail as IsEmail21,
-  ValidateNested as ValidateNested8,
-  IsOptional as IsOptional57
+  ValidateNested as ValidateNested9,
+  IsOptional as IsOptional58
 } from "class-validator";
-import { Type as Type16 } from "class-transformer";
+import { Type as Type17 } from "class-transformer";
 var InterviewInviteCandidateType = /* @__PURE__ */ ((InterviewInviteCandidateType2) => {
   InterviewInviteCandidateType2["SHORTLISTED"] = "SHORTLISTED";
   InterviewInviteCandidateType2["APPLICANTS"] = "APPLICANTS";
@@ -9684,342 +9918,342 @@ var ExistingCandidateDto2 = class {
 };
 __decorateClass([
   IsUUID21("4", { message: "Candidate ID must be a valid UUID." }),
-  IsNotEmpty85({ message: "Candidate ID is required." })
+  IsNotEmpty86({ message: "Candidate ID is required." })
 ], ExistingCandidateDto2.prototype, "id", 2);
 __decorateClass([
-  IsEnum38(InterviewInviteCandidateType, {
+  IsEnum39(InterviewInviteCandidateType, {
     message: "Type must be one of SHORTLISTED, APPLICANTS, or RECOMMENDED."
   }),
-  IsNotEmpty85({ message: "Candidate type is required." })
+  IsNotEmpty86({ message: "Candidate type is required." })
 ], ExistingCandidateDto2.prototype, "type", 2);
 var NewCandidateDto2 = class {
 };
 __decorateClass([
-  IsString56({ message: "Name must be a string." }),
-  IsNotEmpty85({ message: "Candidate name is required." })
+  IsString57({ message: "Name must be a string." }),
+  IsNotEmpty86({ message: "Candidate name is required." })
 ], NewCandidateDto2.prototype, "name", 2);
 __decorateClass([
   IsEmail21({}, { message: "Please enter a valid email address." }),
-  IsNotEmpty85({ message: "Email is required." })
+  IsNotEmpty86({ message: "Email is required." })
 ], NewCandidateDto2.prototype, "email", 2);
 __decorateClass([
-  IsEnum38(InterviewInviteCandidateType, {
+  IsEnum39(InterviewInviteCandidateType, {
     message: "Type must be NEW for new candidates."
   }),
-  IsNotEmpty85({ message: "Candidate type is required." })
+  IsNotEmpty86({ message: "Candidate type is required." })
 ], NewCandidateDto2.prototype, "type", 2);
 var SendInterviewInviteDto = class {
 };
 __decorateClass([
   IsUUID21("4", { message: "Job ID must be a valid UUID." }),
-  IsNotEmpty85({ message: "Job ID is required." })
+  IsNotEmpty86({ message: "Job ID is required." })
 ], SendInterviewInviteDto.prototype, "jobId", 2);
 __decorateClass([
-  IsArray21({ message: "Existing candidates must be an array." }),
-  ValidateNested8({ each: true }),
-  Type16(() => ExistingCandidateDto2),
-  IsOptional57()
+  IsArray22({ message: "Existing candidates must be an array." }),
+  ValidateNested9({ each: true }),
+  Type17(() => ExistingCandidateDto2),
+  IsOptional58()
 ], SendInterviewInviteDto.prototype, "existingCandidates", 2);
 __decorateClass([
-  IsArray21({ message: "New candidates must be an array." }),
-  ValidateNested8({ each: true }),
-  Type16(() => NewCandidateDto2),
-  IsOptional57()
+  IsArray22({ message: "New candidates must be an array." }),
+  ValidateNested9({ each: true }),
+  Type17(() => NewCandidateDto2),
+  IsOptional58()
 ], SendInterviewInviteDto.prototype, "newCandidates", 2);
 
 // src/modules/interview/dto/create-f2f-interview.dto.ts
 import {
-  IsString as IsString57,
-  IsNotEmpty as IsNotEmpty86,
+  IsString as IsString58,
+  IsNotEmpty as IsNotEmpty87,
   IsEmail as IsEmail22,
-  IsNumber as IsNumber16
+  IsNumber as IsNumber17
 } from "class-validator";
 var CreateF2FInterviewDto = class {
 };
 __decorateClass([
   IsEmail22({}, { message: "Please enter a valid email address." }),
-  IsNotEmpty86({ message: "Invitee email is required." })
+  IsNotEmpty87({ message: "Invitee email is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  IsString57({ message: "Invitee name must be a string." }),
-  IsNotEmpty86({ message: "Invitee name is required." })
+  IsString58({ message: "Invitee name must be a string." }),
+  IsNotEmpty87({ message: "Invitee name is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeName", 2);
 __decorateClass([
-  IsNumber16({}, { message: "Interview ID must be a number." })
+  IsNumber17({}, { message: "Interview ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "interviewId", 2);
 __decorateClass([
-  IsNumber16({}, { message: "Candidate ID must be a number." })
+  IsNumber17({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-direct.dto.ts
-import {
-  IsString as IsString58,
-  IsNotEmpty as IsNotEmpty87,
+import {
+  IsString as IsString59,
+  IsNotEmpty as IsNotEmpty88,
   IsEmail as IsEmail23,
-  IsNumber as IsNumber17
+  IsNumber as IsNumber18
 } from "class-validator";
 var CreateF2FInterviewDirectDto = class {
 };
 __decorateClass([
   IsEmail23({}, { message: "Please enter a valid email address." }),
-  IsNotEmpty87({ message: "Invitee email is required." })
+  IsNotEmpty88({ message: "Invitee email is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  IsString58({ message: "Invitee name must be a string." }),
-  IsNotEmpty87({ message: "Invitee name is required." })
+  IsString59({ message: "Invitee name must be a string." }),
+  IsNotEmpty88({ message: "Invitee name is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeName", 2);
 __decorateClass([
-  IsNumber17({}, { message: "Job ID must be a number." })
+  IsNumber18({}, { message: "Job ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNumber17({}, { message: "Candidate ID must be a number." })
+  IsNumber18({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-reschedule-request.dto.ts
 import {
-  IsString as IsString59,
-  IsNotEmpty as IsNotEmpty88,
-  IsOptional as IsOptional58,
+  IsString as IsString60,
+  IsNotEmpty as IsNotEmpty89,
+  IsOptional as IsOptional59,
   IsUUID as IsUUID22
 } from "class-validator";
 var CreateF2FInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
   IsUUID22("4", { message: "F2F Interview ID must be a valid UUID." }),
-  IsNotEmpty88({ message: "F2F Interview ID is required." })
+  IsNotEmpty89({ message: "F2F Interview ID is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "f2FInterviewId", 2);
 __decorateClass([
-  IsNotEmpty88({ message: "Rescheduled date is required." })
+  IsNotEmpty89({ message: "Rescheduled date is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledDate", 2);
 __decorateClass([
-  IsString59({ message: "Rescheduled slot must be a string." }),
-  IsNotEmpty88({ message: "Rescheduled slot is required." })
+  IsString60({ message: "Rescheduled slot must be a string." }),
+  IsNotEmpty89({ message: "Rescheduled slot is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledSlot", 2);
 __decorateClass([
-  IsOptional58(),
-  IsString59({ message: "Freelancer request reason must be a string." })
+  IsOptional59(),
+  IsString60({ message: "Freelancer request reason must be a string." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/interview/dto/create-ai-interview-reschedule-request.dto.ts
 import {
-  IsString as IsString60,
-  IsNotEmpty as IsNotEmpty89
+  IsString as IsString61,
+  IsNotEmpty as IsNotEmpty90
 } from "class-validator";
 var CreateAIInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  IsNotEmpty89({ message: "AI Interview ID is required." })
+  IsNotEmpty90({ message: "AI Interview ID is required." })
 ], CreateAIInterviewRescheduleRequestDto.prototype, "aiInterviewId", 2);
 __decorateClass([
-  IsString60({ message: "Freelancer reason must be a string." })
+  IsString61({ message: "Freelancer reason must be a string." })
 ], CreateAIInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/interview/dto/reject-ai-interview-reschedule-request.dto.ts
 import {
-  IsString as IsString61
+  IsString as IsString62
 } from "class-validator";
 var RejectAIInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  IsString61({ message: "Client reject reason must be a string." })
+  IsString62({ message: "Client reject reason must be a string." })
 ], RejectAIInterviewRescheduleRequestDto.prototype, "clientRejectReason", 2);
 
 // src/modules/interview/dto/reject-f2f-interview-reschedule-request.dto.ts
-import { IsOptional as IsOptional60, IsString as IsString62 } from "class-validator";
+import { IsOptional as IsOptional61, IsString as IsString63 } from "class-validator";
 var RejectF2FInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  IsOptional60(),
-  IsString62()
+  IsOptional61(),
+  IsString63()
 ], RejectF2FInterviewRescheduleRequestDto.prototype, "clientRejectReason", 2);
 
 // src/modules/interview/dto/capture-ai-interview-result-public.dto.ts
-import { IsNotEmpty as IsNotEmpty90, IsString as IsString63, IsOptional as IsOptional61, IsObject as IsObject6 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty91, IsString as IsString64, IsOptional as IsOptional62, IsObject as IsObject6 } from "class-validator";
 var CaptureAiInterviewResultPublicDto = class {
 };
 __decorateClass([
-  IsNotEmpty90({ message: "AI Interview UUID is required" }),
-  IsString63({ message: "AI Interview UUID must be a string" })
+  IsNotEmpty91({ message: "AI Interview UUID is required" }),
+  IsString64({ message: "AI Interview UUID must be a string" })
 ], CaptureAiInterviewResultPublicDto.prototype, "aiInterviewUuid", 2);
 __decorateClass([
-  IsOptional61(),
+  IsOptional62(),
   IsObject6()
 ], CaptureAiInterviewResultPublicDto.prototype, "result", 2);
 __decorateClass([
-  IsOptional61(),
-  IsString63()
+  IsOptional62(),
+  IsString64()
 ], CaptureAiInterviewResultPublicDto.prototype, "status", 2);
 
 // src/modules/interview/dto/create-interview-basic-information.dto.ts
-import { IsNotEmpty as IsNotEmpty91, IsString as IsString64, IsNumber as IsNumber18 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty92, IsString as IsString65, IsNumber as IsNumber19 } from "class-validator";
 var CreateInterviewBasicInformationDto = class {
 };
 __decorateClass([
-  IsNotEmpty91({ message: "Job ID is required" }),
-  IsNumber18({}, { message: "Job ID must be a number" })
+  IsNotEmpty92({ message: "Job ID is required" }),
+  IsNumber19({}, { message: "Job ID must be a number" })
 ], CreateInterviewBasicInformationDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty91({ message: "Interview name is required" }),
-  IsString64({ message: "Interview name must be a string" })
+  IsNotEmpty92({ message: "Interview name is required" }),
+  IsString65({ message: "Interview name must be a string" })
 ], CreateInterviewBasicInformationDto.prototype, "interviewName", 2);
 
 // src/modules/interview/dto/update-interview-basic-information.dto.ts
-import { IsOptional as IsOptional63, IsString as IsString65, IsNumber as IsNumber19, IsArray as IsArray23, IsDateString as IsDateString8 } from "class-validator";
+import { IsOptional as IsOptional64, IsString as IsString66, IsNumber as IsNumber20, IsArray as IsArray24, IsDateString as IsDateString8 } from "class-validator";
 var UpdateInterviewBasicInformationDto = class {
 };
 __decorateClass([
-  IsOptional63(),
-  IsString65()
+  IsOptional64(),
+  IsString66()
 ], UpdateInterviewBasicInformationDto.prototype, "title", 2);
 __decorateClass([
-  IsOptional63(),
-  IsString65()
+  IsOptional64(),
+  IsString66()
 ], UpdateInterviewBasicInformationDto.prototype, "description", 2);
 __decorateClass([
-  IsOptional63(),
+  IsOptional64(),
   IsDateString8()
 ], UpdateInterviewBasicInformationDto.prototype, "scheduledAt", 2);
 __decorateClass([
-  IsOptional63(),
-  IsNumber19({}, { message: "Duration must be a number" })
+  IsOptional64(),
+  IsNumber20({}, { message: "Duration must be a number" })
 ], UpdateInterviewBasicInformationDto.prototype, "duration", 2);
 __decorateClass([
-  IsOptional63(),
-  IsArray23(),
-  IsNumber19({}, { each: true, message: "Each skill ID must be a number" })
+  IsOptional64(),
+  IsArray24(),
+  IsNumber20({}, { each: true, message: "Each skill ID must be a number" })
 ], UpdateInterviewBasicInformationDto.prototype, "skillIds", 2);
 __decorateClass([
-  IsOptional63(),
-  IsString65()
+  IsOptional64(),
+  IsString66()
 ], UpdateInterviewBasicInformationDto.prototype, "location", 2);
 
 // src/modules/interview/dto/create-interview-skills.dto.ts
 import {
-  IsArray as IsArray24,
-  IsNotEmpty as IsNotEmpty92,
-  IsOptional as IsOptional64,
-  IsString as IsString66,
-  ValidateNested as ValidateNested9
+  IsArray as IsArray25,
+  IsNotEmpty as IsNotEmpty93,
+  IsOptional as IsOptional65,
+  IsString as IsString67,
+  ValidateNested as ValidateNested10
 } from "class-validator";
-import { Type as Type17 } from "class-transformer";
+import { Type as Type18 } from "class-transformer";
 var InterviewSkillItemDto = class {
 };
 __decorateClass([
-  IsOptional64()
+  IsOptional65()
 ], InterviewSkillItemDto.prototype, "uuid", 2);
 __decorateClass([
-  IsString66({ message: "Skill name must be a string." }),
-  IsNotEmpty92({ message: "Skill name is required." })
+  IsString67({ message: "Skill name must be a string." }),
+  IsNotEmpty93({ message: "Skill name is required." })
 ], InterviewSkillItemDto.prototype, "skill", 2);
 __decorateClass([
-  IsOptional64(),
-  IsString66({ message: "Skill description must be a string." })
+  IsOptional65(),
+  IsString67({ message: "Skill description must be a string." })
 ], InterviewSkillItemDto.prototype, "description", 2);
 var CreateInterviewSkillsDto = class {
 };
 __decorateClass([
-  IsArray24({ message: "Skills must be an array." }),
-  IsNotEmpty92({ message: "At least one skill is required." }),
-  ValidateNested9({ each: true }),
-  Type17(() => InterviewSkillItemDto)
+  IsArray25({ message: "Skills must be an array." }),
+  IsNotEmpty93({ message: "At least one skill is required." }),
+  ValidateNested10({ each: true }),
+  Type18(() => InterviewSkillItemDto)
 ], CreateInterviewSkillsDto.prototype, "skills", 2);
 
 // src/modules/interview/dto/create-interview-questions.dto.ts
 import {
-  IsArray as IsArray25,
-  IsNotEmpty as IsNotEmpty93,
-  IsOptional as IsOptional65,
-  IsString as IsString67,
+  IsArray as IsArray26,
+  IsNotEmpty as IsNotEmpty94,
+  IsOptional as IsOptional66,
+  IsString as IsString68,
   IsUUID as IsUUID24,
-  ValidateNested as ValidateNested10
+  ValidateNested as ValidateNested11
 } from "class-validator";
-import { Type as Type18 } from "class-transformer";
+import { Type as Type19 } from "class-transformer";
 var CustomQuestionItemDto = class {
 };
 __decorateClass([
-  IsOptional65(),
+  IsOptional66(),
   IsUUID24("4", { message: "Question UUID must be a valid UUID." })
 ], CustomQuestionItemDto.prototype, "uuid", 2);
 __decorateClass([
-  IsString67({ message: "Question must be a string." }),
-  IsNotEmpty93({ message: "Question is required." })
+  IsString68({ message: "Question must be a string." }),
+  IsNotEmpty94({ message: "Question is required." })
 ], CustomQuestionItemDto.prototype, "question", 2);
 var AiQuestionItemDto = class {
 };
 __decorateClass([
-  IsOptional65(),
+  IsOptional66(),
   IsUUID24("4", { message: "Question UUID must be a valid UUID." })
 ], AiQuestionItemDto.prototype, "uuid", 2);
 __decorateClass([
-  IsString67({ message: "Question must be a string." }),
-  IsNotEmpty93({ message: "Question is required." })
+  IsString68({ message: "Question must be a string." }),
+  IsNotEmpty94({ message: "Question is required." })
 ], AiQuestionItemDto.prototype, "question", 2);
 __decorateClass([
-  IsOptional65(),
-  IsArray25({ message: "Concepts must be an array." }),
-  IsString67({ each: true, message: "Each concept must be a string." })
+  IsOptional66(),
+  IsArray26({ message: "Concepts must be an array." }),
+  IsString68({ each: true, message: "Each concept must be a string." })
 ], AiQuestionItemDto.prototype, "concepts", 2);
 var CreateInterviewQuestionsDto = class {
 };
 __decorateClass([
-  IsOptional65(),
-  IsArray25({ message: "Questions must be an array." }),
-  ValidateNested10({ each: true }),
-  Type18(() => CustomQuestionItemDto)
+  IsOptional66(),
+  IsArray26({ message: "Questions must be an array." }),
+  ValidateNested11({ each: true }),
+  Type19(() => CustomQuestionItemDto)
 ], CreateInterviewQuestionsDto.prototype, "questions", 2);
 __decorateClass([
-  IsOptional65(),
-  IsArray25({ message: "AI questions must be an array." }),
-  ValidateNested10({ each: true }),
-  Type18(() => AiQuestionItemDto)
+  IsOptional66(),
+  IsArray26({ message: "AI questions must be an array." }),
+  ValidateNested11({ each: true }),
+  Type19(() => AiQuestionItemDto)
 ], CreateInterviewQuestionsDto.prototype, "aiQuestions", 2);
 
 // src/modules/interview/dto/update-interview-setting.dto.ts
 import {
   IsBoolean as IsBoolean21,
-  IsOptional as IsOptional66,
-  IsString as IsString68
+  IsOptional as IsOptional67,
+  IsString as IsString69
 } from "class-validator";
-import { Type as Type19 } from "class-transformer";
+import { Type as Type20 } from "class-transformer";
 var UpdateInterviewSettingDto = class {
 };
 __decorateClass([
-  IsOptional66(),
-  IsString68({ message: "Interview language must be a string." })
+  IsOptional67(),
+  IsString69({ message: "Interview language must be a string." })
 ], UpdateInterviewSettingDto.prototype, "interviewLanguage", 2);
 __decorateClass([
-  IsOptional66(),
+  IsOptional67(),
   IsBoolean21({ message: "Allow proctoring must be a boolean." }),
-  Type19(() => Boolean)
+  Type20(() => Boolean)
 ], UpdateInterviewSettingDto.prototype, "allowProctoring", 2);
 __decorateClass([
-  IsOptional66(),
-  IsString68({ message: "Interview duration must be a string." })
+  IsOptional67(),
+  IsString69({ message: "Interview duration must be a string." })
 ], UpdateInterviewSettingDto.prototype, "interviewDuration", 2);
 __decorateClass([
-  IsOptional66(),
-  IsString68({ message: "Interview validity period must be a string." })
+  IsOptional67(),
+  IsString69({ message: "Interview validity period must be a string." })
 ], UpdateInterviewSettingDto.prototype, "interviewValidityPeriod", 2);
 __decorateClass([
-  IsOptional66(),
-  IsString68({ message: "Maximum attempts allowed must be a string." })
+  IsOptional67(),
+  IsString69({ message: "Maximum attempts allowed must be a string." })
 ], UpdateInterviewSettingDto.prototype, "maximumAttemptsAllowed", 2);
 __decorateClass([
-  IsOptional66(),
-  IsString68({ message: "Start interview message must be a string." })
+  IsOptional67(),
+  IsString69({ message: "Start interview message must be a string." })
 ], UpdateInterviewSettingDto.prototype, "startInterviewMessage", 2);
 __decorateClass([
-  IsOptional66(),
-  IsString68({ message: "End interview message must be a string." })
+  IsOptional67(),
+  IsString69({ message: "End interview message must be a string." })
 ], UpdateInterviewSettingDto.prototype, "endInterviewMessage", 2);
 
 // src/modules/interview/dto/update-interview-type-information.dto.ts
-import { IsOptional as IsOptional67, IsString as IsString69 } from "class-validator";
+import { IsOptional as IsOptional68, IsString as IsString70 } from "class-validator";
 var UpdateInterviewTypeInformationDto = class {
 };
 __decorateClass([
-  IsOptional67(),
-  IsString69({ message: "Interview type must be a string." })
+  IsOptional68(),
+  IsString70({ message: "Interview type must be a string." })
 ], UpdateInterviewTypeInformationDto.prototype, "interviewType", 2);
 
 // src/modules/contract/pattern/pattern.ts
@@ -10058,53 +10292,53 @@ var CONTRACT_PATTERN = {
 };
 
 // src/modules/contract/dto/sign-contract-for-client.dto.ts
-import { IsEnum as IsEnum39, IsNotEmpty as IsNotEmpty94, IsNumber as IsNumber20 } from "class-validator";
-import { Type as Type20 } from "class-transformer";
+import { IsEnum as IsEnum40, IsNotEmpty as IsNotEmpty95, IsNumber as IsNumber21 } from "class-validator";
+import { Type as Type21 } from "class-transformer";
 var SignContractForClientDto = class {
 };
 __decorateClass([
-  IsNotEmpty94({ message: "Job Id is required." }),
-  Type20(() => Number),
-  IsNumber20({}, { message: "Job ID must be a number." })
+  IsNotEmpty95({ message: "Job Id is required." }),
+  Type21(() => Number),
+  IsNumber21({}, { message: "Job ID must be a number." })
 ], SignContractForClientDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty94({ message: "Freelancer ID is required." }),
-  Type20(() => Number),
-  IsNumber20({}, { message: "Freelancer ID must be a number." })
+  IsNotEmpty95({ message: "Freelancer ID is required." }),
+  Type21(() => Number),
+  IsNumber21({}, { message: "Freelancer ID must be a number." })
 ], SignContractForClientDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsNotEmpty94({ message: "Contract type is required." }),
-  IsEnum39(ContractTypeEnum)
+  IsNotEmpty95({ message: "Contract type is required." }),
+  IsEnum40(ContractTypeEnum)
 ], SignContractForClientDto.prototype, "contractType", 2);
 
 // src/modules/contract/dto/sign-contract-for-freelancer.dto.ts
-import { IsEnum as IsEnum40, IsNotEmpty as IsNotEmpty95, IsNumber as IsNumber21 } from "class-validator";
-import { Type as Type21 } from "class-transformer";
+import { IsEnum as IsEnum41, IsNotEmpty as IsNotEmpty96, IsNumber as IsNumber22 } from "class-validator";
+import { Type as Type22 } from "class-transformer";
 var SignContractForFreelancerDto = class {
 };
 __decorateClass([
-  IsNotEmpty95({ message: "Job Id is required." }),
-  Type21(() => Number),
-  IsNumber21({}, { message: "Job ID must be a number." })
+  IsNotEmpty96({ message: "Job Id is required." }),
+  Type22(() => Number),
+  IsNumber22({}, { message: "Job ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty95({ message: "Client ID is required." }),
-  Type21(() => Number),
-  IsNumber21({}, { message: "Client ID must be a number." })
+  IsNotEmpty96({ message: "Client ID is required." }),
+  Type22(() => Number),
+  IsNumber22({}, { message: "Client ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "clientId", 2);
 __decorateClass([
-  IsNotEmpty95({ message: "Contract type is required." }),
-  IsEnum40(ContractTypeEnum)
+  IsNotEmpty96({ message: "Contract type is required." }),
+  IsEnum41(ContractTypeEnum)
 ], SignContractForFreelancerDto.prototype, "contractType", 2);
 
 // src/modules/contract/dto/generate-contract.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty96,
-  IsNumber as IsNumber22,
-  IsOptional as IsOptional68,
-  IsString as IsString70,
+  IsNotEmpty as IsNotEmpty97,
+  IsNumber as IsNumber23,
+  IsOptional as IsOptional69,
+  IsString as IsString71,
   IsUUID as IsUUID25,
-  IsEnum as IsEnum41
+  IsEnum as IsEnum42
 } from "class-validator";
 var ContractSourceEnum = /* @__PURE__ */ ((ContractSourceEnum3) => {
   ContractSourceEnum3["AI_INTERVIEW"] = "AI_INTERVIEW";
@@ -10126,73 +10360,73 @@ var PreferredEngagementTypeEnum = /* @__PURE__ */ ((PreferredEngagementTypeEnum3
 var GenerateContractDto = class {
 };
 __decorateClass([
-  IsNumber22({}, { message: "Job ID must be a number." }),
-  IsNotEmpty96({ message: "Job ID is required." })
+  IsNumber23({}, { message: "Job ID must be a number." }),
+  IsNotEmpty97({ message: "Job ID is required." })
 ], GenerateContractDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNumber22({}, { message: "Freelancer ID must be a number." }),
-  IsNotEmpty96({ message: "Freelancer ID is required." })
+  IsNumber23({}, { message: "Freelancer ID must be a number." }),
+  IsNotEmpty97({ message: "Freelancer ID is required." })
 ], GenerateContractDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsOptional68(),
-  IsEnum41(ContractTypeEnumDto, {
+  IsOptional69(),
+  IsEnum42(ContractTypeEnumDto, {
     message: "Contract type must be one of NDA, MSA, SOW, or WORK."
   })
 ], GenerateContractDto.prototype, "contractType", 2);
 __decorateClass([
-  IsOptional68(),
-  IsString70({ message: "Contract start date must be a string." })
+  IsOptional69(),
+  IsString71({ message: "Contract start date must be a string." })
 ], GenerateContractDto.prototype, "contractStartDate", 2);
 __decorateClass([
-  IsOptional68(),
-  IsString70({ message: "Contract invoicing cycle must be a string." })
+  IsOptional69(),
+  IsString71({ message: "Contract invoicing cycle must be a string." })
 ], GenerateContractDto.prototype, "contractInvoicingCycle", 2);
 __decorateClass([
-  IsNotEmpty96({ message: "Preferred engagement type is required" }),
-  IsEnum41(PreferredEngagementTypeEnum, {
+  IsNotEmpty97({ message: "Preferred engagement type is required" }),
+  IsEnum42(PreferredEngagementTypeEnum, {
     message: "Preferred engagement type must be FREELANCE."
   })
 ], GenerateContractDto.prototype, "preferredEngagementType", 2);
 __decorateClass([
-  IsOptional68(),
-  IsEnum41(ContractSourceEnum, {
+  IsOptional69(),
+  IsEnum42(ContractSourceEnum, {
     message: "Source must be one of AI_INTERVIEW, F2F_INTERVIEW, or JOB."
   })
 ], GenerateContractDto.prototype, "source", 2);
 __decorateClass([
-  IsOptional68(),
+  IsOptional69(),
   IsUUID25("4", { message: "Source UUID must be a valid UUID." })
 ], GenerateContractDto.prototype, "sourceUuid", 2);
 
 // src/modules/contract/dto/esign-contract-client.dto.ts
-import { IsNotEmpty as IsNotEmpty97, IsUUID as IsUUID26 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty98, IsUUID as IsUUID26 } from "class-validator";
 var EsignContractClientDto = class {
 };
 __decorateClass([
   IsUUID26("4", { message: "Contract UUID must be a valid UUID." }),
-  IsNotEmpty97({ message: "Contract UUID is required." })
+  IsNotEmpty98({ message: "Contract UUID is required." })
 ], EsignContractClientDto.prototype, "contractUuid", 2);
 
 // src/modules/contract/dto/esign-contract-freelancer.dto.ts
-import { IsNotEmpty as IsNotEmpty98, IsUUID as IsUUID27 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty99, IsUUID as IsUUID27 } from "class-validator";
 var EsignContractFreelancerDto = class {
 };
 __decorateClass([
   IsUUID27("4", { message: "Contract UUID must be a valid UUID." }),
-  IsNotEmpty98({ message: "Contract UUID is required." })
+  IsNotEmpty99({ message: "Contract UUID is required." })
 ], EsignContractFreelancerDto.prototype, "contractUuid", 2);
 
 // src/modules/contract/dto/escrow-fund-contract.dto.ts
-import { IsNotEmpty as IsNotEmpty99, IsUUID as IsUUID28 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty100, IsUUID as IsUUID28 } from "class-validator";
 var EscrowFundContractDto = class {
 };
 __decorateClass([
   IsUUID28("4", { message: "Contract ID must be a valid UUID." }),
-  IsNotEmpty99({ message: "Contract ID is required." })
+  IsNotEmpty100({ message: "Contract ID is required." })
 ], EscrowFundContractDto.prototype, "contractId", 2);
 
 // src/modules/contract/dto/send-nda-contract-to-freelancer.dto.ts
-import { IsNotEmpty as IsNotEmpty100, IsOptional as IsOptional69, IsUUID as IsUUID29, IsEnum as IsEnum42 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty101, IsOptional as IsOptional70, IsUUID as IsUUID29, IsEnum as IsEnum43 } from "class-validator";
 var ContractSourceEnum2 = /* @__PURE__ */ ((ContractSourceEnum3) => {
   ContractSourceEnum3["AI_INTERVIEW"] = "AI_INTERVIEW";
   ContractSourceEnum3["F2F_INTERVIEW"] = "F2F_INTERVIEW";
@@ -10203,26 +10437,26 @@ var SendNdaContractToFreelancerDto = class {
 };
 __decorateClass([
   IsUUID29("4", { message: "Contract UUID must be a valid UUID." }),
-  IsNotEmpty100({ message: "Contract UUID is required." })
+  IsNotEmpty101({ message: "Contract UUID is required." })
 ], SendNdaContractToFreelancerDto.prototype, "contractUuid", 2);
 __decorateClass([
-  IsOptional69(),
-  IsEnum42(ContractSourceEnum2, {
+  IsOptional70(),
+  IsEnum43(ContractSourceEnum2, {
     message: "Source must be one of AI_INTERVIEW, F2F_INTERVIEW, or JOB."
   })
 ], SendNdaContractToFreelancerDto.prototype, "source", 2);
 __decorateClass([
-  IsOptional69(),
+  IsOptional70(),
   IsUUID29("4", { message: "Source UUID must be a valid UUID." })
 ], SendNdaContractToFreelancerDto.prototype, "sourceUuid", 2);
 
 // src/modules/contract/dto/reject-contract.dto.ts
-import { IsOptional as IsOptional70, IsString as IsString72 } from "class-validator";
+import { IsOptional as IsOptional71, IsString as IsString73 } from "class-validator";
 var RejectContractDto = class {
 };
 __decorateClass([
-  IsOptional70(),
-  IsString72({ message: "Reject reason must be a string." })
+  IsOptional71(),
+  IsString73({ message: "Reject reason must be a string." })
 ], RejectContractDto.prototype, "rejectReason", 2);
 
 // src/modules/stripe/pattern/pattern.ts
@@ -10247,55 +10481,55 @@ var STRIPE_PATTERN = {
 
 // src/modules/stripe/dto/create-checkout-session.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty101
+  IsNotEmpty as IsNotEmpty102
 } from "class-validator";
 var CreateCheckoutSessionDto = class {
 };
 __decorateClass([
-  IsNotEmpty101({ message: "Amount is required" })
+  IsNotEmpty102({ message: "Amount is required" })
 ], CreateCheckoutSessionDto.prototype, "amount", 2);
 
 // src/modules/stripe/dto/pre-checkout-calculation.dto.ts
-import { IsNotEmpty as IsNotEmpty102, IsNumber as IsNumber23, IsOptional as IsOptional71, IsString as IsString73 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty103, IsNumber as IsNumber24, IsOptional as IsOptional72, IsString as IsString74 } from "class-validator";
 var PreCheckoutCalculationDto = class {
 };
 __decorateClass([
-  IsNotEmpty102({ message: "Amount is required" }),
-  IsNumber23({}, { message: "Amount must be a number" })
+  IsNotEmpty103({ message: "Amount is required" }),
+  IsNumber24({}, { message: "Amount must be a number" })
 ], PreCheckoutCalculationDto.prototype, "amount", 2);
 __decorateClass([
-  IsOptional71(),
-  IsString73()
+  IsOptional72(),
+  IsString74()
 ], PreCheckoutCalculationDto.prototype, "currency", 2);
 __decorateClass([
-  IsOptional71(),
-  IsString73()
+  IsOptional72(),
+  IsString74()
 ], PreCheckoutCalculationDto.prototype, "description", 2);
 
 // src/modules/stripe/dto/client-add-fund.dto.ts
-import { IsNotEmpty as IsNotEmpty103, IsNumber as IsNumber24, IsOptional as IsOptional72, IsString as IsString74 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty104, IsNumber as IsNumber25, IsOptional as IsOptional73, IsString as IsString75 } from "class-validator";
 var ClientAddFundDto = class {
 };
 __decorateClass([
-  IsNotEmpty103({ message: "Amount is required" }),
-  IsNumber24({}, { message: "Amount must be a number" })
+  IsNotEmpty104({ message: "Amount is required" }),
+  IsNumber25({}, { message: "Amount must be a number" })
 ], ClientAddFundDto.prototype, "amount", 2);
 __decorateClass([
-  IsOptional72(),
-  IsString74()
+  IsOptional73(),
+  IsString75()
 ], ClientAddFundDto.prototype, "currency", 2);
 __decorateClass([
-  IsOptional72(),
-  IsString74()
+  IsOptional73(),
+  IsString75()
 ], ClientAddFundDto.prototype, "description", 2);
 
 // src/modules/stripe/dto/transfer-funds.dto.ts
-import { IsNotEmpty as IsNotEmpty104, IsUUID as IsUUID30 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty105, IsUUID as IsUUID30 } from "class-validator";
 var TransferFundsDto = class {
 };
 __decorateClass([
   IsUUID30("4", { message: "Invoice UUID must be a valid UUID." }),
-  IsNotEmpty104({ message: "Invoice UUID is required." })
+  IsNotEmpty105({ message: "Invoice UUID is required." })
 ], TransferFundsDto.prototype, "invoiceUuid", 2);
 
 // src/modules/timesheet/pattern/pattern.ts
@@ -10342,173 +10576,173 @@ var TIMESHEET_CLIENT_PATTERN = {
 import {
   IsDateString as IsDateString10,
   IsInt as IsInt13,
-  IsNotEmpty as IsNotEmpty105,
-  IsOptional as IsOptional73,
-  IsString as IsString75,
+  IsNotEmpty as IsNotEmpty106,
+  IsOptional as IsOptional74,
+  IsString as IsString76,
   Matches as Matches13,
-  IsNumber as IsNumber25
+  IsNumber as IsNumber26
 } from "class-validator";
 var CreateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty105({ message: "Job id is required" }),
-  IsNumber25({}, { message: "Job id must be a number" })
+  IsNotEmpty106({ message: "Job id is required" }),
+  IsNumber26({}, { message: "Job id must be a number" })
 ], CreateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty105({ message: "start date is required" }),
+  IsNotEmpty106({ message: "start date is required" }),
   IsDateString10()
 ], CreateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  IsNotEmpty105({ message: "end date is required" }),
+  IsNotEmpty106({ message: "end date is required" }),
   IsDateString10()
 ], CreateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  IsNotEmpty105({ message: "start time is required" }),
+  IsNotEmpty106({ message: "start time is required" }),
   Matches13(/^([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([
-  IsNotEmpty105({ message: "end time is required" }),
+  IsNotEmpty106({ message: "end time is required" }),
   Matches13(/^([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([
-  IsOptional73(),
+  IsOptional74(),
   IsInt13()
 ], CreateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  IsOptional73(),
-  IsString75()
+  IsOptional74(),
+  IsString76()
 ], CreateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional73(),
-  IsString75()
+  IsOptional74(),
+  IsString76()
 ], CreateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  IsOptional73(),
-  IsString75()
+  IsOptional74(),
+  IsString76()
 ], CreateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  IsNotEmpty105({ message: "Description is required" })
+  IsNotEmpty106({ message: "Description is required" })
 ], CreateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/timesheet/dto/update-freelancer-timesheet.dto.ts
 import {
   IsDateString as IsDateString11,
   IsInt as IsInt14,
-  IsNotEmpty as IsNotEmpty106,
-  IsOptional as IsOptional74,
-  IsString as IsString76,
+  IsNotEmpty as IsNotEmpty107,
+  IsOptional as IsOptional75,
+  IsString as IsString77,
   Matches as Matches14,
-  IsNumber as IsNumber26
+  IsNumber as IsNumber27
 } from "class-validator";
 var UpdateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty106({ message: "Job id is required" }),
-  IsNumber26({}, { message: "Job id must be a number" })
+  IsNotEmpty107({ message: "Job id is required" }),
+  IsNumber27({}, { message: "Job id must be a number" })
 ], UpdateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty106({ message: "start date is required" }),
+  IsNotEmpty107({ message: "start date is required" }),
   IsDateString11()
 ], UpdateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  IsNotEmpty106({ message: "end date is required" }),
+  IsNotEmpty107({ message: "end date is required" }),
   IsDateString11()
 ], UpdateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  IsNotEmpty106({ message: "start time is required" }),
+  IsNotEmpty107({ message: "start time is required" }),
   Matches14(/^([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([
-  IsNotEmpty106({ message: "end time is required" }),
+  IsNotEmpty107({ message: "end time is required" }),
   Matches14(/^([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([
-  IsOptional74(),
+  IsOptional75(),
   IsInt14()
 ], UpdateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  IsOptional74(),
-  IsString76()
+  IsOptional75(),
+  IsString77()
 ], UpdateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional74(),
-  IsString76()
+  IsOptional75(),
+  IsString77()
 ], UpdateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  IsOptional74(),
-  IsString76()
+  IsOptional75(),
+  IsString77()
 ], UpdateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  IsNotEmpty106({ message: "Description is required" })
+  IsNotEmpty107({ message: "Description is required" })
 ], UpdateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/timesheet/dto/submit-timesheet.dto.ts
-import { IsNotEmpty as IsNotEmpty107, IsNumber as IsNumber27 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty108, IsNumber as IsNumber28 } from "class-validator";
 var SubmitTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty107({ message: "Timesheet line ID is required" }),
-  IsNumber27({}, { message: "Timesheet line ID must be a number" })
+  IsNotEmpty108({ message: "Timesheet line ID is required" }),
+  IsNumber28({}, { message: "Timesheet line ID must be a number" })
 ], SubmitTimesheetDto.prototype, "timesheetLineId", 2);
 
 // src/modules/timesheet/dto/resubmit-timesheet.dto.ts
-import { IsNotEmpty as IsNotEmpty108, IsNumber as IsNumber28 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty109, IsNumber as IsNumber29 } from "class-validator";
 var ResubmitTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty108({ message: "Timesheet line ID is required" }),
-  IsNumber28({}, { message: "Timesheet line ID must be a number" })
+  IsNotEmpty109({ message: "Timesheet line ID is required" }),
+  IsNumber29({}, { message: "Timesheet line ID must be a number" })
 ], ResubmitTimesheetDto.prototype, "timesheetLineId", 2);
 
 // src/modules/timesheet/dto/approve-timesheets.dto.ts
-import { IsNotEmpty as IsNotEmpty109, IsNumber as IsNumber29 } from "class-validator";
-import { Type as Type22 } from "class-transformer";
+import { IsNotEmpty as IsNotEmpty110, IsNumber as IsNumber30 } from "class-validator";
+import { Type as Type23 } from "class-transformer";
 var ApproveTimesheetsDto = class {
 };
 __decorateClass([
-  IsNumber29({}, { message: "Timesheet line ID must be a number." }),
-  IsNotEmpty109({ message: "Timesheet line ID is required." }),
-  Type22(() => Number)
+  IsNumber30({}, { message: "Timesheet line ID must be a number." }),
+  IsNotEmpty110({ message: "Timesheet line ID is required." }),
+  Type23(() => Number)
 ], ApproveTimesheetsDto.prototype, "timesheetLineId", 2);
 
 // src/modules/timesheet/dto/send-back-timesheets.dto.ts
-import { IsNotEmpty as IsNotEmpty110, IsNumber as IsNumber30, IsOptional as IsOptional75, IsString as IsString77 } from "class-validator";
-import { Type as Type23 } from "class-transformer";
+import { IsNotEmpty as IsNotEmpty111, IsNumber as IsNumber31, IsOptional as IsOptional76, IsString as IsString78 } from "class-validator";
+import { Type as Type24 } from "class-transformer";
 var SendBackTimesheetsDto = class {
 };
 __decorateClass([
-  IsNumber30({}, { message: "Timesheet line ID must be a number." }),
-  IsNotEmpty110({ message: "Timesheet line ID is required." }),
-  Type23(() => Number)
+  IsNumber31({}, { message: "Timesheet line ID must be a number." }),
+  IsNotEmpty111({ message: "Timesheet line ID is required." }),
+  Type24(() => Number)
 ], SendBackTimesheetsDto.prototype, "timesheetLineId", 2);
 __decorateClass([
-  IsOptional75(),
-  IsString77({ message: "Client send back reason must be a string." })
+  IsOptional76(),
+  IsString78({ message: "Client send back reason must be a string." })
 ], SendBackTimesheetsDto.prototype, "clientSendBackReason", 2);
 
 // src/modules/timesheet/dto/create-default-timesheet-line.dto.ts
-import { IsNotEmpty as IsNotEmpty111, IsNumber as IsNumber31 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty112, IsNumber as IsNumber32 } from "class-validator";
 var CreateDefaultTimesheetLineDto = class {
 };
 __decorateClass([
-  IsNotEmpty111({ message: "Contract ID is required" }),
-  IsNumber31({}, { message: "Contract ID must be a number" })
+  IsNotEmpty112({ message: "Contract ID is required" }),
+  IsNumber32({}, { message: "Contract ID must be a number" })
 ], CreateDefaultTimesheetLineDto.prototype, "contractId", 2);
 __decorateClass([
-  IsNotEmpty111({ message: "Freelancer ID is required" }),
-  IsNumber31({}, { message: "Freelancer ID must be a number" })
+  IsNotEmpty112({ message: "Freelancer ID is required" }),
+  IsNumber32({}, { message: "Freelancer ID must be a number" })
 ], CreateDefaultTimesheetLineDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsNotEmpty111({ message: "Client ID is required" }),
-  IsNumber31({}, { message: "Client ID must be a number" })
+  IsNotEmpty112({ message: "Client ID is required" }),
+  IsNumber32({}, { message: "Client ID must be a number" })
 ], CreateDefaultTimesheetLineDto.prototype, "clientId", 2);
 
 // src/modules/invoice/pattern/pattern.ts
@@ -10530,23 +10764,23 @@ var INVOICE_PATTERN = {
 };
 
 // src/modules/invoice/dto/update-invoice-status.dto.ts
-import { IsEnum as IsEnum45, IsNotEmpty as IsNotEmpty112 } from "class-validator";
+import { IsEnum as IsEnum46, IsNotEmpty as IsNotEmpty113 } from "class-validator";
 var UpdateInvoiceStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty112({ message: "Please provide invoice status." }),
-  IsEnum45(InvoiceStatusEnum, {
+  IsNotEmpty113({ message: "Please provide invoice status." }),
+  IsEnum46(InvoiceStatusEnum, {
     message: "Status must be one of: APPROVED, REJECTED"
   })
 ], UpdateInvoiceStatusDto.prototype, "status", 2);
 
 // src/modules/invoice/dto/create-invoice.dto.ts
-import { IsNotEmpty as IsNotEmpty113, IsNumber as IsNumber32 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty114, IsNumber as IsNumber33 } from "class-validator";
 var CreateInvoiceDto = class {
 };
 __decorateClass([
-  IsNotEmpty113({ message: "Timesheet line ID is required" }),
-  IsNumber32({}, { message: "Timesheet line ID must be a number" })
+  IsNotEmpty114({ message: "Timesheet line ID is required" }),
+  IsNumber33({}, { message: "Timesheet line ID must be a number" })
 ], CreateInvoiceDto.prototype, "timeSheetLineId", 2);
 
 // src/modules/dispute/pattern/pattern.ts
@@ -10558,49 +10792,49 @@ var DISPUTE_PATTERN = {
 
 // src/modules/dispute/dto/create-dispute.dto.ts
 import {
-  IsString as IsString78,
-  IsNotEmpty as IsNotEmpty114,
+  IsString as IsString79,
+  IsNotEmpty as IsNotEmpty115,
   IsIn as IsIn4,
-  IsOptional as IsOptional76,
-  MaxLength as MaxLength22,
+  IsOptional as IsOptional77,
+  MaxLength as MaxLength23,
   IsObject as IsObject7,
-  IsNumber as IsNumber33,
-  ValidateIf as ValidateIf12
+  IsNumber as IsNumber34,
+  ValidateIf as ValidateIf13
 } from "class-validator";
-import { Transform as Transform7, Type as Type24 } from "class-transformer";
+import { Transform as Transform7, Type as Type25 } from "class-transformer";
 var CreateDisputeDto = class {
 };
 __decorateClass([
-  ValidateIf12((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
-  IsNumber33({}, { message: "Client id must be a number" }),
-  Type24(() => Number)
+  ValidateIf13((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
+  IsNumber34({}, { message: "Client id must be a number" }),
+  Type25(() => Number)
 ], CreateDisputeDto.prototype, "clientId", 2);
 __decorateClass([
-  ValidateIf12((o) => o.initiatorType === "CLIENT" /* CLIENT */),
-  IsNumber33({}, { message: "Freelancer id must be a number" }),
-  Type24(() => Number)
+  ValidateIf13((o) => o.initiatorType === "CLIENT" /* CLIENT */),
+  IsNumber34({}, { message: "Freelancer id must be a number" }),
+  Type25(() => Number)
 ], CreateDisputeDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsNotEmpty114({ message: "Please select dispute type." }),
-  IsString78(),
+  IsNotEmpty115({ message: "Please select dispute type." }),
+  IsString79(),
   IsIn4(["JOB", "INVOICE"])
 ], CreateDisputeDto.prototype, "disputeType", 2);
 __decorateClass([
-  IsNotEmpty114({ message: "Please provide initiator type." }),
-  IsString78()
+  IsNotEmpty115({ message: "Please provide initiator type." }),
+  IsString79()
 ], CreateDisputeDto.prototype, "initiatorType", 2);
 __decorateClass([
-  IsNotEmpty114({ message: "Please enter description." }),
-  IsString78({ message: "Description must be a string" }),
-  MaxLength22(500, { message: "Description must not exceed 500 characters" })
+  IsNotEmpty115({ message: "Please enter description." }),
+  IsString79({ message: "Description must be a string" }),
+  MaxLength23(500, { message: "Description must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "description", 2);
 __decorateClass([
-  IsOptional76(),
-  IsString78({ message: "Comment must be a string" }),
-  MaxLength22(500, { message: "Comment must not exceed 500 characters" })
+  IsOptional77(),
+  IsString79({ message: "Comment must be a string" }),
+  MaxLength23(500, { message: "Comment must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "comment", 2);
 __decorateClass([
-  IsOptional76(),
+  IsOptional77(),
   IsObject7({ message: "Dynamic fields must be a valid object" }),
   Transform7(({ value }) => {
     if (typeof value === "string") {
@@ -10623,126 +10857,126 @@ var SENSELOAF_PATTERN = {
 
 // src/modules/senseloaf/dto/ai-interview-question-generate.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty115
+  IsNotEmpty as IsNotEmpty116
 } from "class-validator";
 var AiInterviewQuestionGenerateDto = class {
 };
 __decorateClass([
-  IsNotEmpty115({ message: "Please enter job description." })
+  IsNotEmpty116({ message: "Please enter job description." })
 ], AiInterviewQuestionGenerateDto.prototype, "jobDescription", 2);
 __decorateClass([
-  IsNotEmpty115({ message: "Please enter number of questions." })
+  IsNotEmpty116({ message: "Please enter number of questions." })
 ], AiInterviewQuestionGenerateDto.prototype, "numQuestions", 2);
 
 // src/modules/senseloaf/dto/resume-parsing-by-url.dto.ts
-import { IsNotEmpty as IsNotEmpty116, IsString as IsString79, IsOptional as IsOptional77 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty117, IsString as IsString80, IsOptional as IsOptional78 } from "class-validator";
 var ResumeParsingByUrlDto = class {
 };
 __decorateClass([
-  IsNotEmpty116({ message: "Resume URL is required" }),
-  IsString79({ message: "Resume URL must be a string" })
+  IsNotEmpty117({ message: "Resume URL is required" }),
+  IsString80({ message: "Resume URL must be a string" })
 ], ResumeParsingByUrlDto.prototype, "resumeUrl", 2);
 __decorateClass([
-  IsOptional77(),
-  IsString79()
+  IsOptional78(),
+  IsString80()
 ], ResumeParsingByUrlDto.prototype, "fileName", 2);
 
 // src/modules/senseloaf/dto/resume-data-processing.dto.ts
-import { IsNotEmpty as IsNotEmpty117, IsString as IsString80, IsOptional as IsOptional78, IsObject as IsObject8 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty118, IsString as IsString81, IsOptional as IsOptional79, IsObject as IsObject8 } from "class-validator";
 var ResumeDataProcessingDto = class {
 };
 __decorateClass([
-  IsNotEmpty117({ message: "Resume data is required" }),
+  IsNotEmpty118({ message: "Resume data is required" }),
   IsObject8()
 ], ResumeDataProcessingDto.prototype, "resumeData", 2);
 __decorateClass([
-  IsOptional78(),
-  IsString80()
+  IsOptional79(),
+  IsString81()
 ], ResumeDataProcessingDto.prototype, "userId", 2);
 __decorateClass([
-  IsOptional78(),
-  IsString80()
+  IsOptional79(),
+  IsString81()
 ], ResumeDataProcessingDto.prototype, "processingType", 2);
 
 // src/modules/senseloaf/dto/check-resume-eligibility.dto.ts
-import { IsNotEmpty as IsNotEmpty118, IsString as IsString81, IsOptional as IsOptional79, IsObject as IsObject9 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty119, IsString as IsString82, IsOptional as IsOptional80, IsObject as IsObject9 } from "class-validator";
 var CheckResumeEligibilityDto = class {
 };
 __decorateClass([
-  IsNotEmpty118({ message: "Resume data is required" }),
+  IsNotEmpty119({ message: "Resume data is required" }),
   IsObject9()
 ], CheckResumeEligibilityDto.prototype, "resumeData", 2);
 __decorateClass([
-  IsOptional79(),
-  IsString81()
+  IsOptional80(),
+  IsString82()
 ], CheckResumeEligibilityDto.prototype, "jobId", 2);
 __decorateClass([
-  IsOptional79(),
-  IsString81()
+  IsOptional80(),
+  IsString82()
 ], CheckResumeEligibilityDto.prototype, "userId", 2);
 
 // src/modules/senseloaf/dto/ai-interview-template-generation.dto.ts
-import { IsNotEmpty as IsNotEmpty119, IsString as IsString82, IsOptional as IsOptional80, IsArray as IsArray26, IsNumber as IsNumber34 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty120, IsString as IsString83, IsOptional as IsOptional81, IsArray as IsArray27, IsNumber as IsNumber35 } from "class-validator";
 var AiInterviewTemplateGenerationDto = class {
 };
 __decorateClass([
-  IsNotEmpty119({ message: "Job ID is required" }),
-  IsString82({ message: "Job ID must be a string" })
+  IsNotEmpty120({ message: "Job ID is required" }),
+  IsString83({ message: "Job ID must be a string" })
 ], AiInterviewTemplateGenerationDto.prototype, "jobId", 2);
 __decorateClass([
-  IsOptional80(),
-  IsArray26(),
-  IsString82({ each: true, message: "Each skill must be a string" })
+  IsOptional81(),
+  IsArray27(),
+  IsString83({ each: true, message: "Each skill must be a string" })
 ], AiInterviewTemplateGenerationDto.prototype, "skills", 2);
 __decorateClass([
-  IsOptional80(),
-  IsNumber34({}, { message: "Number of questions must be a number" })
+  IsOptional81(),
+  IsNumber35({}, { message: "Number of questions must be a number" })
 ], AiInterviewTemplateGenerationDto.prototype, "numberOfQuestions", 2);
 __decorateClass([
-  IsOptional80(),
-  IsString82()
+  IsOptional81(),
+  IsString83()
 ], AiInterviewTemplateGenerationDto.prototype, "difficulty", 2);
 
 // src/modules/senseloaf/dto/ai-interview-link-generation.dto.ts
-import { IsNotEmpty as IsNotEmpty120, IsString as IsString83, IsOptional as IsOptional81, IsNumber as IsNumber35 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty121, IsString as IsString84, IsOptional as IsOptional82, IsNumber as IsNumber36 } from "class-validator";
 var AiInterviewLinkGenerationDto = class {
 };
 __decorateClass([
-  IsNotEmpty120({ message: "Template ID is required" }),
-  IsString83({ message: "Template ID must be a string" })
+  IsNotEmpty121({ message: "Template ID is required" }),
+  IsString84({ message: "Template ID must be a string" })
 ], AiInterviewLinkGenerationDto.prototype, "templateId", 2);
 __decorateClass([
-  IsNotEmpty120({ message: "Freelancer ID is required" }),
-  IsString83({ message: "Freelancer ID must be a string" })
+  IsNotEmpty121({ message: "Freelancer ID is required" }),
+  IsString84({ message: "Freelancer ID must be a string" })
 ], AiInterviewLinkGenerationDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsOptional81(),
-  IsString83()
+  IsOptional82(),
+  IsString84()
 ], AiInterviewLinkGenerationDto.prototype, "jobId", 2);
 __decorateClass([
-  IsOptional81(),
-  IsNumber35({}, { message: "Expiry hours must be a number" })
+  IsOptional82(),
+  IsNumber36({}, { message: "Expiry hours must be a number" })
 ], AiInterviewLinkGenerationDto.prototype, "expiryHours", 2);
 
 // src/modules/senseloaf/dto/ai-assessment-creation.dto.ts
-import { IsNotEmpty as IsNotEmpty121, IsString as IsString84, IsOptional as IsOptional82, IsNumber as IsNumber36 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty122, IsString as IsString85, IsOptional as IsOptional83, IsNumber as IsNumber37 } from "class-validator";
 var AiAssessmentCreationDto = class {
 };
 __decorateClass([
-  IsNotEmpty121({ message: "User ID is required" }),
-  IsString84({ message: "User ID must be a string" })
+  IsNotEmpty122({ message: "User ID is required" }),
+  IsString85({ message: "User ID must be a string" })
 ], AiAssessmentCreationDto.prototype, "userId", 2);
 __decorateClass([
-  IsOptional82(),
-  IsString84()
+  IsOptional83(),
+  IsString85()
 ], AiAssessmentCreationDto.prototype, "assessmentType", 2);
 __decorateClass([
-  IsOptional82(),
-  IsNumber36({}, { message: "Number of questions must be a number" })
+  IsOptional83(),
+  IsNumber37({}, { message: "Number of questions must be a number" })
 ], AiAssessmentCreationDto.prototype, "numberOfQuestions", 2);
 __decorateClass([
-  IsOptional82(),
-  IsString84()
+  IsOptional83(),
+  IsString85()
 ], AiAssessmentCreationDto.prototype, "difficulty", 2);
 
 // src/modules/commission/pattern/pattern.ts
@@ -10758,7 +10992,7 @@ var HIRING_PATTERN = {
 };
 
 // src/modules/hiring/dto/create-hiring.dto.ts
-import { IsEnum as IsEnum46, IsNotEmpty as IsNotEmpty122, IsNumber as IsNumber37 } from "class-validator";
+import { IsEnum as IsEnum47, IsNotEmpty as IsNotEmpty123, IsNumber as IsNumber38 } from "class-validator";
 var PreferredEngagementTypeEnum2 = /* @__PURE__ */ ((PreferredEngagementTypeEnum3) => {
   PreferredEngagementTypeEnum3["FTE"] = "FTE";
   PreferredEngagementTypeEnum3["FREELANCE"] = "FREELANCE";
@@ -10767,16 +11001,16 @@ var PreferredEngagementTypeEnum2 = /* @__PURE__ */ ((PreferredEngagementTypeEnum
 var CreateHiringDto = class {
 };
 __decorateClass([
-  IsNotEmpty122({ message: "Freelancer ID is required" }),
-  IsNumber37({}, { message: "Freelancer ID must be a number" })
+  IsNotEmpty123({ message: "Freelancer ID is required" }),
+  IsNumber38({}, { message: "Freelancer ID must be a number" })
 ], CreateHiringDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsNotEmpty122({ message: "Job ID is required" }),
-  IsNumber37({}, { message: "Job ID must be a number" })
+  IsNotEmpty123({ message: "Job ID is required" }),
+  IsNumber38({}, { message: "Job ID must be a number" })
 ], CreateHiringDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty122({ message: "Preferred engagement type is required" }),
-  IsEnum46(PreferredEngagementTypeEnum2, {
+  IsNotEmpty123({ message: "Preferred engagement type is required" }),
+  IsEnum47(PreferredEngagementTypeEnum2, {
     message: "Preferred engagement type must be one of FTE or FREELANCE."
   })
 ], CreateHiringDto.prototype, "preferredEngagementType", 2);
@@ -10799,16 +11033,16 @@ var SIGNATURE_PATTERN = {
 };
 
 // src/modules/user/signature/dto/save-signature.dto.ts
-import { IsOptional as IsOptional83, IsString as IsString85 } from "class-validator";
+import { IsOptional as IsOptional84, IsString as IsString86 } from "class-validator";
 var SaveSignatureDto = class {
 };
 __decorateClass([
-  IsOptional83(),
-  IsString85()
+  IsOptional84(),
+  IsString86()
 ], SaveSignatureDto.prototype, "signatureType", 2);
 __decorateClass([
-  IsOptional83(),
-  IsString85()
+  IsOptional84(),
+  IsString86()
 ], SaveSignatureDto.prototype, "description", 2);
 
 // src/modules/wallet/pattern/pattern.ts
@@ -10826,25 +11060,25 @@ var WALLET_ADMIN_PATTERN = {
 };
 
 // src/modules/wallet/dto/add-topup-escrow-amount.dto.ts
-import { IsNotEmpty as IsNotEmpty123, IsNumber as IsNumber38, IsUUID as IsUUID31 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty124, IsNumber as IsNumber39, IsUUID as IsUUID31 } from "class-validator";
 var AddTopupEscrowAmountDto = class {
 };
 __decorateClass([
-  IsNotEmpty123({ message: "Amount is required" }),
-  IsNumber38({}, { message: "Amount must be a number" })
+  IsNotEmpty124({ message: "Amount is required" }),
+  IsNumber39({}, { message: "Amount must be a number" })
 ], AddTopupEscrowAmountDto.prototype, "amount", 2);
 __decorateClass([
-  IsNotEmpty123({ message: "Escrow wallet UUID is required" }),
+  IsNotEmpty124({ message: "Escrow wallet UUID is required" }),
   IsUUID31("4", { message: "Escrow wallet UUID must be a valid UUID" })
 ], AddTopupEscrowAmountDto.prototype, "escrowWalletUuid", 2);
 
 // src/modules/wallet/dto/debit-commission-fte-hiring.dto.ts
-import { IsNotEmpty as IsNotEmpty124, IsUUID as IsUUID32 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty125, IsUUID as IsUUID32 } from "class-validator";
 var DebitCommissionFteHiringDto = class {
 };
 __decorateClass([
   IsUUID32("4", { message: "Invoice UUID must be a valid UUID." }),
-  IsNotEmpty124({ message: "Invoice UUID is required." })
+  IsNotEmpty125({ message: "Invoice UUID is required." })
 ], DebitCommissionFteHiringDto.prototype, "invoiceUuid", 2);
 
 // src/modules/discord/discord-alert.interface.ts
@@ -13097,6 +13331,7 @@ export {
   CreateInterviewSkillsDto,
   CreateInvoiceDto,
   CreateJobApplicationDto,
+  CreateJobViaAIDto,
   CreateLeadDto,
   CreateQuestionDto,
   CreateRatingDto,
@@ -13209,7 +13444,7 @@ export {
   JobIdParamDto,
   JobLocation,
   JobLocationAdminDto,
-  JobLocationDto,
+  JobLocationDto2 as JobLocationDto,
   JobLocationEnum,
   JobRMQAdapter,
   JobRecommendation,