@experts_hub/shared 1.0.567 → 1.0.569

package/dist/index.js

@@ -51,6 +51,7 @@ __export(index_exports, {
   AiInterviewStatusEnum: () => AiInterviewStatusEnum,
   AnswerTypeEnum: () => AnswerTypeEnum,
   ApplicationStatusEnum: () => ApplicationStatusEnum,
+  ApproveTimesheetsDto: () => ApproveTimesheetsDto,
   AssessmentAnswer: () => AssessmentAnswer,
   AssessmentRequestStatusEnum: () => AssessmentRequestStatusEnum,
   AssessmentStatusEnum: () => AssessmentStatusEnum,
@@ -79,6 +80,8 @@ __export(index_exports, {
   CaseStudyDto: () => CaseStudyDto,
   CategoryEmum: () => CategoryEmum,
   CategoryEmumDto: () => CategoryEmumDto,
+  ChangeJobApplicationStatusBulkDto: () => ChangeJobApplicationStatusBulkDto,
+  ChangeJobApplicationStatusDto: () => ChangeJobApplicationStatusDto,
   ChatRMQAdapter: () => ChatRMQAdapter,
   ChatTCPAdapter: () => ChatTCPAdapter,
   City: () => City,
@@ -88,6 +91,7 @@ __export(index_exports, {
   ClientCreateAccountDto: () => ClientCreateAccountDto,
   ClientFreelancerRecommendation: () => ClientFreelancerRecommendation,
   ClientProfileQuestionDto: () => ClientProfileQuestionDto,
+  CloseJobDto: () => CloseJobDto,
   Cms: () => Cms,
   Commission: () => Commission,
   CommissionTypeEnum: () => CommissionTypeEnum,
@@ -118,6 +122,9 @@ __export(index_exports, {
   CreateF2FInterviewRescheduleRequestDto: () => CreateF2FInterviewRescheduleRequestDto,
   CreateFreelancerDto: () => CreateFreelancerDto,
   CreateFreelancerTimesheetDto: () => CreateFreelancerTimesheetDto,
+  CreateHiringDto: () => CreateHiringDto,
+  CreateInvoiceDto: () => CreateInvoiceDto,
+  CreateJobApplicationDto: () => CreateJobApplicationDto,
   CreateLeadDto: () => CreateLeadDto,
   CreateQuestionDto: () => CreateQuestionDto,
   CreateRatingDto: () => CreateRatingDto,
@@ -209,6 +216,7 @@ __export(index_exports, {
   Job: () => Job,
   JobAdditionalCommentDto: () => JobAdditionalCommentDto,
   JobApplication: () => JobApplication,
+  JobApplicationStatus: () => JobApplicationStatus,
   JobBasicInformationDto: () => JobBasicInformationDto,
   JobBasicInformationV2Dto: () => JobBasicInformationV2Dto,
   JobDescriptionDto: () => JobDescriptionDto,
@@ -273,6 +281,7 @@ __export(index_exports, {
   RejectAIInterviewRescheduleRequestDto: () => RejectAIInterviewRescheduleRequestDto,
   ResetPasswordDto: () => ResetPasswordDto,
   ResetPasswordTokenValidationDto: () => ResetPasswordTokenValidationDto,
+  ResubmitTimesheetDto: () => ResubmitTimesheetDto,
   ResultStatusEnum: () => ResultStatusEnum,
   SENSELOAF_PATTERN: () => SENSELOAF_PATTERN,
   SIGNATURE_PATTERN: () => SIGNATURE_PATTERN,
@@ -284,6 +293,7 @@ __export(index_exports, {
   SYSTEM_PREFERENCES_PATTERN: () => SYSTEM_PREFERENCES_PATTERN,
   ScopeEnum: () => ScopeEnum,
   SelectedAnswerTypeEnum: () => SelectedAnswerTypeEnum,
+  SendBackTimesheetsDto: () => SendBackTimesheetsDto,
   SendGuestOtpDto: () => SendGuestOtpDto,
   SendGuestOtpPurposeEnum: () => SendGuestOtpPurposeEnum,
   SendGuestOtpScopeEnum: () => SendGuestOtpScopeEnum,
@@ -305,6 +315,7 @@ __export(index_exports, {
   StripeTransaction: () => StripeTransaction,
   StripeTransactionStatusEnum: () => StripeTransactionStatusEnum,
   StripeTransactionTypeEnum: () => StripeTransactionTypeEnum,
+  SubmitTimesheetDto: () => SubmitTimesheetDto,
   SystemPreference: () => SystemPreference,
   SystemPreferenceDto: () => SystemPreferenceDto,
   SystemPreferenceKey: () => SystemPreferenceKey,
@@ -1761,6 +1772,63 @@ __decorateClass([
   (0, import_class_validator38.MaxLength)(500, { message: "Additional comment must not exceed 500 characters" })
 ], JobBasicInformationV2Dto.prototype, "additionalComment", 2);
 
+// src/modules/job/dto/close-job.dto.ts
+var import_class_validator39 = require("class-validator");
+var CloseJobDto = class {
+};
+__decorateClass([
+  (0, import_class_validator39.IsOptional)(),
+  (0, import_class_validator39.IsString)()
+], CloseJobDto.prototype, "reason", 2);
+
+// src/modules/job/dto/create-job-application.dto.ts
+var import_class_validator40 = require("class-validator");
+var CreateJobApplicationDto = class {
+};
+__decorateClass([
+  (0, import_class_validator40.IsNotEmpty)({ message: "Job ID is required" }),
+  (0, import_class_validator40.IsNumber)({}, { message: "Job ID must be a number" })
+], CreateJobApplicationDto.prototype, "jobId", 2);
+__decorateClass([
+  (0, import_class_validator40.IsOptional)(),
+  (0, import_class_validator40.IsBoolean)({ message: "isCta must be a boolean" })
+], CreateJobApplicationDto.prototype, "isCta", 2);
+
+// src/modules/job/dto/change-job-application-status.dto.ts
+var import_class_validator41 = require("class-validator");
+var JobApplicationStatus = /* @__PURE__ */ ((JobApplicationStatus2) => {
+  JobApplicationStatus2["PENDING"] = "PENDING";
+  JobApplicationStatus2["SHORTLISTED"] = "SHORTLISTED";
+  JobApplicationStatus2["REJECTED"] = "REJECTED";
+  JobApplicationStatus2["HIRED"] = "HIRED";
+  JobApplicationStatus2["WITHDRAWN"] = "WITHDRAWN";
+  return JobApplicationStatus2;
+})(JobApplicationStatus || {});
+var ChangeJobApplicationStatusDto = class {
+};
+__decorateClass([
+  (0, import_class_validator41.IsNotEmpty)({ message: "Status is required" }),
+  (0, import_class_validator41.IsEnum)(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
+var import_class_validator42 = require("class-validator");
+var ChangeJobApplicationStatusBulkDto = class {
+};
+__decorateClass([
+  (0, import_class_validator42.IsArray)({ message: "Job application IDs must be an array" }),
+  (0, import_class_validator42.ArrayNotEmpty)({ message: "At least one job application ID is required" }),
+  (0, import_class_validator42.IsNumber)({}, { each: true, message: "Each job application ID must be a number" })
+], ChangeJobApplicationStatusBulkDto.prototype, "jobApplicationIds", 2);
+__decorateClass([
+  (0, import_class_validator42.IsNotEmpty)({ message: "Status is required" }),
+  (0, import_class_validator42.IsEnum)(JobApplicationStatus, {
+    message: `Status must be one of: ${Object.values(JobApplicationStatus).join(", ")}`
+  })
+], ChangeJobApplicationStatusBulkDto.prototype, "status", 2);
+
 // src/modules/user/freelancer-profile/pattern/pattern.ts
 var PROFILE_PATTERN = {
   fetchFreelancerProfile: "fetch.freelancer.profile",
@@ -1803,25 +1871,25 @@ var FREELANCER_ASSESSMENT_REQUEST_PATTERN = {
 };
 
 // src/modules/user/freelancer-profile/dto/freelancer-change-password.dto.ts
-var import_class_validator39 = require("class-validator");
+var import_class_validator43 = require("class-validator");
 var FreelancerChangePasswordDto = class {
 };
 __decorateClass([
-  (0, import_class_validator39.IsNotEmpty)({ message: "Please enter Old Password." }),
-  (0, import_class_validator39.IsString)()
+  (0, import_class_validator43.IsNotEmpty)({ message: "Please enter Old Password." }),
+  (0, import_class_validator43.IsString)()
 ], FreelancerChangePasswordDto.prototype, "oldPassword", 2);
 __decorateClass([
-  (0, import_class_validator39.IsNotEmpty)({ message: "Please enter New Password." }),
-  (0, import_class_validator39.IsString)(),
-  (0, import_class_validator39.MinLength)(6),
-  (0, import_class_validator39.MaxLength)(32),
-  (0, import_class_validator39.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
+  (0, import_class_validator43.IsNotEmpty)({ message: "Please enter New Password." }),
+  (0, import_class_validator43.IsString)(),
+  (0, import_class_validator43.MinLength)(6),
+  (0, import_class_validator43.MaxLength)(32),
+  (0, import_class_validator43.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "New Password must include letters, numbers and symbols."
   })
 ], FreelancerChangePasswordDto.prototype, "newPassword", 2);
 
 // src/modules/user/freelancer-profile/dto/update-freelancer-profile.dto.ts
-var import_class_validator40 = require("class-validator");
+var import_class_validator44 = require("class-validator");
 var NatureOfWorkDto = /* @__PURE__ */ ((NatureOfWorkDto3) => {
   NatureOfWorkDto3["FREELANCE"] = "FREELANCE";
   NatureOfWorkDto3["FTE"] = "FTE";
@@ -1837,114 +1905,114 @@ var ModeOfWorkDto = /* @__PURE__ */ ((ModeOfWorkDto2) => {
 var UpdateFreelancerProfileDto = class {
 };
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter first name." }),
-  (0, import_class_validator40.IsString)({ message: "Please enter valid first name." })
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter first name." }),
+  (0, import_class_validator44.IsString)({ message: "Please enter valid first name." })
 ], UpdateFreelancerProfileDto.prototype, "firstName", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter last name." }),
-  (0, import_class_validator40.IsString)({ message: "Please enter valid last name." })
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter last name." }),
+  (0, import_class_validator44.IsString)({ message: "Please enter valid last name." })
 ], UpdateFreelancerProfileDto.prototype, "lastName", 2);
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter designation." }),
-  (0, import_class_validator40.IsString)({ message: "Please enter valid designation." })
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter designation." }),
+  (0, import_class_validator44.IsString)({ message: "Please enter valid designation." })
 ], UpdateFreelancerProfileDto.prototype, "designation", 2);
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter experience." }),
-  (0, import_class_validator40.IsString)({ message: "Please enter valid experience." })
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter experience." }),
+  (0, import_class_validator44.IsString)({ message: "Please enter valid experience." })
 ], UpdateFreelancerProfileDto.prototype, "experience", 2);
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter email id." }),
-  (0, import_class_validator40.IsEmail)()
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter email id." }),
+  (0, import_class_validator44.IsEmail)()
 ], UpdateFreelancerProfileDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter mobile code." }),
-  (0, import_class_validator40.IsString)({ message: "Please enter valid mobile code." })
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter mobile code." }),
+  (0, import_class_validator44.IsString)({ message: "Please enter valid mobile code." })
 ], UpdateFreelancerProfileDto.prototype, "mobileCode", 2);
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter mobile number." }),
-  (0, import_class_validator40.IsString)({ message: "Please enter valid mobile number." })
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter mobile number." }),
+  (0, import_class_validator44.IsString)({ message: "Please enter valid mobile number." })
 ], UpdateFreelancerProfileDto.prototype, "mobile", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsNumber)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsNumber)()
 ], UpdateFreelancerProfileDto.prototype, "countryId", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsNumber)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsNumber)()
 ], UpdateFreelancerProfileDto.prototype, "stateId", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsNumber)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsNumber)()
 ], UpdateFreelancerProfileDto.prototype, "cityId", 2);
 //@IsString({ message: "Please enter valid expected hourly compensation." })
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter expected hourly compensation." })
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter expected hourly compensation." })
 ], UpdateFreelancerProfileDto.prototype, "expectedHourlyCompensation", 2);
 __decorateClass([
-  (0, import_class_validator40.ValidateIf)((dto) => dto.NatureOfWorkDto === "BOTH" /* BOTH */),
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter expected annual compensation." })
+  (0, import_class_validator44.ValidateIf)((dto) => dto.NatureOfWorkDto === "BOTH" /* BOTH */),
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter expected annual compensation." })
 ], UpdateFreelancerProfileDto.prototype, "expectedAnnualCompensation", 2);
 __decorateClass([
-  (0, import_class_validator40.ValidateIf)((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
-  (0, import_class_validator40.IsInt)({ message: "Please enter valid weekly availability hours (integer)." }),
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter weekly availability hours" })
+  (0, import_class_validator44.ValidateIf)((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
+  (0, import_class_validator44.IsInt)({ message: "Please enter valid weekly availability hours (integer)." }),
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter weekly availability hours" })
 ], UpdateFreelancerProfileDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please select engagement type." }),
-  (0, import_class_validator40.IsEnum)(NatureOfWorkDto, {
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please select engagement type." }),
+  (0, import_class_validator44.IsEnum)(NatureOfWorkDto, {
     message: `Engagement Type must be one of: ${Object.values(
       NatureOfWorkDto
     ).join(", ")}`
   })
 ], UpdateFreelancerProfileDto.prototype, "natureOfWork", 2);
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please select mode of work." }),
-  (0, import_class_validator40.IsEnum)(ModeOfWorkDto, {
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please select mode of work." }),
+  (0, import_class_validator44.IsEnum)(ModeOfWorkDto, {
     message: `Mode of work must be one of: ${Object.values(ModeOfWorkDto).join(
       ", "
     )}`
   })
 ], UpdateFreelancerProfileDto.prototype, "modeOfWork", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "portfolioLink", 2);
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter address." }),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter address." }),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "address", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "addressLine", 2);
 __decorateClass([
-  (0, import_class_validator40.IsNotEmpty)({ message: "Please enter postalCode." }),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter postalCode." }),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "postalCode", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "about", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator40.IsOptional)(),
-  (0, import_class_validator40.IsString)()
+  (0, import_class_validator44.IsOptional)(),
+  (0, import_class_validator44.IsString)()
 ], UpdateFreelancerProfileDto.prototype, "resumeUrl", 2);
 
 // src/modules/bank/pattern/pattern.ts
@@ -1958,7 +2026,7 @@ var BANK_PATTERN = {
 };
 
 // src/modules/bank/dto/freelancer-bank-details.dto.ts
-var import_class_validator41 = require("class-validator");
+var import_class_validator45 = require("class-validator");
 var BankAccountScope = /* @__PURE__ */ ((BankAccountScope2) => {
   BankAccountScope2["DOMESTIC"] = "DOMESTIC";
   BankAccountScope2["INTERNATIONAL"] = "INTERNATIONAL";
@@ -1967,51 +2035,51 @@ var BankAccountScope = /* @__PURE__ */ ((BankAccountScope2) => {
 var FreelancerBankDetailsDto = class {
 };
 __decorateClass([
-  (0, import_class_validator41.IsNotEmpty)({ message: "Please enter Account Holder Name." })
+  (0, import_class_validator45.IsNotEmpty)({ message: "Please enter Account Holder Name." })
 ], FreelancerBankDetailsDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator41.IsNotEmpty)({ message: "Please enter Mobile Code." })
+  (0, import_class_validator45.IsNotEmpty)({ message: "Please enter Mobile Code." })
 ], FreelancerBankDetailsDto.prototype, "mobileCode", 2);
 __decorateClass([
-  (0, import_class_validator41.IsNotEmpty)({ message: "Please enter Mobile Number." })
+  (0, import_class_validator45.IsNotEmpty)({ message: "Please enter Mobile Number." })
 ], FreelancerBankDetailsDto.prototype, "mobile", 2);
 __decorateClass([
-  (0, import_class_validator41.IsNotEmpty)({ message: "Please enter Email." })
+  (0, import_class_validator45.IsNotEmpty)({ message: "Please enter Email." })
 ], FreelancerBankDetailsDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator41.IsOptional)()
+  (0, import_class_validator45.IsOptional)()
 ], FreelancerBankDetailsDto.prototype, "address", 2);
 __decorateClass([
-  (0, import_class_validator41.IsNotEmpty)({ message: "Please enter Account Number." })
+  (0, import_class_validator45.IsNotEmpty)({ message: "Please enter Account Number." })
 ], FreelancerBankDetailsDto.prototype, "accountNumber", 2);
 __decorateClass([
-  (0, import_class_validator41.IsNotEmpty)({ message: "Please enter Bank Name." })
+  (0, import_class_validator45.IsNotEmpty)({ message: "Please enter Bank Name." })
 ], FreelancerBankDetailsDto.prototype, "bankName", 2);
 __decorateClass([
-  (0, import_class_validator41.IsOptional)(),
-  (0, import_class_validator41.IsString)()
+  (0, import_class_validator45.IsOptional)(),
+  (0, import_class_validator45.IsString)()
 ], FreelancerBankDetailsDto.prototype, "branchName", 2);
 __decorateClass([
-  (0, import_class_validator41.ValidateIf)((dto) => dto.accountScope === "DOMESTIC"),
-  (0, import_class_validator41.IsNotEmpty)({ message: "IFSC Code is required for DOMESTIC accounts." })
+  (0, import_class_validator45.ValidateIf)((dto) => dto.accountScope === "DOMESTIC"),
+  (0, import_class_validator45.IsNotEmpty)({ message: "IFSC Code is required for DOMESTIC accounts." })
 ], FreelancerBankDetailsDto.prototype, "ifscCode", 2);
 __decorateClass([
-  (0, import_class_validator41.ValidateIf)((dto) => dto.accountScope === "INTERNATIONAL"),
-  (0, import_class_validator41.IsNotEmpty)({ message: "Routing Number/Sort Code is required for INTERNATIONAL accounts." })
+  (0, import_class_validator45.ValidateIf)((dto) => dto.accountScope === "INTERNATIONAL"),
+  (0, import_class_validator45.IsNotEmpty)({ message: "Routing Number/Sort Code is required for INTERNATIONAL accounts." })
 ], FreelancerBankDetailsDto.prototype, "routingNo", 2);
 __decorateClass([
-  (0, import_class_validator41.ValidateIf)((dto) => dto.accountScope === "INTERNATIONAL"),
-  (0, import_class_validator41.IsNotEmpty)({ message: "ABA Number is required for INTERNATIONAL accounts." })
+  (0, import_class_validator45.ValidateIf)((dto) => dto.accountScope === "INTERNATIONAL"),
+  (0, import_class_validator45.IsNotEmpty)({ message: "ABA Number is required for INTERNATIONAL accounts." })
 ], FreelancerBankDetailsDto.prototype, "abaNumber", 2);
 __decorateClass([
-  (0, import_class_validator41.ValidateIf)((dto) => dto.accountScope === "INTERNATIONAL"),
-  (0, import_class_validator41.IsNotEmpty)({ message: "IBAN is required for INTERNATIONAL accounts." })
+  (0, import_class_validator45.ValidateIf)((dto) => dto.accountScope === "INTERNATIONAL"),
+  (0, import_class_validator45.IsNotEmpty)({ message: "IBAN is required for INTERNATIONAL accounts." })
 ], FreelancerBankDetailsDto.prototype, "iban", 2);
 __decorateClass([
-  (0, import_class_validator41.IsOptional)()
+  (0, import_class_validator45.IsOptional)()
 ], FreelancerBankDetailsDto.prototype, "accountType", 2);
 __decorateClass([
-  (0, import_class_validator41.IsEnum)(BankAccountScope, {
+  (0, import_class_validator45.IsEnum)(BankAccountScope, {
     message: `Type of Account Scope must be one of: ${Object.values(
       BankAccountScope
     ).join(", ")}`
@@ -2031,7 +2099,7 @@ var SYSTEM_PREFERENCES_PATTERN = {
 };
 
 // src/modules/system-preference/dto/system-preference.dto.ts
-var import_class_validator42 = require("class-validator");
+var import_class_validator46 = require("class-validator");
 var SystemPreferenceKey = /* @__PURE__ */ ((SystemPreferenceKey2) => {
   SystemPreferenceKey2["EMAIL_NOTIFICATION"] = "EMAIL_NOTIFICATION";
   SystemPreferenceKey2["DARK_MODE"] = "DARK_MODE";
@@ -2040,10 +2108,10 @@ var SystemPreferenceKey = /* @__PURE__ */ ((SystemPreferenceKey2) => {
 var SystemPreferenceDto = class {
 };
 __decorateClass([
-  (0, import_class_validator42.IsBoolean)()
+  (0, import_class_validator46.IsBoolean)()
 ], SystemPreferenceDto.prototype, "value", 2);
 __decorateClass([
-  (0, import_class_validator42.IsEnum)(SystemPreferenceKey, {
+  (0, import_class_validator46.IsEnum)(SystemPreferenceKey, {
     message: `key must be one of: ${Object.values(
       SystemPreferenceKey
     ).join(", ")}`
@@ -2088,7 +2156,7 @@ var RATING_PATTERN = {
 };
 
 // src/modules/rating/dto/add.rating.dto.ts
-var import_class_validator43 = require("class-validator");
+var import_class_validator47 = require("class-validator");
 
 // src/entities/rating.entity.ts
 var import_typeorm65 = require("typeorm");
@@ -6658,22 +6726,22 @@ Rating = __decorateClass([
 var CreateRatingDto = class {
 };
 __decorateClass([
-  (0, import_class_validator43.IsInt)({ message: "Reviewee ID must be a valid integer" }),
-  (0, import_class_validator43.IsNotEmpty)({ message: "Reviewee ID is required" })
+  (0, import_class_validator47.IsInt)({ message: "Reviewee ID must be a valid integer" }),
+  (0, import_class_validator47.IsNotEmpty)({ message: "Reviewee ID is required" })
 ], CreateRatingDto.prototype, "revieweeId", 2);
 __decorateClass([
-  (0, import_class_validator43.IsEnum)(RatingTypeEnum, {
+  (0, import_class_validator47.IsEnum)(RatingTypeEnum, {
     message: `Rating type must be one of: ${Object.values(RatingTypeEnum).join(", ")}`
   })
 ], CreateRatingDto.prototype, "ratingType", 2);
 __decorateClass([
-  (0, import_class_validator43.IsInt)({ message: "Rating must be an integer value" }),
-  (0, import_class_validator43.Min)(1, { message: "Rating must be at least 1" }),
-  (0, import_class_validator43.Max)(5, { message: "Rating must be at most 5" })
+  (0, import_class_validator47.IsInt)({ message: "Rating must be an integer value" }),
+  (0, import_class_validator47.Min)(1, { message: "Rating must be at least 1" }),
+  (0, import_class_validator47.Max)(5, { message: "Rating must be at most 5" })
 ], CreateRatingDto.prototype, "rating", 2);
 __decorateClass([
-  (0, import_class_validator43.IsOptional)(),
-  (0, import_class_validator43.IsString)({ message: "Review must be a string" })
+  (0, import_class_validator47.IsOptional)(),
+  (0, import_class_validator47.IsString)({ message: "Review must be a string" })
 ], CreateRatingDto.prototype, "review", 2);
 
 // src/modules/company-role/pattern/pattern.ts
@@ -6689,57 +6757,57 @@ var COMPANY_ROLES_PATTERNS = {
 };
 
 // src/modules/company-role/dto/create-company-role.dto.ts
-var import_class_validator44 = require("class-validator");
+var import_class_validator48 = require("class-validator");
 var CreateCompanyRoleDto = class {
 };
 __decorateClass([
-  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter company role name." })
+  (0, import_class_validator48.IsNotEmpty)({ message: "Please enter company role name." })
 ], CreateCompanyRoleDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter company role slug" })
+  (0, import_class_validator48.IsNotEmpty)({ message: "Please enter company role slug" })
 ], CreateCompanyRoleDto.prototype, "slug", 2);
 __decorateClass([
-  (0, import_class_validator44.IsNotEmpty)({ message: "Please enter description" })
+  (0, import_class_validator48.IsNotEmpty)({ message: "Please enter description" })
 ], CreateCompanyRoleDto.prototype, "description", 2);
 __decorateClass([
-  (0, import_class_validator44.IsArray)({ message: "Permission IDs must be an array." }),
-  (0, import_class_validator44.ArrayNotEmpty)({ message: "Please select at least one permission." }),
-  (0, import_class_validator44.IsInt)({ each: true, message: "Each permission ID must be an integer." })
+  (0, import_class_validator48.IsArray)({ message: "Permission IDs must be an array." }),
+  (0, import_class_validator48.ArrayNotEmpty)({ message: "Please select at least one permission." }),
+  (0, import_class_validator48.IsInt)({ each: true, message: "Each permission ID must be an integer." })
 ], CreateCompanyRoleDto.prototype, "permissionIds", 2);
 __decorateClass([
-  (0, import_class_validator44.IsOptional)(),
-  (0, import_class_validator44.IsBoolean)({ message: "Is active must be a boolean value" })
+  (0, import_class_validator48.IsOptional)(),
+  (0, import_class_validator48.IsBoolean)({ message: "Is active must be a boolean value" })
 ], CreateCompanyRoleDto.prototype, "isActive", 2);
 
 // src/modules/company-role/dto/update-company-role.dto.ts
-var import_class_validator45 = require("class-validator");
+var import_class_validator49 = require("class-validator");
 var UpdateCompanyRoleDto = class {
 };
 __decorateClass([
-  (0, import_class_validator45.IsNotEmpty)({ message: "Please enter company name." })
+  (0, import_class_validator49.IsNotEmpty)({ message: "Please enter company name." })
 ], UpdateCompanyRoleDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator45.IsNotEmpty)({ message: "Please enter slug" })
+  (0, import_class_validator49.IsNotEmpty)({ message: "Please enter slug" })
 ], UpdateCompanyRoleDto.prototype, "slug", 2);
 __decorateClass([
-  (0, import_class_validator45.IsNotEmpty)({ message: "Please enter description" })
+  (0, import_class_validator49.IsNotEmpty)({ message: "Please enter description" })
 ], UpdateCompanyRoleDto.prototype, "description", 2);
 __decorateClass([
-  (0, import_class_validator45.IsArray)({ message: "Permission IDs must be an array." }),
-  (0, import_class_validator45.ArrayNotEmpty)({ message: "Please select at least one permission." }),
-  (0, import_class_validator45.IsInt)({ each: true, message: "Each permission ID must be an integer." })
+  (0, import_class_validator49.IsArray)({ message: "Permission IDs must be an array." }),
+  (0, import_class_validator49.ArrayNotEmpty)({ message: "Please select at least one permission." }),
+  (0, import_class_validator49.IsInt)({ each: true, message: "Each permission ID must be an integer." })
 ], UpdateCompanyRoleDto.prototype, "permissionIds", 2);
 __decorateClass([
-  (0, import_class_validator45.IsOptional)(),
-  (0, import_class_validator45.IsBoolean)({ message: "Is active must be a boolean value" })
+  (0, import_class_validator49.IsOptional)(),
+  (0, import_class_validator49.IsBoolean)({ message: "Is active must be a boolean value" })
 ], UpdateCompanyRoleDto.prototype, "isActive", 2);
 
 // src/modules/company-role/dto/toggle-company-role-visibility.dto.ts
-var import_class_validator46 = require("class-validator");
+var import_class_validator50 = require("class-validator");
 var ToggleCompanyRoleVisibilityDto = class {
 };
 __decorateClass([
-  (0, import_class_validator46.IsBoolean)()
+  (0, import_class_validator50.IsBoolean)()
 ], ToggleCompanyRoleVisibilityDto.prototype, "isActive", 2);
 
 // src/modules/user/freelancer-experience/pattern/pattern.ts
@@ -6749,35 +6817,35 @@ var FREELANCER_EXPERIENCE_PATTERN = {
 };
 
 // src/modules/user/freelancer-experience/dto/freelancer-experience.dto.ts
-var import_class_validator47 = require("class-validator");
+var import_class_validator51 = require("class-validator");
 var import_class_transformer5 = require("class-transformer");
 var ExperienceDto = class {
 };
 __decorateClass([
-  (0, import_class_validator47.IsOptional)()
+  (0, import_class_validator51.IsOptional)()
 ], ExperienceDto.prototype, "uuid", 2);
 __decorateClass([
-  (0, import_class_validator47.IsNotEmpty)(),
-  (0, import_class_validator47.IsString)()
+  (0, import_class_validator51.IsNotEmpty)(),
+  (0, import_class_validator51.IsString)()
 ], ExperienceDto.prototype, "companyName", 2);
 __decorateClass([
-  (0, import_class_validator47.IsNotEmpty)(),
-  (0, import_class_validator47.IsString)()
+  (0, import_class_validator51.IsNotEmpty)(),
+  (0, import_class_validator51.IsString)()
 ], ExperienceDto.prototype, "designation", 2);
 __decorateClass([
-  (0, import_class_validator47.IsNotEmpty)(),
-  (0, import_class_validator47.IsString)()
+  (0, import_class_validator51.IsNotEmpty)(),
+  (0, import_class_validator51.IsString)()
 ], ExperienceDto.prototype, "jobDuration", 2);
 __decorateClass([
-  (0, import_class_validator47.IsOptional)(),
-  (0, import_class_validator47.IsString)(),
-  (0, import_class_validator47.MaxLength)(5e3, { message: "Description must not exceed 5000 characters" })
+  (0, import_class_validator51.IsOptional)(),
+  (0, import_class_validator51.IsString)(),
+  (0, import_class_validator51.MaxLength)(5e3, { message: "Description must not exceed 5000 characters" })
 ], ExperienceDto.prototype, "description", 2);
 var FreelancerExperienceDto = class {
 };
 __decorateClass([
-  (0, import_class_validator47.ValidateNested)({ each: true }),
-  (0, import_class_validator47.ArrayMinSize)(1, { message: "At least one experience is required." }),
+  (0, import_class_validator51.ValidateNested)({ each: true }),
+  (0, import_class_validator51.ArrayMinSize)(1, { message: "At least one experience is required." }),
   (0, import_class_transformer5.Type)(() => ExperienceDto)
 ], FreelancerExperienceDto.prototype, "experiences", 2);
 
@@ -6794,43 +6862,43 @@ var COMPANY_MEMBERS_PATTERNS = {
 };
 
 // src/modules/company-member/dto/create-company-member.dto.ts
-var import_class_validator48 = require("class-validator");
+var import_class_validator52 = require("class-validator");
 var CreateCompanyMemberDto = class {
 };
 __decorateClass([
-  (0, import_class_validator48.IsNotEmpty)({ message: "Please enter name." })
+  (0, import_class_validator52.IsNotEmpty)({ message: "Please enter name." })
 ], CreateCompanyMemberDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator48.IsNotEmpty)({ message: "Please enter email" })
+  (0, import_class_validator52.IsNotEmpty)({ message: "Please enter email" })
 ], CreateCompanyMemberDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator48.IsArray)({ message: "Role IDs must be an array." }),
-  (0, import_class_validator48.ArrayNotEmpty)({ message: "Please select at least one role." }),
-  (0, import_class_validator48.IsInt)({ each: true, message: "Each role ID must be an integer." })
+  (0, import_class_validator52.IsArray)({ message: "Role IDs must be an array." }),
+  (0, import_class_validator52.ArrayNotEmpty)({ message: "Please select at least one role." }),
+  (0, import_class_validator52.IsInt)({ each: true, message: "Each role ID must be an integer." })
 ], CreateCompanyMemberDto.prototype, "roleIds", 2);
 
 // src/modules/company-member/dto/update-company-member.dto.ts
-var import_class_validator49 = require("class-validator");
+var import_class_validator53 = require("class-validator");
 var UpdateCompanyMemberDto = class {
 };
 __decorateClass([
-  (0, import_class_validator49.IsNotEmpty)({ message: "Please enter name." })
+  (0, import_class_validator53.IsNotEmpty)({ message: "Please enter name." })
 ], UpdateCompanyMemberDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator49.IsNotEmpty)({ message: "Please enter email" })
+  (0, import_class_validator53.IsNotEmpty)({ message: "Please enter email" })
 ], UpdateCompanyMemberDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator49.IsArray)({ message: "Role IDs must be an array." }),
-  (0, import_class_validator49.ArrayNotEmpty)({ message: "Please select at least one role." }),
-  (0, import_class_validator49.IsInt)({ each: true, message: "Each role ID must be an integer." })
+  (0, import_class_validator53.IsArray)({ message: "Role IDs must be an array." }),
+  (0, import_class_validator53.ArrayNotEmpty)({ message: "Please select at least one role." }),
+  (0, import_class_validator53.IsInt)({ each: true, message: "Each role ID must be an integer." })
 ], UpdateCompanyMemberDto.prototype, "roleIds", 2);
 
 // src/modules/company-member/dto/toggle-company-member-visibility.dto.ts
-var import_class_validator50 = require("class-validator");
+var import_class_validator54 = require("class-validator");
 var ToggleCompanyMemberVisibilityDto = class {
 };
 __decorateClass([
-  (0, import_class_validator50.IsBoolean)()
+  (0, import_class_validator54.IsBoolean)()
 ], ToggleCompanyMemberVisibilityDto.prototype, "isActive", 2);
 
 // src/modules/user/freelancer-education/pattern/pattern.ts
@@ -6840,31 +6908,31 @@ var FREELANCER_EDUCATION_PATTERN = {
 };
 
 // src/modules/user/freelancer-education/dto/freelancer-education.dto.ts
-var import_class_validator51 = require("class-validator");
+var import_class_validator55 = require("class-validator");
 var import_class_transformer6 = require("class-transformer");
 var EducationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator51.IsOptional)()
+  (0, import_class_validator55.IsOptional)()
 ], EducationDto.prototype, "uuid", 2);
 __decorateClass([
-  (0, import_class_validator51.IsString)(),
-  (0, import_class_validator51.IsNotEmpty)({ message: "Please Enter Degree " })
+  (0, import_class_validator55.IsString)(),
+  (0, import_class_validator55.IsNotEmpty)({ message: "Please Enter Degree " })
 ], EducationDto.prototype, "degree", 2);
 __decorateClass([
-  (0, import_class_validator51.IsString)(),
-  (0, import_class_validator51.IsNotEmpty)({ message: "Please Enter University " })
+  (0, import_class_validator55.IsString)(),
+  (0, import_class_validator55.IsNotEmpty)({ message: "Please Enter University " })
 ], EducationDto.prototype, "university", 2);
 __decorateClass([
-  (0, import_class_validator51.IsString)(),
-  (0, import_class_validator51.IsNotEmpty)({ message: "Please Enter Year of Graduation " })
+  (0, import_class_validator55.IsString)(),
+  (0, import_class_validator55.IsNotEmpty)({ message: "Please Enter Year of Graduation " })
 ], EducationDto.prototype, "yearOfGraduation", 2);
 var FreelancerEducationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator51.IsArray)(),
-  (0, import_class_validator51.ArrayMinSize)(1, { message: "At least one education is required." }),
-  (0, import_class_validator51.ValidateNested)({ each: true }),
+  (0, import_class_validator55.IsArray)(),
+  (0, import_class_validator55.ArrayMinSize)(1, { message: "At least one education is required." }),
+  (0, import_class_validator55.ValidateNested)({ each: true }),
   (0, import_class_transformer6.Type)(() => EducationDto)
 ], FreelancerEducationDto.prototype, "educations", 2);
 
@@ -6875,67 +6943,67 @@ var FREELANCER_PROJECT_PATTERN = {
 };
 
 // src/modules/user/freelancer-project/dto/freelancer-project.dto.ts
-var import_class_validator52 = require("class-validator");
+var import_class_validator56 = require("class-validator");
 var import_class_transformer7 = require("class-transformer");
 var ProjectDto = class {
 };
 __decorateClass([
-  (0, import_class_validator52.IsOptional)()
+  (0, import_class_validator56.IsOptional)()
 ], ProjectDto.prototype, "uuid", 2);
 __decorateClass([
-  (0, import_class_validator52.IsString)(),
-  (0, import_class_validator52.IsNotEmpty)({ message: "Please Enter Project Name " })
+  (0, import_class_validator56.IsString)(),
+  (0, import_class_validator56.IsNotEmpty)({ message: "Please Enter Project Name " })
 ], ProjectDto.prototype, "projectName", 2);
 __decorateClass([
-  (0, import_class_validator52.IsDateString)(),
-  (0, import_class_validator52.IsNotEmpty)({ message: "Please Enter Start Date " })
+  (0, import_class_validator56.IsDateString)(),
+  (0, import_class_validator56.IsNotEmpty)({ message: "Please Enter Start Date " })
 ], ProjectDto.prototype, "startDate", 2);
 __decorateClass([
-  (0, import_class_validator52.IsDateString)(),
-  (0, import_class_validator52.IsNotEmpty)({ message: "Please Enter End Date " })
+  (0, import_class_validator56.IsDateString)(),
+  (0, import_class_validator56.IsNotEmpty)({ message: "Please Enter End Date " })
 ], ProjectDto.prototype, "endDate", 2);
 __decorateClass([
-  (0, import_class_validator52.IsOptional)(),
-  (0, import_class_validator52.IsString)()
+  (0, import_class_validator56.IsOptional)(),
+  (0, import_class_validator56.IsString)()
 ], ProjectDto.prototype, "clientName", 2);
 __decorateClass([
-  (0, import_class_validator52.IsOptional)(),
-  (0, import_class_validator52.IsString)()
+  (0, import_class_validator56.IsOptional)(),
+  (0, import_class_validator56.IsString)()
 ], ProjectDto.prototype, "gitLink", 2);
 __decorateClass([
-  (0, import_class_validator52.IsOptional)(),
-  (0, import_class_validator52.IsString)(),
-  (0, import_class_validator52.MaxLength)(5e3, { message: "Description must not exceed 5000 characters" })
+  (0, import_class_validator56.IsOptional)(),
+  (0, import_class_validator56.IsString)(),
+  (0, import_class_validator56.MaxLength)(5e3, { message: "Description must not exceed 5000 characters" })
 ], ProjectDto.prototype, "description", 2);
 var CaseStudyDto = class {
 };
 __decorateClass([
-  (0, import_class_validator52.IsOptional)()
+  (0, import_class_validator56.IsOptional)()
 ], CaseStudyDto.prototype, "uuid", 2);
 __decorateClass([
-  (0, import_class_validator52.IsString)(),
-  (0, import_class_validator52.IsNotEmpty)({ message: "Please Enter Project Name " })
+  (0, import_class_validator56.IsString)(),
+  (0, import_class_validator56.IsNotEmpty)({ message: "Please Enter Project Name " })
 ], CaseStudyDto.prototype, "projectName", 2);
 __decorateClass([
-  (0, import_class_validator52.IsOptional)(),
-  (0, import_class_validator52.IsString)()
+  (0, import_class_validator56.IsOptional)(),
+  (0, import_class_validator56.IsString)()
 ], CaseStudyDto.prototype, "caseStudyLink", 2);
 __decorateClass([
-  (0, import_class_validator52.IsOptional)(),
-  (0, import_class_validator52.IsString)(),
-  (0, import_class_validator52.MaxLength)(5e3, { message: "Description must not exceed 5000 characters" })
+  (0, import_class_validator56.IsOptional)(),
+  (0, import_class_validator56.IsString)(),
+  (0, import_class_validator56.MaxLength)(5e3, { message: "Description must not exceed 5000 characters" })
 ], CaseStudyDto.prototype, "description", 2);
 var FreelancerProjectDto = class {
 };
 __decorateClass([
-  (0, import_class_validator52.IsArray)(),
-  (0, import_class_validator52.ArrayMinSize)(1, { message: "At least one project is required." }),
-  (0, import_class_validator52.ValidateNested)({ each: true }),
+  (0, import_class_validator56.IsArray)(),
+  (0, import_class_validator56.ArrayMinSize)(1, { message: "At least one project is required." }),
+  (0, import_class_validator56.ValidateNested)({ each: true }),
   (0, import_class_transformer7.Type)(() => ProjectDto)
 ], FreelancerProjectDto.prototype, "projects", 2);
 __decorateClass([
-  (0, import_class_validator52.IsArray)(),
-  (0, import_class_validator52.ValidateNested)({ each: true }),
+  (0, import_class_validator56.IsArray)(),
+  (0, import_class_validator56.ValidateNested)({ each: true }),
   (0, import_class_transformer7.Type)(() => CaseStudyDto)
 ], FreelancerProjectDto.prototype, "casestudies", 2);
 
@@ -6952,7 +7020,7 @@ var FREELANCER_SKILL_PATTERN = {
 };
 
 // src/modules/user/freelancer-skill/dto/freelancer-skill.dto.ts
-var import_class_validator53 = require("class-validator");
+var import_class_validator57 = require("class-validator");
 var import_class_transformer8 = require("class-transformer");
 var FreelancerSkillDto = class {
   constructor() {
@@ -6963,28 +7031,28 @@ var FreelancerSkillDto = class {
   }
 };
 __decorateClass([
-  (0, import_class_validator53.IsOptional)(),
-  (0, import_class_validator53.IsArray)(),
+  (0, import_class_validator57.IsOptional)(),
+  (0, import_class_validator57.IsArray)(),
   (0, import_class_transformer8.Type)(() => String),
-  (0, import_class_validator53.IsString)({ each: true })
+  (0, import_class_validator57.IsString)({ each: true })
 ], FreelancerSkillDto.prototype, "coreSkills", 2);
 __decorateClass([
-  (0, import_class_validator53.IsOptional)(),
-  (0, import_class_validator53.IsArray)(),
+  (0, import_class_validator57.IsOptional)(),
+  (0, import_class_validator57.IsArray)(),
   (0, import_class_transformer8.Type)(() => String),
-  (0, import_class_validator53.IsString)({ each: true })
+  (0, import_class_validator57.IsString)({ each: true })
 ], FreelancerSkillDto.prototype, "secondarySkills", 2);
 __decorateClass([
-  (0, import_class_validator53.IsOptional)(),
-  (0, import_class_validator53.IsArray)(),
+  (0, import_class_validator57.IsOptional)(),
+  (0, import_class_validator57.IsArray)(),
   (0, import_class_transformer8.Type)(() => String),
-  (0, import_class_validator53.IsString)({ each: true })
+  (0, import_class_validator57.IsString)({ each: true })
 ], FreelancerSkillDto.prototype, "tools", 2);
 __decorateClass([
-  (0, import_class_validator53.IsOptional)(),
-  (0, import_class_validator53.IsArray)(),
+  (0, import_class_validator57.IsOptional)(),
+  (0, import_class_validator57.IsArray)(),
   (0, import_class_transformer8.Type)(() => String),
-  (0, import_class_validator53.IsString)({ each: true })
+  (0, import_class_validator57.IsString)({ each: true })
 ], FreelancerSkillDto.prototype, "frameworks", 2);
 
 // src/modules/freelancer-admin/pattern/pattern.ts
@@ -6993,6 +7061,11 @@ var ADMIN_FREELANCER_PATTERN = {
   adminFreelancerCount: "admin.freelancer.count",
   adminExportFreelancer: "admin.export.freelancer",
   adminFetchFreelancerById: "admin.fetch.freelancer.by.id",
+  adminFetchFreelancerSkillsById: "admin.fetch.freelancer.skills.by.id",
+  adminFetchFreelancerProjectsById: "admin.fetch.freelancer.projects.by.id",
+  adminFetchFreelancerExperiencesById: "admin.fetch.freelancer.experiences.by.id",
+  adminFetchFreelancerEducationsById: "admin.fetch.freelancer.educations.by.id",
+  adminFetchFreelancerAgreementById: "admin.fetch.freelancer.agreement.by.id",
   adminCreateFreelancer: "admin.create.freelancer",
   adminUpdateFreelancer: "admin.update.freelancer",
   adminDeleteFreelancer: "admin.delete.freelancer",
@@ -7005,7 +7078,7 @@ var ADMIN_FREELANCER_PATTERN = {
 };
 
 // src/modules/freelancer-admin/dto/create-freelancer.dto.ts
-var import_class_validator54 = require("class-validator");
+var import_class_validator58 = require("class-validator");
 var import_class_transformer9 = require("class-transformer");
 var NatureOfWorkDto2 = /* @__PURE__ */ ((NatureOfWorkDto3) => {
   NatureOfWorkDto3["FREELANCE"] = "FREELANCE";
@@ -7028,93 +7101,93 @@ var ModeOfWorkEnum = /* @__PURE__ */ ((ModeOfWorkEnum3) => {
 var CreateFreelancerDto = class {
 };
 __decorateClass([
-  (0, import_class_validator54.IsString)({ message: "Full name must be a string" }),
-  (0, import_class_validator54.MaxLength)(100, { message: "Full name must not exceed 100 characters" })
+  (0, import_class_validator58.IsString)({ message: "Full name must be a string" }),
+  (0, import_class_validator58.MaxLength)(100, { message: "Full name must not exceed 100 characters" })
 ], CreateFreelancerDto.prototype, "fullName", 2);
 __decorateClass([
-  (0, import_class_validator54.IsEmail)({}, { message: "Invalid email address" })
+  (0, import_class_validator58.IsEmail)({}, { message: "Invalid email address" })
 ], CreateFreelancerDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator54.IsString)({ message: "Mobile code must be a string (e.g., +1)" })
+  (0, import_class_validator58.IsString)({ message: "Mobile code must be a string (e.g., +1)" })
 ], CreateFreelancerDto.prototype, "mobileCode", 2);
 __decorateClass([
-  (0, import_class_validator54.IsString)({ message: "Mobile must be a string (e.g., 1243253534)" })
+  (0, import_class_validator58.IsString)({ message: "Mobile must be a string (e.g., 1243253534)" })
 ], CreateFreelancerDto.prototype, "mobile", 2);
 __decorateClass([
-  (0, import_class_validator54.IsNotEmpty)({ message: "Please enter password." }),
-  (0, import_class_validator54.MinLength)(6),
-  (0, import_class_validator54.MaxLength)(32),
-  (0, import_class_validator54.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
+  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter password." }),
+  (0, import_class_validator58.MinLength)(6),
+  (0, import_class_validator58.MaxLength)(32),
+  (0, import_class_validator58.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "Password must include letters, numbers and symbols."
   })
 ], CreateFreelancerDto.prototype, "password", 2);
 __decorateClass([
-  (0, import_class_validator54.IsNotEmpty)({ message: "Please enter confirm password." }),
+  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter confirm password." }),
   Match("confirmPassword", { message: "Passwords do not match" })
 ], CreateFreelancerDto.prototype, "confirmPassword", 2);
 __decorateClass([
-  (0, import_class_validator54.IsBoolean)({ message: "Developer flag must be true or false" }),
+  (0, import_class_validator58.IsBoolean)({ message: "Developer flag must be true or false" }),
   (0, import_class_transformer9.Type)(() => Boolean)
 ], CreateFreelancerDto.prototype, "developer", 2);
 __decorateClass([
-  (0, import_class_validator54.IsEnum)(NatureOfWorkEnum, {
+  (0, import_class_validator58.IsEnum)(NatureOfWorkEnum, {
     message: `Nature of work must be one of: ${Object.values(
       NatureOfWorkEnum
     ).join(", ")}`
   })
 ], CreateFreelancerDto.prototype, "natureOfWork", 2);
 __decorateClass([
-  (0, import_class_validator54.IsNumber)({}, { message: "Expected hourly compensation must be a number" }),
-  (0, import_class_validator54.Min)(0, { message: "Expected hourly compensation must be 0 or more" }),
+  (0, import_class_validator58.IsNumber)({}, { message: "Expected hourly compensation must be a number" }),
+  (0, import_class_validator58.Min)(0, { message: "Expected hourly compensation must be 0 or more" }),
   (0, import_class_transformer9.Type)(() => Number)
 ], CreateFreelancerDto.prototype, "expectedHourlyCompensation", 2);
 __decorateClass([
-  (0, import_class_validator54.ValidateIf)((dto) => dto.NatureOfWorkDto === "BOTH" /* BOTH */),
-  (0, import_class_validator54.IsNotEmpty)({ message: "Please enter expected annual compensation." })
+  (0, import_class_validator58.ValidateIf)((dto) => dto.NatureOfWorkDto === "BOTH" /* BOTH */),
+  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter expected annual compensation." })
 ], CreateFreelancerDto.prototype, "expectedAnnualCompensation", 2);
 __decorateClass([
-  (0, import_class_validator54.ValidateIf)((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
-  (0, import_class_validator54.IsInt)({ message: "Please enter valid weekly availability hours (integer)." }),
-  (0, import_class_validator54.IsNotEmpty)({ message: "Please enter weekly availability hours" })
+  (0, import_class_validator58.ValidateIf)((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
+  (0, import_class_validator58.IsInt)({ message: "Please enter valid weekly availability hours (integer)." }),
+  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter weekly availability hours" })
 ], CreateFreelancerDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  (0, import_class_validator54.IsEnum)(ModeOfWorkEnum, {
+  (0, import_class_validator58.IsEnum)(ModeOfWorkEnum, {
     message: `Mode of work must be one of: ${Object.values(ModeOfWorkEnum).join(
       ", "
     )}`
   })
 ], CreateFreelancerDto.prototype, "modeOfWork", 2);
 __decorateClass([
-  (0, import_class_validator54.IsBoolean)({ message: "isImmediateJoiner must be true or false" }),
+  (0, import_class_validator58.IsBoolean)({ message: "isImmediateJoiner must be true or false" }),
   (0, import_class_transformer9.Type)(() => Boolean)
 ], CreateFreelancerDto.prototype, "isImmediateJoiner", 2);
 __decorateClass([
-  (0, import_class_validator54.ValidateIf)((o) => o.isImmediateJoiner === false),
-  (0, import_class_validator54.IsNotEmpty)({ message: "Please enter availability to join." })
+  (0, import_class_validator58.ValidateIf)((o) => o.isImmediateJoiner === false),
+  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter availability to join." })
 ], CreateFreelancerDto.prototype, "availabilityToJoin", 2);
 __decorateClass([
-  (0, import_class_validator54.IsOptional)(),
-  (0, import_class_validator54.IsUrl)({}, { message: "LinkedIn profile link must be a valid URL" })
+  (0, import_class_validator58.IsOptional)(),
+  (0, import_class_validator58.IsUrl)({}, { message: "LinkedIn profile link must be a valid URL" })
 ], CreateFreelancerDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator54.IsOptional)(),
-  (0, import_class_validator54.IsString)({ message: "Kaggle profile link must be a string" })
+  (0, import_class_validator58.IsOptional)(),
+  (0, import_class_validator58.IsString)({ message: "Kaggle profile link must be a string" })
 ], CreateFreelancerDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator54.IsOptional)(),
-  (0, import_class_validator54.IsUrl)({}, { message: "GitHub profile link must be a valid URL" })
+  (0, import_class_validator58.IsOptional)(),
+  (0, import_class_validator58.IsUrl)({}, { message: "GitHub profile link must be a valid URL" })
 ], CreateFreelancerDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator54.IsOptional)(),
-  (0, import_class_validator54.IsUrl)({}, { message: "StackOverflow profile link must be a valid URL" })
+  (0, import_class_validator58.IsOptional)(),
+  (0, import_class_validator58.IsUrl)({}, { message: "StackOverflow profile link must be a valid URL" })
 ], CreateFreelancerDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator54.IsOptional)(),
-  (0, import_class_validator54.IsUrl)({}, { message: "Portfolio link must be a valid URL" })
+  (0, import_class_validator58.IsOptional)(),
+  (0, import_class_validator58.IsUrl)({}, { message: "Portfolio link must be a valid URL" })
 ], CreateFreelancerDto.prototype, "portfolioLink", 2);
 
 // src/modules/freelancer-admin/dto/update-freelancer.dto.ts
-var import_class_validator55 = require("class-validator");
+var import_class_validator59 = require("class-validator");
 var import_class_transformer10 = require("class-transformer");
 var NatureOfWorkEnum2 = /* @__PURE__ */ ((NatureOfWorkEnum3) => {
   NatureOfWorkEnum3["FTE"] = "FTE";
@@ -7131,97 +7204,97 @@ var ModeOfWorkEnum2 = /* @__PURE__ */ ((ModeOfWorkEnum3) => {
 var UpdateFreelancerDto = class {
 };
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsString)({ message: "Full name must be a string" }),
-  (0, import_class_validator55.MaxLength)(100, { message: "Full name must not exceed 100 characters" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsString)({ message: "Full name must be a string" }),
+  (0, import_class_validator59.MaxLength)(100, { message: "Full name must not exceed 100 characters" })
 ], UpdateFreelancerDto.prototype, "fullName", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsEmail)({}, { message: "Invalid email address" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsEmail)({}, { message: "Invalid email address" })
 ], UpdateFreelancerDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsString)({ message: "Mobile code must be a string (e.g., +1)" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsString)({ message: "Mobile code must be a string (e.g., +1)" })
 ], UpdateFreelancerDto.prototype, "mobileCode", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsString)({ message: "Mobile must be a string (e.g., 1243253534)" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsString)({ message: "Mobile must be a string (e.g., 1243253534)" })
 ], UpdateFreelancerDto.prototype, "mobile", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
+  (0, import_class_validator59.IsOptional)(),
   (0, import_class_transformer10.Transform)(({ value }) => value === null || value === "" ? void 0 : value),
-  (0, import_class_validator55.MinLength)(6, { message: "Password must be at least 6 characters." }),
-  (0, import_class_validator55.MaxLength)(32, { message: "Password must not exceed 32 characters." }),
-  (0, import_class_validator55.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
+  (0, import_class_validator59.MinLength)(6, { message: "Password must be at least 6 characters." }),
+  (0, import_class_validator59.MaxLength)(32, { message: "Password must not exceed 32 characters." }),
+  (0, import_class_validator59.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "Password must include letters, numbers and symbols."
   })
 ], UpdateFreelancerDto.prototype, "password", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsBoolean)({ message: "Developer flag must be true or false" }),
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsBoolean)({ message: "Developer flag must be true or false" }),
   (0, import_class_transformer10.Type)(() => Boolean)
 ], UpdateFreelancerDto.prototype, "developer", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsEnum)(NatureOfWorkEnum2, {
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsEnum)(NatureOfWorkEnum2, {
     message: `Nature of work must be one of: ${Object.values(
       NatureOfWorkEnum2
     ).join(", ")}`
   })
 ], UpdateFreelancerDto.prototype, "natureOfWork", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsNumber)({}, { message: "Expected hourly compensation must be a number" }),
-  (0, import_class_validator55.Min)(0, { message: "Expected hourly compensation must be 0 or more" }),
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsNumber)({}, { message: "Expected hourly compensation must be a number" }),
+  (0, import_class_validator59.Min)(0, { message: "Expected hourly compensation must be 0 or more" }),
   (0, import_class_transformer10.Type)(() => Number)
 ], UpdateFreelancerDto.prototype, "expectedHourlyCompensation", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.ValidateIf)((dto) => dto.NatureOfWorkDto === "BOTH" /* BOTH */),
-  (0, import_class_validator55.IsNotEmpty)({ message: "Please enter expected annual compensation." })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.ValidateIf)((dto) => dto.NatureOfWorkDto === "BOTH" /* BOTH */),
+  (0, import_class_validator59.IsNotEmpty)({ message: "Please enter expected annual compensation." })
 ], UpdateFreelancerDto.prototype, "expectedAnnualCompensation", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.ValidateIf)((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
-  (0, import_class_validator55.IsInt)({ message: "Please enter valid weekly availability hours (integer)." }),
-  (0, import_class_validator55.IsNotEmpty)({ message: "Please enter weekly availability hours" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.ValidateIf)((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
+  (0, import_class_validator59.IsInt)({ message: "Please enter valid weekly availability hours (integer)." }),
+  (0, import_class_validator59.IsNotEmpty)({ message: "Please enter weekly availability hours" })
 ], UpdateFreelancerDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsEnum)(ModeOfWorkEnum2, {
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsEnum)(ModeOfWorkEnum2, {
     message: `Mode of work must be one of: ${Object.values(ModeOfWorkEnum2).join(
       ", "
     )}`
   })
 ], UpdateFreelancerDto.prototype, "modeOfWork", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsBoolean)({ message: "isImmediateJoiner must be true or false" }),
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsBoolean)({ message: "isImmediateJoiner must be true or false" }),
   (0, import_class_transformer10.Type)(() => Boolean)
 ], UpdateFreelancerDto.prototype, "isImmediateJoiner", 2);
 __decorateClass([
-  (0, import_class_validator55.ValidateIf)((o) => o.isImmediateJoiner === false),
-  (0, import_class_validator55.IsNotEmpty)({ message: "Please enter availability to join." })
+  (0, import_class_validator59.ValidateIf)((o) => o.isImmediateJoiner === false),
+  (0, import_class_validator59.IsNotEmpty)({ message: "Please enter availability to join." })
 ], UpdateFreelancerDto.prototype, "availabilityToJoin", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsUrl)({}, { message: "LinkedIn profile link must be a valid URL" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsUrl)({}, { message: "LinkedIn profile link must be a valid URL" })
 ], UpdateFreelancerDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsString)({ message: "Kaggle profile link must be a string" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsString)({ message: "Kaggle profile link must be a string" })
 ], UpdateFreelancerDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsUrl)({}, { message: "GitHub profile link must be a valid URL" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsUrl)({}, { message: "GitHub profile link must be a valid URL" })
 ], UpdateFreelancerDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsUrl)({}, { message: "StackOverflow profile link must be a valid URL" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsUrl)({}, { message: "StackOverflow profile link must be a valid URL" })
 ], UpdateFreelancerDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  (0, import_class_validator55.IsOptional)(),
-  (0, import_class_validator55.IsUrl)({}, { message: "Portfolio link must be a valid URL" })
+  (0, import_class_validator59.IsOptional)(),
+  (0, import_class_validator59.IsUrl)({}, { message: "Portfolio link must be a valid URL" })
 ], UpdateFreelancerDto.prototype, "portfolioLink", 2);
 
 // src/modules/client-admin/pattern/pattern.ts
@@ -7238,7 +7311,7 @@ var CLIENT_ADMIN_PATTERNS = {
 };
 
 // src/modules/client-admin/dto/create-client.dto.ts
-var import_class_validator56 = require("class-validator");
+var import_class_validator60 = require("class-validator");
 var CreateClientHiringModeEnum = /* @__PURE__ */ ((CreateClientHiringModeEnum2) => {
   CreateClientHiringModeEnum2["REMOTE"] = "REMOTE";
   CreateClientHiringModeEnum2["ONSITE"] = "ONSITE";
@@ -7254,78 +7327,78 @@ var CreateClientHiringTypeEnum = /* @__PURE__ */ ((CreateClientHiringTypeEnum2)
 var CreateClientDto = class {
 };
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please enter first name." }),
-  (0, import_class_validator56.IsString)()
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please enter first name." }),
+  (0, import_class_validator60.IsString)()
 ], CreateClientDto.prototype, "firstName", 2);
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please enter last name." }),
-  (0, import_class_validator56.IsString)()
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please enter last name." }),
+  (0, import_class_validator60.IsString)()
 ], CreateClientDto.prototype, "lastName", 2);
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please enter email." }),
-  (0, import_class_validator56.IsEmail)()
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please enter email." }),
+  (0, import_class_validator60.IsEmail)()
 ], CreateClientDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please enter password." }),
-  (0, import_class_validator56.MinLength)(6),
-  (0, import_class_validator56.MaxLength)(32),
-  (0, import_class_validator56.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please enter password." }),
+  (0, import_class_validator60.MinLength)(6),
+  (0, import_class_validator60.MaxLength)(32),
+  (0, import_class_validator60.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "Password must include letters, numbers and symbols."
   })
 ], CreateClientDto.prototype, "password", 2);
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please enter confirm password." }),
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please enter confirm password." }),
   Match("confirmPassword", { message: "Passwords do not match" })
 ], CreateClientDto.prototype, "confirmPassword", 2);
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please enter company name." }),
-  (0, import_class_validator56.IsString)()
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please enter company name." }),
+  (0, import_class_validator60.IsString)()
 ], CreateClientDto.prototype, "companyName", 2);
 __decorateClass([
-  (0, import_class_validator56.IsArray)({ message: "Skills should be an array." }),
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please enter skills." })
+  (0, import_class_validator60.IsArray)({ message: "Skills should be an array." }),
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please enter skills." })
 ], CreateClientDto.prototype, "skills", 2);
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please specify required freelancer count." }),
-  (0, import_class_validator56.IsString)()
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please specify required freelancer count." }),
+  (0, import_class_validator60.IsString)()
 ], CreateClientDto.prototype, "requiredFreelancer", 2);
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please specify the kind of hiring." }),
-  (0, import_class_validator56.IsEnum)(CreateClientHiringTypeEnum)
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please specify the kind of hiring." }),
+  (0, import_class_validator60.IsEnum)(CreateClientHiringTypeEnum)
 ], CreateClientDto.prototype, "kindOfHiring", 2);
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please specify the mode of hire." }),
-  (0, import_class_validator56.IsEnum)(CreateClientHiringModeEnum)
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please specify the mode of hire." }),
+  (0, import_class_validator60.IsEnum)(CreateClientHiringModeEnum)
 ], CreateClientDto.prototype, "modeOfHire", 2);
 __decorateClass([
-  (0, import_class_validator56.IsNotEmpty)({ message: "Please let us know how you found us." }),
-  (0, import_class_validator56.IsString)()
+  (0, import_class_validator60.IsNotEmpty)({ message: "Please let us know how you found us." }),
+  (0, import_class_validator60.IsString)()
 ], CreateClientDto.prototype, "foundUsOn", 2);
 __decorateClass([
-  (0, import_class_validator56.IsOptional)(),
-  (0, import_class_validator56.IsString)()
+  (0, import_class_validator60.IsOptional)(),
+  (0, import_class_validator60.IsString)()
 ], CreateClientDto.prototype, "foundUsOnDetail", 2);
 __decorateClass([
-  (0, import_class_validator56.IsOptional)(),
-  (0, import_class_validator56.IsString)()
+  (0, import_class_validator60.IsOptional)(),
+  (0, import_class_validator60.IsString)()
 ], CreateClientDto.prototype, "hiringCommisionTypeForFte", 2);
 __decorateClass([
-  (0, import_class_validator56.IsOptional)(),
-  (0, import_class_validator56.IsString)()
+  (0, import_class_validator60.IsOptional)(),
+  (0, import_class_validator60.IsString)()
 ], CreateClientDto.prototype, "hiringCommissionValueForFte", 2);
 
 // src/modules/client-admin/dto/update-client-status.dto.ts
-var import_class_validator57 = require("class-validator");
+var import_class_validator61 = require("class-validator");
 var UpdateClientAccountStatusDto = class {
 };
 __decorateClass([
-  (0, import_class_validator57.IsNotEmpty)({ message: "Please enter account status." }),
-  (0, import_class_validator57.IsString)()
+  (0, import_class_validator61.IsNotEmpty)({ message: "Please enter account status." }),
+  (0, import_class_validator61.IsString)()
 ], UpdateClientAccountStatusDto.prototype, "accountStatus", 2);
 
 // src/modules/client-admin/dto/update-client.dto.ts
 var import_class_transformer11 = require("class-transformer");
-var import_class_validator58 = require("class-validator");
+var import_class_validator62 = require("class-validator");
 var UpdateClientHiringModeEnum = /* @__PURE__ */ ((UpdateClientHiringModeEnum2) => {
   UpdateClientHiringModeEnum2["REMOTE"] = "REMOTE";
   UpdateClientHiringModeEnum2["ONSITE"] = "ONSITE";
@@ -7341,61 +7414,61 @@ var UpdateClientHiringTypeEnum = /* @__PURE__ */ ((UpdateClientHiringTypeEnum2)
 var UpdateClientDto = class {
 };
 __decorateClass([
-  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter first name." }),
-  (0, import_class_validator58.IsString)()
+  (0, import_class_validator62.IsNotEmpty)({ message: "Please enter first name." }),
+  (0, import_class_validator62.IsString)()
 ], UpdateClientDto.prototype, "firstName", 2);
 __decorateClass([
-  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter last name." }),
-  (0, import_class_validator58.IsString)()
+  (0, import_class_validator62.IsNotEmpty)({ message: "Please enter last name." }),
+  (0, import_class_validator62.IsString)()
 ], UpdateClientDto.prototype, "lastName", 2);
 __decorateClass([
-  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter email." }),
-  (0, import_class_validator58.IsEmail)()
+  (0, import_class_validator62.IsNotEmpty)({ message: "Please enter email." }),
+  (0, import_class_validator62.IsEmail)()
 ], UpdateClientDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator58.IsOptional)(),
+  (0, import_class_validator62.IsOptional)(),
   (0, import_class_transformer11.Transform)(({ value }) => value === null || value === "" ? void 0 : value),
-  (0, import_class_validator58.MinLength)(6, { message: "Password must be at least 6 characters." }),
-  (0, import_class_validator58.MaxLength)(32, { message: "Password must not exceed 32 characters." }),
-  (0, import_class_validator58.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
+  (0, import_class_validator62.MinLength)(6, { message: "Password must be at least 6 characters." }),
+  (0, import_class_validator62.MaxLength)(32, { message: "Password must not exceed 32 characters." }),
+  (0, import_class_validator62.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
     message: "Password must include letters, numbers and symbols."
   })
 ], UpdateClientDto.prototype, "password", 2);
 __decorateClass([
-  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter company name." }),
-  (0, import_class_validator58.IsString)()
+  (0, import_class_validator62.IsNotEmpty)({ message: "Please enter company name." }),
+  (0, import_class_validator62.IsString)()
 ], UpdateClientDto.prototype, "companyName", 2);
 __decorateClass([
-  (0, import_class_validator58.IsArray)({ message: "Skills should be an array." }),
-  (0, import_class_validator58.IsNotEmpty)({ message: "Please enter skills." })
+  (0, import_class_validator62.IsArray)({ message: "Skills should be an array." }),
+  (0, import_class_validator62.IsNotEmpty)({ message: "Please enter skills." })
 ], UpdateClientDto.prototype, "skills", 2);
 __decorateClass([
-  (0, import_class_validator58.IsNotEmpty)({ message: "Please specify required freelancer count." }),
-  (0, import_class_validator58.IsString)()
+  (0, import_class_validator62.IsNotEmpty)({ message: "Please specify required freelancer count." }),
+  (0, import_class_validator62.IsString)()
 ], UpdateClientDto.prototype, "requiredFreelancer", 2);
 __decorateClass([
-  (0, import_class_validator58.IsNotEmpty)({ message: "Please specify the kind of hiring." }),
-  (0, import_class_validator58.IsEnum)(UpdateClientHiringTypeEnum)
+  (0, import_class_validator62.IsNotEmpty)({ message: "Please specify the kind of hiring." }),
+  (0, import_class_validator62.IsEnum)(UpdateClientHiringTypeEnum)
 ], UpdateClientDto.prototype, "kindOfHiring", 2);
 __decorateClass([
-  (0, import_class_validator58.IsNotEmpty)({ message: "Please specify the mode of hire." }),
-  (0, import_class_validator58.IsEnum)(UpdateClientHiringModeEnum)
+  (0, import_class_validator62.IsNotEmpty)({ message: "Please specify the mode of hire." }),
+  (0, import_class_validator62.IsEnum)(UpdateClientHiringModeEnum)
 ], UpdateClientDto.prototype, "modeOfHire", 2);
 __decorateClass([
-  (0, import_class_validator58.IsNotEmpty)({ message: "Please let us know how you found us." }),
-  (0, import_class_validator58.IsString)()
+  (0, import_class_validator62.IsNotEmpty)({ message: "Please let us know how you found us." }),
+  (0, import_class_validator62.IsString)()
 ], UpdateClientDto.prototype, "foundUsOn", 2);
 __decorateClass([
-  (0, import_class_validator58.IsOptional)(),
-  (0, import_class_validator58.IsString)()
+  (0, import_class_validator62.IsOptional)(),
+  (0, import_class_validator62.IsString)()
 ], UpdateClientDto.prototype, "foundUsOnDetail", 2);
 __decorateClass([
-  (0, import_class_validator58.IsOptional)(),
-  (0, import_class_validator58.IsString)()
+  (0, import_class_validator62.IsOptional)(),
+  (0, import_class_validator62.IsString)()
 ], UpdateClientDto.prototype, "hiringCommisionTypeForFte", 2);
 __decorateClass([
-  (0, import_class_validator58.IsOptional)(),
-  (0, import_class_validator58.IsString)()
+  (0, import_class_validator62.IsOptional)(),
+  (0, import_class_validator62.IsString)()
 ], UpdateClientDto.prototype, "hiringCommissionValueForFte", 2);
 
 // src/modules/user/freelancer-declaration/pattern/pattern.ts
@@ -7405,7 +7478,7 @@ var FREELANCER_DECLARATION_PATTERN = {
 };
 
 // src/modules/user/freelancer-declaration/dto/freelancer-declaration.dto.ts
-var import_class_validator59 = require("class-validator");
+var import_class_validator63 = require("class-validator");
 var DocumentTypeEnum = /* @__PURE__ */ ((DocumentTypeEnum2) => {
   DocumentTypeEnum2["AADHAAR"] = "AADHAAR_CARD";
   DocumentTypeEnum2["PASSPORT"] = "PASSPORT";
@@ -7416,16 +7489,16 @@ var DocumentTypeEnum = /* @__PURE__ */ ((DocumentTypeEnum2) => {
 var FreelancerDeclarationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator59.IsOptional)(),
-  (0, import_class_validator59.IsString)({ message: "UUID must be a string" })
+  (0, import_class_validator63.IsOptional)(),
+  (0, import_class_validator63.IsString)({ message: "UUID must be a string" })
 ], FreelancerDeclarationDto.prototype, "uuid", 2);
 __decorateClass([
-  (0, import_class_validator59.IsEnum)(DocumentTypeEnum, { message: "Document type must be one of AADHAAR_CARD, PASSPORT, DRIVING_LICENSE, PAN_CARD" })
+  (0, import_class_validator63.IsEnum)(DocumentTypeEnum, { message: "Document type must be one of AADHAAR_CARD, PASSPORT, DRIVING_LICENSE, PAN_CARD" })
 ], FreelancerDeclarationDto.prototype, "documentType", 2);
 __decorateClass([
-  (0, import_class_validator59.IsNotEmpty)({ message: "Please accept the declaration " }),
-  (0, import_class_validator59.IsString)(),
-  (0, import_class_validator59.IsIn)([
+  (0, import_class_validator63.IsNotEmpty)({ message: "Please accept the declaration " }),
+  (0, import_class_validator63.IsString)(),
+  (0, import_class_validator63.IsIn)([
     "true"
   ])
 ], FreelancerDeclarationDto.prototype, "declarationAccepted", 2);
@@ -7449,36 +7522,36 @@ var CMS_PATTERNS = {
 };
 
 // src/modules/cms/dto/create-cms.dto.ts
-var import_class_validator60 = require("class-validator");
+var import_class_validator64 = require("class-validator");
 var CreateCmsDto = class {
 };
 __decorateClass([
-  (0, import_class_validator60.IsNotEmpty)({ message: "Please enter name." })
+  (0, import_class_validator64.IsNotEmpty)({ message: "Please enter name." })
 ], CreateCmsDto.prototype, "title", 2);
 __decorateClass([
-  (0, import_class_validator60.IsOptional)()
+  (0, import_class_validator64.IsOptional)()
 ], CreateCmsDto.prototype, "content", 2);
 __decorateClass([
-  (0, import_class_validator60.IsOptional)(),
-  (0, import_class_validator60.IsBoolean)({ message: "Is active must be a boolean value" })
+  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator64.IsBoolean)({ message: "Is active must be a boolean value" })
 ], CreateCmsDto.prototype, "isActive", 2);
 
 // src/modules/cms/dto/update-cms.dto.ts
-var import_class_validator61 = require("class-validator");
+var import_class_validator65 = require("class-validator");
 var UpdateCmsDto = class {
 };
 __decorateClass([
-  (0, import_class_validator61.IsOptional)()
+  (0, import_class_validator65.IsOptional)()
 ], UpdateCmsDto.prototype, "uuid", 2);
 __decorateClass([
-  (0, import_class_validator61.IsNotEmpty)({ message: "Please enter name." })
+  (0, import_class_validator65.IsNotEmpty)({ message: "Please enter name." })
 ], UpdateCmsDto.prototype, "title", 2);
 __decorateClass([
-  (0, import_class_validator61.IsOptional)()
+  (0, import_class_validator65.IsOptional)()
 ], UpdateCmsDto.prototype, "content", 2);
 __decorateClass([
-  (0, import_class_validator61.IsOptional)(),
-  (0, import_class_validator61.IsBoolean)({ message: "Is active must be a boolean value" })
+  (0, import_class_validator65.IsOptional)(),
+  (0, import_class_validator65.IsBoolean)({ message: "Is active must be a boolean value" })
 ], UpdateCmsDto.prototype, "isActive", 2);
 
 // src/modules/geographic/pattern/pattern.ts
@@ -7512,7 +7585,7 @@ var ADMIN_JOB_PATTERN = {
 
 // src/modules/job-admin/dto/admin-create-job-information.dto.ts
 var import_class_transformer12 = require("class-transformer");
-var import_class_validator62 = require("class-validator");
+var import_class_validator66 = require("class-validator");
 var JobLocationEnumDto = /* @__PURE__ */ ((JobLocationEnumDto2) => {
   JobLocationEnumDto2["ONSITE"] = "ONSITE";
   JobLocationEnumDto2["REMOTE"] = "REMOTE";
@@ -7528,91 +7601,91 @@ var TypeOfEmploymentEnumDto = /* @__PURE__ */ ((TypeOfEmploymentEnumDto2) => {
 var AdminCreateJobInformationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator62.IsString)({ message: "Job role must be a string." }),
-  (0, import_class_validator62.IsNotEmpty)({ message: "Job role is required." })
+  (0, import_class_validator66.IsString)({ message: "Job role must be a string." }),
+  (0, import_class_validator66.IsNotEmpty)({ message: "Job role is required." })
 ], AdminCreateJobInformationDto.prototype, "jobRole", 2);
 __decorateClass([
-  (0, import_class_validator62.IsOptional)(),
-  (0, import_class_validator62.IsString)({ message: "Note must be a string." })
+  (0, import_class_validator66.IsOptional)(),
+  (0, import_class_validator66.IsString)({ message: "Note must be a string." })
 ], AdminCreateJobInformationDto.prototype, "note", 2);
 __decorateClass([
-  (0, import_class_validator62.IsArray)({ message: "Skills must be an array of skill names." }),
-  (0, import_class_validator62.ArrayNotEmpty)({ message: "At least one skill must be provided." }),
-  (0, import_class_validator62.IsString)({ each: true, message: "Each skill must be a valid string." })
+  (0, import_class_validator66.IsArray)({ message: "Skills must be an array of skill names." }),
+  (0, import_class_validator66.ArrayNotEmpty)({ message: "At least one skill must be provided." }),
+  (0, import_class_validator66.IsString)({ each: true, message: "Each skill must be a valid string." })
 ], AdminCreateJobInformationDto.prototype, "skills", 2);
 __decorateClass([
-  (0, import_class_validator62.IsInt)({ message: "Openings must be a valid integer." }),
-  (0, import_class_validator62.Min)(1, { message: "There must be at least one opening." })
+  (0, import_class_validator66.IsInt)({ message: "Openings must be a valid integer." }),
+  (0, import_class_validator66.Min)(1, { message: "There must be at least one opening." })
 ], AdminCreateJobInformationDto.prototype, "openings", 2);
 __decorateClass([
-  (0, import_class_validator62.IsEnum)(JobLocationEnumDto, {
+  (0, import_class_validator66.IsEnum)(JobLocationEnumDto, {
     message: `Location must be one of: ${Object.values(JobLocationEnumDto).join(
       ", "
     )}.`
   })
 ], AdminCreateJobInformationDto.prototype, "location", 2);
 __decorateClass([
-  (0, import_class_validator62.IsEnum)(TypeOfEmploymentEnumDto, {
+  (0, import_class_validator66.IsEnum)(TypeOfEmploymentEnumDto, {
     message: `Type of employment must be one of: ${Object.values(
       TypeOfEmploymentEnumDto
     ).join(", ")}.`
   })
 ], AdminCreateJobInformationDto.prototype, "typeOfEmployment", 2);
 __decorateClass([
-  (0, import_class_validator62.IsString)({ message: "Onboarding Days must be a string." }),
-  (0, import_class_validator62.IsNotEmpty)({ message: "Onboarding Days is required." })
+  (0, import_class_validator66.IsString)({ message: "Onboarding Days must be a string." }),
+  (0, import_class_validator66.IsNotEmpty)({ message: "Onboarding Days is required." })
 ], AdminCreateJobInformationDto.prototype, "onboardingTat", 2);
 __decorateClass([
-  (0, import_class_validator62.IsString)({ message: "Communication skills must be a string." }),
-  (0, import_class_validator62.IsNotEmpty)({ message: "Communication skills are required." })
+  (0, import_class_validator66.IsString)({ message: "Communication skills must be a string." }),
+  (0, import_class_validator66.IsNotEmpty)({ message: "Communication skills are required." })
 ], AdminCreateJobInformationDto.prototype, "candidateCommunicationSkills", 2);
 __decorateClass([
-  (0, import_class_validator62.IsString)({ message: "Currency must be a string." }),
-  (0, import_class_validator62.IsNotEmpty)({ message: "Currency is required." })
+  (0, import_class_validator66.IsString)({ message: "Currency must be a string." }),
+  (0, import_class_validator66.IsNotEmpty)({ message: "Currency is required." })
 ], AdminCreateJobInformationDto.prototype, "currency", 2);
 __decorateClass([
   (0, import_class_transformer12.Type)(() => Number),
-  (0, import_class_validator62.IsNumber)({}, { message: "Expected salary from must be a number." })
+  (0, import_class_validator66.IsNumber)({}, { message: "Expected salary from must be a number." })
 ], AdminCreateJobInformationDto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
   (0, import_class_transformer12.Type)(() => Number),
-  (0, import_class_validator62.IsNumber)({}, { message: "Expected salary to must be a number." })
+  (0, import_class_validator66.IsNumber)({}, { message: "Expected salary to must be a number." })
 ], AdminCreateJobInformationDto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
-  (0, import_class_validator62.IsDateString)(
+  (0, import_class_validator66.IsDateString)(
     { strict: true },
     { message: "Start date must be in YYYY-MM-DD format." }
   )
 ], AdminCreateJobInformationDto.prototype, "tentativeStartDate", 2);
 __decorateClass([
-  (0, import_class_validator62.IsDateString)(
+  (0, import_class_validator66.IsDateString)(
     { strict: true },
     { message: "End date must be in YYYY-MM-DD format." }
   )
 ], AdminCreateJobInformationDto.prototype, "tentativeEndDate", 2);
 __decorateClass([
-  (0, import_class_validator62.IsOptional)(),
-  (0, import_class_validator62.IsString)({ message: "Additional comment must be a string." })
+  (0, import_class_validator66.IsOptional)(),
+  (0, import_class_validator66.IsString)({ message: "Additional comment must be a string." })
 ], AdminCreateJobInformationDto.prototype, "additionalComment", 2);
 __decorateClass([
-  (0, import_class_validator62.IsOptional)(),
-  (0, import_class_validator62.IsInt)({ message: "Country ID must be a valid integer." })
+  (0, import_class_validator66.IsOptional)(),
+  (0, import_class_validator66.IsInt)({ message: "Country ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "countryId", 2);
 __decorateClass([
-  (0, import_class_validator62.IsOptional)(),
-  (0, import_class_validator62.IsInt)({ message: "State ID must be a valid integer." })
+  (0, import_class_validator66.IsOptional)(),
+  (0, import_class_validator66.IsInt)({ message: "State ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "stateId", 2);
 __decorateClass([
-  (0, import_class_validator62.IsOptional)(),
-  (0, import_class_validator62.IsInt)({ message: "City ID must be a valid integer." })
+  (0, import_class_validator66.IsOptional)(),
+  (0, import_class_validator66.IsInt)({ message: "City ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "cityId", 2);
 __decorateClass([
-  (0, import_class_validator62.IsInt)({ message: "Client ID must be a valid integer." })
+  (0, import_class_validator66.IsInt)({ message: "Client ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "clientId", 2);
 
 // src/modules/job-admin/dto/admin-update-job-information.dto.ts
 var import_class_transformer13 = require("class-transformer");
-var import_class_validator63 = require("class-validator");
+var import_class_validator67 = require("class-validator");
 var JobLocationEnums = /* @__PURE__ */ ((JobLocationEnums2) => {
   JobLocationEnums2["ONSITE"] = "ONSITE";
   JobLocationEnums2["REMOTE"] = "REMOTE";
@@ -7628,90 +7701,90 @@ var TypeOfEmploymentEnums = /* @__PURE__ */ ((TypeOfEmploymentEnums2) => {
 var AdminUpdateJobInformationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator63.IsString)({ message: "Job role must be a string." }),
-  (0, import_class_validator63.IsNotEmpty)({ message: "Job role is required." })
+  (0, import_class_validator67.IsString)({ message: "Job role must be a string." }),
+  (0, import_class_validator67.IsNotEmpty)({ message: "Job role is required." })
 ], AdminUpdateJobInformationDto.prototype, "jobRole", 2);
 __decorateClass([
-  (0, import_class_validator63.IsOptional)(),
-  (0, import_class_validator63.IsString)({ message: "Note must be a string." })
+  (0, import_class_validator67.IsOptional)(),
+  (0, import_class_validator67.IsString)({ message: "Note must be a string." })
 ], AdminUpdateJobInformationDto.prototype, "note", 2);
 __decorateClass([
-  (0, import_class_validator63.IsArray)({ message: "Skills must be an array of skill names." }),
-  (0, import_class_validator63.ArrayNotEmpty)({ message: "At least one skill must be provided." }),
-  (0, import_class_validator63.IsString)({ each: true, message: "Each skill must be a valid string." })
+  (0, import_class_validator67.IsArray)({ message: "Skills must be an array of skill names." }),
+  (0, import_class_validator67.ArrayNotEmpty)({ message: "At least one skill must be provided." }),
+  (0, import_class_validator67.IsString)({ each: true, message: "Each skill must be a valid string." })
 ], AdminUpdateJobInformationDto.prototype, "skills", 2);
 __decorateClass([
-  (0, import_class_validator63.IsInt)({ message: "Openings must be a valid integer." }),
-  (0, import_class_validator63.Min)(1, { message: "There must be at least one opening." })
+  (0, import_class_validator67.IsInt)({ message: "Openings must be a valid integer." }),
+  (0, import_class_validator67.Min)(1, { message: "There must be at least one opening." })
 ], AdminUpdateJobInformationDto.prototype, "openings", 2);
 __decorateClass([
-  (0, import_class_validator63.IsEnum)(JobLocationEnums, {
+  (0, import_class_validator67.IsEnum)(JobLocationEnums, {
     message: `Location must be one of: ${Object.values(JobLocationEnums).join(
       ", "
     )}.`
   })
 ], AdminUpdateJobInformationDto.prototype, "location", 2);
 __decorateClass([
-  (0, import_class_validator63.IsEnum)(TypeOfEmploymentEnums, {
+  (0, import_class_validator67.IsEnum)(TypeOfEmploymentEnums, {
     message: `Type of employment must be one of: ${Object.values(
       TypeOfEmploymentEnums
     ).join(", ")}.`
   })
 ], AdminUpdateJobInformationDto.prototype, "typeOfEmployment", 2);
 __decorateClass([
-  (0, import_class_validator63.IsString)({ message: "Onboarding Days must be a string." }),
-  (0, import_class_validator63.IsNotEmpty)({ message: "Onboarding Days is required." })
+  (0, import_class_validator67.IsString)({ message: "Onboarding Days must be a string." }),
+  (0, import_class_validator67.IsNotEmpty)({ message: "Onboarding Days is required." })
 ], AdminUpdateJobInformationDto.prototype, "onboardingTat", 2);
 __decorateClass([
-  (0, import_class_validator63.IsString)({ message: "Communication skills must be a string." }),
-  (0, import_class_validator63.IsNotEmpty)({ message: "Communication skills are required." })
+  (0, import_class_validator67.IsString)({ message: "Communication skills must be a string." }),
+  (0, import_class_validator67.IsNotEmpty)({ message: "Communication skills are required." })
 ], AdminUpdateJobInformationDto.prototype, "candidateCommunicationSkills", 2);
 __decorateClass([
-  (0, import_class_validator63.IsString)({ message: "Currency must be a string." }),
-  (0, import_class_validator63.IsNotEmpty)({ message: "Currency is required." })
+  (0, import_class_validator67.IsString)({ message: "Currency must be a string." }),
+  (0, import_class_validator67.IsNotEmpty)({ message: "Currency is required." })
 ], AdminUpdateJobInformationDto.prototype, "currency", 2);
 __decorateClass([
   (0, import_class_transformer13.Type)(() => Number),
-  (0, import_class_validator63.IsNumber)({}, { message: "Expected salary from must be a number." })
+  (0, import_class_validator67.IsNumber)({}, { message: "Expected salary from must be a number." })
 ], AdminUpdateJobInformationDto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
   (0, import_class_transformer13.Type)(() => Number),
-  (0, import_class_validator63.IsNumber)({}, { message: "Expected salary to must be a number." })
+  (0, import_class_validator67.IsNumber)({}, { message: "Expected salary to must be a number." })
 ], AdminUpdateJobInformationDto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
-  (0, import_class_validator63.IsDateString)(
+  (0, import_class_validator67.IsDateString)(
     { strict: true },
     { message: "Start date must be in YYYY-MM-DD format." }
   )
 ], AdminUpdateJobInformationDto.prototype, "tentativeStartDate", 2);
 __decorateClass([
-  (0, import_class_validator63.IsDateString)(
+  (0, import_class_validator67.IsDateString)(
     { strict: true },
     { message: "End date must be in YYYY-MM-DD format." }
   )
 ], AdminUpdateJobInformationDto.prototype, "tentativeEndDate", 2);
 __decorateClass([
-  (0, import_class_validator63.IsOptional)(),
-  (0, import_class_validator63.IsString)({ message: "Additional comment must be a string." })
+  (0, import_class_validator67.IsOptional)(),
+  (0, import_class_validator67.IsString)({ message: "Additional comment must be a string." })
 ], AdminUpdateJobInformationDto.prototype, "additionalComment", 2);
 __decorateClass([
-  (0, import_class_validator63.IsOptional)(),
-  (0, import_class_validator63.IsInt)({ message: "Country ID must be a valid integer." })
+  (0, import_class_validator67.IsOptional)(),
+  (0, import_class_validator67.IsInt)({ message: "Country ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "countryId", 2);
 __decorateClass([
-  (0, import_class_validator63.IsOptional)(),
-  (0, import_class_validator63.IsInt)({ message: "State ID must be a valid integer." })
+  (0, import_class_validator67.IsOptional)(),
+  (0, import_class_validator67.IsInt)({ message: "State ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "stateId", 2);
 __decorateClass([
-  (0, import_class_validator63.IsOptional)(),
-  (0, import_class_validator63.IsInt)({ message: "City ID must be a valid integer." })
+  (0, import_class_validator67.IsOptional)(),
+  (0, import_class_validator67.IsInt)({ message: "City ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "cityId", 2);
 __decorateClass([
-  (0, import_class_validator63.IsInt)({ message: "Client ID must be a valid integer." })
+  (0, import_class_validator67.IsInt)({ message: "Client ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "clientId", 2);
 
 // src/modules/job-admin/dto/admin-job-basic-information-v2.dto.ts
-var import_class_validator64 = require("class-validator");
+var import_class_validator68 = require("class-validator");
 var import_class_transformer14 = require("class-transformer");
 var JobLocationAdminEnumDto = /* @__PURE__ */ ((JobLocationAdminEnumDto2) => {
   JobLocationAdminEnumDto2["ONSITE"] = "ONSITE";
@@ -7741,16 +7814,16 @@ var AdminStepCompletedEnumV2 = /* @__PURE__ */ ((AdminStepCompletedEnumV22) => {
 var JobLocationAdminDto = class {
 };
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsNumber)()
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsNumber)()
 ], JobLocationAdminDto.prototype, "countryId", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsNumber)()
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsNumber)()
 ], JobLocationAdminDto.prototype, "stateId", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsNumber)()
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsNumber)()
 ], JobLocationAdminDto.prototype, "cityId", 2);
 var AdminJobBasicInformationV2Dto = class {
   constructor() {
@@ -7758,158 +7831,158 @@ var AdminJobBasicInformationV2Dto = class {
   }
 };
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator68.IsOptional)(),
   (0, import_class_transformer14.Type)(() => Boolean)
 ], AdminJobBasicInformationV2Dto.prototype, "isDraft", 2);
 __decorateClass([
-  (0, import_class_validator64.IsInt)({ message: "Client ID must be a valid integer." })
+  (0, import_class_validator68.IsInt)({ message: "Client ID must be a valid integer." })
 ], AdminJobBasicInformationV2Dto.prototype, "clientId", 2);
 __decorateClass([
-  (0, import_class_validator64.IsNotEmpty)({ message: "Please enter job role" }),
-  (0, import_class_validator64.IsString)({ message: "Job role must be a string" })
+  (0, import_class_validator68.IsNotEmpty)({ message: "Please enter job role" }),
+  (0, import_class_validator68.IsString)({ message: "Job role must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "jobRole", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsString)({ message: "Note must be a string" })
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsString)({ message: "Note must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "note", 2);
 __decorateClass([
-  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsArray)({ message: "Skills must be an array" }),
-  (0, import_class_validator64.ArrayNotEmpty)({ message: "Please select at least one skill" }),
-  (0, import_class_validator64.IsString)({ each: true, message: "Each skill must be a string" }),
+  (0, import_class_validator68.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsArray)({ message: "Skills must be an array" }),
+  (0, import_class_validator68.ArrayNotEmpty)({ message: "Please select at least one skill" }),
+  (0, import_class_validator68.IsString)({ each: true, message: "Each skill must be a string" }),
   (0, import_class_transformer14.Type)(() => String)
 ], AdminJobBasicInformationV2Dto.prototype, "skills", 2);
 __decorateClass([
-  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
-  (0, import_class_validator64.IsNumber)({}, { message: "Openings must be a number" }),
-  (0, import_class_validator64.Min)(1, { message: "There must be at least 1 opening" }),
+  (0, import_class_validator68.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator68.IsNumber)({}, { message: "Openings must be a number" }),
+  (0, import_class_validator68.Min)(1, { message: "There must be at least 1 opening" }),
   (0, import_class_transformer14.Type)(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "openings", 2);
 __decorateClass([
-  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
-  (0, import_class_validator64.IsEnum)(JobLocationAdminEnumDto, {
+  (0, import_class_validator68.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator68.IsEnum)(JobLocationAdminEnumDto, {
     message: `Location must be one of: ${Object.values(JobLocationAdminEnumDto).join(
       ", "
     )}`
   })
 ], AdminJobBasicInformationV2Dto.prototype, "location", 2);
 __decorateClass([
-  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
-  (0, import_class_validator64.IsEnum)(EmploymentTypeAdminEnumDto, {
+  (0, import_class_validator68.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator68.IsEnum)(EmploymentTypeAdminEnumDto, {
     message: `Type of employment must be one of: ${Object.values(
       EmploymentTypeAdminEnumDto
     ).join(", ")}`
   })
 ], AdminJobBasicInformationV2Dto.prototype, "typeOfEmployment", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsNumber)({}, { message: "Expected salary (from) must be a number" }),
-  (0, import_class_validator64.Min)(0, { message: "Expected salary (from) cannot be negative" }),
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsNumber)({}, { message: "Expected salary (from) must be a number" }),
+  (0, import_class_validator68.Min)(0, { message: "Expected salary (from) cannot be negative" }),
   (0, import_class_transformer14.Type)(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsNumber)({}, { message: "Expected salary (to) must be a number" }),
-  (0, import_class_validator64.Min)(0, { message: "Expected salary (to) cannot be negative" }),
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsNumber)({}, { message: "Expected salary (to) must be a number" }),
+  (0, import_class_validator68.Min)(0, { message: "Expected salary (to) cannot be negative" }),
   (0, import_class_transformer14.Type)(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator68.IsOptional)(),
   (0, import_class_transformer14.Type)(() => JobLocationAdminDto)
 ], AdminJobBasicInformationV2Dto.prototype, "locations", 2);
 __decorateClass([
-  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
-  (0, import_class_validator64.IsNotEmpty)({ message: "Please enter the academic qualification" }),
-  (0, import_class_validator64.IsString)({ message: "Academic qualification must be a string" })
+  (0, import_class_validator68.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator68.IsNotEmpty)({ message: "Please enter the academic qualification" }),
+  (0, import_class_validator68.IsString)({ message: "Academic qualification must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "academicQualification", 2);
 __decorateClass([
-  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
-  (0, import_class_validator64.IsEnum)(typeOfExperienceAdminEnumDto, {
+  (0, import_class_validator68.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator68.IsEnum)(typeOfExperienceAdminEnumDto, {
     message: `Type of experience must be one of: ${Object.values(
       typeOfExperienceAdminEnumDto
     ).join(", ")}`
   })
 ], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceType", 2);
 __decorateClass([
-  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
-  (0, import_class_validator64.IsNotEmpty)({ message: "Please enter the years of experience" }),
-  (0, import_class_validator64.IsString)({ message: "Years of experience must be a string" })
+  (0, import_class_validator68.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator68.IsNotEmpty)({ message: "Please enter the years of experience" }),
+  (0, import_class_validator68.IsString)({ message: "Years of experience must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceFrom", 2);
 __decorateClass([
-  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
-  (0, import_class_validator64.IsNotEmpty)({ message: "Please enter the years of experience upto" }),
-  (0, import_class_validator64.IsString)({ message: "Years of experience must be a string" })
+  (0, import_class_validator68.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator68.IsNotEmpty)({ message: "Please enter the years of experience upto" }),
+  (0, import_class_validator68.IsString)({ message: "Years of experience must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceTo", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsString)({ message: "Business industry must be a string" })
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsString)({ message: "Business industry must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "businessIndustry", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsString)({ message: "Project name must be a string" })
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsString)({ message: "Project name must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "projectName", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)()
+  (0, import_class_validator68.IsOptional)()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryFrom", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)()
+  (0, import_class_validator68.IsOptional)()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryTo", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsNumber)({}, { message: "Expected annual budget (from) must be a number" }),
-  (0, import_class_validator64.Min)(0, { message: "Expected annual budget (from) cannot be negative" }),
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsNumber)({}, { message: "Expected annual budget (from) must be a number" }),
+  (0, import_class_validator68.Min)(0, { message: "Expected annual budget (from) cannot be negative" }),
   (0, import_class_transformer14.Type)(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedAnnualBudgetFrom", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)()
+  (0, import_class_validator68.IsOptional)()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetFrom", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsNumber)({}, { message: "Expected annual budget (to) must be a number" }),
-  (0, import_class_validator64.Min)(0, { message: "Expected annual budget (to) cannot be negative" }),
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsNumber)({}, { message: "Expected annual budget (to) must be a number" }),
+  (0, import_class_validator68.Min)(0, { message: "Expected annual budget (to) cannot be negative" }),
   (0, import_class_transformer14.Type)(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedAnnualBudgetTo", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)()
+  (0, import_class_validator68.IsOptional)()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetTo", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsNumber)({}, { message: "Number of hours must be a number" }),
-  (0, import_class_validator64.Min)(0, { message: "Number of hours cannot be negative" }),
-  (0, import_class_validator64.Max)(40, { message: "Number of hours cannot exceed 40" }),
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsNumber)({}, { message: "Number of hours must be a number" }),
+  (0, import_class_validator68.Min)(0, { message: "Number of hours cannot be negative" }),
+  (0, import_class_validator68.Max)(40, { message: "Number of hours cannot exceed 40" }),
   (0, import_class_transformer14.Type)(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "numberOfHours", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)()
+  (0, import_class_validator68.IsOptional)()
 ], AdminJobBasicInformationV2Dto.prototype, "years", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)()
+  (0, import_class_validator68.IsOptional)()
 ], AdminJobBasicInformationV2Dto.prototype, "months", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)()
+  (0, import_class_validator68.IsOptional)()
 ], AdminJobBasicInformationV2Dto.prototype, "weeks", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)()
+  (0, import_class_validator68.IsOptional)()
 ], AdminJobBasicInformationV2Dto.prototype, "days", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsString)({ message: "Additional comment must be a string" }),
-  (0, import_class_validator64.MaxLength)(500, { message: "Additional comment must not exceed 500 characters" })
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsString)({ message: "Additional comment must be a string" }),
+  (0, import_class_validator68.MaxLength)(500, { message: "Additional comment must not exceed 500 characters" })
 ], AdminJobBasicInformationV2Dto.prototype, "additionalComment", 2);
 __decorateClass([
-  (0, import_class_validator64.ValidateIf)((o) => !o.isDraft),
-  (0, import_class_validator64.IsArray)({ message: "Good to have skills must be an array" }),
-  (0, import_class_validator64.IsString)({ each: true, message: "Each skill must be a string" }),
-  (0, import_class_validator64.IsOptional)(),
+  (0, import_class_validator68.ValidateIf)((o) => !o.isDraft),
+  (0, import_class_validator68.IsArray)({ message: "Good to have skills must be an array" }),
+  (0, import_class_validator68.IsString)({ each: true, message: "Each skill must be a string" }),
+  (0, import_class_validator68.IsOptional)(),
   (0, import_class_transformer14.Type)(() => String)
 ], AdminJobBasicInformationV2Dto.prototype, "goodToHaveSkills", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)()
+  (0, import_class_validator68.IsOptional)()
 ], AdminJobBasicInformationV2Dto.prototype, "jobRoleCanonicalName", 2);
 __decorateClass([
-  (0, import_class_validator64.IsOptional)(),
-  (0, import_class_validator64.IsEnum)(AdminStepCompletedEnumV2, {
+  (0, import_class_validator68.IsOptional)(),
+  (0, import_class_validator68.IsEnum)(AdminStepCompletedEnumV2, {
     message: `Type of stepCompleted must be one of: ${Object.values(
       AdminStepCompletedEnumV2
     ).join(", ")}`
@@ -7923,7 +7996,7 @@ var LEAD_PATTERN = {
 };
 
 // src/modules/lead/dto/create-lead.dto.ts
-var import_class_validator65 = require("class-validator");
+var import_class_validator69 = require("class-validator");
 var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
   CategoryEmumDto2["BUSINESS"] = "BUSINESS";
   CategoryEmumDto2["FREELANCER"] = "FREELANCER";
@@ -7932,23 +8005,23 @@ var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
 var CreateLeadDto = class {
 };
 __decorateClass([
-  (0, import_class_validator65.IsString)({ message: "Name must be a string" })
+  (0, import_class_validator69.IsString)({ message: "Name must be a string" })
 ], CreateLeadDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator65.IsEmail)({}, { message: "Invalid email address" })
+  (0, import_class_validator69.IsEmail)({}, { message: "Invalid email address" })
 ], CreateLeadDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator65.IsString)({ message: "Mobile code must be a string (e.g., +1)" })
+  (0, import_class_validator69.IsString)({ message: "Mobile code must be a string (e.g., +1)" })
 ], CreateLeadDto.prototype, "mobileCode", 2);
 __decorateClass([
-  (0, import_class_validator65.IsString)({ message: "Mobile must be a string (e.g., 1243253534)" })
+  (0, import_class_validator69.IsString)({ message: "Mobile must be a string (e.g., 1243253534)" })
 ], CreateLeadDto.prototype, "mobile", 2);
 __decorateClass([
-  (0, import_class_validator65.IsOptional)(),
-  (0, import_class_validator65.IsString)({ message: "Description must be a string" })
+  (0, import_class_validator69.IsOptional)(),
+  (0, import_class_validator69.IsString)({ message: "Description must be a string" })
 ], CreateLeadDto.prototype, "description", 2);
 __decorateClass([
-  (0, import_class_validator65.IsEnum)(CategoryEmumDto, {
+  (0, import_class_validator69.IsEnum)(CategoryEmumDto, {
     message: `Type of category must be one of: ${Object.values(
       CategoryEmumDto
     ).join(", ")}`
@@ -7969,46 +8042,46 @@ var ADMIN_ROLE_PATTERN = {
 };
 
 // src/modules/admin-role/dto/create-admin-role.dto.ts
-var import_class_validator66 = require("class-validator");
+var import_class_validator70 = require("class-validator");
 var CreateAdminRoleDto = class {
 };
 __decorateClass([
-  (0, import_class_validator66.IsNotEmpty)({ message: "Please enter admin role name." }),
-  (0, import_class_validator66.IsString)({ message: "Role name must be a string." })
+  (0, import_class_validator70.IsNotEmpty)({ message: "Please enter admin role name." }),
+  (0, import_class_validator70.IsString)({ message: "Role name must be a string." })
 ], CreateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  (0, import_class_validator66.IsOptional)(),
-  (0, import_class_validator66.IsString)({ message: "Role description must be a string." })
+  (0, import_class_validator70.IsOptional)(),
+  (0, import_class_validator70.IsString)({ message: "Role description must be a string." })
 ], CreateAdminRoleDto.prototype, "roleDescription", 2);
 
 // src/modules/admin-role/dto/update-admin-role.dto.ts
-var import_class_validator67 = require("class-validator");
+var import_class_validator71 = require("class-validator");
 var UpdateAdminRoleDto = class {
 };
 __decorateClass([
-  (0, import_class_validator67.IsNotEmpty)({ message: "Please enter admin role name." }),
-  (0, import_class_validator67.IsString)({ message: "Role name must be a string." })
+  (0, import_class_validator71.IsNotEmpty)({ message: "Please enter admin role name." }),
+  (0, import_class_validator71.IsString)({ message: "Role name must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  (0, import_class_validator67.IsOptional)(),
-  (0, import_class_validator67.IsString)({ message: "Role description must be a string." })
+  (0, import_class_validator71.IsOptional)(),
+  (0, import_class_validator71.IsString)({ message: "Role description must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleDescription", 2);
 __decorateClass([
-  (0, import_class_validator67.IsOptional)(),
-  (0, import_class_validator67.IsBoolean)({ message: "Is active must be a boolean value." })
+  (0, import_class_validator71.IsOptional)(),
+  (0, import_class_validator71.IsBoolean)({ message: "Is active must be a boolean value." })
 ], UpdateAdminRoleDto.prototype, "isActive", 2);
 
 // src/modules/admin-role/dto/attach-permissions-to-role.dto.ts
-var import_class_validator68 = require("class-validator");
+var import_class_validator72 = require("class-validator");
 var AttachPermissionsToRoleDto = class {
 };
 __decorateClass([
-  (0, import_class_validator68.IsNotEmpty)({ message: "Please enter admin role ID." }),
-  (0, import_class_validator68.IsString)({ message: "Role ID must be a string." })
+  (0, import_class_validator72.IsNotEmpty)({ message: "Please enter admin role ID." }),
+  (0, import_class_validator72.IsString)({ message: "Role ID must be a string." })
 ], AttachPermissionsToRoleDto.prototype, "roleId", 2);
 __decorateClass([
-  (0, import_class_validator68.IsNotEmpty)({ message: "Please enter permission IDs." }),
-  (0, import_class_validator68.IsString)({ message: "Permission IDs must be a comma-separated string." })
+  (0, import_class_validator72.IsNotEmpty)({ message: "Please enter permission IDs." }),
+  (0, import_class_validator72.IsString)({ message: "Permission IDs must be a comma-separated string." })
 ], AttachPermissionsToRoleDto.prototype, "permissionIds", 2);
 
 // src/modules/admin-permission/pattern/pattern.ts
@@ -8088,7 +8161,7 @@ var INTERVIEW_PATTERN = {
 };
 
 // src/modules/interview/dto/interview-invite.dto.ts
-var import_class_validator69 = require("class-validator");
+var import_class_validator73 = require("class-validator");
 var import_class_transformer15 = require("class-transformer");
 var CandidateType = /* @__PURE__ */ ((CandidateType2) => {
   CandidateType2["SHORTLISTED"] = "SHORTLISTED";
@@ -8100,126 +8173,126 @@ var CandidateType = /* @__PURE__ */ ((CandidateType2) => {
 var ExistingCandidateDto = class {
 };
 __decorateClass([
-  (0, import_class_validator69.IsUUID)()
+  (0, import_class_validator73.IsUUID)()
 ], ExistingCandidateDto.prototype, "id", 2);
 __decorateClass([
-  (0, import_class_validator69.IsEnum)(CandidateType, {
+  (0, import_class_validator73.IsEnum)(CandidateType, {
     message: "type must be one of SHORTLISTED, APPLICATNTS, or RECOMMENDED"
   })
 ], ExistingCandidateDto.prototype, "type", 2);
 var NewCandidateDto = class {
 };
 __decorateClass([
-  (0, import_class_validator69.IsNotEmpty)({ message: "Please enter the candidate name" }),
-  (0, import_class_validator69.IsString)({ message: "Name must be a string" })
+  (0, import_class_validator73.IsNotEmpty)({ message: "Please enter the candidate name" }),
+  (0, import_class_validator73.IsString)({ message: "Name must be a string" })
 ], NewCandidateDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator69.IsEmail)({}, { message: "Please enter a valid email." })
+  (0, import_class_validator73.IsEmail)({}, { message: "Please enter a valid email." })
 ], NewCandidateDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator69.IsEnum)(CandidateType, {
+  (0, import_class_validator73.IsEnum)(CandidateType, {
     message: "type must be NEW"
   })
 ], NewCandidateDto.prototype, "type", 2);
 var CandidatesDto = class {
 };
 __decorateClass([
-  (0, import_class_validator69.ValidateIf)((o) => o.exixtingCandidates?.length > 0),
-  (0, import_class_validator69.IsArray)({ message: "Existing candidates should be an array." }),
-  (0, import_class_validator69.ArrayNotEmpty)({ message: "Please select at least one candidate." }),
-  (0, import_class_validator69.ValidateNested)({ each: true }),
+  (0, import_class_validator73.ValidateIf)((o) => o.exixtingCandidates?.length > 0),
+  (0, import_class_validator73.IsArray)({ message: "Existing candidates should be an array." }),
+  (0, import_class_validator73.ArrayNotEmpty)({ message: "Please select at least one candidate." }),
+  (0, import_class_validator73.ValidateNested)({ each: true }),
   (0, import_class_transformer15.Type)(() => ExistingCandidateDto)
 ], CandidatesDto.prototype, "exixtingCandidates", 2);
 __decorateClass([
-  (0, import_class_validator69.ValidateIf)((o) => o.newCandidates?.length > 0),
-  (0, import_class_validator69.IsArray)({ message: "New candidates should be an array." }),
-  (0, import_class_validator69.ArrayNotEmpty)({ message: "Please add at least one candidate." }),
-  (0, import_class_validator69.ValidateNested)({ each: true }),
+  (0, import_class_validator73.ValidateIf)((o) => o.newCandidates?.length > 0),
+  (0, import_class_validator73.IsArray)({ message: "New candidates should be an array." }),
+  (0, import_class_validator73.ArrayNotEmpty)({ message: "Please add at least one candidate." }),
+  (0, import_class_validator73.ValidateNested)({ each: true }),
   (0, import_class_transformer15.Type)(() => NewCandidateDto)
 ], CandidatesDto.prototype, "newCandidates", 2);
 var InterviewInviteDto = class {
 };
 __decorateClass([
-  (0, import_class_validator69.IsUUID)()
+  (0, import_class_validator73.IsUUID)()
 ], InterviewInviteDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator69.ValidateNested)({ each: true }),
+  (0, import_class_validator73.ValidateNested)({ each: true }),
   (0, import_class_transformer15.Type)(() => CandidatesDto)
 ], InterviewInviteDto.prototype, "candidates", 2);
 
 // src/modules/interview/dto/create-f2f-interview.dto.ts
-var import_class_validator70 = require("class-validator");
+var import_class_validator74 = require("class-validator");
 var CreateF2FInterviewDto = class {
 };
 __decorateClass([
-  (0, import_class_validator70.IsEmail)({}, { message: "Please enter a valid email address." }),
-  (0, import_class_validator70.IsNotEmpty)({ message: "Invitee email is required." })
+  (0, import_class_validator74.IsEmail)({}, { message: "Please enter a valid email address." }),
+  (0, import_class_validator74.IsNotEmpty)({ message: "Invitee email is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  (0, import_class_validator70.IsString)({ message: "Invitee name must be a string." }),
-  (0, import_class_validator70.IsNotEmpty)({ message: "Invitee name is required." })
+  (0, import_class_validator74.IsString)({ message: "Invitee name must be a string." }),
+  (0, import_class_validator74.IsNotEmpty)({ message: "Invitee name is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeName", 2);
 __decorateClass([
-  (0, import_class_validator70.IsNumber)({}, { message: "Interview ID must be a number." })
+  (0, import_class_validator74.IsNumber)({}, { message: "Interview ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "interviewId", 2);
 __decorateClass([
-  (0, import_class_validator70.IsNumber)({}, { message: "Candidate ID must be a number." })
+  (0, import_class_validator74.IsNumber)({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-direct.dto.ts
-var import_class_validator71 = require("class-validator");
+var import_class_validator75 = require("class-validator");
 var CreateF2FInterviewDirectDto = class {
 };
 __decorateClass([
-  (0, import_class_validator71.IsEmail)({}, { message: "Please enter a valid email address." }),
-  (0, import_class_validator71.IsNotEmpty)({ message: "Invitee email is required." })
+  (0, import_class_validator75.IsEmail)({}, { message: "Please enter a valid email address." }),
+  (0, import_class_validator75.IsNotEmpty)({ message: "Invitee email is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  (0, import_class_validator71.IsString)({ message: "Invitee name must be a string." }),
-  (0, import_class_validator71.IsNotEmpty)({ message: "Invitee name is required." })
+  (0, import_class_validator75.IsString)({ message: "Invitee name must be a string." }),
+  (0, import_class_validator75.IsNotEmpty)({ message: "Invitee name is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeName", 2);
 __decorateClass([
-  (0, import_class_validator71.IsNumber)({}, { message: "Job ID must be a number." })
+  (0, import_class_validator75.IsNumber)({}, { message: "Job ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator71.IsNumber)({}, { message: "Candidate ID must be a number." })
+  (0, import_class_validator75.IsNumber)({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-reschedule-request.dto.ts
-var import_class_validator72 = require("class-validator");
+var import_class_validator76 = require("class-validator");
 var CreateF2FInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  (0, import_class_validator72.IsNotEmpty)({ message: "F2F Interview ID is required." })
+  (0, import_class_validator76.IsNotEmpty)({ message: "F2F Interview ID is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "f2FInterviewId", 2);
 __decorateClass([
-  (0, import_class_validator72.IsNotEmpty)({ message: "Rescheduled date is required." })
+  (0, import_class_validator76.IsNotEmpty)({ message: "Rescheduled date is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledDate", 2);
 __decorateClass([
-  (0, import_class_validator72.IsString)({ message: "Rescheduled slot must be a string." }),
-  (0, import_class_validator72.IsNotEmpty)({ message: "Rescheduled slot is required." })
+  (0, import_class_validator76.IsString)({ message: "Rescheduled slot must be a string." }),
+  (0, import_class_validator76.IsNotEmpty)({ message: "Rescheduled slot is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledSlot", 2);
 __decorateClass([
-  (0, import_class_validator72.IsString)({ message: "Freelancer reason must be a string." })
+  (0, import_class_validator76.IsString)({ message: "Freelancer reason must be a string." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/interview/dto/create-ai-interview-reschedule-request.dto.ts
-var import_class_validator73 = require("class-validator");
+var import_class_validator77 = require("class-validator");
 var CreateAIInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  (0, import_class_validator73.IsNotEmpty)({ message: "AI Interview ID is required." })
+  (0, import_class_validator77.IsNotEmpty)({ message: "AI Interview ID is required." })
 ], CreateAIInterviewRescheduleRequestDto.prototype, "aiInterviewId", 2);
 __decorateClass([
-  (0, import_class_validator73.IsString)({ message: "Freelancer reason must be a string." })
+  (0, import_class_validator77.IsString)({ message: "Freelancer reason must be a string." })
 ], CreateAIInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/interview/dto/reject-ai-interview-reschedule-request.dto.ts
-var import_class_validator74 = require("class-validator");
+var import_class_validator78 = require("class-validator");
 var RejectAIInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  (0, import_class_validator74.IsString)({ message: "Client reject reason must be a string." })
+  (0, import_class_validator78.IsString)({ message: "Client reject reason must be a string." })
 ], RejectAIInterviewRescheduleRequestDto.prototype, "clientRejectReason", 2);
 
 // src/modules/contract/pattern/pattern.ts
@@ -8257,43 +8330,43 @@ var CONTRACT_PATTERN = {
 };
 
 // src/modules/contract/dto/sign-contract-for-client.dto.ts
-var import_class_validator75 = require("class-validator");
+var import_class_validator79 = require("class-validator");
 var import_class_transformer16 = require("class-transformer");
 var SignContractForClientDto = class {
 };
 __decorateClass([
-  (0, import_class_validator75.IsNotEmpty)({ message: "Job Id is required." }),
+  (0, import_class_validator79.IsNotEmpty)({ message: "Job Id is required." }),
   (0, import_class_transformer16.Type)(() => Number),
-  (0, import_class_validator75.IsNumber)({}, { message: "Job ID must be a number." })
+  (0, import_class_validator79.IsNumber)({}, { message: "Job ID must be a number." })
 ], SignContractForClientDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator75.IsNotEmpty)({ message: "Freelancer ID is required." }),
+  (0, import_class_validator79.IsNotEmpty)({ message: "Freelancer ID is required." }),
   (0, import_class_transformer16.Type)(() => Number),
-  (0, import_class_validator75.IsNumber)({}, { message: "Freelancer ID must be a number." })
+  (0, import_class_validator79.IsNumber)({}, { message: "Freelancer ID must be a number." })
 ], SignContractForClientDto.prototype, "freelancerId", 2);
 __decorateClass([
-  (0, import_class_validator75.IsNotEmpty)({ message: "Contract type is required." }),
-  (0, import_class_validator75.IsEnum)(ContractTypeEnum)
+  (0, import_class_validator79.IsNotEmpty)({ message: "Contract type is required." }),
+  (0, import_class_validator79.IsEnum)(ContractTypeEnum)
 ], SignContractForClientDto.prototype, "contractType", 2);
 
 // src/modules/contract/dto/sign-contract-for-freelancer.dto.ts
-var import_class_validator76 = require("class-validator");
+var import_class_validator80 = require("class-validator");
 var import_class_transformer17 = require("class-transformer");
 var SignContractForFreelancerDto = class {
 };
 __decorateClass([
-  (0, import_class_validator76.IsNotEmpty)({ message: "Job Id is required." }),
+  (0, import_class_validator80.IsNotEmpty)({ message: "Job Id is required." }),
   (0, import_class_transformer17.Type)(() => Number),
-  (0, import_class_validator76.IsNumber)({}, { message: "Job ID must be a number." })
+  (0, import_class_validator80.IsNumber)({}, { message: "Job ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator76.IsNotEmpty)({ message: "Client ID is required." }),
+  (0, import_class_validator80.IsNotEmpty)({ message: "Client ID is required." }),
   (0, import_class_transformer17.Type)(() => Number),
-  (0, import_class_validator76.IsNumber)({}, { message: "Client ID must be a number." })
+  (0, import_class_validator80.IsNumber)({}, { message: "Client ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "clientId", 2);
 __decorateClass([
-  (0, import_class_validator76.IsNotEmpty)({ message: "Contract type is required." }),
-  (0, import_class_validator76.IsEnum)(ContractTypeEnum)
+  (0, import_class_validator80.IsNotEmpty)({ message: "Contract type is required." }),
+  (0, import_class_validator80.IsEnum)(ContractTypeEnum)
 ], SignContractForFreelancerDto.prototype, "contractType", 2);
 
 // src/modules/stripe/pattern/pattern.ts
@@ -8317,11 +8390,11 @@ var STRIPE_PATTERN = {
 };
 
 // src/modules/stripe/dto/create-checkout-session.dto.ts
-var import_class_validator77 = require("class-validator");
+var import_class_validator81 = require("class-validator");
 var CreateCheckoutSessionDto = class {
 };
 __decorateClass([
-  (0, import_class_validator77.IsNotEmpty)({ message: "Amount is required" })
+  (0, import_class_validator81.IsNotEmpty)({ message: "Amount is required" })
 ], CreateCheckoutSessionDto.prototype, "amount", 2);
 
 // src/modules/timesheet/pattern/pattern.ts
@@ -8365,101 +8438,143 @@ var TIMESHEET_CLIENT_PATTERN = {
 };
 
 // src/modules/timesheet/dto/create-freelancer-timesheet.dto.ts
-var import_class_validator78 = require("class-validator");
+var import_class_validator82 = require("class-validator");
 var CreateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  (0, import_class_validator78.IsNotEmpty)({ message: "Job id is required" }),
-  (0, import_class_validator78.IsNumber)({}, { message: "Job id must be a number" })
+  (0, import_class_validator82.IsNotEmpty)({ message: "Job id is required" }),
+  (0, import_class_validator82.IsNumber)({}, { message: "Job id must be a number" })
 ], CreateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator78.IsNotEmpty)({ message: "start date is required" }),
-  (0, import_class_validator78.IsDateString)()
+  (0, import_class_validator82.IsNotEmpty)({ message: "start date is required" }),
+  (0, import_class_validator82.IsDateString)()
 ], CreateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  (0, import_class_validator78.IsNotEmpty)({ message: "end date is required" }),
-  (0, import_class_validator78.IsDateString)()
+  (0, import_class_validator82.IsNotEmpty)({ message: "end date is required" }),
+  (0, import_class_validator82.IsDateString)()
 ], CreateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  (0, import_class_validator78.IsNotEmpty)({ message: "start time is required" }),
-  (0, import_class_validator78.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator82.IsNotEmpty)({ message: "start time is required" }),
+  (0, import_class_validator82.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "startTime must be in HH:mm:ss format"
   })
 ], CreateFreelancerTimesheetDto.prototype, "startTime", 2);
 __decorateClass([
-  (0, import_class_validator78.IsNotEmpty)({ message: "end time is required" }),
-  (0, import_class_validator78.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator82.IsNotEmpty)({ message: "end time is required" }),
+  (0, import_class_validator82.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "endTime must be in HH:mm:ss format"
   })
 ], CreateFreelancerTimesheetDto.prototype, "endTime", 2);
 __decorateClass([
-  (0, import_class_validator78.IsOptional)(),
-  (0, import_class_validator78.IsInt)()
+  (0, import_class_validator82.IsOptional)(),
+  (0, import_class_validator82.IsInt)()
 ], CreateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  (0, import_class_validator78.IsOptional)(),
-  (0, import_class_validator78.IsString)()
+  (0, import_class_validator82.IsOptional)(),
+  (0, import_class_validator82.IsString)()
 ], CreateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  (0, import_class_validator78.IsOptional)(),
-  (0, import_class_validator78.IsString)()
+  (0, import_class_validator82.IsOptional)(),
+  (0, import_class_validator82.IsString)()
 ], CreateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  (0, import_class_validator78.IsOptional)(),
-  (0, import_class_validator78.IsString)()
+  (0, import_class_validator82.IsOptional)(),
+  (0, import_class_validator82.IsString)()
 ], CreateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  (0, import_class_validator78.IsNotEmpty)({ message: "Description is required" })
+  (0, import_class_validator82.IsNotEmpty)({ message: "Description is required" })
 ], CreateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/timesheet/dto/update-freelancer-timesheet.dto.ts
-var import_class_validator79 = require("class-validator");
+var import_class_validator83 = require("class-validator");
 var UpdateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  (0, import_class_validator79.IsNotEmpty)({ message: "Job id is required" }),
-  (0, import_class_validator79.IsNumber)({}, { message: "Job id must be a number" })
+  (0, import_class_validator83.IsNotEmpty)({ message: "Job id is required" }),
+  (0, import_class_validator83.IsNumber)({}, { message: "Job id must be a number" })
 ], UpdateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator79.IsNotEmpty)({ message: "start date is required" }),
-  (0, import_class_validator79.IsDateString)()
+  (0, import_class_validator83.IsNotEmpty)({ message: "start date is required" }),
+  (0, import_class_validator83.IsDateString)()
 ], UpdateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  (0, import_class_validator79.IsNotEmpty)({ message: "end date is required" }),
-  (0, import_class_validator79.IsDateString)()
+  (0, import_class_validator83.IsNotEmpty)({ message: "end date is required" }),
+  (0, import_class_validator83.IsDateString)()
 ], UpdateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  (0, import_class_validator79.IsNotEmpty)({ message: "start time is required" }),
-  (0, import_class_validator79.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator83.IsNotEmpty)({ message: "start time is required" }),
+  (0, import_class_validator83.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "startTime must be in HH:mm:ss format"
   })
 ], UpdateFreelancerTimesheetDto.prototype, "startTime", 2);
 __decorateClass([
-  (0, import_class_validator79.IsNotEmpty)({ message: "end time is required" }),
-  (0, import_class_validator79.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator83.IsNotEmpty)({ message: "end time is required" }),
+  (0, import_class_validator83.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "endTime must be in HH:mm:ss format"
   })
 ], UpdateFreelancerTimesheetDto.prototype, "endTime", 2);
 __decorateClass([
-  (0, import_class_validator79.IsOptional)(),
-  (0, import_class_validator79.IsInt)()
+  (0, import_class_validator83.IsOptional)(),
+  (0, import_class_validator83.IsInt)()
 ], UpdateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  (0, import_class_validator79.IsOptional)(),
-  (0, import_class_validator79.IsString)()
+  (0, import_class_validator83.IsOptional)(),
+  (0, import_class_validator83.IsString)()
 ], UpdateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  (0, import_class_validator79.IsOptional)(),
-  (0, import_class_validator79.IsString)()
+  (0, import_class_validator83.IsOptional)(),
+  (0, import_class_validator83.IsString)()
 ], UpdateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  (0, import_class_validator79.IsOptional)(),
-  (0, import_class_validator79.IsString)()
+  (0, import_class_validator83.IsOptional)(),
+  (0, import_class_validator83.IsString)()
 ], UpdateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  (0, import_class_validator79.IsNotEmpty)({ message: "Description is required" })
+  (0, import_class_validator83.IsNotEmpty)({ message: "Description is required" })
 ], UpdateFreelancerTimesheetDto.prototype, "description", 2);
 
+// src/modules/timesheet/dto/submit-timesheet.dto.ts
+var import_class_validator84 = require("class-validator");
+var SubmitTimesheetDto = class {
+};
+__decorateClass([
+  (0, import_class_validator84.IsNotEmpty)({ message: "Timesheet line ID is required" }),
+  (0, import_class_validator84.IsNumber)({}, { message: "Timesheet line ID must be a number" })
+], SubmitTimesheetDto.prototype, "timesheetLineId", 2);
+
+// src/modules/timesheet/dto/resubmit-timesheet.dto.ts
+var import_class_validator85 = require("class-validator");
+var ResubmitTimesheetDto = class {
+};
+__decorateClass([
+  (0, import_class_validator85.IsNotEmpty)({ message: "Timesheet line ID is required" }),
+  (0, import_class_validator85.IsNumber)({}, { message: "Timesheet line ID must be a number" })
+], ResubmitTimesheetDto.prototype, "timesheetLineId", 2);
+
+// src/modules/timesheet/dto/approve-timesheets.dto.ts
+var import_class_validator86 = require("class-validator");
+var ApproveTimesheetsDto = class {
+};
+__decorateClass([
+  (0, import_class_validator86.IsArray)({ message: "Timesheet line IDs must be an array" }),
+  (0, import_class_validator86.ArrayNotEmpty)({ message: "At least one timesheet line ID is required" }),
+  (0, import_class_validator86.IsNumber)({}, { each: true, message: "Each timesheet line ID must be a number" })
+], ApproveTimesheetsDto.prototype, "timesheetLineIds", 2);
+
+// src/modules/timesheet/dto/send-back-timesheets.dto.ts
+var import_class_validator87 = require("class-validator");
+var SendBackTimesheetsDto = class {
+};
+__decorateClass([
+  (0, import_class_validator87.IsArray)({ message: "Timesheet line IDs must be an array" }),
+  (0, import_class_validator87.ArrayNotEmpty)({ message: "At least one timesheet line ID is required" }),
+  (0, import_class_validator87.IsNumber)({}, { each: true, message: "Each timesheet line ID must be a number" })
+], SendBackTimesheetsDto.prototype, "timesheetLineIds", 2);
+__decorateClass([
+  (0, import_class_validator87.IsOptional)(),
+  (0, import_class_validator87.IsString)()
+], SendBackTimesheetsDto.prototype, "reason", 2);
+
 // src/modules/invoice/pattern/pattern.ts
 var INVOICE_PATTERN = {
   createInvoice: "invoice.create",
@@ -8479,16 +8594,25 @@ var INVOICE_PATTERN = {
 };
 
 // src/modules/invoice/dto/update-invoice-status.dto.ts
-var import_class_validator80 = require("class-validator");
+var import_class_validator88 = require("class-validator");
 var UpdateInvoiceStatusDto = class {
 };
 __decorateClass([
-  (0, import_class_validator80.IsNotEmpty)({ message: "Please provide invoice status." }),
-  (0, import_class_validator80.IsEnum)(InvoiceStatusEnum, {
+  (0, import_class_validator88.IsNotEmpty)({ message: "Please provide invoice status." }),
+  (0, import_class_validator88.IsEnum)(InvoiceStatusEnum, {
     message: "Status must be one of: APPROVED, REJECTED"
   })
 ], UpdateInvoiceStatusDto.prototype, "status", 2);
 
+// src/modules/invoice/dto/create-invoice.dto.ts
+var import_class_validator89 = require("class-validator");
+var CreateInvoiceDto = class {
+};
+__decorateClass([
+  (0, import_class_validator89.IsNotEmpty)({ message: "Timesheet line ID is required" }),
+  (0, import_class_validator89.IsNumber)({}, { message: "Timesheet line ID must be a number" })
+], CreateInvoiceDto.prototype, "timeSheetLineId", 2);
+
 // src/modules/dispute/pattern/pattern.ts
 var DISPUTE_PATTERN = {
   fetchDisputes: "fetch.disputes",
@@ -8497,42 +8621,42 @@ var DISPUTE_PATTERN = {
 };
 
 // src/modules/dispute/dto/create-dispute.dto.ts
-var import_class_validator81 = require("class-validator");
+var import_class_validator90 = require("class-validator");
 var import_class_transformer18 = require("class-transformer");
 var CreateDisputeDto = class {
 };
 __decorateClass([
-  (0, import_class_validator81.ValidateIf)((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
-  (0, import_class_validator81.IsNumber)({}, { message: "Client id must be a number" }),
+  (0, import_class_validator90.ValidateIf)((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
+  (0, import_class_validator90.IsNumber)({}, { message: "Client id must be a number" }),
   (0, import_class_transformer18.Type)(() => Number)
 ], CreateDisputeDto.prototype, "clientId", 2);
 __decorateClass([
-  (0, import_class_validator81.ValidateIf)((o) => o.initiatorType === "CLIENT" /* CLIENT */),
-  (0, import_class_validator81.IsNumber)({}, { message: "Freelancer id must be a number" }),
+  (0, import_class_validator90.ValidateIf)((o) => o.initiatorType === "CLIENT" /* CLIENT */),
+  (0, import_class_validator90.IsNumber)({}, { message: "Freelancer id must be a number" }),
   (0, import_class_transformer18.Type)(() => Number)
 ], CreateDisputeDto.prototype, "freelancerId", 2);
 __decorateClass([
-  (0, import_class_validator81.IsNotEmpty)({ message: "Please select dispute type." }),
-  (0, import_class_validator81.IsString)(),
-  (0, import_class_validator81.IsIn)(["JOB", "INVOICE"])
+  (0, import_class_validator90.IsNotEmpty)({ message: "Please select dispute type." }),
+  (0, import_class_validator90.IsString)(),
+  (0, import_class_validator90.IsIn)(["JOB", "INVOICE"])
 ], CreateDisputeDto.prototype, "disputeType", 2);
 __decorateClass([
-  (0, import_class_validator81.IsNotEmpty)({ message: "Please provide initiator type." }),
-  (0, import_class_validator81.IsString)()
+  (0, import_class_validator90.IsNotEmpty)({ message: "Please provide initiator type." }),
+  (0, import_class_validator90.IsString)()
 ], CreateDisputeDto.prototype, "initiatorType", 2);
 __decorateClass([
-  (0, import_class_validator81.IsNotEmpty)({ message: "Please enter description." }),
-  (0, import_class_validator81.IsString)({ message: "Description must be a string" }),
-  (0, import_class_validator81.MaxLength)(500, { message: "Description must not exceed 500 characters" })
+  (0, import_class_validator90.IsNotEmpty)({ message: "Please enter description." }),
+  (0, import_class_validator90.IsString)({ message: "Description must be a string" }),
+  (0, import_class_validator90.MaxLength)(500, { message: "Description must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "description", 2);
 __decorateClass([
-  (0, import_class_validator81.IsOptional)(),
-  (0, import_class_validator81.IsString)({ message: "Comment must be a string" }),
-  (0, import_class_validator81.MaxLength)(500, { message: "Comment must not exceed 500 characters" })
+  (0, import_class_validator90.IsOptional)(),
+  (0, import_class_validator90.IsString)({ message: "Comment must be a string" }),
+  (0, import_class_validator90.MaxLength)(500, { message: "Comment must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "comment", 2);
 __decorateClass([
-  (0, import_class_validator81.IsOptional)(),
-  (0, import_class_validator81.IsObject)({ message: "Dynamic fields must be a valid object" }),
+  (0, import_class_validator90.IsOptional)(),
+  (0, import_class_validator90.IsObject)({ message: "Dynamic fields must be a valid object" }),
   (0, import_class_transformer18.Transform)(({ value }) => {
     if (typeof value === "string") {
       try {
@@ -8553,14 +8677,14 @@ var SENSELOAF_PATTERN = {
 };
 
 // src/modules/senseloaf/dto/ai-interview-question-generate.dto.ts
-var import_class_validator82 = require("class-validator");
+var import_class_validator91 = require("class-validator");
 var AiInterviewQuestionGenerateDto = class {
 };
 __decorateClass([
-  (0, import_class_validator82.IsNotEmpty)({ message: "Please enter job description." })
+  (0, import_class_validator91.IsNotEmpty)({ message: "Please enter job description." })
 ], AiInterviewQuestionGenerateDto.prototype, "jobDescription", 2);
 __decorateClass([
-  (0, import_class_validator82.IsNotEmpty)({ message: "Please enter number of questions." })
+  (0, import_class_validator91.IsNotEmpty)({ message: "Please enter number of questions." })
 ], AiInterviewQuestionGenerateDto.prototype, "numQuestions", 2);
 
 // src/modules/commission/pattern/pattern.ts
@@ -8575,6 +8699,19 @@ var HIRING_PATTERN = {
   createHiring: "create.hiring"
 };
 
+// src/modules/hiring/dto/create-hiring.dto.ts
+var import_class_validator92 = require("class-validator");
+var CreateHiringDto = class {
+};
+__decorateClass([
+  (0, import_class_validator92.IsNotEmpty)({ message: "Freelancer ID is required" }),
+  (0, import_class_validator92.IsNumber)({}, { message: "Freelancer ID must be a number" })
+], CreateHiringDto.prototype, "freelancerId", 2);
+__decorateClass([
+  (0, import_class_validator92.IsNotEmpty)({ message: "Job ID is required" }),
+  (0, import_class_validator92.IsNumber)({}, { message: "Job ID must be a number" })
+], CreateHiringDto.prototype, "jobId", 2);
+
 // src/modules/llm/pattern/pattern.ts
 var LLM_PATTERN = {
   handleMcqGeneration: "handle.mcq.generation"
@@ -9621,6 +9758,7 @@ RecommendationWeightageConfig = __decorateClass([
   AiInterviewStatusEnum,
   AnswerTypeEnum,
   ApplicationStatusEnum,
+  ApproveTimesheetsDto,
   AssessmentAnswer,
   AssessmentRequestStatusEnum,
   AssessmentStatusEnum,
@@ -9649,6 +9787,8 @@ RecommendationWeightageConfig = __decorateClass([
   CaseStudyDto,
   CategoryEmum,
   CategoryEmumDto,
+  ChangeJobApplicationStatusBulkDto,
+  ChangeJobApplicationStatusDto,
   ChatRMQAdapter,
   ChatTCPAdapter,
   City,
@@ -9658,6 +9798,7 @@ RecommendationWeightageConfig = __decorateClass([
   ClientCreateAccountDto,
   ClientFreelancerRecommendation,
   ClientProfileQuestionDto,
+  CloseJobDto,
   Cms,
   Commission,
   CommissionTypeEnum,
@@ -9688,6 +9829,9 @@ RecommendationWeightageConfig = __decorateClass([
   CreateF2FInterviewRescheduleRequestDto,
   CreateFreelancerDto,
   CreateFreelancerTimesheetDto,
+  CreateHiringDto,
+  CreateInvoiceDto,
+  CreateJobApplicationDto,
   CreateLeadDto,
   CreateQuestionDto,
   CreateRatingDto,
@@ -9779,6 +9923,7 @@ RecommendationWeightageConfig = __decorateClass([
   Job,
   JobAdditionalCommentDto,
   JobApplication,
+  JobApplicationStatus,
   JobBasicInformationDto,
   JobBasicInformationV2Dto,
   JobDescriptionDto,
@@ -9843,6 +9988,7 @@ RecommendationWeightageConfig = __decorateClass([
   RejectAIInterviewRescheduleRequestDto,
   ResetPasswordDto,
   ResetPasswordTokenValidationDto,
+  ResubmitTimesheetDto,
   ResultStatusEnum,
   SENSELOAF_PATTERN,
   SIGNATURE_PATTERN,
@@ -9854,6 +10000,7 @@ RecommendationWeightageConfig = __decorateClass([
   SYSTEM_PREFERENCES_PATTERN,
   ScopeEnum,
   SelectedAnswerTypeEnum,
+  SendBackTimesheetsDto,
   SendGuestOtpDto,
   SendGuestOtpPurposeEnum,
   SendGuestOtpScopeEnum,
@@ -9875,6 +10022,7 @@ RecommendationWeightageConfig = __decorateClass([
   StripeTransaction,
   StripeTransactionStatusEnum,
   StripeTransactionTypeEnum,
+  SubmitTimesheetDto,
   SystemPreference,
   SystemPreferenceDto,
   SystemPreferenceKey,