@experts_hub/shared 1.0.570 → 1.0.572

package/dist/index.mjs

@@ -197,6 +197,49 @@ __decorateClass([
   })
 ], ResetPasswordTokenValidationDto.prototype, "scope", 2);
 
+// src/modules/authentication/dto/validate-email.dto.ts
+import { IsNotEmpty as IsNotEmpty9, IsEmail as IsEmail2 } from "class-validator";
+var ValidateEmailDto = class {
+};
+__decorateClass([
+  IsNotEmpty9({ message: "Email is required" }),
+  IsEmail2({}, { message: "Email must be valid" })
+], ValidateEmailDto.prototype, "email", 2);
+
+// src/modules/authentication/dto/validate-mobile.dto.ts
+import { IsNotEmpty as IsNotEmpty10, IsPhoneNumber } from "class-validator";
+var ValidateMobileDto = class {
+};
+__decorateClass([
+  IsNotEmpty10({ message: "Mobile number is required" }),
+  IsPhoneNumber()
+], ValidateMobileDto.prototype, "mobile", 2);
+
+// src/modules/authentication/dto/social-auth.dto.ts
+import { IsOptional, IsString, IsObject } from "class-validator";
+var SocialAuthDto = class {
+};
+__decorateClass([
+  IsOptional(),
+  IsString()
+], SocialAuthDto.prototype, "accessToken", 2);
+__decorateClass([
+  IsOptional(),
+  IsString()
+], SocialAuthDto.prototype, "refreshToken", 2);
+__decorateClass([
+  IsOptional(),
+  IsObject()
+], SocialAuthDto.prototype, "profile", 2);
+__decorateClass([
+  IsOptional(),
+  IsString()
+], SocialAuthDto.prototype, "provider", 2);
+__decorateClass([
+  IsOptional(),
+  IsString()
+], SocialAuthDto.prototype, "providerId", 2);
+
 // src/modules/otp/pattern/pattern.ts
 var OTP_PATTERN = {
   handleSendGuestOtp: "handle.send.guest.otp",
@@ -207,7 +250,7 @@ var OTP_PATTERN = {
 };
 
 // src/modules/otp/dto/send-guest-otp.dto.ts
-import { IsEnum as IsEnum7, IsNotEmpty as IsNotEmpty9, IsOptional, IsString } from "class-validator";
+import { IsEnum as IsEnum7, IsNotEmpty as IsNotEmpty11, IsOptional as IsOptional2, IsString as IsString2 } from "class-validator";
 var SendGuestOtpPurposeEnum = /* @__PURE__ */ ((SendGuestOtpPurposeEnum2) => {
   SendGuestOtpPurposeEnum2["ACCOUNT_VERIFICATION"] = "ACCOUNT_VERIFICATION";
   return SendGuestOtpPurposeEnum2;
@@ -220,28 +263,28 @@ var SendGuestOtpScopeEnum = /* @__PURE__ */ ((SendGuestOtpScopeEnum2) => {
 var SendGuestOtpDto = class {
 };
 __decorateClass([
-  IsNotEmpty9({ message: "Please enter full name." }),
-  IsString({ message: "Please enter valid full name." })
+  IsNotEmpty11({ message: "Please enter full name." }),
+  IsString2({ message: "Please enter valid full name." })
 ], SendGuestOtpDto.prototype, "fullName", 2);
 __decorateClass([
-  IsNotEmpty9({ message: "Please enter target." }),
-  IsString({ message: "Please enter valid target." })
+  IsNotEmpty11({ message: "Please enter target." }),
+  IsString2({ message: "Please enter valid target." })
 ], SendGuestOtpDto.prototype, "target", 2);
 __decorateClass([
-  IsOptional(),
-  IsString({ message: "Please enter valid fallback target." })
+  IsOptional2(),
+  IsString2({ message: "Please enter valid fallback target." })
 ], SendGuestOtpDto.prototype, "fallbackTarget", 2);
 __decorateClass([
-  IsNotEmpty9({ message: "Please enter OTP purpose." }),
+  IsNotEmpty11({ message: "Please enter OTP purpose." }),
   IsEnum7(SendGuestOtpPurposeEnum, { message: "Purpose must be a valid OTP purpose" })
 ], SendGuestOtpDto.prototype, "purpose", 2);
 __decorateClass([
-  IsNotEmpty9({ message: "Please enter scope." }),
+  IsNotEmpty11({ message: "Please enter scope." }),
   IsEnum7(SendGuestOtpScopeEnum, { message: "scope must be a valid" })
 ], SendGuestOtpDto.prototype, "scope", 2);
 
 // src/modules/otp/dto/send-login-otp.dto.ts
-import { IsEnum as IsEnum8, IsNotEmpty as IsNotEmpty10, IsString as IsString2 } from "class-validator";
+import { IsEnum as IsEnum8, IsNotEmpty as IsNotEmpty12, IsString as IsString3 } from "class-validator";
 var SendLoginOtpPurposeEnum = /* @__PURE__ */ ((SendLoginOtpPurposeEnum2) => {
   SendLoginOtpPurposeEnum2["ACCOUNT_VERIFICATION"] = "ACCOUNT_VERIFICATION";
   return SendLoginOtpPurposeEnum2;
@@ -254,20 +297,20 @@ var SendLoginOtpScopeEnum = /* @__PURE__ */ ((SendLoginOtpScopeEnum2) => {
 var SendLoginOtpDto = class {
 };
 __decorateClass([
-  IsNotEmpty10({ message: "Please enter target." }),
-  IsString2({ message: "Please enter valid target." })
+  IsNotEmpty12({ message: "Please enter target." }),
+  IsString3({ message: "Please enter valid target." })
 ], SendLoginOtpDto.prototype, "target", 2);
 __decorateClass([
-  IsNotEmpty10({ message: "Please enter OTP purpose." }),
+  IsNotEmpty12({ message: "Please enter OTP purpose." }),
   IsEnum8(SendLoginOtpPurposeEnum, { message: "Purpose must be a valid OTP purpose" })
 ], SendLoginOtpDto.prototype, "purpose", 2);
 __decorateClass([
-  IsNotEmpty10({ message: "Please enter scope." }),
+  IsNotEmpty12({ message: "Please enter scope." }),
   IsEnum8(SendLoginOtpScopeEnum, { message: "scope must be a valid" })
 ], SendLoginOtpDto.prototype, "scope", 2);
 
 // src/modules/otp/dto/verify-guest-otp.dto.ts
-import { IsEnum as IsEnum9, IsNotEmpty as IsNotEmpty11, IsString as IsString3, Length } from "class-validator";
+import { IsEnum as IsEnum9, IsNotEmpty as IsNotEmpty13, IsString as IsString4, Length } from "class-validator";
 var VerifyGuestOtpPurposeEnum = /* @__PURE__ */ ((VerifyGuestOtpPurposeEnum2) => {
   VerifyGuestOtpPurposeEnum2["ACCOUNT_VERIFICATION"] = "ACCOUNT_VERIFICATION";
   return VerifyGuestOtpPurposeEnum2;
@@ -275,21 +318,60 @@ var VerifyGuestOtpPurposeEnum = /* @__PURE__ */ ((VerifyGuestOtpPurposeEnum2) =>
 var VerifyGuestOtpDto = class {
 };
 __decorateClass([
-  IsNotEmpty11({ message: "Please enter target." }),
-  IsString3({ message: "Please enter valid target." })
+  IsNotEmpty13({ message: "Please enter target." }),
+  IsString4({ message: "Please enter valid target." })
 ], VerifyGuestOtpDto.prototype, "target", 2);
 __decorateClass([
-  IsNotEmpty11({ message: "Please enter otp." }),
-  IsString3({ message: "Please enter valid otp." }),
+  IsNotEmpty13({ message: "Please enter otp." }),
+  IsString4({ message: "Please enter valid otp." }),
   Length(4, 6, { message: "OTP must be between 4 and 6 characters" })
 ], VerifyGuestOtpDto.prototype, "otp", 2);
 __decorateClass([
-  IsNotEmpty11({ message: "Please enter OTP purpose." }),
+  IsNotEmpty13({ message: "Please enter OTP purpose." }),
   IsEnum9(VerifyGuestOtpPurposeEnum, {
     message: "Purpose must be a valid OTP purpose"
   })
 ], VerifyGuestOtpDto.prototype, "purpose", 2);
 
+// src/modules/otp/dto/send-otp.dto.ts
+import { IsNotEmpty as IsNotEmpty14, IsString as IsString5, IsOptional as IsOptional4, IsEnum as IsEnum10 } from "class-validator";
+var OtpType = /* @__PURE__ */ ((OtpType2) => {
+  OtpType2["SMS"] = "SMS";
+  OtpType2["EMAIL"] = "EMAIL";
+  return OtpType2;
+})(OtpType || {});
+var SendOtpDto = class {
+};
+__decorateClass([
+  IsNotEmpty14({ message: "Recipient is required" }),
+  IsString5({ message: "Recipient must be a string" })
+], SendOtpDto.prototype, "recipient", 2);
+__decorateClass([
+  IsOptional4(),
+  IsEnum10(OtpType, { message: `Type must be one of: ${Object.values(OtpType).join(", ")}` })
+], SendOtpDto.prototype, "type", 2);
+__decorateClass([
+  IsOptional4(),
+  IsString5()
+], SendOtpDto.prototype, "purpose", 2);
+
+// src/modules/otp/dto/verify-otp.dto.ts
+import { IsNotEmpty as IsNotEmpty15, IsString as IsString6, IsOptional as IsOptional5 } from "class-validator";
+var VerifyOtpDto = class {
+};
+__decorateClass([
+  IsNotEmpty15({ message: "Recipient is required" }),
+  IsString6({ message: "Recipient must be a string" })
+], VerifyOtpDto.prototype, "recipient", 2);
+__decorateClass([
+  IsNotEmpty15({ message: "OTP code is required" }),
+  IsString6({ message: "OTP code must be a string" })
+], VerifyOtpDto.prototype, "otp", 2);
+__decorateClass([
+  IsOptional5(),
+  IsString6()
+], VerifyOtpDto.prototype, "purpose", 2);
+
 // src/modules/onboarding/pattern/pattern.ts
 var ONBOARDING_PATTERN = {
   handleFreelancerAccountCreation: "handle.freelancer.account.creation",
@@ -316,11 +398,11 @@ var ONBOARDING_PATTERN = {
 
 // src/modules/onboarding/dto/freelancer-create-account.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty12,
-  IsEmail as IsEmail2,
+  IsNotEmpty as IsNotEmpty16,
+  IsEmail as IsEmail3,
   Matches as Matches3,
-  IsString as IsString4,
-  IsOptional as IsOptional3
+  IsString as IsString7,
+  IsOptional as IsOptional6
 } from "class-validator";
 
 // src/decorators/match.decorator.ts
@@ -496,123 +578,123 @@ function IsBusinessEmail(validationOptions) {
 var FreelancerCreateAccountDto = class {
 };
 __decorateClass([
-  IsNotEmpty12({ message: "Please enter full name." }),
-  IsString4({ message: "Please enter valid full name." })
+  IsNotEmpty16({ message: "Please enter full name." }),
+  IsString7({ message: "Please enter valid full name." })
 ], FreelancerCreateAccountDto.prototype, "fullName", 2);
 __decorateClass([
-  IsNotEmpty12({ message: "Please enter email." }),
-  IsEmail2()
+  IsNotEmpty16({ message: "Please enter email." }),
+  IsEmail3()
 ], FreelancerCreateAccountDto.prototype, "email", 2);
 __decorateClass([
-  IsNotEmpty12({ message: "Please enter mobile code." }),
+  IsNotEmpty16({ message: "Please enter mobile code." }),
   Matches3(/^\+\d{1,4}$/, {
     message: "Please enter a valid country mobile code (e.g., +91, +1, +44)."
   })
 ], FreelancerCreateAccountDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsNotEmpty12({ message: "Please enter mobile number." }),
+  IsNotEmpty16({ message: "Please enter mobile number." }),
   IsValidMobileNumber({ message: "Mobile number is not valid for the selected country code." })
 ], FreelancerCreateAccountDto.prototype, "mobile", 2);
 __decorateClass([
-  IsNotEmpty12({ message: "Please enter country iso code." })
+  IsNotEmpty16({ message: "Please enter country iso code." })
 ], FreelancerCreateAccountDto.prototype, "countryISOCode", 2);
 __decorateClass([
-  IsOptional3()
+  IsOptional6()
 ], FreelancerCreateAccountDto.prototype, "onBoardedBy", 2);
 
 // src/modules/onboarding/dto/freelancer-upload-resume.dto.ts
-import { IsUUID, IsNotEmpty as IsNotEmpty13 } from "class-validator";
+import { IsUUID, IsNotEmpty as IsNotEmpty17 } from "class-validator";
 var FreelancerUploadResumeDto = class {
 };
 __decorateClass([
-  IsNotEmpty13({ message: "Please enter uuid." }),
+  IsNotEmpty17({ message: "Please enter uuid." }),
   IsUUID()
 ], FreelancerUploadResumeDto.prototype, "uuid", 2);
 
 // src/modules/onboarding/dto/freelancer-parse-resume.dto.ts
-import { IsUUID as IsUUID2, IsNotEmpty as IsNotEmpty14 } from "class-validator";
+import { IsUUID as IsUUID2, IsNotEmpty as IsNotEmpty18 } from "class-validator";
 var FreelancerParseResumeDto = class {
 };
 __decorateClass([
-  IsNotEmpty14({ message: "Please enter uuid." }),
+  IsNotEmpty18({ message: "Please enter uuid." }),
   IsUUID2()
 ], FreelancerParseResumeDto.prototype, "uuid", 2);
 
 // src/modules/onboarding/dto/freelancer-initiate-mcq-assessment.dto.ts
-import { IsUUID as IsUUID3, IsNotEmpty as IsNotEmpty15 } from "class-validator";
+import { IsUUID as IsUUID3, IsNotEmpty as IsNotEmpty19 } from "class-validator";
 var FreelancerInitiateMcqAssessmentDto = class {
 };
 __decorateClass([
-  IsNotEmpty15({ message: "Please enter uuid." }),
+  IsNotEmpty19({ message: "Please enter uuid." }),
   IsUUID3()
 ], FreelancerInitiateMcqAssessmentDto.prototype, "uuid", 2);
 
 // src/modules/onboarding/dto/freelancer-skip-ai-assessment.dto.ts
-import { IsUUID as IsUUID4, IsNotEmpty as IsNotEmpty16 } from "class-validator";
+import { IsUUID as IsUUID4, IsNotEmpty as IsNotEmpty20 } from "class-validator";
 var FreelancerSkipAiAssessmentDto = class {
 };
 __decorateClass([
-  IsNotEmpty16({ message: "Please enter uuid." }),
+  IsNotEmpty20({ message: "Please enter uuid." }),
   IsUUID4()
 ], FreelancerSkipAiAssessmentDto.prototype, "uuid", 2);
 
 // src/modules/onboarding/dto/freelancer-initiate-ai-assessment.dto.ts
-import { IsUUID as IsUUID5, IsNotEmpty as IsNotEmpty17 } from "class-validator";
+import { IsUUID as IsUUID5, IsNotEmpty as IsNotEmpty21 } from "class-validator";
 var FreelancerInitiateAiAssessmentDto = class {
 };
 __decorateClass([
-  IsNotEmpty17({ message: "Please enter uuid." }),
+  IsNotEmpty21({ message: "Please enter uuid." }),
   IsUUID5()
 ], FreelancerInitiateAiAssessmentDto.prototype, "uuid", 2);
 
 // src/modules/onboarding/dto/freelancer-capture-ai-assessment-status.dto.ts
-import { IsUUID as IsUUID6, IsNotEmpty as IsNotEmpty18, IsOptional as IsOptional4 } from "class-validator";
+import { IsUUID as IsUUID6, IsNotEmpty as IsNotEmpty22, IsOptional as IsOptional7 } from "class-validator";
 var FreelancerCaptureAiAssessmentStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty18({ message: "Please enter uuid." }),
+  IsNotEmpty22({ message: "Please enter uuid." }),
   IsUUID6()
 ], FreelancerCaptureAiAssessmentStatusDto.prototype, "uuid", 2);
 __decorateClass([
-  IsNotEmpty18({ message: "Please enter assessment id." })
+  IsNotEmpty22({ message: "Please enter assessment id." })
 ], FreelancerCaptureAiAssessmentStatusDto.prototype, "assessmentId", 2);
 __decorateClass([
-  IsNotEmpty18({ message: "Please enter assessment status." })
+  IsNotEmpty22({ message: "Please enter assessment status." })
 ], FreelancerCaptureAiAssessmentStatusDto.prototype, "assessmentStatus", 2);
 __decorateClass([
-  IsOptional4()
+  IsOptional7()
 ], FreelancerCaptureAiAssessmentStatusDto.prototype, "iframeEventData", 2);
 
 // src/modules/onboarding/dto/freelancer-development-preference.dto.ts
-import { IsUUID as IsUUID7, IsNotEmpty as IsNotEmpty19, IsBoolean } from "class-validator";
+import { IsUUID as IsUUID7, IsNotEmpty as IsNotEmpty23, IsBoolean } from "class-validator";
 var FreelancerDevelopmentPreferenceDto = class {
 };
 __decorateClass([
-  IsNotEmpty19({ message: "Please enter uuid." }),
+  IsNotEmpty23({ message: "Please enter uuid." }),
   IsUUID7()
 ], FreelancerDevelopmentPreferenceDto.prototype, "uuid", 2);
 __decorateClass([
-  IsNotEmpty19({ message: "Please select development flag." }),
+  IsNotEmpty23({ message: "Please select development flag." }),
   IsBoolean()
 ], FreelancerDevelopmentPreferenceDto.prototype, "developer", 2);
 
 // src/modules/onboarding/dto/freelancer-profile-question.dto.ts
 import {
   IsUUID as IsUUID8,
-  IsString as IsString5,
-  IsNotEmpty as IsNotEmpty20,
+  IsString as IsString8,
+  IsNotEmpty as IsNotEmpty24,
   IsIn,
-  IsOptional as IsOptional5
+  IsOptional as IsOptional8
 } from "class-validator";
 var FreelancerProfileQuestionDto = class {
 };
 __decorateClass([
-  IsNotEmpty20({ message: "Please enter uuid." }),
+  IsNotEmpty24({ message: "Please enter uuid." }),
   IsUUID8()
 ], FreelancerProfileQuestionDto.prototype, "uuid", 2);
 __decorateClass([
-  IsNotEmpty20({ message: "Please enter question slug." }),
-  IsString5(),
+  IsNotEmpty24({ message: "Please enter question slug." }),
+  IsString8(),
   IsIn([
     "natureOfWork",
     "expectedHourlyCompensation",
@@ -622,35 +704,35 @@ __decorateClass([
   ])
 ], FreelancerProfileQuestionDto.prototype, "question_slug", 2);
 __decorateClass([
-  IsNotEmpty20({ message: "Please enter answer." })
+  IsNotEmpty24({ message: "Please enter answer." })
 ], FreelancerProfileQuestionDto.prototype, "answer", 2);
 __decorateClass([
-  IsOptional5()
+  IsOptional8()
 ], FreelancerProfileQuestionDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  IsOptional5()
+  IsOptional8()
 ], FreelancerProfileQuestionDto.prototype, "currency", 2);
 __decorateClass([
-  IsOptional5()
+  IsOptional8()
 ], FreelancerProfileQuestionDto.prototype, "ctc", 2);
 
 // src/modules/onboarding/dto/freelancer-work-showcase.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty21,
-  IsOptional as IsOptional6,
+  IsNotEmpty as IsNotEmpty25,
+  IsOptional as IsOptional9,
   IsUrl,
-  IsString as IsString6,
+  IsString as IsString9,
   IsUUID as IsUUID9
 } from "class-validator";
 var FreelancerWorkShowcaseDto = class {
 };
 __decorateClass([
-  IsNotEmpty21({ message: "Please enter uuid." }),
+  IsNotEmpty25({ message: "Please enter uuid." }),
   IsUUID9()
 ], FreelancerWorkShowcaseDto.prototype, "uuid", 2);
 __decorateClass([
-  IsNotEmpty21({ message: "Please enter likedin profile url." }),
-  IsString6(),
+  IsNotEmpty25({ message: "Please enter likedin profile url." }),
+  IsString9(),
   IsUrl(
     { require_protocol: false },
     {
@@ -659,7 +741,7 @@ __decorateClass([
   )
 ], FreelancerWorkShowcaseDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  IsOptional6(),
+  IsOptional9(),
   IsUrl(
     { require_protocol: false },
     {
@@ -668,7 +750,7 @@ __decorateClass([
   )
 ], FreelancerWorkShowcaseDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  IsOptional6(),
+  IsOptional9(),
   IsUrl(
     { require_protocol: false },
     {
@@ -677,7 +759,7 @@ __decorateClass([
   )
 ], FreelancerWorkShowcaseDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  IsOptional6(),
+  IsOptional9(),
   IsUrl(
     { require_protocol: false },
     {
@@ -686,7 +768,7 @@ __decorateClass([
   )
 ], FreelancerWorkShowcaseDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  IsOptional6(),
+  IsOptional9(),
   IsUrl(
     { require_protocol: false },
     {
@@ -698,21 +780,21 @@ __decorateClass([
 // src/modules/onboarding/dto/client-profile-question.dto.ts
 import {
   IsUUID as IsUUID10,
-  IsString as IsString7,
-  IsNotEmpty as IsNotEmpty22,
+  IsString as IsString10,
+  IsNotEmpty as IsNotEmpty26,
   IsIn as IsIn2,
   ValidateIf,
-  IsOptional as IsOptional7
+  IsOptional as IsOptional10
 } from "class-validator";
 var ClientProfileQuestionDto = class {
 };
 __decorateClass([
-  IsNotEmpty22({ message: "Please enter uuid." }),
+  IsNotEmpty26({ message: "Please enter uuid." }),
   IsUUID10()
 ], ClientProfileQuestionDto.prototype, "uuid", 2);
 __decorateClass([
-  IsNotEmpty22({ message: "Please enter question slug." }),
-  IsString7(),
+  IsNotEmpty26({ message: "Please enter question slug." }),
+  IsString10(),
   IsIn2([
     "skills",
     "requiredFreelancer",
@@ -722,43 +804,52 @@ __decorateClass([
   ])
 ], ClientProfileQuestionDto.prototype, "question_slug", 2);
 __decorateClass([
-  IsNotEmpty22({ message: "Please enter answer." })
+  IsNotEmpty26({ message: "Please enter answer." })
 ], ClientProfileQuestionDto.prototype, "answer", 2);
 __decorateClass([
-  IsOptional7()
+  IsOptional10()
 ], ClientProfileQuestionDto.prototype, "numberOfHours", 2);
 __decorateClass([
   ValidateIf((o) => o.questionSlug === "foundUsOn" && o.answer === "OTHER"),
-  IsNotEmpty22({ message: "Please enter foundUsOnDetail if answer is OTHER." }),
-  IsString7()
+  IsNotEmpty26({ message: "Please enter foundUsOnDetail if answer is OTHER." }),
+  IsString10()
 ], ClientProfileQuestionDto.prototype, "foundUsOnDetail", 2);
 
 // src/modules/onboarding/dto/client-create-account.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty23,
-  IsEmail as IsEmail3,
-  IsString as IsString8,
-  IsOptional as IsOptional8
+  IsNotEmpty as IsNotEmpty27,
+  IsEmail as IsEmail4,
+  IsString as IsString11,
+  IsOptional as IsOptional11
 } from "class-validator";
 var ClientCreateAccountDto = class {
 };
 __decorateClass([
-  IsNotEmpty23({ message: "Please enter full name." }),
-  IsString8({ message: "Please enter valid full name." })
+  IsNotEmpty27({ message: "Please enter full name." }),
+  IsString11({ message: "Please enter valid full name." })
 ], ClientCreateAccountDto.prototype, "fullName", 2);
 __decorateClass([
-  IsNotEmpty23({ message: "Please enter email." }),
-  IsEmail3(),
+  IsNotEmpty27({ message: "Please enter email." }),
+  IsEmail4(),
   IsBusinessEmail()
 ], ClientCreateAccountDto.prototype, "email", 2);
 __decorateClass([
-  IsNotEmpty23({ message: "Please enter company name." }),
-  IsString8({ message: "Please enter valid company name." })
+  IsNotEmpty27({ message: "Please enter company name." }),
+  IsString11({ message: "Please enter valid company name." })
 ], ClientCreateAccountDto.prototype, "companyName", 2);
 __decorateClass([
-  IsOptional8()
+  IsOptional11()
 ], ClientCreateAccountDto.prototype, "onBoardedBy", 2);
 
+// src/modules/onboarding/dto/verify-onboarding-token.dto.ts
+import { IsNotEmpty as IsNotEmpty28, IsString as IsString12 } from "class-validator";
+var VerifyOnboardingTokenDto = class {
+};
+__decorateClass([
+  IsNotEmpty28({ message: "Token is required" }),
+  IsString12({ message: "Token must be a string" })
+], VerifyOnboardingTokenDto.prototype, "token", 2);
+
 // src/modules/maintenance/pattern/pattern.ts
 var MAINTENANCE_PATTERN = {
   truncateData: "truncate.data"
@@ -789,68 +880,68 @@ var SUBADMIN_PATTERN = {
 
 // src/modules/user/subadmin/dto/create-subadmin.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty24
+  IsNotEmpty as IsNotEmpty29
 } from "class-validator";
 var CreateSubAdminDto = class {
 };
 __decorateClass([
-  IsNotEmpty24({ message: "Please enter username." })
+  IsNotEmpty29({ message: "Please enter username." })
 ], CreateSubAdminDto.prototype, "userName", 2);
 __decorateClass([
-  IsNotEmpty24({ message: "Please enter first name." })
+  IsNotEmpty29({ message: "Please enter first name." })
 ], CreateSubAdminDto.prototype, "firstName", 2);
 __decorateClass([
-  IsNotEmpty24({ message: "Please enter last name." })
+  IsNotEmpty29({ message: "Please enter last name." })
 ], CreateSubAdminDto.prototype, "lastName", 2);
 __decorateClass([
-  IsNotEmpty24({ message: "Please enter email." })
+  IsNotEmpty29({ message: "Please enter email." })
 ], CreateSubAdminDto.prototype, "email", 2);
 __decorateClass([
-  IsNotEmpty24({ message: "Please enter mobile Code." })
+  IsNotEmpty29({ message: "Please enter mobile Code." })
 ], CreateSubAdminDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsNotEmpty24({ message: "Please enter mobile number." })
+  IsNotEmpty29({ message: "Please enter mobile number." })
 ], CreateSubAdminDto.prototype, "mobile", 2);
 __decorateClass([
-  IsNotEmpty24({ message: "Please enter the password." })
+  IsNotEmpty29({ message: "Please enter the password." })
 ], CreateSubAdminDto.prototype, "password", 2);
 __decorateClass([
-  IsNotEmpty24({ message: "Please Select Roles." })
+  IsNotEmpty29({ message: "Please Select Roles." })
 ], CreateSubAdminDto.prototype, "roleIds", 2);
 
 // src/modules/user/subadmin/dto/update-subadmin-status.dto.ts
-import { IsString as IsString9 } from "class-validator";
+import { IsString as IsString13 } from "class-validator";
 var UpdateSubAdminAccountStatusDto = class {
 };
 __decorateClass([
-  IsString9()
+  IsString13()
 ], UpdateSubAdminAccountStatusDto.prototype, "accountStatus", 2);
 
 // src/modules/user/subadmin/dto/update-subadmin.dto.ts
 import { Transform } from "class-transformer";
-import { IsNotEmpty as IsNotEmpty25, IsOptional as IsOptional9, Matches as Matches5, MaxLength as MaxLength5, MinLength as MinLength5 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty30, IsOptional as IsOptional12, Matches as Matches5, MaxLength as MaxLength5, MinLength as MinLength5 } from "class-validator";
 var UpdateSubAdminDto = class {
 };
 __decorateClass([
-  IsNotEmpty25({ message: "Please enter username." })
+  IsNotEmpty30({ message: "Please enter username." })
 ], UpdateSubAdminDto.prototype, "userName", 2);
 __decorateClass([
-  IsNotEmpty25({ message: "Please enter first name." })
+  IsNotEmpty30({ message: "Please enter first name." })
 ], UpdateSubAdminDto.prototype, "firstName", 2);
 __decorateClass([
-  IsNotEmpty25({ message: "Please enter last name." })
+  IsNotEmpty30({ message: "Please enter last name." })
 ], UpdateSubAdminDto.prototype, "lastName", 2);
 __decorateClass([
-  IsNotEmpty25({ message: "Please enter email." })
+  IsNotEmpty30({ message: "Please enter email." })
 ], UpdateSubAdminDto.prototype, "email", 2);
 __decorateClass([
-  IsNotEmpty25({ message: "Please enter mobile Code." })
+  IsNotEmpty30({ message: "Please enter mobile Code." })
 ], UpdateSubAdminDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsNotEmpty25({ message: "Please enter mobile number." })
+  IsNotEmpty30({ message: "Please enter mobile number." })
 ], UpdateSubAdminDto.prototype, "mobile", 2);
 __decorateClass([
-  IsOptional9(),
+  IsOptional12(),
   Transform(({ value }) => value === null || value === "" ? void 0 : value),
   MinLength5(6, { message: "Password must be at least 6 characters." }),
   MaxLength5(32, { message: "Password must not exceed 32 characters." }),
@@ -859,7 +950,7 @@ __decorateClass([
   })
 ], UpdateSubAdminDto.prototype, "password", 2);
 __decorateClass([
-  IsNotEmpty25({ message: "Please Select Roles." })
+  IsNotEmpty30({ message: "Please Select Roles." })
 ], UpdateSubAdminDto.prototype, "roleIds", 2);
 
 // src/modules/user/client-profile/pattern/pattern.ts
@@ -887,95 +978,122 @@ var CLIENT_PROFILE_PATTERN = {
 
 // src/modules/user/client-profile/dto/update-client-profile.dto.ts
 import {
-  IsString as IsString10,
-  IsNotEmpty as IsNotEmpty26,
-  IsEmail as IsEmail4,
+  IsString as IsString14,
+  IsNotEmpty as IsNotEmpty31,
+  IsEmail as IsEmail5,
   Length as Length2,
   IsUrl as IsUrl2,
-  IsOptional as IsOptional10,
+  IsOptional as IsOptional13,
   ValidateIf as ValidateIf2,
   IsNumber
 } from "class-validator";
 var UpdateCompanyProfileDto = class {
 };
 __decorateClass([
-  IsNotEmpty26({ message: "Please enter company name." }),
-  IsString10({ message: "Company name must be a string." }),
+  IsNotEmpty31({ message: "Please enter company name." }),
+  IsString14({ message: "Company name must be a string." }),
   Length2(2, 255, {
     message: "Company name must be between 2 and 255 characters"
   })
 ], UpdateCompanyProfileDto.prototype, "companyName", 2);
 __decorateClass([
-  IsOptional10(),
+  IsOptional13(),
   ValidateIf2((o) => o.webSite !== ""),
   IsUrl2({}, { message: "Invalid website URL format" })
 ], UpdateCompanyProfileDto.prototype, "webSite", 2);
 __decorateClass([
-  IsOptional10(),
+  IsOptional13(),
   IsNumber()
 ], UpdateCompanyProfileDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional10(),
+  IsOptional13(),
   IsNumber()
 ], UpdateCompanyProfileDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional10(),
+  IsOptional13(),
   IsNumber()
 ], UpdateCompanyProfileDto.prototype, "cityId", 2);
 __decorateClass([
-  IsNotEmpty26({ message: "Please enter company address." }),
-  IsString10({ message: "Company address must be a string" }),
+  IsNotEmpty31({ message: "Please enter company address." }),
+  IsString14({ message: "Company address must be a string" }),
   Length2(5, 1e3, { message: "Address must be between 5 and 1000 characters" })
 ], UpdateCompanyProfileDto.prototype, "companyAddress", 2);
 __decorateClass([
-  IsOptional10(),
-  IsString10({ message: "Address line must be a string" })
+  IsOptional13(),
+  IsString14({ message: "Address line must be a string" })
 ], UpdateCompanyProfileDto.prototype, "addressLine", 2);
 __decorateClass([
-  IsNotEmpty26({ message: "Please enter postal code." }),
-  IsString10({ message: "Postal Code must be a string" })
+  IsNotEmpty31({ message: "Please enter postal code." }),
+  IsString14({ message: "Postal Code must be a string" })
 ], UpdateCompanyProfileDto.prototype, "postalCode", 2);
 __decorateClass([
-  IsNotEmpty26({ message: "Please enter mobile code." }),
-  IsString10({ message: "Mobile Code must be a string" })
+  IsNotEmpty31({ message: "Please enter mobile code." }),
+  IsString14({ message: "Mobile Code must be a string" })
 ], UpdateCompanyProfileDto.prototype, "mobileCode", 2);
 // @Matches(/^(\+1\s?)?(\(?\d{3}\)?[\s.-]?)?\d{3}[\s.-]?\d{4}$/, {
 //   message: "Please enter a valid US phone number",
 // })
 __decorateClass([
-  IsNotEmpty26({ message: "Please enter phone number." }),
-  IsString10({ message: "Please enter valid phone number." })
+  IsNotEmpty31({ message: "Please enter phone number." }),
+  IsString14({ message: "Please enter valid phone number." })
 ], UpdateCompanyProfileDto.prototype, "phoneNumber", 2);
 __decorateClass([
-  IsNotEmpty26({ message: "Please enter email." }),
-  IsEmail4()
+  IsNotEmpty31({ message: "Please enter email." }),
+  IsEmail5()
 ], UpdateCompanyProfileDto.prototype, "email", 2);
 __decorateClass([
-  IsOptional10(),
-  IsString10({ message: "About company must be a string." })
+  IsOptional13(),
+  IsString14({ message: "About company must be a string." })
 ], UpdateCompanyProfileDto.prototype, "aboutCompany", 2);
 
 // src/modules/user/client-profile/dto/client-change-password.dto.ts
 import {
-  IsString as IsString11,
+  IsString as IsString15,
   MinLength as MinLength6,
   Matches as Matches7,
-  IsNotEmpty as IsNotEmpty27
+  IsNotEmpty as IsNotEmpty32
 } from "class-validator";
 var ClientChangePasswordDto = class {
 };
 __decorateClass([
-  IsString11(),
+  IsString15(),
   MinLength6(8, { message: "Password must be at least 8 characters long." }),
   Matches7(/^(?=.*[A-Z])(?=.*\d).+$/, {
     message: "Password must contain at least one uppercase letter and one number."
   })
 ], ClientChangePasswordDto.prototype, "newPassword", 2);
 __decorateClass([
-  IsNotEmpty27({ message: "Please enter confirm password." }),
+  IsNotEmpty32({ message: "Please enter confirm password." }),
   Match("newPassword", { message: "Passwords do not match" })
 ], ClientChangePasswordDto.prototype, "confirmPassword", 2);
 
+// src/modules/user/client-profile/dto/client-service-agreement-upload.dto.ts
+import { IsOptional as IsOptional14, IsString as IsString16 } from "class-validator";
+var ClientServiceAgreementUploadDto = class {
+};
+__decorateClass([
+  IsOptional14(),
+  IsString16()
+], ClientServiceAgreementUploadDto.prototype, "agreementType", 2);
+
+// src/modules/user/client-profile/dto/client-e-signature.dto.ts
+import { IsNotEmpty as IsNotEmpty33, IsString as IsString17 } from "class-validator";
+var ClientESignatureDto = class {
+};
+__decorateClass([
+  IsNotEmpty33({ message: "Agreement UUID is required" }),
+  IsString17({ message: "Agreement UUID must be a string" })
+], ClientESignatureDto.prototype, "agreementUuid", 2);
+
+// src/modules/user/client-profile/dto/fetch-freelancer-info-for-chat.dto.ts
+import { IsNotEmpty as IsNotEmpty34, IsNumber as IsNumber2 } from "class-validator";
+var FetchFreelancerInfoForChatDto = class {
+};
+__decorateClass([
+  IsNotEmpty34({ message: "Freelancer ID is required" }),
+  IsNumber2({}, { message: "Freelancer ID must be a number" })
+], FetchFreelancerInfoForChatDto.prototype, "freelancerId", 2);
+
 // src/modules/question/pattern/pattern.ts
 var ONBOARDING_QUESTION_PATTERN = {
   fetchOnboardingQuestions: "fetch.onboarding.questions"
@@ -990,29 +1108,68 @@ var ASSESSMENT_QUESTION_PATTERN = {
 
 // src/modules/question/dto/create-question.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty28,
-  IsOptional as IsOptional11,
+  IsNotEmpty as IsNotEmpty35,
+  IsOptional as IsOptional15,
   IsBoolean as IsBoolean2
 } from "class-validator";
 var CreateQuestionDto = class {
 };
 __decorateClass([
-  IsNotEmpty28({ message: "Please enter unique id." })
+  IsNotEmpty35({ message: "Please enter unique id." })
 ], CreateQuestionDto.prototype, "questionId", 2);
 __decorateClass([
-  IsNotEmpty28({ message: "Please enter question." })
+  IsNotEmpty35({ message: "Please enter question." })
 ], CreateQuestionDto.prototype, "question", 2);
 __decorateClass([
-  IsNotEmpty28({ message: "Please enter for whom the question is." })
+  IsNotEmpty35({ message: "Please enter for whom the question is." })
 ], CreateQuestionDto.prototype, "questionFor", 2);
 __decorateClass([
-  IsNotEmpty28({ message: "Please enter options." })
+  IsNotEmpty35({ message: "Please enter options." })
 ], CreateQuestionDto.prototype, "options", 2);
 __decorateClass([
-  IsOptional11(),
+  IsOptional15(),
   IsBoolean2({ message: "Whether the question status active" })
 ], CreateQuestionDto.prototype, "isActive", 2);
 
+// src/modules/question/dto/record-assessment-answer.dto.ts
+import { IsNotEmpty as IsNotEmpty36, IsString as IsString18, IsOptional as IsOptional16, IsObject as IsObject2 } from "class-validator";
+var RecordAssessmentAnswerDto = class {
+};
+__decorateClass([
+  IsNotEmpty36({ message: "Question ID is required" }),
+  IsString18({ message: "Question ID must be a string" })
+], RecordAssessmentAnswerDto.prototype, "questionId", 2);
+__decorateClass([
+  IsNotEmpty36({ message: "Answer is required" }),
+  IsObject2()
+], RecordAssessmentAnswerDto.prototype, "answer", 2);
+__decorateClass([
+  IsOptional16(),
+  IsString18()
+], RecordAssessmentAnswerDto.prototype, "assessmentId", 2);
+__decorateClass([
+  IsOptional16(),
+  IsString18()
+], RecordAssessmentAnswerDto.prototype, "userId", 2);
+
+// src/modules/question/dto/record-assessment-answers.dto.ts
+import { IsNotEmpty as IsNotEmpty37, IsArray, IsObject as IsObject3, IsOptional as IsOptional17, IsString as IsString19 } from "class-validator";
+var RecordAssessmentAnswersDto = class {
+};
+__decorateClass([
+  IsNotEmpty37({ message: "Answers array is required" }),
+  IsArray({ message: "Answers must be an array" }),
+  IsObject3({ each: true, message: "Each answer must be an object" })
+], RecordAssessmentAnswersDto.prototype, "answers", 2);
+__decorateClass([
+  IsOptional17(),
+  IsString19()
+], RecordAssessmentAnswersDto.prototype, "assessmentId", 2);
+__decorateClass([
+  IsOptional17(),
+  IsString19()
+], RecordAssessmentAnswersDto.prototype, "userId", 2);
+
 // src/modules/job/pattern/pattern.ts
 var JOB_ROLE_PATTERN = {
   fetchJobRolesForDropdown: "fetch.job.roles.for.dropdown"
@@ -1070,13 +1227,13 @@ var JOB_APPLICATION_PATTERN = {
 
 // src/modules/job/dto/job-basic-information.dto.ts
 import {
-  IsString as IsString12,
-  IsNotEmpty as IsNotEmpty29,
-  IsArray,
+  IsString as IsString20,
+  IsNotEmpty as IsNotEmpty38,
+  IsArray as IsArray2,
   ArrayNotEmpty,
-  IsNumber as IsNumber2,
-  IsOptional as IsOptional12,
-  IsEnum as IsEnum10,
+  IsNumber as IsNumber3,
+  IsOptional as IsOptional18,
+  IsEnum as IsEnum11,
   Min,
   ValidateIf as ValidateIf3,
   MaxLength as MaxLength6,
@@ -1104,71 +1261,71 @@ var JobBasicInformationDto = class {
   }
 };
 __decorateClass([
-  IsOptional12(),
+  IsOptional18(),
   Type(() => Boolean)
 ], JobBasicInformationDto.prototype, "isDraft", 2);
 __decorateClass([
-  IsNotEmpty29({ message: "Please enter job role" }),
-  IsString12({ message: "Job role must be a string" })
+  IsNotEmpty38({ message: "Please enter job role" }),
+  IsString20({ message: "Job role must be a string" })
 ], JobBasicInformationDto.prototype, "jobRole", 2);
 __decorateClass([
-  IsOptional12()
+  IsOptional18()
 ], JobBasicInformationDto.prototype, "jobRoleCanonicalName", 2);
 __decorateClass([
-  IsOptional12(),
-  IsString12({ message: "Project name must be a string" })
+  IsOptional18(),
+  IsString20({ message: "Project name must be a string" })
 ], JobBasicInformationDto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional12(),
-  IsString12({ message: "Note must be a string" })
+  IsOptional18(),
+  IsString20({ message: "Note must be a string" })
 ], JobBasicInformationDto.prototype, "note", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsOptional12(),
-  IsArray({ message: "Skills must be an array" }),
+  IsOptional18(),
+  IsArray2({ message: "Skills must be an array" }),
   ArrayNotEmpty({ message: "Please select at least one skill" }),
-  IsString12({ each: true, message: "Each skill must be a string" }),
+  IsString20({ each: true, message: "Each skill must be a string" }),
   Type(() => String)
 ], JobBasicInformationDto.prototype, "skills", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsArray({ message: "Good to have skills must be an array" }),
-  IsString12({ each: true, message: "Each skill must be a string" }),
-  IsOptional12(),
+  IsArray2({ message: "Good to have skills must be an array" }),
+  IsString20({ each: true, message: "Each skill must be a string" }),
+  IsOptional18(),
   Type(() => String)
 ], JobBasicInformationDto.prototype, "goodToHaveSkills", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsNumber2({}, { message: "Openings must be a number" }),
+  IsNumber3({}, { message: "Openings must be a number" }),
   Min(1, { message: "There must be at least 1 opening" }),
   Type(() => Number)
 ], JobBasicInformationDto.prototype, "openings", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsEnum10(JobLocationEnum, {
+  IsEnum11(JobLocationEnum, {
     message: `Location must be one of: ${Object.values(JobLocationEnum).join(
       ", "
     )}`
   })
 ], JobBasicInformationDto.prototype, "location", 2);
 __decorateClass([
-  IsOptional12(),
-  IsNumber2({}, { message: "Country id must be a number" }),
+  IsOptional18(),
+  IsNumber3({}, { message: "Country id must be a number" }),
   Type(() => Number)
 ], JobBasicInformationDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional12(),
-  IsNumber2({}, { message: "State id must be a number" }),
+  IsOptional18(),
+  IsNumber3({}, { message: "State id must be a number" }),
   Type(() => Number)
 ], JobBasicInformationDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional12(),
-  IsNumber2({}, { message: "City id must be a number" }),
+  IsOptional18(),
+  IsNumber3({}, { message: "City id must be a number" }),
   Type(() => Number)
 ], JobBasicInformationDto.prototype, "cityId", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsEnum10(EmploymentType, {
+  IsEnum11(EmploymentType, {
     message: `Type of employment must be one of: ${Object.values(
       EmploymentType
     ).join(", ")}`
@@ -1176,82 +1333,82 @@ __decorateClass([
 ], JobBasicInformationDto.prototype, "typeOfEmployment", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsString12({ message: "Currency must be a string" })
+  IsString20({ message: "Currency must be a string" })
 ], JobBasicInformationDto.prototype, "currency", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsNumber2({}, { message: "Expected salary (from) must be a number" }),
+  IsNumber3({}, { message: "Expected salary (from) must be a number" }),
   Min(0, { message: "Expected salary (from) cannot be negative" }),
   Type(() => Number)
 ], JobBasicInformationDto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
-  IsOptional12()
+  IsOptional18()
 ], JobBasicInformationDto.prototype, "hideExpectedSalaryFrom", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsNumber2({}, { message: "Expected salary (to) must be a number" }),
+  IsNumber3({}, { message: "Expected salary (to) must be a number" }),
   Min(0, { message: "Expected salary (to) cannot be negative" }),
   Type(() => Number)
 ], JobBasicInformationDto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
-  IsOptional12()
+  IsOptional18()
 ], JobBasicInformationDto.prototype, "hideExpectedSalaryTo", 2);
 __decorateClass([
-  IsOptional12()
+  IsOptional18()
 ], JobBasicInformationDto.prototype, "years", 2);
 __decorateClass([
-  IsOptional12()
+  IsOptional18()
 ], JobBasicInformationDto.prototype, "months", 2);
 __decorateClass([
-  IsOptional12()
+  IsOptional18()
 ], JobBasicInformationDto.prototype, "weeks", 2);
 __decorateClass([
-  IsOptional12()
+  IsOptional18()
 ], JobBasicInformationDto.prototype, "days", 2);
 __decorateClass([
-  IsOptional12(),
-  IsNumber2({}, { message: "Number of hours must be a number" }),
+  IsOptional18(),
+  IsNumber3({}, { message: "Number of hours must be a number" }),
   Min(0, { message: "Number of hours cannot be negative" }),
   Max(40, { message: "Number of hours cannot exceed 40" }),
   Type(() => Number)
 ], JobBasicInformationDto.prototype, "numberOfHours", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsString12({ message: "Candidate communication skills must be a string" }),
-  IsOptional12()
+  IsString20({ message: "Candidate communication skills must be a string" }),
+  IsOptional18()
 ], JobBasicInformationDto.prototype, "candidateCommunicationSkills", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsNotEmpty29({ message: "Please enter the academic qualification" }),
-  IsString12({ message: "Academic qualification must be a string" })
+  IsNotEmpty38({ message: "Please enter the academic qualification" }),
+  IsString20({ message: "Academic qualification must be a string" })
 ], JobBasicInformationDto.prototype, "academicQualification", 2);
 __decorateClass([
   ValidateIf3((o) => !o.isDraft),
-  IsNotEmpty29({ message: "Please enter the years of experience" }),
-  IsString12({ message: "Years of experience must be a string" })
+  IsNotEmpty38({ message: "Please enter the years of experience" }),
+  IsString20({ message: "Years of experience must be a string" })
 ], JobBasicInformationDto.prototype, "yearsOfExperience", 2);
 __decorateClass([
-  IsOptional12(),
-  IsString12({ message: "Business industry must be a string" })
+  IsOptional18(),
+  IsString20({ message: "Business industry must be a string" })
 ], JobBasicInformationDto.prototype, "businessIndustry", 2);
 __decorateClass([
-  IsOptional12(),
-  IsString12({ message: "Additional comment must be a string" }),
+  IsOptional18(),
+  IsString20({ message: "Additional comment must be a string" }),
   MaxLength6(500, { message: "Additional comment must not exceed 500 characters" })
 ], JobBasicInformationDto.prototype, "additionalComment", 2);
 
 // src/modules/job/dto/job-additional-comment.dto.ts
-import { IsOptional as IsOptional13, IsString as IsString13, MaxLength as MaxLength7 } from "class-validator";
+import { IsOptional as IsOptional19, IsString as IsString21, MaxLength as MaxLength7 } from "class-validator";
 var JobAdditionalCommentDto = class {
 };
 __decorateClass([
-  IsOptional13(),
-  IsString13({ message: "Additional comment must be a string" }),
+  IsOptional19(),
+  IsString21({ message: "Additional comment must be a string" }),
   MaxLength7(500, { message: "Additional comment must not exceed 500 characters" })
 ], JobAdditionalCommentDto.prototype, "additionalComment", 2);
 
 // src/modules/job/dto/job-description.dto.ts
-import { IsString as IsString14, IsNotEmpty as IsNotEmpty30, MaxLength as MaxLength8, IsOptional as IsOptional14 } from "class-validator";
+import { IsString as IsString22, IsNotEmpty as IsNotEmpty39, MaxLength as MaxLength8, IsOptional as IsOptional20 } from "class-validator";
 import { Type as Type2 } from "class-transformer";
 var JobDescriptionDto = class {
   constructor() {
@@ -1259,17 +1416,17 @@ var JobDescriptionDto = class {
   }
 };
 __decorateClass([
-  IsOptional14(),
+  IsOptional20(),
   Type2(() => Boolean)
 ], JobDescriptionDto.prototype, "isDraft", 2);
 __decorateClass([
-  IsNotEmpty30({ message: "Please enter job description" }),
-  IsString14({ message: "Description must be a string" }),
+  IsNotEmpty39({ message: "Please enter job description" }),
+  IsString22({ message: "Description must be a string" }),
   MaxLength8(5e3, { message: "Description must not exceed 5000 characters" })
 ], JobDescriptionDto.prototype, "description", 2);
 
 // src/modules/job/dto/job-status.dto.ts
-import { IsEnum as IsEnum11, IsNotEmpty as IsNotEmpty31 } from "class-validator";
+import { IsEnum as IsEnum12, IsNotEmpty as IsNotEmpty40 } from "class-validator";
 var JobStatus = /* @__PURE__ */ ((JobStatus2) => {
   JobStatus2["ACTIVE"] = "ACTIVE";
   JobStatus2["OPEN"] = "OPEN";
@@ -1281,8 +1438,8 @@ var JobStatus = /* @__PURE__ */ ((JobStatus2) => {
 var JobStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty31({ message: "Please provide a job status" }),
-  IsEnum11(JobStatus, {
+  IsNotEmpty40({ message: "Please provide a job status" }),
+  IsEnum12(JobStatus, {
     message: `Status must be one of: ${Object.values(JobStatus).join(", ")}`
   })
 ], JobStatusDto.prototype, "status", 2);
@@ -1299,13 +1456,13 @@ __decorateClass([
 
 // src/modules/job/dto/job-basic-information-v2.dto.ts
 import {
-  IsString as IsString15,
-  IsNotEmpty as IsNotEmpty32,
-  IsArray as IsArray2,
+  IsString as IsString23,
+  IsNotEmpty as IsNotEmpty41,
+  IsArray as IsArray3,
   ArrayNotEmpty as ArrayNotEmpty2,
-  IsNumber as IsNumber3,
-  IsOptional as IsOptional15,
-  IsEnum as IsEnum12,
+  IsNumber as IsNumber4,
+  IsOptional as IsOptional21,
+  IsEnum as IsEnum13,
   Min as Min2,
   ValidateIf as ValidateIf4,
   MaxLength as MaxLength9,
@@ -1340,77 +1497,92 @@ var StepCompletedEnumV2 = /* @__PURE__ */ ((StepCompletedEnumV22) => {
 var JobLocationDto = class {
 };
 __decorateClass([
-  IsOptional15(),
+  IsOptional21(),
   Type3(() => Number)
 ], JobLocationDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional15(),
+  IsOptional21(),
   Type3(() => Number)
 ], JobLocationDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional15(),
+  IsOptional21(),
   Type3(() => Number)
 ], JobLocationDto.prototype, "cityId", 2);
+__decorateClass([
+  IsOptional21(),
+  IsString23({ message: "Country name must be a string" }),
+  MaxLength9(255, { message: "Country name must not exceed 255 characters" })
+], JobLocationDto.prototype, "countryName", 2);
+__decorateClass([
+  IsOptional21(),
+  IsString23({ message: "State name must be a string" }),
+  MaxLength9(255, { message: "State name must not exceed 255 characters" })
+], JobLocationDto.prototype, "stateName", 2);
+__decorateClass([
+  IsOptional21(),
+  IsString23({ message: "City name must be a string" }),
+  MaxLength9(255, { message: "City name must not exceed 255 characters" })
+], JobLocationDto.prototype, "cityName", 2);
 var JobBasicInformationV2Dto = class {
   constructor() {
     this.isDraft = false;
   }
 };
 __decorateClass([
-  IsOptional15(),
+  IsOptional21(),
   Type3(() => Boolean)
 ], JobBasicInformationV2Dto.prototype, "isDraft", 2);
 __decorateClass([
-  IsNotEmpty32({ message: "Please enter job role" }),
-  IsString15({ message: "Job role must be a string" })
+  IsNotEmpty41({ message: "Please enter job role" }),
+  IsString23({ message: "Job role must be a string" })
 ], JobBasicInformationV2Dto.prototype, "jobRole", 2);
 __decorateClass([
-  IsOptional15()
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "jobRoleCanonicalName", 2);
 __decorateClass([
-  IsOptional15(),
-  IsString15({ message: "Project name must be a string" })
+  IsOptional21(),
+  IsString23({ message: "Project name must be a string" })
 ], JobBasicInformationV2Dto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional15(),
-  IsString15({ message: "Note must be a string" })
+  IsOptional21(),
+  IsString23({ message: "Note must be a string" })
 ], JobBasicInformationV2Dto.prototype, "note", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsOptional15(),
-  IsArray2({ message: "Skills must be an array" }),
+  IsOptional21(),
+  IsArray3({ message: "Skills must be an array" }),
   ArrayNotEmpty2({ message: "Please select at least one skill" }),
-  IsString15({ each: true, message: "Each skill must be a string" }),
+  IsString23({ each: true, message: "Each skill must be a string" }),
   Type3(() => String)
 ], JobBasicInformationV2Dto.prototype, "skills", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsArray2({ message: "Good to have skills must be an array" }),
-  IsString15({ each: true, message: "Each skill must be a string" }),
-  IsOptional15(),
+  IsArray3({ message: "Good to have skills must be an array" }),
+  IsString23({ each: true, message: "Each skill must be a string" }),
+  IsOptional21(),
   Type3(() => String)
 ], JobBasicInformationV2Dto.prototype, "goodToHaveSkills", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsNumber3({}, { message: "Openings must be a number" }),
+  IsNumber4({}, { message: "Openings must be a number" }),
   Min2(1, { message: "There must be at least 1 opening" }),
   Type3(() => Number)
 ], JobBasicInformationV2Dto.prototype, "openings", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsEnum12(JobLocationEnumV2, {
+  IsEnum13(JobLocationEnumV2, {
     message: `Location must be one of: ${Object.values(JobLocationEnumV2).join(
       ", "
     )}`
   })
 ], JobBasicInformationV2Dto.prototype, "locationMode", 2);
 __decorateClass([
-  IsOptional15(),
+  IsOptional21(),
   Type3(() => JobLocationDto)
 ], JobBasicInformationV2Dto.prototype, "locations", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsEnum12(EmploymentTypeV2, {
+  IsEnum13(EmploymentTypeV2, {
     message: `Type of employment must be one of: ${Object.values(
       EmploymentTypeV2
     ).join(", ")}`
@@ -1418,125 +1590,125 @@ __decorateClass([
 ], JobBasicInformationV2Dto.prototype, "typeOfEmployment", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsString15({ message: "Currency must be a string" })
+  IsString23({ message: "Currency must be a string" })
 ], JobBasicInformationV2Dto.prototype, "currency", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsNumber3({}, { message: "Expected salary (from) must be a number" }),
+  IsNumber4({}, { message: "Expected salary (from) must be a number" }),
   Min2(0, { message: "Expected salary (from) cannot be negative" }),
   Type3(() => Number)
 ], JobBasicInformationV2Dto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
-  IsOptional15()
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "hideExpectedSalaryFrom", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsNumber3({}, { message: "Expected salary (to) must be a number" }),
+  IsNumber4({}, { message: "Expected salary (to) must be a number" }),
   Min2(0, { message: "Expected salary (to) cannot be negative" }),
   Type3(() => Number)
 ], JobBasicInformationV2Dto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
-  IsOptional15()
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "hideExpectedSalaryTo", 2);
 __decorateClass([
-  IsOptional15(),
-  IsNumber3({}, { message: "Expected annual budget (from) must be a number" }),
+  IsOptional21(),
+  IsNumber4({}, { message: "Expected annual budget (from) must be a number" }),
   Min2(0, { message: "Expected annual budget (from) cannot be negative" }),
   Type3(() => Number)
 ], JobBasicInformationV2Dto.prototype, "expectedAnnualBudgetFrom", 2);
 __decorateClass([
-  IsOptional15()
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetFrom", 2);
 __decorateClass([
-  IsOptional15(),
-  IsNumber3({}, { message: "Expected annual budget (to) must be a number" }),
+  IsOptional21(),
+  IsNumber4({}, { message: "Expected annual budget (to) must be a number" }),
   Min2(0, { message: "Expected annual budget (to) cannot be negative" }),
   Type3(() => Number)
 ], JobBasicInformationV2Dto.prototype, "expectedAnnualBudgetTo", 2);
 __decorateClass([
-  IsOptional15()
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetTo", 2);
 __decorateClass([
-  IsOptional15()
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "years", 2);
 __decorateClass([
-  IsOptional15()
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "months", 2);
 __decorateClass([
-  IsOptional15()
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "weeks", 2);
 __decorateClass([
-  IsOptional15()
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "days", 2);
 __decorateClass([
-  IsOptional15(),
-  IsNumber3({}, { message: "Number of hours must be a number" }),
+  IsOptional21(),
+  IsNumber4({}, { message: "Number of hours must be a number" }),
   Min2(0, { message: "Number of hours cannot be negative" }),
   Max2(40, { message: "Number of hours cannot exceed 40" }),
   Type3(() => Number)
 ], JobBasicInformationV2Dto.prototype, "numberOfHours", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsString15({ message: "Candidate communication skills must be a string" }),
-  IsOptional15()
+  IsString23({ message: "Candidate communication skills must be a string" }),
+  IsOptional21()
 ], JobBasicInformationV2Dto.prototype, "candidateCommunicationSkills", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsNotEmpty32({ message: "Please enter the academic qualification" }),
-  IsString15({ message: "Academic qualification must be a string" })
+  IsNotEmpty41({ message: "Please enter the academic qualification" }),
+  IsString23({ message: "Academic qualification must be a string" })
 ], JobBasicInformationV2Dto.prototype, "academicQualification", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsNotEmpty32({ message: "Please enter the years of experience" }),
-  IsString15({ message: "Years of experience must be a string" })
+  IsNotEmpty41({ message: "Please enter the years of experience" }),
+  IsString23({ message: "Years of experience must be a string" })
 ], JobBasicInformationV2Dto.prototype, "yearsOfExperienceFrom", 2);
 __decorateClass([
   ValidateIf4((o) => !o.isDraft),
-  IsNotEmpty32({ message: "Please enter the years of experience upto" }),
-  IsString15({ message: "Years of experience must be a string" })
+  IsNotEmpty41({ message: "Please enter the years of experience upto" }),
+  IsString23({ message: "Years of experience must be a string" })
 ], JobBasicInformationV2Dto.prototype, "yearsOfExperienceTo", 2);
 __decorateClass([
-  IsOptional15(),
-  IsString15({ message: "Business industry must be a string" })
+  IsOptional21(),
+  IsString23({ message: "Business industry must be a string" })
 ], JobBasicInformationV2Dto.prototype, "businessIndustry", 2);
 __decorateClass([
-  IsOptional15(),
-  IsEnum12(StepCompletedEnumV2, {
+  IsOptional21(),
+  IsEnum13(StepCompletedEnumV2, {
     message: `Type of stepCompleted must be one of: ${Object.values(
       StepCompletedEnumV2
     ).join(", ")}`
   })
 ], JobBasicInformationV2Dto.prototype, "stepCompleted", 2);
 __decorateClass([
-  IsOptional15(),
-  IsString15({ message: "Additional comment must be a string" }),
+  IsOptional21(),
+  IsString23({ message: "Additional comment must be a string" }),
   MaxLength9(500, { message: "Additional comment must not exceed 500 characters" })
 ], JobBasicInformationV2Dto.prototype, "additionalComment", 2);
 
 // src/modules/job/dto/close-job.dto.ts
-import { IsOptional as IsOptional16, IsString as IsString16 } from "class-validator";
+import { IsOptional as IsOptional22, IsString as IsString24 } from "class-validator";
 var CloseJobDto = class {
 };
 __decorateClass([
-  IsOptional16(),
-  IsString16()
+  IsOptional22(),
+  IsString24()
 ], CloseJobDto.prototype, "reason", 2);
 
 // src/modules/job/dto/create-job-application.dto.ts
-import { IsBoolean as IsBoolean3, IsNotEmpty as IsNotEmpty33, IsOptional as IsOptional17, IsString as IsString17 } from "class-validator";
+import { IsBoolean as IsBoolean3, IsNotEmpty as IsNotEmpty42, IsOptional as IsOptional23, IsString as IsString25 } from "class-validator";
 var CreateJobApplicationDto = class {
 };
 __decorateClass([
-  IsNotEmpty33({ message: "Job ID is required" }),
-  IsString17({ message: "Job ID must be a string" })
+  IsNotEmpty42({ message: "Job ID is required" }),
+  IsString25({ message: "Job ID must be a string" })
 ], CreateJobApplicationDto.prototype, "jobId", 2);
 __decorateClass([
-  IsOptional17(),
+  IsOptional23(),
   IsBoolean3({ message: "isCta must be a boolean" })
 ], CreateJobApplicationDto.prototype, "isCta", 2);
 
 // src/modules/job/dto/change-job-application-status.dto.ts
-import { IsEnum as IsEnum13, IsNotEmpty as IsNotEmpty34 } from "class-validator";
+import { IsEnum as IsEnum14, IsNotEmpty as IsNotEmpty43 } from "class-validator";
 var JobApplicationStatus = /* @__PURE__ */ ((JobApplicationStatus2) => {
   JobApplicationStatus2["PENDING"] = "PENDING";
   JobApplicationStatus2["SHORTLISTED"] = "SHORTLISTED";
@@ -1548,24 +1720,24 @@ var JobApplicationStatus = /* @__PURE__ */ ((JobApplicationStatus2) => {
 var ChangeJobApplicationStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty34({ message: "Status is required" }),
-  IsEnum13(JobApplicationStatus, {
+  IsNotEmpty43({ message: "Status is required" }),
+  IsEnum14(JobApplicationStatus, {
     message: `Status must be one of: ${Object.values(JobApplicationStatus).join(", ")}`
   })
 ], ChangeJobApplicationStatusDto.prototype, "status", 2);
 
 // src/modules/job/dto/change-job-application-status-bulk.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty3, IsArray as IsArray3, IsEnum as IsEnum14, IsNotEmpty as IsNotEmpty35, IsNumber as IsNumber4 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty3, IsArray as IsArray4, IsEnum as IsEnum15, IsNotEmpty as IsNotEmpty44, IsNumber as IsNumber5 } from "class-validator";
 var ChangeJobApplicationStatusBulkDto = class {
 };
 __decorateClass([
-  IsArray3({ message: "Job application IDs must be an array" }),
+  IsArray4({ message: "Job application IDs must be an array" }),
   ArrayNotEmpty3({ message: "At least one job application ID is required" }),
-  IsNumber4({}, { each: true, message: "Each job application ID must be a number" })
+  IsNumber5({}, { each: true, message: "Each job application ID must be a number" })
 ], ChangeJobApplicationStatusBulkDto.prototype, "jobApplicationIds", 2);
 __decorateClass([
-  IsNotEmpty35({ message: "Status is required" }),
-  IsEnum14(JobApplicationStatus, {
+  IsNotEmpty44({ message: "Status is required" }),
+  IsEnum15(JobApplicationStatus, {
     message: `Status must be one of: ${Object.values(JobApplicationStatus).join(", ")}`
   })
 ], ChangeJobApplicationStatusBulkDto.prototype, "status", 2);
@@ -1613,8 +1785,8 @@ var FREELANCER_ASSESSMENT_REQUEST_PATTERN = {
 
 // src/modules/user/freelancer-profile/dto/freelancer-change-password.dto.ts
 import {
-  IsString as IsString18,
-  IsNotEmpty as IsNotEmpty36,
+  IsString as IsString26,
+  IsNotEmpty as IsNotEmpty45,
   MaxLength as MaxLength10,
   MinLength as MinLength7,
   Matches as Matches8
@@ -1622,12 +1794,12 @@ import {
 var FreelancerChangePasswordDto = class {
 };
 __decorateClass([
-  IsNotEmpty36({ message: "Please enter Old Password." }),
-  IsString18()
+  IsNotEmpty45({ message: "Please enter Old Password." }),
+  IsString26()
 ], FreelancerChangePasswordDto.prototype, "oldPassword", 2);
 __decorateClass([
-  IsNotEmpty36({ message: "Please enter New Password." }),
-  IsString18(),
+  IsNotEmpty45({ message: "Please enter New Password." }),
+  IsString26(),
   MinLength7(6),
   MaxLength10(32),
   Matches8(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
@@ -1637,12 +1809,12 @@ __decorateClass([
 
 // src/modules/user/freelancer-profile/dto/update-freelancer-profile.dto.ts
 import {
-  IsOptional as IsOptional18,
-  IsString as IsString19,
-  IsEmail as IsEmail5,
-  IsNumber as IsNumber5,
-  IsEnum as IsEnum15,
-  IsNotEmpty as IsNotEmpty37,
+  IsOptional as IsOptional24,
+  IsString as IsString27,
+  IsEmail as IsEmail6,
+  IsNumber as IsNumber6,
+  IsEnum as IsEnum16,
+  IsNotEmpty as IsNotEmpty46,
   ValidateIf as ValidateIf5,
   IsInt
 } from "class-validator";
@@ -1661,116 +1833,151 @@ var ModeOfWorkDto = /* @__PURE__ */ ((ModeOfWorkDto2) => {
 var UpdateFreelancerProfileDto = class {
 };
 __decorateClass([
-  IsNotEmpty37({ message: "Please enter first name." }),
-  IsString19({ message: "Please enter valid first name." })
+  IsNotEmpty46({ message: "Please enter first name." }),
+  IsString27({ message: "Please enter valid first name." })
 ], UpdateFreelancerProfileDto.prototype, "firstName", 2);
 __decorateClass([
-  IsOptional18(),
-  IsNotEmpty37({ message: "Please enter last name." }),
-  IsString19({ message: "Please enter valid last name." })
+  IsOptional24(),
+  IsNotEmpty46({ message: "Please enter last name." }),
+  IsString27({ message: "Please enter valid last name." })
 ], UpdateFreelancerProfileDto.prototype, "lastName", 2);
 __decorateClass([
-  IsNotEmpty37({ message: "Please enter designation." }),
-  IsString19({ message: "Please enter valid designation." })
+  IsNotEmpty46({ message: "Please enter designation." }),
+  IsString27({ message: "Please enter valid designation." })
 ], UpdateFreelancerProfileDto.prototype, "designation", 2);
 __decorateClass([
-  IsNotEmpty37({ message: "Please enter experience." }),
-  IsString19({ message: "Please enter valid experience." })
+  IsNotEmpty46({ message: "Please enter experience." }),
+  IsString27({ message: "Please enter valid experience." })
 ], UpdateFreelancerProfileDto.prototype, "experience", 2);
 __decorateClass([
-  IsNotEmpty37({ message: "Please enter email id." }),
-  IsEmail5()
+  IsNotEmpty46({ message: "Please enter email id." }),
+  IsEmail6()
 ], UpdateFreelancerProfileDto.prototype, "email", 2);
 __decorateClass([
-  IsNotEmpty37({ message: "Please enter mobile code." }),
-  IsString19({ message: "Please enter valid mobile code." })
+  IsNotEmpty46({ message: "Please enter mobile code." }),
+  IsString27({ message: "Please enter valid mobile code." })
 ], UpdateFreelancerProfileDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsNotEmpty37({ message: "Please enter mobile number." }),
-  IsString19({ message: "Please enter valid mobile number." })
+  IsNotEmpty46({ message: "Please enter mobile number." }),
+  IsString27({ message: "Please enter valid mobile number." })
 ], UpdateFreelancerProfileDto.prototype, "mobile", 2);
 __decorateClass([
-  IsOptional18(),
-  IsNumber5()
+  IsOptional24(),
+  IsNumber6()
 ], UpdateFreelancerProfileDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional18(),
-  IsNumber5()
+  IsOptional24(),
+  IsNumber6()
 ], UpdateFreelancerProfileDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional18(),
-  IsNumber5()
+  IsOptional24(),
+  IsNumber6()
 ], UpdateFreelancerProfileDto.prototype, "cityId", 2);
 //@IsString({ message: "Please enter valid expected hourly compensation." })
 __decorateClass([
-  IsNotEmpty37({ message: "Please enter expected hourly compensation." })
+  IsNotEmpty46({ message: "Please enter expected hourly compensation." })
 ], UpdateFreelancerProfileDto.prototype, "expectedHourlyCompensation", 2);
 __decorateClass([
   ValidateIf5((dto) => dto.NatureOfWorkDto === "BOTH" /* BOTH */),
-  IsNotEmpty37({ message: "Please enter expected annual compensation." })
+  IsNotEmpty46({ message: "Please enter expected annual compensation." })
 ], UpdateFreelancerProfileDto.prototype, "expectedAnnualCompensation", 2);
 __decorateClass([
   ValidateIf5((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
   IsInt({ message: "Please enter valid weekly availability hours (integer)." }),
-  IsNotEmpty37({ message: "Please enter weekly availability hours" })
+  IsNotEmpty46({ message: "Please enter weekly availability hours" })
 ], UpdateFreelancerProfileDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  IsNotEmpty37({ message: "Please select engagement type." }),
-  IsEnum15(NatureOfWorkDto, {
+  IsNotEmpty46({ message: "Please select engagement type." }),
+  IsEnum16(NatureOfWorkDto, {
     message: `Engagement Type must be one of: ${Object.values(
       NatureOfWorkDto
     ).join(", ")}`
   })
 ], UpdateFreelancerProfileDto.prototype, "natureOfWork", 2);
 __decorateClass([
-  IsNotEmpty37({ message: "Please select mode of work." }),
-  IsEnum15(ModeOfWorkDto, {
+  IsNotEmpty46({ message: "Please select mode of work." }),
+  IsEnum16(ModeOfWorkDto, {
     message: `Mode of work must be one of: ${Object.values(ModeOfWorkDto).join(
       ", "
     )}`
   })
 ], UpdateFreelancerProfileDto.prototype, "modeOfWork", 2);
 __decorateClass([
-  IsOptional18(),
-  IsString19()
+  IsOptional24(),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "portfolioLink", 2);
 __decorateClass([
-  IsNotEmpty37({ message: "Please enter address." }),
-  IsString19()
+  IsNotEmpty46({ message: "Please enter address." }),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "address", 2);
 __decorateClass([
-  IsOptional18(),
-  IsString19()
+  IsOptional24(),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "addressLine", 2);
 __decorateClass([
-  IsNotEmpty37({ message: "Please enter postalCode." }),
-  IsString19()
+  IsNotEmpty46({ message: "Please enter postalCode." }),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "postalCode", 2);
 __decorateClass([
-  IsOptional18(),
-  IsString19()
+  IsOptional24(),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "about", 2);
 __decorateClass([
-  IsOptional18(),
-  IsString19()
+  IsOptional24(),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  IsOptional18(),
-  IsString19()
+  IsOptional24(),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  IsOptional18(),
-  IsString19()
+  IsOptional24(),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  IsOptional18(),
-  IsString19()
+  IsOptional24(),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  IsOptional18(),
-  IsString19()
+  IsOptional24(),
+  IsString27()
 ], UpdateFreelancerProfileDto.prototype, "resumeUrl", 2);
 
+// src/modules/user/freelancer-profile/dto/freelancer-e-signature.dto.ts
+import { IsNotEmpty as IsNotEmpty47, IsString as IsString28 } from "class-validator";
+var FreelancerESignatureDto = class {
+};
+__decorateClass([
+  IsNotEmpty47({ message: "Agreement UUID is required" }),
+  IsString28({ message: "Agreement UUID must be a string" })
+], FreelancerESignatureDto.prototype, "agreementUuid", 2);
+
+// src/modules/user/freelancer-profile/dto/fetch-client-info-for-chat.dto.ts
+import { IsNotEmpty as IsNotEmpty48, IsNumber as IsNumber7 } from "class-validator";
+var FetchClientInfoForChatDto = class {
+};
+__decorateClass([
+  IsNotEmpty48({ message: "Client ID is required" }),
+  IsNumber7({}, { message: "Client ID must be a number" })
+], FetchClientInfoForChatDto.prototype, "clientId", 2);
+
+// src/modules/user/freelancer-profile/dto/capture-ai-assessment-result.dto.ts
+import { IsNotEmpty as IsNotEmpty49, IsString as IsString29, IsOptional as IsOptional25, IsObject as IsObject4 } from "class-validator";
+var CaptureAiAssessmentResultDto = class {
+};
+__decorateClass([
+  IsNotEmpty49({ message: "AI Assessment UUID is required" }),
+  IsString29({ message: "AI Assessment UUID must be a string" })
+], CaptureAiAssessmentResultDto.prototype, "aiAssessmentUuid", 2);
+__decorateClass([
+  IsOptional25(),
+  IsObject4()
+], CaptureAiAssessmentResultDto.prototype, "result", 2);
+__decorateClass([
+  IsOptional25(),
+  IsString29()
+], CaptureAiAssessmentResultDto.prototype, "status", 2);
+
 // src/modules/bank/pattern/pattern.ts
 var BANK_PATTERN = {
   addFreelancerBankDetails: "add.freelancer.bankdetails",
@@ -1783,10 +1990,10 @@ var BANK_PATTERN = {
 
 // src/modules/bank/dto/freelancer-bank-details.dto.ts
 import {
-  IsEnum as IsEnum16,
-  IsNotEmpty as IsNotEmpty38,
-  IsOptional as IsOptional19,
-  IsString as IsString20,
+  IsEnum as IsEnum17,
+  IsNotEmpty as IsNotEmpty50,
+  IsOptional as IsOptional26,
+  IsString as IsString30,
   ValidateIf as ValidateIf6
 } from "class-validator";
 var BankAccountScope = /* @__PURE__ */ ((BankAccountScope2) => {
@@ -1797,51 +2004,51 @@ var BankAccountScope = /* @__PURE__ */ ((BankAccountScope2) => {
 var FreelancerBankDetailsDto = class {
 };
 __decorateClass([
-  IsNotEmpty38({ message: "Please enter Account Holder Name." })
+  IsNotEmpty50({ message: "Please enter Account Holder Name." })
 ], FreelancerBankDetailsDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty38({ message: "Please enter Mobile Code." })
+  IsNotEmpty50({ message: "Please enter Mobile Code." })
 ], FreelancerBankDetailsDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsNotEmpty38({ message: "Please enter Mobile Number." })
+  IsNotEmpty50({ message: "Please enter Mobile Number." })
 ], FreelancerBankDetailsDto.prototype, "mobile", 2);
 __decorateClass([
-  IsNotEmpty38({ message: "Please enter Email." })
+  IsNotEmpty50({ message: "Please enter Email." })
 ], FreelancerBankDetailsDto.prototype, "email", 2);
 __decorateClass([
-  IsOptional19()
+  IsOptional26()
 ], FreelancerBankDetailsDto.prototype, "address", 2);
 __decorateClass([
-  IsNotEmpty38({ message: "Please enter Account Number." })
+  IsNotEmpty50({ message: "Please enter Account Number." })
 ], FreelancerBankDetailsDto.prototype, "accountNumber", 2);
 __decorateClass([
-  IsNotEmpty38({ message: "Please enter Bank Name." })
+  IsNotEmpty50({ message: "Please enter Bank Name." })
 ], FreelancerBankDetailsDto.prototype, "bankName", 2);
 __decorateClass([
-  IsOptional19(),
-  IsString20()
+  IsOptional26(),
+  IsString30()
 ], FreelancerBankDetailsDto.prototype, "branchName", 2);
 __decorateClass([
   ValidateIf6((dto) => dto.accountScope === "DOMESTIC"),
-  IsNotEmpty38({ message: "IFSC Code is required for DOMESTIC accounts." })
+  IsNotEmpty50({ message: "IFSC Code is required for DOMESTIC accounts." })
 ], FreelancerBankDetailsDto.prototype, "ifscCode", 2);
 __decorateClass([
   ValidateIf6((dto) => dto.accountScope === "INTERNATIONAL"),
-  IsNotEmpty38({ message: "Routing Number/Sort Code is required for INTERNATIONAL accounts." })
+  IsNotEmpty50({ message: "Routing Number/Sort Code is required for INTERNATIONAL accounts." })
 ], FreelancerBankDetailsDto.prototype, "routingNo", 2);
 __decorateClass([
   ValidateIf6((dto) => dto.accountScope === "INTERNATIONAL"),
-  IsNotEmpty38({ message: "ABA Number is required for INTERNATIONAL accounts." })
+  IsNotEmpty50({ message: "ABA Number is required for INTERNATIONAL accounts." })
 ], FreelancerBankDetailsDto.prototype, "abaNumber", 2);
 __decorateClass([
   ValidateIf6((dto) => dto.accountScope === "INTERNATIONAL"),
-  IsNotEmpty38({ message: "IBAN is required for INTERNATIONAL accounts." })
+  IsNotEmpty50({ message: "IBAN is required for INTERNATIONAL accounts." })
 ], FreelancerBankDetailsDto.prototype, "iban", 2);
 __decorateClass([
-  IsOptional19()
+  IsOptional26()
 ], FreelancerBankDetailsDto.prototype, "accountType", 2);
 __decorateClass([
-  IsEnum16(BankAccountScope, {
+  IsEnum17(BankAccountScope, {
     message: `Type of Account Scope must be one of: ${Object.values(
       BankAccountScope
     ).join(", ")}`
@@ -1863,7 +2070,7 @@ var SYSTEM_PREFERENCES_PATTERN = {
 // src/modules/system-preference/dto/system-preference.dto.ts
 import {
   IsBoolean as IsBoolean4,
-  IsEnum as IsEnum17
+  IsEnum as IsEnum18
 } from "class-validator";
 var SystemPreferenceKey = /* @__PURE__ */ ((SystemPreferenceKey2) => {
   SystemPreferenceKey2["EMAIL_NOTIFICATION"] = "EMAIL_NOTIFICATION";
@@ -1876,7 +2083,7 @@ __decorateClass([
   IsBoolean4()
 ], SystemPreferenceDto.prototype, "value", 2);
 __decorateClass([
-  IsEnum17(SystemPreferenceKey, {
+  IsEnum18(SystemPreferenceKey, {
     message: `key must be one of: ${Object.values(
       SystemPreferenceKey
     ).join(", ")}`
@@ -1914,6 +2121,31 @@ var EMAIL_PATTERN = {
   cleanQueue: "email.clean.queue"
 };
 
+// src/modules/notification/dto/test-notification.dto.ts
+import { IsOptional as IsOptional27, IsString as IsString31, IsObject as IsObject5, IsEmail as IsEmail7, IsPhoneNumber as IsPhoneNumber2 } from "class-validator";
+var TestNotificationDto = class {
+};
+__decorateClass([
+  IsOptional27(),
+  IsEmail7({}, { message: "Email must be valid" })
+], TestNotificationDto.prototype, "email", 2);
+__decorateClass([
+  IsOptional27(),
+  IsPhoneNumber2()
+], TestNotificationDto.prototype, "phone", 2);
+__decorateClass([
+  IsOptional27(),
+  IsString31()
+], TestNotificationDto.prototype, "message", 2);
+__decorateClass([
+  IsOptional27(),
+  IsObject5()
+], TestNotificationDto.prototype, "data", 2);
+__decorateClass([
+  IsOptional27(),
+  IsString31()
+], TestNotificationDto.prototype, "type", 2);
+
 // src/modules/rating/pattern/pattern.ts
 var RATING_PATTERN = {
   addRating: "add.rating",
@@ -1922,11 +2154,11 @@ var RATING_PATTERN = {
 
 // src/modules/rating/dto/add.rating.dto.ts
 import {
-  IsEnum as IsEnum18,
+  IsEnum as IsEnum19,
   IsInt as IsInt2,
-  IsNotEmpty as IsNotEmpty39,
-  IsOptional as IsOptional20,
-  IsString as IsString21,
+  IsNotEmpty as IsNotEmpty51,
+  IsOptional as IsOptional28,
+  IsString as IsString32,
   Max as Max3,
   Min as Min3
 } from "class-validator";
@@ -6727,10 +6959,10 @@ var CreateRatingDto = class {
 };
 __decorateClass([
   IsInt2({ message: "Reviewee ID must be a valid integer" }),
-  IsNotEmpty39({ message: "Reviewee ID is required" })
+  IsNotEmpty51({ message: "Reviewee ID is required" })
 ], CreateRatingDto.prototype, "revieweeId", 2);
 __decorateClass([
-  IsEnum18(RatingTypeEnum, {
+  IsEnum19(RatingTypeEnum, {
     message: `Rating type must be one of: ${Object.values(RatingTypeEnum).join(", ")}`
   })
 ], CreateRatingDto.prototype, "ratingType", 2);
@@ -6740,8 +6972,8 @@ __decorateClass([
   Max3(5, { message: "Rating must be at most 5" })
 ], CreateRatingDto.prototype, "rating", 2);
 __decorateClass([
-  IsOptional20(),
-  IsString21({ message: "Review must be a string" })
+  IsOptional28(),
+  IsString32({ message: "Review must be a string" })
 ], CreateRatingDto.prototype, "review", 2);
 
 // src/modules/company-role/pattern/pattern.ts
@@ -6757,48 +6989,48 @@ var COMPANY_ROLES_PATTERNS = {
 };
 
 // src/modules/company-role/dto/create-company-role.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty4, IsArray as IsArray4, IsBoolean as IsBoolean5, IsInt as IsInt3, IsNotEmpty as IsNotEmpty40, IsOptional as IsOptional21 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty4, IsArray as IsArray5, IsBoolean as IsBoolean5, IsInt as IsInt3, IsNotEmpty as IsNotEmpty52, IsOptional as IsOptional29 } from "class-validator";
 var CreateCompanyRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty40({ message: "Please enter company role name." })
+  IsNotEmpty52({ message: "Please enter company role name." })
 ], CreateCompanyRoleDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty40({ message: "Please enter company role slug" })
+  IsNotEmpty52({ message: "Please enter company role slug" })
 ], CreateCompanyRoleDto.prototype, "slug", 2);
 __decorateClass([
-  IsNotEmpty40({ message: "Please enter description" })
+  IsNotEmpty52({ message: "Please enter description" })
 ], CreateCompanyRoleDto.prototype, "description", 2);
 __decorateClass([
-  IsArray4({ message: "Permission IDs must be an array." }),
+  IsArray5({ message: "Permission IDs must be an array." }),
   ArrayNotEmpty4({ message: "Please select at least one permission." }),
   IsInt3({ each: true, message: "Each permission ID must be an integer." })
 ], CreateCompanyRoleDto.prototype, "permissionIds", 2);
 __decorateClass([
-  IsOptional21(),
+  IsOptional29(),
   IsBoolean5({ message: "Is active must be a boolean value" })
 ], CreateCompanyRoleDto.prototype, "isActive", 2);
 
 // src/modules/company-role/dto/update-company-role.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty5, IsArray as IsArray5, IsBoolean as IsBoolean6, IsInt as IsInt4, IsNotEmpty as IsNotEmpty41, IsOptional as IsOptional22 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty5, IsArray as IsArray6, IsBoolean as IsBoolean6, IsInt as IsInt4, IsNotEmpty as IsNotEmpty53, IsOptional as IsOptional30 } from "class-validator";
 var UpdateCompanyRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty41({ message: "Please enter company name." })
+  IsNotEmpty53({ message: "Please enter company name." })
 ], UpdateCompanyRoleDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty41({ message: "Please enter slug" })
+  IsNotEmpty53({ message: "Please enter slug" })
 ], UpdateCompanyRoleDto.prototype, "slug", 2);
 __decorateClass([
-  IsNotEmpty41({ message: "Please enter description" })
+  IsNotEmpty53({ message: "Please enter description" })
 ], UpdateCompanyRoleDto.prototype, "description", 2);
 __decorateClass([
-  IsArray5({ message: "Permission IDs must be an array." }),
+  IsArray6({ message: "Permission IDs must be an array." }),
   ArrayNotEmpty5({ message: "Please select at least one permission." }),
   IsInt4({ each: true, message: "Each permission ID must be an integer." })
 ], UpdateCompanyRoleDto.prototype, "permissionIds", 2);
 __decorateClass([
-  IsOptional22(),
+  IsOptional30(),
   IsBoolean6({ message: "Is active must be a boolean value" })
 ], UpdateCompanyRoleDto.prototype, "isActive", 2);
 
@@ -6819,9 +7051,9 @@ var FREELANCER_EXPERIENCE_PATTERN = {
 // src/modules/user/freelancer-experience/dto/freelancer-experience.dto.ts
 import {
   ArrayMinSize,
-  IsNotEmpty as IsNotEmpty42,
-  IsOptional as IsOptional23,
-  IsString as IsString24,
+  IsNotEmpty as IsNotEmpty54,
+  IsOptional as IsOptional31,
+  IsString as IsString35,
   MaxLength as MaxLength12,
   ValidateNested as ValidateNested2
 } from "class-validator";
@@ -6829,23 +7061,23 @@ import { Type as Type4 } from "class-transformer";
 var ExperienceDto = class {
 };
 __decorateClass([
-  IsOptional23()
+  IsOptional31()
 ], ExperienceDto.prototype, "uuid", 2);
 __decorateClass([
-  IsNotEmpty42(),
-  IsString24()
+  IsNotEmpty54(),
+  IsString35()
 ], ExperienceDto.prototype, "companyName", 2);
 __decorateClass([
-  IsNotEmpty42(),
-  IsString24()
+  IsNotEmpty54(),
+  IsString35()
 ], ExperienceDto.prototype, "designation", 2);
 __decorateClass([
-  IsNotEmpty42(),
-  IsString24()
+  IsNotEmpty54(),
+  IsString35()
 ], ExperienceDto.prototype, "jobDuration", 2);
 __decorateClass([
-  IsOptional23(),
-  IsString24(),
+  IsOptional31(),
+  IsString35(),
   MaxLength12(5e3, { message: "Description must not exceed 5000 characters" })
 ], ExperienceDto.prototype, "description", 2);
 var FreelancerExperienceDto = class {
@@ -6869,33 +7101,33 @@ var COMPANY_MEMBERS_PATTERNS = {
 };
 
 // src/modules/company-member/dto/create-company-member.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty6, IsArray as IsArray6, IsInt as IsInt5, IsNotEmpty as IsNotEmpty43 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty6, IsArray as IsArray7, IsInt as IsInt5, IsNotEmpty as IsNotEmpty55 } from "class-validator";
 var CreateCompanyMemberDto = class {
 };
 __decorateClass([
-  IsNotEmpty43({ message: "Please enter name." })
+  IsNotEmpty55({ message: "Please enter name." })
 ], CreateCompanyMemberDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty43({ message: "Please enter email" })
+  IsNotEmpty55({ message: "Please enter email" })
 ], CreateCompanyMemberDto.prototype, "email", 2);
 __decorateClass([
-  IsArray6({ message: "Role IDs must be an array." }),
+  IsArray7({ message: "Role IDs must be an array." }),
   ArrayNotEmpty6({ message: "Please select at least one role." }),
   IsInt5({ each: true, message: "Each role ID must be an integer." })
 ], CreateCompanyMemberDto.prototype, "roleIds", 2);
 
 // src/modules/company-member/dto/update-company-member.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty7, IsArray as IsArray7, IsInt as IsInt6, IsNotEmpty as IsNotEmpty44 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty7, IsArray as IsArray8, IsInt as IsInt6, IsNotEmpty as IsNotEmpty56 } from "class-validator";
 var UpdateCompanyMemberDto = class {
 };
 __decorateClass([
-  IsNotEmpty44({ message: "Please enter name." })
+  IsNotEmpty56({ message: "Please enter name." })
 ], UpdateCompanyMemberDto.prototype, "name", 2);
 __decorateClass([
-  IsNotEmpty44({ message: "Please enter email" })
+  IsNotEmpty56({ message: "Please enter email" })
 ], UpdateCompanyMemberDto.prototype, "email", 2);
 __decorateClass([
-  IsArray7({ message: "Role IDs must be an array." }),
+  IsArray8({ message: "Role IDs must be an array." }),
   ArrayNotEmpty7({ message: "Please select at least one role." }),
   IsInt6({ each: true, message: "Each role ID must be an integer." })
 ], UpdateCompanyMemberDto.prototype, "roleIds", 2);
@@ -6915,29 +7147,29 @@ var FREELANCER_EDUCATION_PATTERN = {
 };
 
 // src/modules/user/freelancer-education/dto/freelancer-education.dto.ts
-import { IsArray as IsArray8, ValidateNested as ValidateNested3, IsString as IsString27, IsNotEmpty as IsNotEmpty45, IsOptional as IsOptional26, ArrayMinSize as ArrayMinSize2 } from "class-validator";
+import { IsArray as IsArray9, ValidateNested as ValidateNested3, IsString as IsString38, IsNotEmpty as IsNotEmpty57, IsOptional as IsOptional34, ArrayMinSize as ArrayMinSize2 } from "class-validator";
 import { Type as Type5 } from "class-transformer";
 var EducationDto = class {
 };
 __decorateClass([
-  IsOptional26()
+  IsOptional34()
 ], EducationDto.prototype, "uuid", 2);
 __decorateClass([
-  IsString27(),
-  IsNotEmpty45({ message: "Please Enter Degree " })
+  IsString38(),
+  IsNotEmpty57({ message: "Please Enter Degree " })
 ], EducationDto.prototype, "degree", 2);
 __decorateClass([
-  IsString27(),
-  IsNotEmpty45({ message: "Please Enter University " })
+  IsString38(),
+  IsNotEmpty57({ message: "Please Enter University " })
 ], EducationDto.prototype, "university", 2);
 __decorateClass([
-  IsString27(),
-  IsNotEmpty45({ message: "Please Enter Year of Graduation " })
+  IsString38(),
+  IsNotEmpty57({ message: "Please Enter Year of Graduation " })
 ], EducationDto.prototype, "yearOfGraduation", 2);
 var FreelancerEducationDto = class {
 };
 __decorateClass([
-  IsArray8(),
+  IsArray9(),
   ArrayMinSize2(1, { message: "At least one education is required." }),
   ValidateNested3({ each: true }),
   Type5(() => EducationDto)
@@ -6950,66 +7182,66 @@ var FREELANCER_PROJECT_PATTERN = {
 };
 
 // src/modules/user/freelancer-project/dto/freelancer-project.dto.ts
-import { IsArray as IsArray9, ValidateNested as ValidateNested4, IsString as IsString28, IsNotEmpty as IsNotEmpty46, IsOptional as IsOptional27, IsDateString, MaxLength as MaxLength14, ArrayMinSize as ArrayMinSize3 } from "class-validator";
+import { IsArray as IsArray10, ValidateNested as ValidateNested4, IsString as IsString39, IsNotEmpty as IsNotEmpty58, IsOptional as IsOptional35, IsDateString, MaxLength as MaxLength14, ArrayMinSize as ArrayMinSize3 } from "class-validator";
 import { Type as Type6 } from "class-transformer";
 var ProjectDto = class {
 };
 __decorateClass([
-  IsOptional27()
+  IsOptional35()
 ], ProjectDto.prototype, "uuid", 2);
 __decorateClass([
-  IsString28(),
-  IsNotEmpty46({ message: "Please Enter Project Name " })
+  IsString39(),
+  IsNotEmpty58({ message: "Please Enter Project Name " })
 ], ProjectDto.prototype, "projectName", 2);
 __decorateClass([
   IsDateString(),
-  IsNotEmpty46({ message: "Please Enter Start Date " })
+  IsNotEmpty58({ message: "Please Enter Start Date " })
 ], ProjectDto.prototype, "startDate", 2);
 __decorateClass([
   IsDateString(),
-  IsNotEmpty46({ message: "Please Enter End Date " })
+  IsNotEmpty58({ message: "Please Enter End Date " })
 ], ProjectDto.prototype, "endDate", 2);
 __decorateClass([
-  IsOptional27(),
-  IsString28()
+  IsOptional35(),
+  IsString39()
 ], ProjectDto.prototype, "clientName", 2);
 __decorateClass([
-  IsOptional27(),
-  IsString28()
+  IsOptional35(),
+  IsString39()
 ], ProjectDto.prototype, "gitLink", 2);
 __decorateClass([
-  IsOptional27(),
-  IsString28(),
+  IsOptional35(),
+  IsString39(),
   MaxLength14(5e3, { message: "Description must not exceed 5000 characters" })
 ], ProjectDto.prototype, "description", 2);
 var CaseStudyDto = class {
 };
 __decorateClass([
-  IsOptional27()
+  IsOptional35()
 ], CaseStudyDto.prototype, "uuid", 2);
 __decorateClass([
-  IsString28(),
-  IsNotEmpty46({ message: "Please Enter Project Name " })
+  IsString39(),
+  IsNotEmpty58({ message: "Please Enter Project Name " })
 ], CaseStudyDto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional27(),
-  IsString28()
+  IsOptional35(),
+  IsString39()
 ], CaseStudyDto.prototype, "caseStudyLink", 2);
 __decorateClass([
-  IsOptional27(),
-  IsString28(),
+  IsOptional35(),
+  IsString39(),
   MaxLength14(5e3, { message: "Description must not exceed 5000 characters" })
 ], CaseStudyDto.prototype, "description", 2);
 var FreelancerProjectDto = class {
 };
 __decorateClass([
-  IsArray9(),
+  IsArray10(),
   ArrayMinSize3(1, { message: "At least one project is required." }),
   ValidateNested4({ each: true }),
   Type6(() => ProjectDto)
 ], FreelancerProjectDto.prototype, "projects", 2);
 __decorateClass([
-  IsArray9(),
+  IsArray10(),
   ValidateNested4({ each: true }),
   Type6(() => CaseStudyDto)
 ], FreelancerProjectDto.prototype, "casestudies", 2);
@@ -7027,7 +7259,7 @@ var FREELANCER_SKILL_PATTERN = {
 };
 
 // src/modules/user/freelancer-skill/dto/freelancer-skill.dto.ts
-import { IsArray as IsArray10, IsString as IsString29, IsOptional as IsOptional28 } from "class-validator";
+import { IsArray as IsArray11, IsString as IsString40, IsOptional as IsOptional36 } from "class-validator";
 import { Type as Type7 } from "class-transformer";
 var FreelancerSkillDto = class {
   constructor() {
@@ -7038,28 +7270,28 @@ var FreelancerSkillDto = class {
   }
 };
 __decorateClass([
-  IsOptional28(),
-  IsArray10(),
+  IsOptional36(),
+  IsArray11(),
   Type7(() => String),
-  IsString29({ each: true })
+  IsString40({ each: true })
 ], FreelancerSkillDto.prototype, "coreSkills", 2);
 __decorateClass([
-  IsOptional28(),
-  IsArray10(),
+  IsOptional36(),
+  IsArray11(),
   Type7(() => String),
-  IsString29({ each: true })
+  IsString40({ each: true })
 ], FreelancerSkillDto.prototype, "secondarySkills", 2);
 __decorateClass([
-  IsOptional28(),
-  IsArray10(),
+  IsOptional36(),
+  IsArray11(),
   Type7(() => String),
-  IsString29({ each: true })
+  IsString40({ each: true })
 ], FreelancerSkillDto.prototype, "tools", 2);
 __decorateClass([
-  IsOptional28(),
-  IsArray10(),
+  IsOptional36(),
+  IsArray11(),
   Type7(() => String),
-  IsString29({ each: true })
+  IsString40({ each: true })
 ], FreelancerSkillDto.prototype, "frameworks", 2);
 
 // src/modules/freelancer-admin/pattern/pattern.ts
@@ -7086,16 +7318,16 @@ var ADMIN_FREELANCER_PATTERN = {
 
 // src/modules/freelancer-admin/dto/create-freelancer.dto.ts
 import {
-  IsString as IsString30,
-  IsEmail as IsEmail10,
+  IsString as IsString41,
+  IsEmail as IsEmail12,
   IsBoolean as IsBoolean11,
-  IsOptional as IsOptional29,
-  IsEnum as IsEnum19,
-  IsNumber as IsNumber6,
+  IsOptional as IsOptional37,
+  IsEnum as IsEnum20,
+  IsNumber as IsNumber8,
   IsUrl as IsUrl3,
   Min as Min4,
   MaxLength as MaxLength16,
-  IsNotEmpty as IsNotEmpty48,
+  IsNotEmpty as IsNotEmpty60,
   MinLength as MinLength12,
   Matches as Matches9,
   ValidateIf as ValidateIf7,
@@ -7123,20 +7355,20 @@ var ModeOfWorkEnum = /* @__PURE__ */ ((ModeOfWorkEnum3) => {
 var CreateFreelancerDto = class {
 };
 __decorateClass([
-  IsString30({ message: "Full name must be a string" }),
+  IsString41({ message: "Full name must be a string" }),
   MaxLength16(100, { message: "Full name must not exceed 100 characters" })
 ], CreateFreelancerDto.prototype, "fullName", 2);
 __decorateClass([
-  IsEmail10({}, { message: "Invalid email address" })
+  IsEmail12({}, { message: "Invalid email address" })
 ], CreateFreelancerDto.prototype, "email", 2);
 __decorateClass([
-  IsString30({ message: "Mobile code must be a string (e.g., +1)" })
+  IsString41({ message: "Mobile code must be a string (e.g., +1)" })
 ], CreateFreelancerDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsString30({ message: "Mobile must be a string (e.g., 1243253534)" })
+  IsString41({ message: "Mobile must be a string (e.g., 1243253534)" })
 ], CreateFreelancerDto.prototype, "mobile", 2);
 __decorateClass([
-  IsNotEmpty48({ message: "Please enter password." }),
+  IsNotEmpty60({ message: "Please enter password." }),
   MinLength12(6),
   MaxLength16(32),
   Matches9(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
@@ -7144,7 +7376,7 @@ __decorateClass([
   })
 ], CreateFreelancerDto.prototype, "password", 2);
 __decorateClass([
-  IsNotEmpty48({ message: "Please enter confirm password." }),
+  IsNotEmpty60({ message: "Please enter confirm password." }),
   Match("confirmPassword", { message: "Passwords do not match" })
 ], CreateFreelancerDto.prototype, "confirmPassword", 2);
 __decorateClass([
@@ -7152,28 +7384,28 @@ __decorateClass([
   Type8(() => Boolean)
 ], CreateFreelancerDto.prototype, "developer", 2);
 __decorateClass([
-  IsEnum19(NatureOfWorkEnum, {
+  IsEnum20(NatureOfWorkEnum, {
     message: `Nature of work must be one of: ${Object.values(
       NatureOfWorkEnum
     ).join(", ")}`
   })
 ], CreateFreelancerDto.prototype, "natureOfWork", 2);
 __decorateClass([
-  IsNumber6({}, { message: "Expected hourly compensation must be a number" }),
+  IsNumber8({}, { message: "Expected hourly compensation must be a number" }),
   Min4(0, { message: "Expected hourly compensation must be 0 or more" }),
   Type8(() => Number)
 ], CreateFreelancerDto.prototype, "expectedHourlyCompensation", 2);
 __decorateClass([
   ValidateIf7((dto) => dto.NatureOfWorkDto === "BOTH" /* BOTH */),
-  IsNotEmpty48({ message: "Please enter expected annual compensation." })
+  IsNotEmpty60({ message: "Please enter expected annual compensation." })
 ], CreateFreelancerDto.prototype, "expectedAnnualCompensation", 2);
 __decorateClass([
   ValidateIf7((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
   IsInt7({ message: "Please enter valid weekly availability hours (integer)." }),
-  IsNotEmpty48({ message: "Please enter weekly availability hours" })
+  IsNotEmpty60({ message: "Please enter weekly availability hours" })
 ], CreateFreelancerDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  IsEnum19(ModeOfWorkEnum, {
+  IsEnum20(ModeOfWorkEnum, {
     message: `Mode of work must be one of: ${Object.values(ModeOfWorkEnum).join(
       ", "
     )}`
@@ -7185,43 +7417,43 @@ __decorateClass([
 ], CreateFreelancerDto.prototype, "isImmediateJoiner", 2);
 __decorateClass([
   ValidateIf7((o) => o.isImmediateJoiner === false),
-  IsNotEmpty48({ message: "Please enter availability to join." })
+  IsNotEmpty60({ message: "Please enter availability to join." })
 ], CreateFreelancerDto.prototype, "availabilityToJoin", 2);
 __decorateClass([
-  IsOptional29(),
+  IsOptional37(),
   IsUrl3({}, { message: "LinkedIn profile link must be a valid URL" })
 ], CreateFreelancerDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  IsOptional29(),
-  IsString30({ message: "Kaggle profile link must be a string" })
+  IsOptional37(),
+  IsString41({ message: "Kaggle profile link must be a string" })
 ], CreateFreelancerDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  IsOptional29(),
+  IsOptional37(),
   IsUrl3({}, { message: "GitHub profile link must be a valid URL" })
 ], CreateFreelancerDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  IsOptional29(),
+  IsOptional37(),
   IsUrl3({}, { message: "StackOverflow profile link must be a valid URL" })
 ], CreateFreelancerDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  IsOptional29(),
+  IsOptional37(),
   IsUrl3({}, { message: "Portfolio link must be a valid URL" })
 ], CreateFreelancerDto.prototype, "portfolioLink", 2);
 
 // src/modules/freelancer-admin/dto/update-freelancer.dto.ts
 import {
-  IsString as IsString31,
-  IsEmail as IsEmail11,
+  IsString as IsString42,
+  IsEmail as IsEmail13,
   IsBoolean as IsBoolean12,
-  IsOptional as IsOptional30,
-  IsEnum as IsEnum20,
-  IsNumber as IsNumber7,
+  IsOptional as IsOptional38,
+  IsEnum as IsEnum21,
+  IsNumber as IsNumber9,
   IsUrl as IsUrl4,
   Min as Min5,
   MaxLength as MaxLength17,
   MinLength as MinLength13,
   Matches as Matches10,
-  IsNotEmpty as IsNotEmpty49,
+  IsNotEmpty as IsNotEmpty61,
   ValidateIf as ValidateIf8,
   IsInt as IsInt8
 } from "class-validator";
@@ -7241,24 +7473,24 @@ var ModeOfWorkEnum2 = /* @__PURE__ */ ((ModeOfWorkEnum3) => {
 var UpdateFreelancerDto = class {
 };
 __decorateClass([
-  IsOptional30(),
-  IsString31({ message: "Full name must be a string" }),
+  IsOptional38(),
+  IsString42({ message: "Full name must be a string" }),
   MaxLength17(100, { message: "Full name must not exceed 100 characters" })
 ], UpdateFreelancerDto.prototype, "fullName", 2);
 __decorateClass([
-  IsOptional30(),
-  IsEmail11({}, { message: "Invalid email address" })
+  IsOptional38(),
+  IsEmail13({}, { message: "Invalid email address" })
 ], UpdateFreelancerDto.prototype, "email", 2);
 __decorateClass([
-  IsOptional30(),
-  IsString31({ message: "Mobile code must be a string (e.g., +1)" })
+  IsOptional38(),
+  IsString42({ message: "Mobile code must be a string (e.g., +1)" })
 ], UpdateFreelancerDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsOptional30(),
-  IsString31({ message: "Mobile must be a string (e.g., 1243253534)" })
+  IsOptional38(),
+  IsString42({ message: "Mobile must be a string (e.g., 1243253534)" })
 ], UpdateFreelancerDto.prototype, "mobile", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional38(),
   Transform2(({ value }) => value === null || value === "" ? void 0 : value),
   MinLength13(6, { message: "Password must be at least 6 characters." }),
   MaxLength17(32, { message: "Password must not exceed 32 characters." }),
@@ -7267,73 +7499,103 @@ __decorateClass([
   })
 ], UpdateFreelancerDto.prototype, "password", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional38(),
   IsBoolean12({ message: "Developer flag must be true or false" }),
   Type9(() => Boolean)
 ], UpdateFreelancerDto.prototype, "developer", 2);
 __decorateClass([
-  IsOptional30(),
-  IsEnum20(NatureOfWorkEnum2, {
+  IsOptional38(),
+  IsEnum21(NatureOfWorkEnum2, {
     message: `Nature of work must be one of: ${Object.values(
       NatureOfWorkEnum2
     ).join(", ")}`
   })
 ], UpdateFreelancerDto.prototype, "natureOfWork", 2);
 __decorateClass([
-  IsOptional30(),
-  IsNumber7({}, { message: "Expected hourly compensation must be a number" }),
+  IsOptional38(),
+  IsNumber9({}, { message: "Expected hourly compensation must be a number" }),
   Min5(0, { message: "Expected hourly compensation must be 0 or more" }),
   Type9(() => Number)
 ], UpdateFreelancerDto.prototype, "expectedHourlyCompensation", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional38(),
   ValidateIf8((dto) => dto.NatureOfWorkDto === "BOTH" /* BOTH */),
-  IsNotEmpty49({ message: "Please enter expected annual compensation." })
+  IsNotEmpty61({ message: "Please enter expected annual compensation." })
 ], UpdateFreelancerDto.prototype, "expectedAnnualCompensation", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional38(),
   ValidateIf8((dto) => dto.NatureOfWorkDto === "FREELANCE" /* FREELANCE */),
   IsInt8({ message: "Please enter valid weekly availability hours (integer)." }),
-  IsNotEmpty49({ message: "Please enter weekly availability hours" })
+  IsNotEmpty61({ message: "Please enter weekly availability hours" })
 ], UpdateFreelancerDto.prototype, "numberOfHours", 2);
 __decorateClass([
-  IsOptional30(),
-  IsEnum20(ModeOfWorkEnum2, {
+  IsOptional38(),
+  IsEnum21(ModeOfWorkEnum2, {
     message: `Mode of work must be one of: ${Object.values(ModeOfWorkEnum2).join(
       ", "
     )}`
   })
 ], UpdateFreelancerDto.prototype, "modeOfWork", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional38(),
   IsBoolean12({ message: "isImmediateJoiner must be true or false" }),
   Type9(() => Boolean)
 ], UpdateFreelancerDto.prototype, "isImmediateJoiner", 2);
 __decorateClass([
   ValidateIf8((o) => o.isImmediateJoiner === false),
-  IsNotEmpty49({ message: "Please enter availability to join." })
+  IsNotEmpty61({ message: "Please enter availability to join." })
 ], UpdateFreelancerDto.prototype, "availabilityToJoin", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional38(),
   IsUrl4({}, { message: "LinkedIn profile link must be a valid URL" })
 ], UpdateFreelancerDto.prototype, "linkedinProfileLink", 2);
 __decorateClass([
-  IsOptional30(),
-  IsString31({ message: "Kaggle profile link must be a string" })
+  IsOptional38(),
+  IsString42({ message: "Kaggle profile link must be a string" })
 ], UpdateFreelancerDto.prototype, "kaggleProfileLink", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional38(),
   IsUrl4({}, { message: "GitHub profile link must be a valid URL" })
 ], UpdateFreelancerDto.prototype, "githubProfileLink", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional38(),
   IsUrl4({}, { message: "StackOverflow profile link must be a valid URL" })
 ], UpdateFreelancerDto.prototype, "stackOverflowProfileLink", 2);
 __decorateClass([
-  IsOptional30(),
+  IsOptional38(),
   IsUrl4({}, { message: "Portfolio link must be a valid URL" })
 ], UpdateFreelancerDto.prototype, "portfolioLink", 2);
 
+// src/modules/freelancer-admin/dto/send-ai-assessment-link.dto.ts
+import { IsNotEmpty as IsNotEmpty62, IsNumber as IsNumber10 } from "class-validator";
+var SendAiAssessmentLinkDto = class {
+};
+__decorateClass([
+  IsNotEmpty62({ message: "User ID is required" }),
+  IsNumber10({}, { message: "User ID must be a number" })
+], SendAiAssessmentLinkDto.prototype, "userId", 2);
+
+// src/modules/freelancer-admin/dto/update-assessment-request-status.dto.ts
+import { IsEnum as IsEnum22, IsOptional as IsOptional39, IsString as IsString43 } from "class-validator";
+var AssessmentRequestStatus = /* @__PURE__ */ ((AssessmentRequestStatus2) => {
+  AssessmentRequestStatus2["PENDING"] = "PENDING";
+  AssessmentRequestStatus2["APPROVED"] = "APPROVED";
+  AssessmentRequestStatus2["REJECTED"] = "REJECTED";
+  AssessmentRequestStatus2["EXPIRED"] = "EXPIRED";
+  return AssessmentRequestStatus2;
+})(AssessmentRequestStatus || {});
+var UpdateAssessmentRequestStatusDto = class {
+};
+__decorateClass([
+  IsEnum22(AssessmentRequestStatus, {
+    message: `Status must be one of: ${Object.values(AssessmentRequestStatus).join(", ")}`
+  })
+], UpdateAssessmentRequestStatusDto.prototype, "status", 2);
+__decorateClass([
+  IsOptional39(),
+  IsString43()
+], UpdateAssessmentRequestStatusDto.prototype, "remarks", 2);
+
 // src/modules/client-admin/pattern/pattern.ts
 var CLIENT_ADMIN_PATTERNS = {
   fetchAdminClients: "fetch.admin.clients",
@@ -7349,14 +7611,14 @@ var CLIENT_ADMIN_PATTERNS = {
 
 // src/modules/client-admin/dto/create-client.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty50,
-  IsEmail as IsEmail12,
-  IsOptional as IsOptional31,
-  IsString as IsString32,
-  IsArray as IsArray11,
+  IsNotEmpty as IsNotEmpty63,
+  IsEmail as IsEmail14,
+  IsOptional as IsOptional40,
+  IsString as IsString44,
+  IsArray as IsArray12,
   MinLength as MinLength14,
   MaxLength as MaxLength18,
-  IsEnum as IsEnum21,
+  IsEnum as IsEnum23,
   Matches as Matches11
 } from "class-validator";
 var CreateClientHiringModeEnum = /* @__PURE__ */ ((CreateClientHiringModeEnum2) => {
@@ -7374,19 +7636,19 @@ var CreateClientHiringTypeEnum = /* @__PURE__ */ ((CreateClientHiringTypeEnum2)
 var CreateClientDto = class {
 };
 __decorateClass([
-  IsNotEmpty50({ message: "Please enter first name." }),
-  IsString32()
+  IsNotEmpty63({ message: "Please enter first name." }),
+  IsString44()
 ], CreateClientDto.prototype, "firstName", 2);
 __decorateClass([
-  IsNotEmpty50({ message: "Please enter last name." }),
-  IsString32()
+  IsNotEmpty63({ message: "Please enter last name." }),
+  IsString44()
 ], CreateClientDto.prototype, "lastName", 2);
 __decorateClass([
-  IsNotEmpty50({ message: "Please enter email." }),
-  IsEmail12()
+  IsNotEmpty63({ message: "Please enter email." }),
+  IsEmail14()
 ], CreateClientDto.prototype, "email", 2);
 __decorateClass([
-  IsNotEmpty50({ message: "Please enter password." }),
+  IsNotEmpty63({ message: "Please enter password." }),
   MinLength14(6),
   MaxLength18(32),
   Matches11(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
@@ -7394,66 +7656,66 @@ __decorateClass([
   })
 ], CreateClientDto.prototype, "password", 2);
 __decorateClass([
-  IsNotEmpty50({ message: "Please enter confirm password." }),
+  IsNotEmpty63({ message: "Please enter confirm password." }),
   Match("confirmPassword", { message: "Passwords do not match" })
 ], CreateClientDto.prototype, "confirmPassword", 2);
 __decorateClass([
-  IsNotEmpty50({ message: "Please enter company name." }),
-  IsString32()
+  IsNotEmpty63({ message: "Please enter company name." }),
+  IsString44()
 ], CreateClientDto.prototype, "companyName", 2);
 __decorateClass([
-  IsArray11({ message: "Skills should be an array." }),
-  IsNotEmpty50({ message: "Please enter skills." })
+  IsArray12({ message: "Skills should be an array." }),
+  IsNotEmpty63({ message: "Please enter skills." })
 ], CreateClientDto.prototype, "skills", 2);
 __decorateClass([
-  IsNotEmpty50({ message: "Please specify required freelancer count." }),
-  IsString32()
+  IsNotEmpty63({ message: "Please specify required freelancer count." }),
+  IsString44()
 ], CreateClientDto.prototype, "requiredFreelancer", 2);
 __decorateClass([
-  IsNotEmpty50({ message: "Please specify the kind of hiring." }),
-  IsEnum21(CreateClientHiringTypeEnum)
+  IsNotEmpty63({ message: "Please specify the kind of hiring." }),
+  IsEnum23(CreateClientHiringTypeEnum)
 ], CreateClientDto.prototype, "kindOfHiring", 2);
 __decorateClass([
-  IsNotEmpty50({ message: "Please specify the mode of hire." }),
-  IsEnum21(CreateClientHiringModeEnum)
+  IsNotEmpty63({ message: "Please specify the mode of hire." }),
+  IsEnum23(CreateClientHiringModeEnum)
 ], CreateClientDto.prototype, "modeOfHire", 2);
 __decorateClass([
-  IsNotEmpty50({ message: "Please let us know how you found us." }),
-  IsString32()
+  IsNotEmpty63({ message: "Please let us know how you found us." }),
+  IsString44()
 ], CreateClientDto.prototype, "foundUsOn", 2);
 __decorateClass([
-  IsOptional31(),
-  IsString32()
+  IsOptional40(),
+  IsString44()
 ], CreateClientDto.prototype, "foundUsOnDetail", 2);
 __decorateClass([
-  IsOptional31(),
-  IsString32()
+  IsOptional40(),
+  IsString44()
 ], CreateClientDto.prototype, "hiringCommisionTypeForFte", 2);
 __decorateClass([
-  IsOptional31(),
-  IsString32()
+  IsOptional40(),
+  IsString44()
 ], CreateClientDto.prototype, "hiringCommissionValueForFte", 2);
 
 // src/modules/client-admin/dto/update-client-status.dto.ts
-import { IsString as IsString33, IsNotEmpty as IsNotEmpty51 } from "class-validator";
+import { IsString as IsString45, IsNotEmpty as IsNotEmpty64 } from "class-validator";
 var UpdateClientAccountStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty51({ message: "Please enter account status." }),
-  IsString33()
+  IsNotEmpty64({ message: "Please enter account status." }),
+  IsString45()
 ], UpdateClientAccountStatusDto.prototype, "accountStatus", 2);
 
 // src/modules/client-admin/dto/update-client.dto.ts
 import { Transform as Transform3 } from "class-transformer";
 import {
-  IsNotEmpty as IsNotEmpty52,
-  IsEmail as IsEmail13,
-  IsOptional as IsOptional32,
-  IsString as IsString34,
-  IsArray as IsArray12,
+  IsNotEmpty as IsNotEmpty65,
+  IsEmail as IsEmail15,
+  IsOptional as IsOptional41,
+  IsString as IsString46,
+  IsArray as IsArray13,
   MinLength as MinLength15,
   MaxLength as MaxLength19,
-  IsEnum as IsEnum22,
+  IsEnum as IsEnum24,
   Matches as Matches12
 } from "class-validator";
 var UpdateClientHiringModeEnum = /* @__PURE__ */ ((UpdateClientHiringModeEnum2) => {
@@ -7471,19 +7733,19 @@ var UpdateClientHiringTypeEnum = /* @__PURE__ */ ((UpdateClientHiringTypeEnum2)
 var UpdateClientDto = class {
 };
 __decorateClass([
-  IsNotEmpty52({ message: "Please enter first name." }),
-  IsString34()
+  IsNotEmpty65({ message: "Please enter first name." }),
+  IsString46()
 ], UpdateClientDto.prototype, "firstName", 2);
 __decorateClass([
-  IsNotEmpty52({ message: "Please enter last name." }),
-  IsString34()
+  IsNotEmpty65({ message: "Please enter last name." }),
+  IsString46()
 ], UpdateClientDto.prototype, "lastName", 2);
 __decorateClass([
-  IsNotEmpty52({ message: "Please enter email." }),
-  IsEmail13()
+  IsNotEmpty65({ message: "Please enter email." }),
+  IsEmail15()
 ], UpdateClientDto.prototype, "email", 2);
 __decorateClass([
-  IsOptional32(),
+  IsOptional41(),
   Transform3(({ value }) => value === null || value === "" ? void 0 : value),
   MinLength15(6, { message: "Password must be at least 6 characters." }),
   MaxLength19(32, { message: "Password must not exceed 32 characters." }),
@@ -7492,40 +7754,40 @@ __decorateClass([
   })
 ], UpdateClientDto.prototype, "password", 2);
 __decorateClass([
-  IsNotEmpty52({ message: "Please enter company name." }),
-  IsString34()
+  IsNotEmpty65({ message: "Please enter company name." }),
+  IsString46()
 ], UpdateClientDto.prototype, "companyName", 2);
 __decorateClass([
-  IsArray12({ message: "Skills should be an array." }),
-  IsNotEmpty52({ message: "Please enter skills." })
+  IsArray13({ message: "Skills should be an array." }),
+  IsNotEmpty65({ message: "Please enter skills." })
 ], UpdateClientDto.prototype, "skills", 2);
 __decorateClass([
-  IsNotEmpty52({ message: "Please specify required freelancer count." }),
-  IsString34()
+  IsNotEmpty65({ message: "Please specify required freelancer count." }),
+  IsString46()
 ], UpdateClientDto.prototype, "requiredFreelancer", 2);
 __decorateClass([
-  IsNotEmpty52({ message: "Please specify the kind of hiring." }),
-  IsEnum22(UpdateClientHiringTypeEnum)
+  IsNotEmpty65({ message: "Please specify the kind of hiring." }),
+  IsEnum24(UpdateClientHiringTypeEnum)
 ], UpdateClientDto.prototype, "kindOfHiring", 2);
 __decorateClass([
-  IsNotEmpty52({ message: "Please specify the mode of hire." }),
-  IsEnum22(UpdateClientHiringModeEnum)
+  IsNotEmpty65({ message: "Please specify the mode of hire." }),
+  IsEnum24(UpdateClientHiringModeEnum)
 ], UpdateClientDto.prototype, "modeOfHire", 2);
 __decorateClass([
-  IsNotEmpty52({ message: "Please let us know how you found us." }),
-  IsString34()
+  IsNotEmpty65({ message: "Please let us know how you found us." }),
+  IsString46()
 ], UpdateClientDto.prototype, "foundUsOn", 2);
 __decorateClass([
-  IsOptional32(),
-  IsString34()
+  IsOptional41(),
+  IsString46()
 ], UpdateClientDto.prototype, "foundUsOnDetail", 2);
 __decorateClass([
-  IsOptional32(),
-  IsString34()
+  IsOptional41(),
+  IsString46()
 ], UpdateClientDto.prototype, "hiringCommisionTypeForFte", 2);
 __decorateClass([
-  IsOptional32(),
-  IsString34()
+  IsOptional41(),
+  IsString46()
 ], UpdateClientDto.prototype, "hiringCommissionValueForFte", 2);
 
 // src/modules/user/freelancer-declaration/pattern/pattern.ts
@@ -7535,7 +7797,7 @@ var FREELANCER_DECLARATION_PATTERN = {
 };
 
 // src/modules/user/freelancer-declaration/dto/freelancer-declaration.dto.ts
-import { IsOptional as IsOptional33, IsEnum as IsEnum23, IsString as IsString35, IsNotEmpty as IsNotEmpty53, IsIn as IsIn3 } from "class-validator";
+import { IsOptional as IsOptional42, IsEnum as IsEnum25, IsString as IsString47, IsNotEmpty as IsNotEmpty66, IsIn as IsIn3 } from "class-validator";
 var DocumentTypeEnum = /* @__PURE__ */ ((DocumentTypeEnum2) => {
   DocumentTypeEnum2["AADHAAR"] = "AADHAAR_CARD";
   DocumentTypeEnum2["PASSPORT"] = "PASSPORT";
@@ -7546,15 +7808,15 @@ var DocumentTypeEnum = /* @__PURE__ */ ((DocumentTypeEnum2) => {
 var FreelancerDeclarationDto = class {
 };
 __decorateClass([
-  IsOptional33(),
-  IsString35({ message: "UUID must be a string" })
+  IsOptional42(),
+  IsString47({ message: "UUID must be a string" })
 ], FreelancerDeclarationDto.prototype, "uuid", 2);
 __decorateClass([
-  IsEnum23(DocumentTypeEnum, { message: "Document type must be one of AADHAAR_CARD, PASSPORT, DRIVING_LICENSE, PAN_CARD" })
+  IsEnum25(DocumentTypeEnum, { message: "Document type must be one of AADHAAR_CARD, PASSPORT, DRIVING_LICENSE, PAN_CARD" })
 ], FreelancerDeclarationDto.prototype, "documentType", 2);
 __decorateClass([
-  IsNotEmpty53({ message: "Please accept the declaration " }),
-  IsString35(),
+  IsNotEmpty66({ message: "Please accept the declaration " }),
+  IsString47(),
   IsIn3([
     "true"
   ])
@@ -7569,6 +7831,25 @@ var CLIENT_CANDIDATE_PREFERENCE_PATTERN = {
   markCandidateAsShortlistedInBulk: "mark.candidate.as.shortlisted.in.bulk"
 };
 
+// src/modules/user/client-candidate-preference/dto/mark-candidate-status.dto.ts
+import { IsNotEmpty as IsNotEmpty67, IsNumber as IsNumber11 } from "class-validator";
+var MarkCandidateStatusDto = class {
+};
+__decorateClass([
+  IsNotEmpty67({ message: "Freelancer ID is required" }),
+  IsNumber11({}, { message: "Freelancer ID must be a number" })
+], MarkCandidateStatusDto.prototype, "freelancerId", 2);
+
+// src/modules/user/client-candidate-preference/dto/mark-candidate-status-bulk.dto.ts
+import { ArrayNotEmpty as ArrayNotEmpty8, IsArray as IsArray14, IsNumber as IsNumber12 } from "class-validator";
+var MarkCandidateStatusBulkDto = class {
+};
+__decorateClass([
+  IsArray14({ message: "Freelancer IDs must be an array" }),
+  ArrayNotEmpty8({ message: "At least one freelancer ID is required" }),
+  IsNumber12({}, { each: true, message: "Each freelancer ID must be a number" })
+], MarkCandidateStatusBulkDto.prototype, "freelancerIds", 2);
+
 // src/modules/cms/pattern/pattern.ts
 var CMS_PATTERNS = {
   fetchCms: "cms.fetch",
@@ -7579,35 +7860,35 @@ var CMS_PATTERNS = {
 };
 
 // src/modules/cms/dto/create-cms.dto.ts
-import { IsBoolean as IsBoolean13, IsNotEmpty as IsNotEmpty54, IsOptional as IsOptional34 } from "class-validator";
+import { IsBoolean as IsBoolean13, IsNotEmpty as IsNotEmpty68, IsOptional as IsOptional43 } from "class-validator";
 var CreateCmsDto = class {
 };
 __decorateClass([
-  IsNotEmpty54({ message: "Please enter name." })
+  IsNotEmpty68({ message: "Please enter name." })
 ], CreateCmsDto.prototype, "title", 2);
 __decorateClass([
-  IsOptional34()
+  IsOptional43()
 ], CreateCmsDto.prototype, "content", 2);
 __decorateClass([
-  IsOptional34(),
+  IsOptional43(),
   IsBoolean13({ message: "Is active must be a boolean value" })
 ], CreateCmsDto.prototype, "isActive", 2);
 
 // src/modules/cms/dto/update-cms.dto.ts
-import { IsBoolean as IsBoolean14, IsNotEmpty as IsNotEmpty55, IsOptional as IsOptional35 } from "class-validator";
+import { IsBoolean as IsBoolean14, IsNotEmpty as IsNotEmpty69, IsOptional as IsOptional44 } from "class-validator";
 var UpdateCmsDto = class {
 };
 __decorateClass([
-  IsOptional35()
+  IsOptional44()
 ], UpdateCmsDto.prototype, "uuid", 2);
 __decorateClass([
-  IsNotEmpty55({ message: "Please enter name." })
+  IsNotEmpty69({ message: "Please enter name." })
 ], UpdateCmsDto.prototype, "title", 2);
 __decorateClass([
-  IsOptional35()
+  IsOptional44()
 ], UpdateCmsDto.prototype, "content", 2);
 __decorateClass([
-  IsOptional35(),
+  IsOptional44(),
   IsBoolean14({ message: "Is active must be a boolean value" })
 ], UpdateCmsDto.prototype, "isActive", 2);
 
@@ -7643,16 +7924,16 @@ var ADMIN_JOB_PATTERN = {
 // src/modules/job-admin/dto/admin-create-job-information.dto.ts
 import { Type as Type10 } from "class-transformer";
 import {
-  IsString as IsString36,
-  IsEnum as IsEnum24,
+  IsString as IsString48,
+  IsEnum as IsEnum26,
   IsInt as IsInt9,
-  IsOptional as IsOptional36,
-  IsArray as IsArray13,
+  IsOptional as IsOptional45,
+  IsArray as IsArray15,
   IsDateString as IsDateString4,
-  IsNotEmpty as IsNotEmpty56,
-  ArrayNotEmpty as ArrayNotEmpty8,
+  IsNotEmpty as IsNotEmpty70,
+  ArrayNotEmpty as ArrayNotEmpty9,
   Min as Min6,
-  IsNumber as IsNumber8
+  IsNumber as IsNumber13
 } from "class-validator";
 var JobLocationEnumDto = /* @__PURE__ */ ((JobLocationEnumDto2) => {
   JobLocationEnumDto2["ONSITE"] = "ONSITE";
@@ -7669,55 +7950,55 @@ var TypeOfEmploymentEnumDto = /* @__PURE__ */ ((TypeOfEmploymentEnumDto2) => {
 var AdminCreateJobInformationDto = class {
 };
 __decorateClass([
-  IsString36({ message: "Job role must be a string." }),
-  IsNotEmpty56({ message: "Job role is required." })
+  IsString48({ message: "Job role must be a string." }),
+  IsNotEmpty70({ message: "Job role is required." })
 ], AdminCreateJobInformationDto.prototype, "jobRole", 2);
 __decorateClass([
-  IsOptional36(),
-  IsString36({ message: "Note must be a string." })
+  IsOptional45(),
+  IsString48({ message: "Note must be a string." })
 ], AdminCreateJobInformationDto.prototype, "note", 2);
 __decorateClass([
-  IsArray13({ message: "Skills must be an array of skill names." }),
-  ArrayNotEmpty8({ message: "At least one skill must be provided." }),
-  IsString36({ each: true, message: "Each skill must be a valid string." })
+  IsArray15({ message: "Skills must be an array of skill names." }),
+  ArrayNotEmpty9({ message: "At least one skill must be provided." }),
+  IsString48({ each: true, message: "Each skill must be a valid string." })
 ], AdminCreateJobInformationDto.prototype, "skills", 2);
 __decorateClass([
   IsInt9({ message: "Openings must be a valid integer." }),
   Min6(1, { message: "There must be at least one opening." })
 ], AdminCreateJobInformationDto.prototype, "openings", 2);
 __decorateClass([
-  IsEnum24(JobLocationEnumDto, {
+  IsEnum26(JobLocationEnumDto, {
     message: `Location must be one of: ${Object.values(JobLocationEnumDto).join(
       ", "
     )}.`
   })
 ], AdminCreateJobInformationDto.prototype, "location", 2);
 __decorateClass([
-  IsEnum24(TypeOfEmploymentEnumDto, {
+  IsEnum26(TypeOfEmploymentEnumDto, {
     message: `Type of employment must be one of: ${Object.values(
       TypeOfEmploymentEnumDto
     ).join(", ")}.`
   })
 ], AdminCreateJobInformationDto.prototype, "typeOfEmployment", 2);
 __decorateClass([
-  IsString36({ message: "Onboarding Days must be a string." }),
-  IsNotEmpty56({ message: "Onboarding Days is required." })
+  IsString48({ message: "Onboarding Days must be a string." }),
+  IsNotEmpty70({ message: "Onboarding Days is required." })
 ], AdminCreateJobInformationDto.prototype, "onboardingTat", 2);
 __decorateClass([
-  IsString36({ message: "Communication skills must be a string." }),
-  IsNotEmpty56({ message: "Communication skills are required." })
+  IsString48({ message: "Communication skills must be a string." }),
+  IsNotEmpty70({ message: "Communication skills are required." })
 ], AdminCreateJobInformationDto.prototype, "candidateCommunicationSkills", 2);
 __decorateClass([
-  IsString36({ message: "Currency must be a string." }),
-  IsNotEmpty56({ message: "Currency is required." })
+  IsString48({ message: "Currency must be a string." }),
+  IsNotEmpty70({ message: "Currency is required." })
 ], AdminCreateJobInformationDto.prototype, "currency", 2);
 __decorateClass([
   Type10(() => Number),
-  IsNumber8({}, { message: "Expected salary from must be a number." })
+  IsNumber13({}, { message: "Expected salary from must be a number." })
 ], AdminCreateJobInformationDto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
   Type10(() => Number),
-  IsNumber8({}, { message: "Expected salary to must be a number." })
+  IsNumber13({}, { message: "Expected salary to must be a number." })
 ], AdminCreateJobInformationDto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
   IsDateString4(
@@ -7732,19 +8013,19 @@ __decorateClass([
   )
 ], AdminCreateJobInformationDto.prototype, "tentativeEndDate", 2);
 __decorateClass([
-  IsOptional36(),
-  IsString36({ message: "Additional comment must be a string." })
+  IsOptional45(),
+  IsString48({ message: "Additional comment must be a string." })
 ], AdminCreateJobInformationDto.prototype, "additionalComment", 2);
 __decorateClass([
-  IsOptional36(),
+  IsOptional45(),
   IsInt9({ message: "Country ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional36(),
+  IsOptional45(),
   IsInt9({ message: "State ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional36(),
+  IsOptional45(),
   IsInt9({ message: "City ID must be a valid integer." })
 ], AdminCreateJobInformationDto.prototype, "cityId", 2);
 __decorateClass([
@@ -7754,16 +8035,16 @@ __decorateClass([
 // src/modules/job-admin/dto/admin-update-job-information.dto.ts
 import { Type as Type11 } from "class-transformer";
 import {
-  IsString as IsString37,
-  IsEnum as IsEnum25,
+  IsString as IsString49,
+  IsEnum as IsEnum27,
   IsInt as IsInt10,
-  IsOptional as IsOptional37,
-  IsArray as IsArray14,
+  IsOptional as IsOptional46,
+  IsArray as IsArray16,
   IsDateString as IsDateString5,
-  IsNotEmpty as IsNotEmpty57,
-  ArrayNotEmpty as ArrayNotEmpty9,
+  IsNotEmpty as IsNotEmpty71,
+  ArrayNotEmpty as ArrayNotEmpty10,
   Min as Min7,
-  IsNumber as IsNumber9
+  IsNumber as IsNumber14
 } from "class-validator";
 var JobLocationEnums = /* @__PURE__ */ ((JobLocationEnums2) => {
   JobLocationEnums2["ONSITE"] = "ONSITE";
@@ -7780,55 +8061,55 @@ var TypeOfEmploymentEnums = /* @__PURE__ */ ((TypeOfEmploymentEnums2) => {
 var AdminUpdateJobInformationDto = class {
 };
 __decorateClass([
-  IsString37({ message: "Job role must be a string." }),
-  IsNotEmpty57({ message: "Job role is required." })
+  IsString49({ message: "Job role must be a string." }),
+  IsNotEmpty71({ message: "Job role is required." })
 ], AdminUpdateJobInformationDto.prototype, "jobRole", 2);
 __decorateClass([
-  IsOptional37(),
-  IsString37({ message: "Note must be a string." })
+  IsOptional46(),
+  IsString49({ message: "Note must be a string." })
 ], AdminUpdateJobInformationDto.prototype, "note", 2);
 __decorateClass([
-  IsArray14({ message: "Skills must be an array of skill names." }),
-  ArrayNotEmpty9({ message: "At least one skill must be provided." }),
-  IsString37({ each: true, message: "Each skill must be a valid string." })
+  IsArray16({ message: "Skills must be an array of skill names." }),
+  ArrayNotEmpty10({ message: "At least one skill must be provided." }),
+  IsString49({ each: true, message: "Each skill must be a valid string." })
 ], AdminUpdateJobInformationDto.prototype, "skills", 2);
 __decorateClass([
   IsInt10({ message: "Openings must be a valid integer." }),
   Min7(1, { message: "There must be at least one opening." })
 ], AdminUpdateJobInformationDto.prototype, "openings", 2);
 __decorateClass([
-  IsEnum25(JobLocationEnums, {
+  IsEnum27(JobLocationEnums, {
     message: `Location must be one of: ${Object.values(JobLocationEnums).join(
       ", "
     )}.`
   })
 ], AdminUpdateJobInformationDto.prototype, "location", 2);
 __decorateClass([
-  IsEnum25(TypeOfEmploymentEnums, {
+  IsEnum27(TypeOfEmploymentEnums, {
     message: `Type of employment must be one of: ${Object.values(
       TypeOfEmploymentEnums
     ).join(", ")}.`
   })
 ], AdminUpdateJobInformationDto.prototype, "typeOfEmployment", 2);
 __decorateClass([
-  IsString37({ message: "Onboarding Days must be a string." }),
-  IsNotEmpty57({ message: "Onboarding Days is required." })
+  IsString49({ message: "Onboarding Days must be a string." }),
+  IsNotEmpty71({ message: "Onboarding Days is required." })
 ], AdminUpdateJobInformationDto.prototype, "onboardingTat", 2);
 __decorateClass([
-  IsString37({ message: "Communication skills must be a string." }),
-  IsNotEmpty57({ message: "Communication skills are required." })
+  IsString49({ message: "Communication skills must be a string." }),
+  IsNotEmpty71({ message: "Communication skills are required." })
 ], AdminUpdateJobInformationDto.prototype, "candidateCommunicationSkills", 2);
 __decorateClass([
-  IsString37({ message: "Currency must be a string." }),
-  IsNotEmpty57({ message: "Currency is required." })
+  IsString49({ message: "Currency must be a string." }),
+  IsNotEmpty71({ message: "Currency is required." })
 ], AdminUpdateJobInformationDto.prototype, "currency", 2);
 __decorateClass([
   Type11(() => Number),
-  IsNumber9({}, { message: "Expected salary from must be a number." })
+  IsNumber14({}, { message: "Expected salary from must be a number." })
 ], AdminUpdateJobInformationDto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
   Type11(() => Number),
-  IsNumber9({}, { message: "Expected salary to must be a number." })
+  IsNumber14({}, { message: "Expected salary to must be a number." })
 ], AdminUpdateJobInformationDto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
   IsDateString5(
@@ -7843,19 +8124,19 @@ __decorateClass([
   )
 ], AdminUpdateJobInformationDto.prototype, "tentativeEndDate", 2);
 __decorateClass([
-  IsOptional37(),
-  IsString37({ message: "Additional comment must be a string." })
+  IsOptional46(),
+  IsString49({ message: "Additional comment must be a string." })
 ], AdminUpdateJobInformationDto.prototype, "additionalComment", 2);
 __decorateClass([
-  IsOptional37(),
+  IsOptional46(),
   IsInt10({ message: "Country ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional37(),
+  IsOptional46(),
   IsInt10({ message: "State ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional37(),
+  IsOptional46(),
   IsInt10({ message: "City ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "cityId", 2);
 __decorateClass([
@@ -7864,13 +8145,13 @@ __decorateClass([
 
 // src/modules/job-admin/dto/admin-job-basic-information-v2.dto.ts
 import {
-  IsString as IsString38,
-  IsNotEmpty as IsNotEmpty58,
-  IsArray as IsArray15,
-  ArrayNotEmpty as ArrayNotEmpty10,
-  IsNumber as IsNumber10,
-  IsOptional as IsOptional38,
-  IsEnum as IsEnum26,
+  IsString as IsString50,
+  IsNotEmpty as IsNotEmpty72,
+  IsArray as IsArray17,
+  ArrayNotEmpty as ArrayNotEmpty11,
+  IsNumber as IsNumber15,
+  IsOptional as IsOptional47,
+  IsEnum as IsEnum28,
   Min as Min8,
   ValidateIf as ValidateIf9,
   MaxLength as MaxLength20,
@@ -7906,16 +8187,16 @@ var AdminStepCompletedEnumV2 = /* @__PURE__ */ ((AdminStepCompletedEnumV22) => {
 var JobLocationAdminDto = class {
 };
 __decorateClass([
-  IsOptional38(),
-  IsNumber10()
+  IsOptional47(),
+  IsNumber15()
 ], JobLocationAdminDto.prototype, "countryId", 2);
 __decorateClass([
-  IsOptional38(),
-  IsNumber10()
+  IsOptional47(),
+  IsNumber15()
 ], JobLocationAdminDto.prototype, "stateId", 2);
 __decorateClass([
-  IsOptional38(),
-  IsNumber10()
+  IsOptional47(),
+  IsNumber15()
 ], JobLocationAdminDto.prototype, "cityId", 2);
 var AdminJobBasicInformationV2Dto = class {
   constructor() {
@@ -7923,37 +8204,37 @@ var AdminJobBasicInformationV2Dto = class {
   }
 };
 __decorateClass([
-  IsOptional38(),
+  IsOptional47(),
   Type12(() => Boolean)
 ], AdminJobBasicInformationV2Dto.prototype, "isDraft", 2);
 __decorateClass([
   IsInt11({ message: "Client ID must be a valid integer." })
 ], AdminJobBasicInformationV2Dto.prototype, "clientId", 2);
 __decorateClass([
-  IsNotEmpty58({ message: "Please enter job role" }),
-  IsString38({ message: "Job role must be a string" })
+  IsNotEmpty72({ message: "Please enter job role" }),
+  IsString50({ message: "Job role must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "jobRole", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString38({ message: "Note must be a string" })
+  IsOptional47(),
+  IsString50({ message: "Note must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "note", 2);
 __decorateClass([
   ValidateIf9((o) => !o.isDraft),
-  IsOptional38(),
-  IsArray15({ message: "Skills must be an array" }),
-  ArrayNotEmpty10({ message: "Please select at least one skill" }),
-  IsString38({ each: true, message: "Each skill must be a string" }),
+  IsOptional47(),
+  IsArray17({ message: "Skills must be an array" }),
+  ArrayNotEmpty11({ message: "Please select at least one skill" }),
+  IsString50({ each: true, message: "Each skill must be a string" }),
   Type12(() => String)
 ], AdminJobBasicInformationV2Dto.prototype, "skills", 2);
 __decorateClass([
   ValidateIf9((o) => !o.isDraft),
-  IsNumber10({}, { message: "Openings must be a number" }),
+  IsNumber15({}, { message: "Openings must be a number" }),
   Min8(1, { message: "There must be at least 1 opening" }),
   Type12(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "openings", 2);
 __decorateClass([
   ValidateIf9((o) => !o.isDraft),
-  IsEnum26(JobLocationAdminEnumDto, {
+  IsEnum28(JobLocationAdminEnumDto, {
     message: `Location must be one of: ${Object.values(JobLocationAdminEnumDto).join(
       ", "
     )}`
@@ -7961,36 +8242,36 @@ __decorateClass([
 ], AdminJobBasicInformationV2Dto.prototype, "location", 2);
 __decorateClass([
   ValidateIf9((o) => !o.isDraft),
-  IsEnum26(EmploymentTypeAdminEnumDto, {
+  IsEnum28(EmploymentTypeAdminEnumDto, {
     message: `Type of employment must be one of: ${Object.values(
       EmploymentTypeAdminEnumDto
     ).join(", ")}`
   })
 ], AdminJobBasicInformationV2Dto.prototype, "typeOfEmployment", 2);
 __decorateClass([
-  IsOptional38(),
-  IsNumber10({}, { message: "Expected salary (from) must be a number" }),
+  IsOptional47(),
+  IsNumber15({}, { message: "Expected salary (from) must be a number" }),
   Min8(0, { message: "Expected salary (from) cannot be negative" }),
   Type12(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryFrom", 2);
 __decorateClass([
-  IsOptional38(),
-  IsNumber10({}, { message: "Expected salary (to) must be a number" }),
+  IsOptional47(),
+  IsNumber15({}, { message: "Expected salary (to) must be a number" }),
   Min8(0, { message: "Expected salary (to) cannot be negative" }),
   Type12(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryTo", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional47(),
   Type12(() => JobLocationAdminDto)
 ], AdminJobBasicInformationV2Dto.prototype, "locations", 2);
 __decorateClass([
   ValidateIf9((o) => !o.isDraft),
-  IsNotEmpty58({ message: "Please enter the academic qualification" }),
-  IsString38({ message: "Academic qualification must be a string" })
+  IsNotEmpty72({ message: "Please enter the academic qualification" }),
+  IsString50({ message: "Academic qualification must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "academicQualification", 2);
 __decorateClass([
   ValidateIf9((o) => !o.isDraft),
-  IsEnum26(typeOfExperienceAdminEnumDto, {
+  IsEnum28(typeOfExperienceAdminEnumDto, {
     message: `Type of experience must be one of: ${Object.values(
       typeOfExperienceAdminEnumDto
     ).join(", ")}`
@@ -7998,83 +8279,83 @@ __decorateClass([
 ], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceType", 2);
 __decorateClass([
   ValidateIf9((o) => !o.isDraft),
-  IsNotEmpty58({ message: "Please enter the years of experience" }),
-  IsString38({ message: "Years of experience must be a string" })
+  IsNotEmpty72({ message: "Please enter the years of experience" }),
+  IsString50({ message: "Years of experience must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceFrom", 2);
 __decorateClass([
   ValidateIf9((o) => !o.isDraft),
-  IsNotEmpty58({ message: "Please enter the years of experience upto" }),
-  IsString38({ message: "Years of experience must be a string" })
+  IsNotEmpty72({ message: "Please enter the years of experience upto" }),
+  IsString50({ message: "Years of experience must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceTo", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString38({ message: "Business industry must be a string" })
+  IsOptional47(),
+  IsString50({ message: "Business industry must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "businessIndustry", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString38({ message: "Project name must be a string" })
+  IsOptional47(),
+  IsString50({ message: "Project name must be a string" })
 ], AdminJobBasicInformationV2Dto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional47()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryFrom", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional47()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryTo", 2);
 __decorateClass([
-  IsOptional38(),
-  IsNumber10({}, { message: "Expected annual budget (from) must be a number" }),
+  IsOptional47(),
+  IsNumber15({}, { message: "Expected annual budget (from) must be a number" }),
   Min8(0, { message: "Expected annual budget (from) cannot be negative" }),
   Type12(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedAnnualBudgetFrom", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional47()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetFrom", 2);
 __decorateClass([
-  IsOptional38(),
-  IsNumber10({}, { message: "Expected annual budget (to) must be a number" }),
+  IsOptional47(),
+  IsNumber15({}, { message: "Expected annual budget (to) must be a number" }),
   Min8(0, { message: "Expected annual budget (to) cannot be negative" }),
   Type12(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "expectedAnnualBudgetTo", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional47()
 ], AdminJobBasicInformationV2Dto.prototype, "hideExpectedAnnualBudgetTo", 2);
 __decorateClass([
-  IsOptional38(),
-  IsNumber10({}, { message: "Number of hours must be a number" }),
+  IsOptional47(),
+  IsNumber15({}, { message: "Number of hours must be a number" }),
   Min8(0, { message: "Number of hours cannot be negative" }),
   Max4(40, { message: "Number of hours cannot exceed 40" }),
   Type12(() => Number)
 ], AdminJobBasicInformationV2Dto.prototype, "numberOfHours", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional47()
 ], AdminJobBasicInformationV2Dto.prototype, "years", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional47()
 ], AdminJobBasicInformationV2Dto.prototype, "months", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional47()
 ], AdminJobBasicInformationV2Dto.prototype, "weeks", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional47()
 ], AdminJobBasicInformationV2Dto.prototype, "days", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString38({ message: "Additional comment must be a string" }),
+  IsOptional47(),
+  IsString50({ message: "Additional comment must be a string" }),
   MaxLength20(500, { message: "Additional comment must not exceed 500 characters" })
 ], AdminJobBasicInformationV2Dto.prototype, "additionalComment", 2);
 __decorateClass([
   ValidateIf9((o) => !o.isDraft),
-  IsArray15({ message: "Good to have skills must be an array" }),
-  IsString38({ each: true, message: "Each skill must be a string" }),
-  IsOptional38(),
+  IsArray17({ message: "Good to have skills must be an array" }),
+  IsString50({ each: true, message: "Each skill must be a string" }),
+  IsOptional47(),
   Type12(() => String)
 ], AdminJobBasicInformationV2Dto.prototype, "goodToHaveSkills", 2);
 __decorateClass([
-  IsOptional38()
+  IsOptional47()
 ], AdminJobBasicInformationV2Dto.prototype, "jobRoleCanonicalName", 2);
 __decorateClass([
-  IsOptional38(),
-  IsEnum26(AdminStepCompletedEnumV2, {
+  IsOptional47(),
+  IsEnum28(AdminStepCompletedEnumV2, {
     message: `Type of stepCompleted must be one of: ${Object.values(
       AdminStepCompletedEnumV2
     ).join(", ")}`
@@ -8088,7 +8369,7 @@ var LEAD_PATTERN = {
 };
 
 // src/modules/lead/dto/create-lead.dto.ts
-import { IsString as IsString39, IsEmail as IsEmail14, IsOptional as IsOptional39, IsEnum as IsEnum27 } from "class-validator";
+import { IsString as IsString51, IsEmail as IsEmail16, IsOptional as IsOptional48, IsEnum as IsEnum29 } from "class-validator";
 var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
   CategoryEmumDto2["BUSINESS"] = "BUSINESS";
   CategoryEmumDto2["FREELANCER"] = "FREELANCER";
@@ -8097,23 +8378,23 @@ var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
 var CreateLeadDto = class {
 };
 __decorateClass([
-  IsString39({ message: "Name must be a string" })
+  IsString51({ message: "Name must be a string" })
 ], CreateLeadDto.prototype, "name", 2);
 __decorateClass([
-  IsEmail14({}, { message: "Invalid email address" })
+  IsEmail16({}, { message: "Invalid email address" })
 ], CreateLeadDto.prototype, "email", 2);
 __decorateClass([
-  IsString39({ message: "Mobile code must be a string (e.g., +1)" })
+  IsString51({ message: "Mobile code must be a string (e.g., +1)" })
 ], CreateLeadDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsString39({ message: "Mobile must be a string (e.g., 1243253534)" })
+  IsString51({ message: "Mobile must be a string (e.g., 1243253534)" })
 ], CreateLeadDto.prototype, "mobile", 2);
 __decorateClass([
-  IsOptional39(),
-  IsString39({ message: "Description must be a string" })
+  IsOptional48(),
+  IsString51({ message: "Description must be a string" })
 ], CreateLeadDto.prototype, "description", 2);
 __decorateClass([
-  IsEnum27(CategoryEmumDto, {
+  IsEnum29(CategoryEmumDto, {
     message: `Type of category must be one of: ${Object.values(
       CategoryEmumDto
     ).join(", ")}`
@@ -8134,46 +8415,46 @@ var ADMIN_ROLE_PATTERN = {
 };
 
 // src/modules/admin-role/dto/create-admin-role.dto.ts
-import { IsNotEmpty as IsNotEmpty59, IsOptional as IsOptional40, IsString as IsString40 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty73, IsOptional as IsOptional49, IsString as IsString52 } from "class-validator";
 var CreateAdminRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty59({ message: "Please enter admin role name." }),
-  IsString40({ message: "Role name must be a string." })
+  IsNotEmpty73({ message: "Please enter admin role name." }),
+  IsString52({ message: "Role name must be a string." })
 ], CreateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  IsOptional40(),
-  IsString40({ message: "Role description must be a string." })
+  IsOptional49(),
+  IsString52({ message: "Role description must be a string." })
 ], CreateAdminRoleDto.prototype, "roleDescription", 2);
 
 // src/modules/admin-role/dto/update-admin-role.dto.ts
-import { IsBoolean as IsBoolean16, IsNotEmpty as IsNotEmpty60, IsOptional as IsOptional41, IsString as IsString41 } from "class-validator";
+import { IsBoolean as IsBoolean16, IsNotEmpty as IsNotEmpty74, IsOptional as IsOptional50, IsString as IsString53 } from "class-validator";
 var UpdateAdminRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty60({ message: "Please enter admin role name." }),
-  IsString41({ message: "Role name must be a string." })
+  IsNotEmpty74({ message: "Please enter admin role name." }),
+  IsString53({ message: "Role name must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  IsOptional41(),
-  IsString41({ message: "Role description must be a string." })
+  IsOptional50(),
+  IsString53({ message: "Role description must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleDescription", 2);
 __decorateClass([
-  IsOptional41(),
+  IsOptional50(),
   IsBoolean16({ message: "Is active must be a boolean value." })
 ], UpdateAdminRoleDto.prototype, "isActive", 2);
 
 // src/modules/admin-role/dto/attach-permissions-to-role.dto.ts
-import { IsNotEmpty as IsNotEmpty61, IsString as IsString42 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty75, IsString as IsString54 } from "class-validator";
 var AttachPermissionsToRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty61({ message: "Please enter admin role ID." }),
-  IsString42({ message: "Role ID must be a string." })
+  IsNotEmpty75({ message: "Please enter admin role ID." }),
+  IsString54({ message: "Role ID must be a string." })
 ], AttachPermissionsToRoleDto.prototype, "roleId", 2);
 __decorateClass([
-  IsNotEmpty61({ message: "Please enter permission IDs." }),
-  IsString42({ message: "Permission IDs must be a comma-separated string." })
+  IsNotEmpty75({ message: "Please enter permission IDs." }),
+  IsString54({ message: "Permission IDs must be a comma-separated string." })
 ], AttachPermissionsToRoleDto.prototype, "permissionIds", 2);
 
 // src/modules/admin-permission/pattern/pattern.ts
@@ -8254,13 +8535,13 @@ var INTERVIEW_PATTERN = {
 
 // src/modules/interview/dto/interview-invite.dto.ts
 import {
-  IsString as IsString43,
-  IsNotEmpty as IsNotEmpty62,
-  IsArray as IsArray16,
-  ArrayNotEmpty as ArrayNotEmpty11,
-  IsEmail as IsEmail15,
+  IsString as IsString55,
+  IsNotEmpty as IsNotEmpty76,
+  IsArray as IsArray18,
+  ArrayNotEmpty as ArrayNotEmpty12,
+  IsEmail as IsEmail17,
   IsUUID as IsUUID12,
-  IsEnum as IsEnum28,
+  IsEnum as IsEnum30,
   ValidateIf as ValidateIf10,
   ValidateNested as ValidateNested7
 } from "class-validator";
@@ -8278,21 +8559,21 @@ __decorateClass([
   IsUUID12()
 ], ExistingCandidateDto.prototype, "id", 2);
 __decorateClass([
-  IsEnum28(CandidateType, {
+  IsEnum30(CandidateType, {
     message: "type must be one of SHORTLISTED, APPLICATNTS, or RECOMMENDED"
   })
 ], ExistingCandidateDto.prototype, "type", 2);
 var NewCandidateDto = class {
 };
 __decorateClass([
-  IsNotEmpty62({ message: "Please enter the candidate name" }),
-  IsString43({ message: "Name must be a string" })
+  IsNotEmpty76({ message: "Please enter the candidate name" }),
+  IsString55({ message: "Name must be a string" })
 ], NewCandidateDto.prototype, "name", 2);
 __decorateClass([
-  IsEmail15({}, { message: "Please enter a valid email." })
+  IsEmail17({}, { message: "Please enter a valid email." })
 ], NewCandidateDto.prototype, "email", 2);
 __decorateClass([
-  IsEnum28(CandidateType, {
+  IsEnum30(CandidateType, {
     message: "type must be NEW"
   })
 ], NewCandidateDto.prototype, "type", 2);
@@ -8300,15 +8581,15 @@ var CandidatesDto = class {
 };
 __decorateClass([
   ValidateIf10((o) => o.exixtingCandidates?.length > 0),
-  IsArray16({ message: "Existing candidates should be an array." }),
-  ArrayNotEmpty11({ message: "Please select at least one candidate." }),
+  IsArray18({ message: "Existing candidates should be an array." }),
+  ArrayNotEmpty12({ message: "Please select at least one candidate." }),
   ValidateNested7({ each: true }),
   Type13(() => ExistingCandidateDto)
 ], CandidatesDto.prototype, "exixtingCandidates", 2);
 __decorateClass([
   ValidateIf10((o) => o.newCandidates?.length > 0),
-  IsArray16({ message: "New candidates should be an array." }),
-  ArrayNotEmpty11({ message: "Please add at least one candidate." }),
+  IsArray18({ message: "New candidates should be an array." }),
+  ArrayNotEmpty12({ message: "Please add at least one candidate." }),
   ValidateNested7({ each: true }),
   Type13(() => NewCandidateDto)
 ], CandidatesDto.prototype, "newCandidates", 2);
@@ -8324,97 +8605,191 @@ __decorateClass([
 
 // src/modules/interview/dto/create-f2f-interview.dto.ts
 import {
-  IsString as IsString44,
-  IsNotEmpty as IsNotEmpty63,
-  IsEmail as IsEmail16,
-  IsNumber as IsNumber11
+  IsString as IsString56,
+  IsNotEmpty as IsNotEmpty77,
+  IsEmail as IsEmail18,
+  IsNumber as IsNumber16
 } from "class-validator";
 var CreateF2FInterviewDto = class {
 };
 __decorateClass([
-  IsEmail16({}, { message: "Please enter a valid email address." }),
-  IsNotEmpty63({ message: "Invitee email is required." })
+  IsEmail18({}, { message: "Please enter a valid email address." }),
+  IsNotEmpty77({ message: "Invitee email is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  IsString44({ message: "Invitee name must be a string." }),
-  IsNotEmpty63({ message: "Invitee name is required." })
+  IsString56({ message: "Invitee name must be a string." }),
+  IsNotEmpty77({ message: "Invitee name is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeName", 2);
 __decorateClass([
-  IsNumber11({}, { message: "Interview ID must be a number." })
+  IsNumber16({}, { message: "Interview ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "interviewId", 2);
 __decorateClass([
-  IsNumber11({}, { message: "Candidate ID must be a number." })
+  IsNumber16({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-direct.dto.ts
 import {
-  IsString as IsString45,
-  IsNotEmpty as IsNotEmpty64,
-  IsEmail as IsEmail17,
-  IsNumber as IsNumber12
+  IsString as IsString57,
+  IsNotEmpty as IsNotEmpty78,
+  IsEmail as IsEmail19,
+  IsNumber as IsNumber17
 } from "class-validator";
 var CreateF2FInterviewDirectDto = class {
 };
 __decorateClass([
-  IsEmail17({}, { message: "Please enter a valid email address." }),
-  IsNotEmpty64({ message: "Invitee email is required." })
+  IsEmail19({}, { message: "Please enter a valid email address." }),
+  IsNotEmpty78({ message: "Invitee email is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  IsString45({ message: "Invitee name must be a string." }),
-  IsNotEmpty64({ message: "Invitee name is required." })
+  IsString57({ message: "Invitee name must be a string." }),
+  IsNotEmpty78({ message: "Invitee name is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeName", 2);
 __decorateClass([
-  IsNumber12({}, { message: "Job ID must be a number." })
+  IsNumber17({}, { message: "Job ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNumber12({}, { message: "Candidate ID must be a number." })
+  IsNumber17({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-reschedule-request.dto.ts
 import {
-  IsString as IsString46,
-  IsNotEmpty as IsNotEmpty65
+  IsString as IsString58,
+  IsNotEmpty as IsNotEmpty79
 } from "class-validator";
 var CreateF2FInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  IsNotEmpty65({ message: "F2F Interview ID is required." })
+  IsNotEmpty79({ message: "F2F Interview ID is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "f2FInterviewId", 2);
 __decorateClass([
-  IsNotEmpty65({ message: "Rescheduled date is required." })
+  IsNotEmpty79({ message: "Rescheduled date is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledDate", 2);
 __decorateClass([
-  IsString46({ message: "Rescheduled slot must be a string." }),
-  IsNotEmpty65({ message: "Rescheduled slot is required." })
+  IsString58({ message: "Rescheduled slot must be a string." }),
+  IsNotEmpty79({ message: "Rescheduled slot is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledSlot", 2);
 __decorateClass([
-  IsString46({ message: "Freelancer reason must be a string." })
+  IsString58({ message: "Freelancer reason must be a string." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/interview/dto/create-ai-interview-reschedule-request.dto.ts
 import {
-  IsString as IsString47,
-  IsNotEmpty as IsNotEmpty66
+  IsString as IsString59,
+  IsNotEmpty as IsNotEmpty80
 } from "class-validator";
 var CreateAIInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  IsNotEmpty66({ message: "AI Interview ID is required." })
+  IsNotEmpty80({ message: "AI Interview ID is required." })
 ], CreateAIInterviewRescheduleRequestDto.prototype, "aiInterviewId", 2);
 __decorateClass([
-  IsString47({ message: "Freelancer reason must be a string." })
+  IsString59({ message: "Freelancer reason must be a string." })
 ], CreateAIInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/interview/dto/reject-ai-interview-reschedule-request.dto.ts
 import {
-  IsString as IsString48
+  IsString as IsString60
 } from "class-validator";
 var RejectAIInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  IsString48({ message: "Client reject reason must be a string." })
+  IsString60({ message: "Client reject reason must be a string." })
 ], RejectAIInterviewRescheduleRequestDto.prototype, "clientRejectReason", 2);
 
+// src/modules/interview/dto/reject-f2f-interview-reschedule-request.dto.ts
+import { IsOptional as IsOptional54, IsString as IsString61 } from "class-validator";
+var RejectF2FInterviewRescheduleRequestDto = class {
+};
+__decorateClass([
+  IsOptional54(),
+  IsString61()
+], RejectF2FInterviewRescheduleRequestDto.prototype, "reason", 2);
+
+// src/modules/interview/dto/capture-ai-interview-result-public.dto.ts
+import { IsNotEmpty as IsNotEmpty81, IsString as IsString62, IsOptional as IsOptional55, IsObject as IsObject6 } from "class-validator";
+var CaptureAiInterviewResultPublicDto = class {
+};
+__decorateClass([
+  IsNotEmpty81({ message: "AI Interview UUID is required" }),
+  IsString62({ message: "AI Interview UUID must be a string" })
+], CaptureAiInterviewResultPublicDto.prototype, "aiInterviewUuid", 2);
+__decorateClass([
+  IsOptional55(),
+  IsObject6()
+], CaptureAiInterviewResultPublicDto.prototype, "result", 2);
+__decorateClass([
+  IsOptional55(),
+  IsString62()
+], CaptureAiInterviewResultPublicDto.prototype, "status", 2);
+
+// src/modules/interview/dto/create-interview-basic-information.dto.ts
+import { IsNotEmpty as IsNotEmpty82, IsString as IsString63, IsOptional as IsOptional56, IsNumber as IsNumber18, IsArray as IsArray19, IsDateString as IsDateString7 } from "class-validator";
+var CreateInterviewBasicInformationDto = class {
+};
+__decorateClass([
+  IsNotEmpty82({ message: "Job ID is required" }),
+  IsNumber18({}, { message: "Job ID must be a number" })
+], CreateInterviewBasicInformationDto.prototype, "jobId", 2);
+__decorateClass([
+  IsNotEmpty82({ message: "Interview type is required" }),
+  IsString63({ message: "Interview type must be a string" })
+], CreateInterviewBasicInformationDto.prototype, "interviewType", 2);
+__decorateClass([
+  IsOptional56(),
+  IsString63()
+], CreateInterviewBasicInformationDto.prototype, "title", 2);
+__decorateClass([
+  IsOptional56(),
+  IsString63()
+], CreateInterviewBasicInformationDto.prototype, "description", 2);
+__decorateClass([
+  IsOptional56(),
+  IsDateString7()
+], CreateInterviewBasicInformationDto.prototype, "scheduledAt", 2);
+__decorateClass([
+  IsOptional56(),
+  IsNumber18({}, { message: "Duration must be a number" })
+], CreateInterviewBasicInformationDto.prototype, "duration", 2);
+__decorateClass([
+  IsOptional56(),
+  IsArray19(),
+  IsNumber18({}, { each: true, message: "Each skill ID must be a number" })
+], CreateInterviewBasicInformationDto.prototype, "skillIds", 2);
+__decorateClass([
+  IsOptional56(),
+  IsString63()
+], CreateInterviewBasicInformationDto.prototype, "location", 2);
+
+// src/modules/interview/dto/update-interview-basic-information.dto.ts
+import { IsOptional as IsOptional57, IsString as IsString64, IsNumber as IsNumber19, IsArray as IsArray20, IsDateString as IsDateString8 } from "class-validator";
+var UpdateInterviewBasicInformationDto = class {
+};
+__decorateClass([
+  IsOptional57(),
+  IsString64()
+], UpdateInterviewBasicInformationDto.prototype, "title", 2);
+__decorateClass([
+  IsOptional57(),
+  IsString64()
+], UpdateInterviewBasicInformationDto.prototype, "description", 2);
+__decorateClass([
+  IsOptional57(),
+  IsDateString8()
+], UpdateInterviewBasicInformationDto.prototype, "scheduledAt", 2);
+__decorateClass([
+  IsOptional57(),
+  IsNumber19({}, { message: "Duration must be a number" })
+], UpdateInterviewBasicInformationDto.prototype, "duration", 2);
+__decorateClass([
+  IsOptional57(),
+  IsArray20(),
+  IsNumber19({}, { each: true, message: "Each skill ID must be a number" })
+], UpdateInterviewBasicInformationDto.prototype, "skillIds", 2);
+__decorateClass([
+  IsOptional57(),
+  IsString64()
+], UpdateInterviewBasicInformationDto.prototype, "location", 2);
+
 // src/modules/contract/pattern/pattern.ts
 var CONTRACT_PATTERN = {
   generateContract: "generate.contract",
@@ -8450,45 +8825,101 @@ var CONTRACT_PATTERN = {
 };
 
 // src/modules/contract/dto/sign-contract-for-client.dto.ts
-import { IsEnum as IsEnum29, IsNotEmpty as IsNotEmpty67, IsNumber as IsNumber13 } from "class-validator";
+import { IsEnum as IsEnum31, IsNotEmpty as IsNotEmpty83, IsNumber as IsNumber20 } from "class-validator";
 import { Type as Type14 } from "class-transformer";
 var SignContractForClientDto = class {
 };
 __decorateClass([
-  IsNotEmpty67({ message: "Job Id is required." }),
+  IsNotEmpty83({ message: "Job Id is required." }),
   Type14(() => Number),
-  IsNumber13({}, { message: "Job ID must be a number." })
+  IsNumber20({}, { message: "Job ID must be a number." })
 ], SignContractForClientDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty67({ message: "Freelancer ID is required." }),
+  IsNotEmpty83({ message: "Freelancer ID is required." }),
   Type14(() => Number),
-  IsNumber13({}, { message: "Freelancer ID must be a number." })
+  IsNumber20({}, { message: "Freelancer ID must be a number." })
 ], SignContractForClientDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsNotEmpty67({ message: "Contract type is required." }),
-  IsEnum29(ContractTypeEnum)
+  IsNotEmpty83({ message: "Contract type is required." }),
+  IsEnum31(ContractTypeEnum)
 ], SignContractForClientDto.prototype, "contractType", 2);
 
 // src/modules/contract/dto/sign-contract-for-freelancer.dto.ts
-import { IsEnum as IsEnum30, IsNotEmpty as IsNotEmpty68, IsNumber as IsNumber14 } from "class-validator";
+import { IsEnum as IsEnum32, IsNotEmpty as IsNotEmpty84, IsNumber as IsNumber21 } from "class-validator";
 import { Type as Type15 } from "class-transformer";
 var SignContractForFreelancerDto = class {
 };
 __decorateClass([
-  IsNotEmpty68({ message: "Job Id is required." }),
+  IsNotEmpty84({ message: "Job Id is required." }),
   Type15(() => Number),
-  IsNumber14({}, { message: "Job ID must be a number." })
+  IsNumber21({}, { message: "Job ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Client ID is required." }),
+  IsNotEmpty84({ message: "Client ID is required." }),
   Type15(() => Number),
-  IsNumber14({}, { message: "Client ID must be a number." })
+  IsNumber21({}, { message: "Client ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "clientId", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Contract type is required." }),
-  IsEnum30(ContractTypeEnum)
+  IsNotEmpty84({ message: "Contract type is required." }),
+  IsEnum32(ContractTypeEnum)
 ], SignContractForFreelancerDto.prototype, "contractType", 2);
 
+// src/modules/contract/dto/generate-contract.dto.ts
+import { IsNotEmpty as IsNotEmpty85, IsNumber as IsNumber22, IsOptional as IsOptional58, IsString as IsString65 } from "class-validator";
+var GenerateContractDto = class {
+};
+__decorateClass([
+  IsNotEmpty85({ message: "Hiring ID is required" }),
+  IsNumber22({}, { message: "Hiring ID must be a number" })
+], GenerateContractDto.prototype, "hiringId", 2);
+__decorateClass([
+  IsOptional58(),
+  IsString65()
+], GenerateContractDto.prototype, "contractType", 2);
+__decorateClass([
+  IsOptional58(),
+  IsString65()
+], GenerateContractDto.prototype, "templateId", 2);
+
+// src/modules/contract/dto/esign-contract-client.dto.ts
+import { IsNotEmpty as IsNotEmpty86, IsString as IsString66 } from "class-validator";
+var EsignContractClientDto = class {
+};
+__decorateClass([
+  IsNotEmpty86({ message: "Contract UUID is required" }),
+  IsString66({ message: "Contract UUID must be a string" })
+], EsignContractClientDto.prototype, "contractUuid", 2);
+
+// src/modules/contract/dto/esign-contract-freelancer.dto.ts
+import { IsNotEmpty as IsNotEmpty87, IsString as IsString67 } from "class-validator";
+var EsignContractFreelancerDto = class {
+};
+__decorateClass([
+  IsNotEmpty87({ message: "Contract UUID is required" }),
+  IsString67({ message: "Contract UUID must be a string" })
+], EsignContractFreelancerDto.prototype, "contractUuid", 2);
+
+// src/modules/contract/dto/escrow-fund-contract.dto.ts
+import { IsNotEmpty as IsNotEmpty88, IsNumber as IsNumber23, IsOptional as IsOptional59, IsString as IsString68 } from "class-validator";
+var EscrowFundContractDto = class {
+};
+__decorateClass([
+  IsNotEmpty88({ message: "Contract ID is required" }),
+  IsNumber23({}, { message: "Contract ID must be a number" })
+], EscrowFundContractDto.prototype, "contractId", 2);
+__decorateClass([
+  IsNotEmpty88({ message: "Amount is required" }),
+  IsNumber23({}, { message: "Amount must be a number" })
+], EscrowFundContractDto.prototype, "amount", 2);
+__decorateClass([
+  IsOptional59(),
+  IsString68()
+], EscrowFundContractDto.prototype, "currency", 2);
+__decorateClass([
+  IsOptional59(),
+  IsString68()
+], EscrowFundContractDto.prototype, "description", 2);
+
 // src/modules/stripe/pattern/pattern.ts
 var STRIPE_PATTERN = {
   handleStripeWebhookEvent: "handle.stripe.webhook.event",
@@ -8511,14 +8942,86 @@ var STRIPE_PATTERN = {
 
 // src/modules/stripe/dto/create-checkout-session.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty69
+  IsNotEmpty as IsNotEmpty89
 } from "class-validator";
 var CreateCheckoutSessionDto = class {
 };
 __decorateClass([
-  IsNotEmpty69({ message: "Amount is required" })
+  IsNotEmpty89({ message: "Amount is required" })
 ], CreateCheckoutSessionDto.prototype, "amount", 2);
 
+// src/modules/stripe/dto/pre-checkout-calculation.dto.ts
+import { IsNotEmpty as IsNotEmpty90, IsNumber as IsNumber24, IsOptional as IsOptional60, IsString as IsString69 } from "class-validator";
+var PreCheckoutCalculationDto = class {
+};
+__decorateClass([
+  IsNotEmpty90({ message: "Amount is required" }),
+  IsNumber24({}, { message: "Amount must be a number" })
+], PreCheckoutCalculationDto.prototype, "amount", 2);
+__decorateClass([
+  IsOptional60(),
+  IsString69()
+], PreCheckoutCalculationDto.prototype, "currency", 2);
+__decorateClass([
+  IsOptional60(),
+  IsString69()
+], PreCheckoutCalculationDto.prototype, "description", 2);
+
+// src/modules/stripe/dto/client-add-fund.dto.ts
+import { IsNotEmpty as IsNotEmpty91, IsNumber as IsNumber25, IsOptional as IsOptional61, IsString as IsString70 } from "class-validator";
+var ClientAddFundDto = class {
+};
+__decorateClass([
+  IsNotEmpty91({ message: "Amount is required" }),
+  IsNumber25({}, { message: "Amount must be a number" })
+], ClientAddFundDto.prototype, "amount", 2);
+__decorateClass([
+  IsOptional61(),
+  IsString70()
+], ClientAddFundDto.prototype, "currency", 2);
+__decorateClass([
+  IsOptional61(),
+  IsString70()
+], ClientAddFundDto.prototype, "description", 2);
+
+// src/modules/stripe/dto/transfer-funds.dto.ts
+import { IsNotEmpty as IsNotEmpty92, IsNumber as IsNumber26, IsOptional as IsOptional62, IsString as IsString71 } from "class-validator";
+var TransferFundsDto = class {
+};
+__decorateClass([
+  IsNotEmpty92({ message: "Amount is required" }),
+  IsNumber26({}, { message: "Amount must be a number" })
+], TransferFundsDto.prototype, "amount", 2);
+__decorateClass([
+  IsNotEmpty92({ message: "Connected account ID is required" }),
+  IsString71({ message: "Connected account ID must be a string" })
+], TransferFundsDto.prototype, "connectedAccountId", 2);
+__decorateClass([
+  IsOptional62(),
+  IsString71()
+], TransferFundsDto.prototype, "description", 2);
+
+// src/modules/stripe/dto/create-payout.dto.ts
+import { IsNotEmpty as IsNotEmpty93, IsNumber as IsNumber27, IsOptional as IsOptional63, IsString as IsString72 } from "class-validator";
+var CreatePayoutDto = class {
+};
+__decorateClass([
+  IsNotEmpty93({ message: "Amount is required" }),
+  IsNumber27({}, { message: "Amount must be a number" })
+], CreatePayoutDto.prototype, "amount", 2);
+__decorateClass([
+  IsNotEmpty93({ message: "Connected account ID is required" }),
+  IsString72({ message: "Connected account ID must be a string" })
+], CreatePayoutDto.prototype, "connectedAccountId", 2);
+__decorateClass([
+  IsOptional63(),
+  IsString72()
+], CreatePayoutDto.prototype, "method", 2);
+__decorateClass([
+  IsOptional63(),
+  IsString72()
+], CreatePayoutDto.prototype, "description", 2);
+
 // src/modules/timesheet/pattern/pattern.ts
 var TIMESHEET_FREELANCER_PATTERN = {
   fetchTimesheetsByDateRangeForFreelancer: "fetch.timesheets.by.date.range.for.freelancer",
@@ -8561,158 +9064,175 @@ var TIMESHEET_CLIENT_PATTERN = {
 
 // src/modules/timesheet/dto/create-freelancer-timesheet.dto.ts
 import {
-  IsDateString as IsDateString7,
+  IsDateString as IsDateString9,
   IsInt as IsInt12,
-  IsNotEmpty as IsNotEmpty70,
-  IsOptional as IsOptional45,
-  IsString as IsString49,
+  IsNotEmpty as IsNotEmpty94,
+  IsOptional as IsOptional64,
+  IsString as IsString73,
   Matches as Matches13,
-  IsNumber as IsNumber15
+  IsNumber as IsNumber28
 } from "class-validator";
 var CreateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty70({ message: "Job id is required" }),
-  IsNumber15({}, { message: "Job id must be a number" })
+  IsNotEmpty94({ message: "Job id is required" }),
+  IsNumber28({}, { message: "Job id must be a number" })
 ], CreateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty70({ message: "start date is required" }),
-  IsDateString7()
+  IsNotEmpty94({ message: "start date is required" }),
+  IsDateString9()
 ], CreateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  IsNotEmpty70({ message: "end date is required" }),
-  IsDateString7()
+  IsNotEmpty94({ message: "end date is required" }),
+  IsDateString9()
 ], CreateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  IsNotEmpty70({ message: "start time is required" }),
+  IsNotEmpty94({ message: "start time is required" }),
   Matches13(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "startTime must be in HH:mm:ss format"
   })
 ], CreateFreelancerTimesheetDto.prototype, "startTime", 2);
 __decorateClass([
-  IsNotEmpty70({ message: "end time is required" }),
+  IsNotEmpty94({ message: "end time is required" }),
   Matches13(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "endTime must be in HH:mm:ss format"
   })
 ], CreateFreelancerTimesheetDto.prototype, "endTime", 2);
 __decorateClass([
-  IsOptional45(),
+  IsOptional64(),
   IsInt12()
 ], CreateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  IsOptional45(),
-  IsString49()
+  IsOptional64(),
+  IsString73()
 ], CreateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional45(),
-  IsString49()
+  IsOptional64(),
+  IsString73()
 ], CreateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  IsOptional45(),
-  IsString49()
+  IsOptional64(),
+  IsString73()
 ], CreateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  IsNotEmpty70({ message: "Description is required" })
+  IsNotEmpty94({ message: "Description is required" })
 ], CreateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/timesheet/dto/update-freelancer-timesheet.dto.ts
 import {
-  IsDateString as IsDateString8,
+  IsDateString as IsDateString10,
   IsInt as IsInt13,
-  IsNotEmpty as IsNotEmpty71,
-  IsOptional as IsOptional46,
-  IsString as IsString50,
+  IsNotEmpty as IsNotEmpty95,
+  IsOptional as IsOptional65,
+  IsString as IsString74,
   Matches as Matches14,
-  IsNumber as IsNumber16
+  IsNumber as IsNumber29
 } from "class-validator";
 var UpdateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty71({ message: "Job id is required" }),
-  IsNumber16({}, { message: "Job id must be a number" })
+  IsNotEmpty95({ message: "Job id is required" }),
+  IsNumber29({}, { message: "Job id must be a number" })
 ], UpdateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty71({ message: "start date is required" }),
-  IsDateString8()
+  IsNotEmpty95({ message: "start date is required" }),
+  IsDateString10()
 ], UpdateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  IsNotEmpty71({ message: "end date is required" }),
-  IsDateString8()
+  IsNotEmpty95({ message: "end date is required" }),
+  IsDateString10()
 ], UpdateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  IsNotEmpty71({ message: "start time is required" }),
+  IsNotEmpty95({ message: "start time is required" }),
   Matches14(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "startTime must be in HH:mm:ss format"
   })
 ], UpdateFreelancerTimesheetDto.prototype, "startTime", 2);
 __decorateClass([
-  IsNotEmpty71({ message: "end time is required" }),
+  IsNotEmpty95({ message: "end time is required" }),
   Matches14(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "endTime must be in HH:mm:ss format"
   })
 ], UpdateFreelancerTimesheetDto.prototype, "endTime", 2);
 __decorateClass([
-  IsOptional46(),
+  IsOptional65(),
   IsInt13()
 ], UpdateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  IsOptional46(),
-  IsString50()
+  IsOptional65(),
+  IsString74()
 ], UpdateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional46(),
-  IsString50()
+  IsOptional65(),
+  IsString74()
 ], UpdateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  IsOptional46(),
-  IsString50()
+  IsOptional65(),
+  IsString74()
 ], UpdateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  IsNotEmpty71({ message: "Description is required" })
+  IsNotEmpty95({ message: "Description is required" })
 ], UpdateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/timesheet/dto/submit-timesheet.dto.ts
-import { IsNotEmpty as IsNotEmpty72, IsNumber as IsNumber17 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty96, IsNumber as IsNumber30 } from "class-validator";
 var SubmitTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty72({ message: "Timesheet line ID is required" }),
-  IsNumber17({}, { message: "Timesheet line ID must be a number" })
+  IsNotEmpty96({ message: "Timesheet line ID is required" }),
+  IsNumber30({}, { message: "Timesheet line ID must be a number" })
 ], SubmitTimesheetDto.prototype, "timesheetLineId", 2);
 
 // src/modules/timesheet/dto/resubmit-timesheet.dto.ts
-import { IsNotEmpty as IsNotEmpty73, IsNumber as IsNumber18 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty97, IsNumber as IsNumber31 } from "class-validator";
 var ResubmitTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty73({ message: "Timesheet line ID is required" }),
-  IsNumber18({}, { message: "Timesheet line ID must be a number" })
+  IsNotEmpty97({ message: "Timesheet line ID is required" }),
+  IsNumber31({}, { message: "Timesheet line ID must be a number" })
 ], ResubmitTimesheetDto.prototype, "timesheetLineId", 2);
 
 // src/modules/timesheet/dto/approve-timesheets.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty12, IsArray as IsArray17, IsNumber as IsNumber19 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty13, IsArray as IsArray21, IsNumber as IsNumber32 } from "class-validator";
 var ApproveTimesheetsDto = class {
 };
 __decorateClass([
-  IsArray17({ message: "Timesheet line IDs must be an array" }),
-  ArrayNotEmpty12({ message: "At least one timesheet line ID is required" }),
-  IsNumber19({}, { each: true, message: "Each timesheet line ID must be a number" })
+  IsArray21({ message: "Timesheet line IDs must be an array" }),
+  ArrayNotEmpty13({ message: "At least one timesheet line ID is required" }),
+  IsNumber32({}, { each: true, message: "Each timesheet line ID must be a number" })
 ], ApproveTimesheetsDto.prototype, "timesheetLineIds", 2);
 
 // src/modules/timesheet/dto/send-back-timesheets.dto.ts
-import { ArrayNotEmpty as ArrayNotEmpty13, IsArray as IsArray18, IsNumber as IsNumber20, IsOptional as IsOptional47, IsString as IsString51 } from "class-validator";
+import { ArrayNotEmpty as ArrayNotEmpty14, IsArray as IsArray22, IsNumber as IsNumber33, IsOptional as IsOptional66, IsString as IsString75 } from "class-validator";
 var SendBackTimesheetsDto = class {
 };
 __decorateClass([
-  IsArray18({ message: "Timesheet line IDs must be an array" }),
-  ArrayNotEmpty13({ message: "At least one timesheet line ID is required" }),
-  IsNumber20({}, { each: true, message: "Each timesheet line ID must be a number" })
+  IsArray22({ message: "Timesheet line IDs must be an array" }),
+  ArrayNotEmpty14({ message: "At least one timesheet line ID is required" }),
+  IsNumber33({}, { each: true, message: "Each timesheet line ID must be a number" })
 ], SendBackTimesheetsDto.prototype, "timesheetLineIds", 2);
 __decorateClass([
-  IsOptional47(),
-  IsString51()
+  IsOptional66(),
+  IsString75()
 ], SendBackTimesheetsDto.prototype, "reason", 2);
 
+// src/modules/timesheet/dto/create-default-timesheet-line.dto.ts
+import { IsNotEmpty as IsNotEmpty98, IsNumber as IsNumber34 } from "class-validator";
+var CreateDefaultTimesheetLineDto = class {
+};
+__decorateClass([
+  IsNotEmpty98({ message: "Contract ID is required" }),
+  IsNumber34({}, { message: "Contract ID must be a number" })
+], CreateDefaultTimesheetLineDto.prototype, "contractId", 2);
+__decorateClass([
+  IsNotEmpty98({ message: "Freelancer ID is required" }),
+  IsNumber34({}, { message: "Freelancer ID must be a number" })
+], CreateDefaultTimesheetLineDto.prototype, "freelancerId", 2);
+__decorateClass([
+  IsNotEmpty98({ message: "Client ID is required" }),
+  IsNumber34({}, { message: "Client ID must be a number" })
+], CreateDefaultTimesheetLineDto.prototype, "clientId", 2);
+
 // src/modules/invoice/pattern/pattern.ts
 var INVOICE_PATTERN = {
   createInvoice: "invoice.create",
@@ -8732,23 +9252,23 @@ var INVOICE_PATTERN = {
 };
 
 // src/modules/invoice/dto/update-invoice-status.dto.ts
-import { IsEnum as IsEnum33, IsNotEmpty as IsNotEmpty74 } from "class-validator";
+import { IsEnum as IsEnum35, IsNotEmpty as IsNotEmpty99 } from "class-validator";
 var UpdateInvoiceStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty74({ message: "Please provide invoice status." }),
-  IsEnum33(InvoiceStatusEnum, {
+  IsNotEmpty99({ message: "Please provide invoice status." }),
+  IsEnum35(InvoiceStatusEnum, {
     message: "Status must be one of: APPROVED, REJECTED"
   })
 ], UpdateInvoiceStatusDto.prototype, "status", 2);
 
 // src/modules/invoice/dto/create-invoice.dto.ts
-import { IsNotEmpty as IsNotEmpty75, IsNumber as IsNumber21 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty100, IsNumber as IsNumber35 } from "class-validator";
 var CreateInvoiceDto = class {
 };
 __decorateClass([
-  IsNotEmpty75({ message: "Timesheet line ID is required" }),
-  IsNumber21({}, { message: "Timesheet line ID must be a number" })
+  IsNotEmpty100({ message: "Timesheet line ID is required" }),
+  IsNumber35({}, { message: "Timesheet line ID must be a number" })
 ], CreateInvoiceDto.prototype, "timeSheetLineId", 2);
 
 // src/modules/dispute/pattern/pattern.ts
@@ -8760,13 +9280,13 @@ var DISPUTE_PATTERN = {
 
 // src/modules/dispute/dto/create-dispute.dto.ts
 import {
-  IsString as IsString52,
-  IsNotEmpty as IsNotEmpty76,
+  IsString as IsString76,
+  IsNotEmpty as IsNotEmpty101,
   IsIn as IsIn4,
-  IsOptional as IsOptional48,
+  IsOptional as IsOptional67,
   MaxLength as MaxLength21,
-  IsObject,
-  IsNumber as IsNumber22,
+  IsObject as IsObject7,
+  IsNumber as IsNumber36,
   ValidateIf as ValidateIf11
 } from "class-validator";
 import { Transform as Transform4, Type as Type16 } from "class-transformer";
@@ -8774,36 +9294,36 @@ var CreateDisputeDto = class {
 };
 __decorateClass([
   ValidateIf11((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
-  IsNumber22({}, { message: "Client id must be a number" }),
+  IsNumber36({}, { message: "Client id must be a number" }),
   Type16(() => Number)
 ], CreateDisputeDto.prototype, "clientId", 2);
 __decorateClass([
   ValidateIf11((o) => o.initiatorType === "CLIENT" /* CLIENT */),
-  IsNumber22({}, { message: "Freelancer id must be a number" }),
+  IsNumber36({}, { message: "Freelancer id must be a number" }),
   Type16(() => Number)
 ], CreateDisputeDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsNotEmpty76({ message: "Please select dispute type." }),
-  IsString52(),
+  IsNotEmpty101({ message: "Please select dispute type." }),
+  IsString76(),
   IsIn4(["JOB", "INVOICE"])
 ], CreateDisputeDto.prototype, "disputeType", 2);
 __decorateClass([
-  IsNotEmpty76({ message: "Please provide initiator type." }),
-  IsString52()
+  IsNotEmpty101({ message: "Please provide initiator type." }),
+  IsString76()
 ], CreateDisputeDto.prototype, "initiatorType", 2);
 __decorateClass([
-  IsNotEmpty76({ message: "Please enter description." }),
-  IsString52({ message: "Description must be a string" }),
+  IsNotEmpty101({ message: "Please enter description." }),
+  IsString76({ message: "Description must be a string" }),
   MaxLength21(500, { message: "Description must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "description", 2);
 __decorateClass([
-  IsOptional48(),
-  IsString52({ message: "Comment must be a string" }),
+  IsOptional67(),
+  IsString76({ message: "Comment must be a string" }),
   MaxLength21(500, { message: "Comment must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "comment", 2);
 __decorateClass([
-  IsOptional48(),
-  IsObject({ message: "Dynamic fields must be a valid object" }),
+  IsOptional67(),
+  IsObject7({ message: "Dynamic fields must be a valid object" }),
   Transform4(({ value }) => {
     if (typeof value === "string") {
       try {
@@ -8825,17 +9345,128 @@ var SENSELOAF_PATTERN = {
 
 // src/modules/senseloaf/dto/ai-interview-question-generate.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty77
+  IsNotEmpty as IsNotEmpty102
 } from "class-validator";
 var AiInterviewQuestionGenerateDto = class {
 };
 __decorateClass([
-  IsNotEmpty77({ message: "Please enter job description." })
+  IsNotEmpty102({ message: "Please enter job description." })
 ], AiInterviewQuestionGenerateDto.prototype, "jobDescription", 2);
 __decorateClass([
-  IsNotEmpty77({ message: "Please enter number of questions." })
+  IsNotEmpty102({ message: "Please enter number of questions." })
 ], AiInterviewQuestionGenerateDto.prototype, "numQuestions", 2);
 
+// src/modules/senseloaf/dto/resume-parsing-by-url.dto.ts
+import { IsNotEmpty as IsNotEmpty103, IsString as IsString77, IsOptional as IsOptional68 } from "class-validator";
+var ResumeParsingByUrlDto = class {
+};
+__decorateClass([
+  IsNotEmpty103({ message: "Resume URL is required" }),
+  IsString77({ message: "Resume URL must be a string" })
+], ResumeParsingByUrlDto.prototype, "resumeUrl", 2);
+__decorateClass([
+  IsOptional68(),
+  IsString77()
+], ResumeParsingByUrlDto.prototype, "fileName", 2);
+
+// src/modules/senseloaf/dto/resume-data-processing.dto.ts
+import { IsNotEmpty as IsNotEmpty104, IsString as IsString78, IsOptional as IsOptional69, IsObject as IsObject8 } from "class-validator";
+var ResumeDataProcessingDto = class {
+};
+__decorateClass([
+  IsNotEmpty104({ message: "Resume data is required" }),
+  IsObject8()
+], ResumeDataProcessingDto.prototype, "resumeData", 2);
+__decorateClass([
+  IsOptional69(),
+  IsString78()
+], ResumeDataProcessingDto.prototype, "userId", 2);
+__decorateClass([
+  IsOptional69(),
+  IsString78()
+], ResumeDataProcessingDto.prototype, "processingType", 2);
+
+// src/modules/senseloaf/dto/check-resume-eligibility.dto.ts
+import { IsNotEmpty as IsNotEmpty105, IsString as IsString79, IsOptional as IsOptional70, IsObject as IsObject9 } from "class-validator";
+var CheckResumeEligibilityDto = class {
+};
+__decorateClass([
+  IsNotEmpty105({ message: "Resume data is required" }),
+  IsObject9()
+], CheckResumeEligibilityDto.prototype, "resumeData", 2);
+__decorateClass([
+  IsOptional70(),
+  IsString79()
+], CheckResumeEligibilityDto.prototype, "jobId", 2);
+__decorateClass([
+  IsOptional70(),
+  IsString79()
+], CheckResumeEligibilityDto.prototype, "userId", 2);
+
+// src/modules/senseloaf/dto/ai-interview-template-generation.dto.ts
+import { IsNotEmpty as IsNotEmpty106, IsString as IsString80, IsOptional as IsOptional71, IsArray as IsArray23, IsNumber as IsNumber37 } from "class-validator";
+var AiInterviewTemplateGenerationDto = class {
+};
+__decorateClass([
+  IsNotEmpty106({ message: "Job ID is required" }),
+  IsString80({ message: "Job ID must be a string" })
+], AiInterviewTemplateGenerationDto.prototype, "jobId", 2);
+__decorateClass([
+  IsOptional71(),
+  IsArray23(),
+  IsString80({ each: true, message: "Each skill must be a string" })
+], AiInterviewTemplateGenerationDto.prototype, "skills", 2);
+__decorateClass([
+  IsOptional71(),
+  IsNumber37({}, { message: "Number of questions must be a number" })
+], AiInterviewTemplateGenerationDto.prototype, "numberOfQuestions", 2);
+__decorateClass([
+  IsOptional71(),
+  IsString80()
+], AiInterviewTemplateGenerationDto.prototype, "difficulty", 2);
+
+// src/modules/senseloaf/dto/ai-interview-link-generation.dto.ts
+import { IsNotEmpty as IsNotEmpty107, IsString as IsString81, IsOptional as IsOptional72, IsNumber as IsNumber38 } from "class-validator";
+var AiInterviewLinkGenerationDto = class {
+};
+__decorateClass([
+  IsNotEmpty107({ message: "Template ID is required" }),
+  IsString81({ message: "Template ID must be a string" })
+], AiInterviewLinkGenerationDto.prototype, "templateId", 2);
+__decorateClass([
+  IsNotEmpty107({ message: "Freelancer ID is required" }),
+  IsString81({ message: "Freelancer ID must be a string" })
+], AiInterviewLinkGenerationDto.prototype, "freelancerId", 2);
+__decorateClass([
+  IsOptional72(),
+  IsString81()
+], AiInterviewLinkGenerationDto.prototype, "jobId", 2);
+__decorateClass([
+  IsOptional72(),
+  IsNumber38({}, { message: "Expiry hours must be a number" })
+], AiInterviewLinkGenerationDto.prototype, "expiryHours", 2);
+
+// src/modules/senseloaf/dto/ai-assessment-creation.dto.ts
+import { IsNotEmpty as IsNotEmpty108, IsString as IsString82, IsOptional as IsOptional73, IsNumber as IsNumber39 } from "class-validator";
+var AiAssessmentCreationDto = class {
+};
+__decorateClass([
+  IsNotEmpty108({ message: "User ID is required" }),
+  IsString82({ message: "User ID must be a string" })
+], AiAssessmentCreationDto.prototype, "userId", 2);
+__decorateClass([
+  IsOptional73(),
+  IsString82()
+], AiAssessmentCreationDto.prototype, "assessmentType", 2);
+__decorateClass([
+  IsOptional73(),
+  IsNumber39({}, { message: "Number of questions must be a number" })
+], AiAssessmentCreationDto.prototype, "numberOfQuestions", 2);
+__decorateClass([
+  IsOptional73(),
+  IsString82()
+], AiAssessmentCreationDto.prototype, "difficulty", 2);
+
 // src/modules/commission/pattern/pattern.ts
 var COMMISSION_PATTERN = {
   fetchCommission: "fetch.commission"
@@ -8849,16 +9480,16 @@ var HIRING_PATTERN = {
 };
 
 // src/modules/hiring/dto/create-hiring.dto.ts
-import { IsNotEmpty as IsNotEmpty78, IsNumber as IsNumber23 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty109, IsNumber as IsNumber40 } from "class-validator";
 var CreateHiringDto = class {
 };
 __decorateClass([
-  IsNotEmpty78({ message: "Freelancer ID is required" }),
-  IsNumber23({}, { message: "Freelancer ID must be a number" })
+  IsNotEmpty109({ message: "Freelancer ID is required" }),
+  IsNumber40({}, { message: "Freelancer ID must be a number" })
 ], CreateHiringDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsNotEmpty78({ message: "Job ID is required" }),
-  IsNumber23({}, { message: "Job ID must be a number" })
+  IsNotEmpty109({ message: "Job ID is required" }),
+  IsNumber40({}, { message: "Job ID must be a number" })
 ], CreateHiringDto.prototype, "jobId", 2);
 
 // src/modules/llm/pattern/pattern.ts
@@ -8878,6 +9509,19 @@ var SIGNATURE_PATTERN = {
   saveSignature: "save.signature"
 };
 
+// src/modules/user/signature/dto/save-signature.dto.ts
+import { IsOptional as IsOptional74, IsString as IsString83 } from "class-validator";
+var SaveSignatureDto = class {
+};
+__decorateClass([
+  IsOptional74(),
+  IsString83()
+], SaveSignatureDto.prototype, "signatureType", 2);
+__decorateClass([
+  IsOptional74(),
+  IsString83()
+], SaveSignatureDto.prototype, "description", 2);
+
 // src/modules/wallet/pattern/pattern.ts
 var WALLET_PATTERN = {
   fetchConnectAccountDetails: "fetch.connect.account.details",
@@ -8892,6 +9536,28 @@ var WALLET_ADMIN_PATTERN = {
   fetchAdminWalletTransactions: "fetch.admin.wallet.transactions"
 };
 
+// src/modules/wallet/dto/add-topup-escrow-amount.dto.ts
+import { IsNotEmpty as IsNotEmpty110, IsNumber as IsNumber41 } from "class-validator";
+var AddTopupEscrowAmountDto = class {
+};
+__decorateClass([
+  IsNotEmpty110({ message: "Amount is required" }),
+  IsNumber41({}, { message: "Amount must be a number" })
+], AddTopupEscrowAmountDto.prototype, "amount", 2);
+
+// src/modules/wallet/dto/debit-commission-fte-hiring.dto.ts
+import { IsNotEmpty as IsNotEmpty111, IsNumber as IsNumber42 } from "class-validator";
+var DebitCommissionFteHiringDto = class {
+};
+__decorateClass([
+  IsNotEmpty111({ message: "Hiring ID is required" }),
+  IsNumber42({}, { message: "Hiring ID must be a number" })
+], DebitCommissionFteHiringDto.prototype, "hiringId", 2);
+__decorateClass([
+  IsNotEmpty111({ message: "Amount is required" }),
+  IsNumber42({}, { message: "Amount must be a number" })
+], DebitCommissionFteHiringDto.prototype, "amount", 2);
+
 // src/adapters/tcp/user.tcp.adapter.ts
 import { config } from "dotenv";
 import { Transport } from "@nestjs/microservices";
@@ -9910,6 +10576,7 @@ export {
   AUTHENTICATION_PATTERN,
   AccountStatus,
   AccountType,
+  AddTopupEscrowAmountDto,
   AdminCreateJobInformationDto,
   AdminJobBasicInformationV2Dto,
   AdminPermission,
@@ -9917,16 +10584,20 @@ export {
   AdminRolePermission,
   AdminUpdateJobInformationDto,
   AdminUserRole,
+  AiAssessmentCreationDto,
   AiAssessmentStatusEnum,
   AiInterview,
+  AiInterviewLinkGenerationDto,
   AiInterviewQuestionGenerateDto,
   AiInterviewRescheduleRequest,
   AiInterviewRescheduleRequestStatusEnum,
   AiInterviewStatusEnum,
+  AiInterviewTemplateGenerationDto,
   AnswerTypeEnum,
   ApplicationStatusEnum,
   ApproveTimesheetsDto,
   AssessmentAnswer,
+  AssessmentRequestStatus,
   AssessmentRequestStatusEnum,
   AssessmentStatusEnum,
   AssessmetQuestion,
@@ -9951,6 +10622,8 @@ export {
   COUNTRY_PATTERN,
   CalendlyMeetingLog,
   CandidateType,
+  CaptureAiAssessmentResultDto,
+  CaptureAiInterviewResultPublicDto,
   CaseStudyDto,
   CategoryEmum,
   CategoryEmumDto,
@@ -9958,13 +10631,17 @@ export {
   ChangeJobApplicationStatusDto,
   ChatRMQAdapter,
   ChatTCPAdapter,
+  CheckResumeEligibilityDto,
   City,
+  ClientAddFundDto,
   ClientCandidatePreference,
   ClientCandidatePreferenceEnum,
   ClientChangePasswordDto,
   ClientCreateAccountDto,
+  ClientESignatureDto,
   ClientFreelancerRecommendation,
   ClientProfileQuestionDto,
+  ClientServiceAgreementUploadDto,
   CloseJobDto,
   Cms,
   Commission,
@@ -9990,6 +10667,7 @@ export {
   CreateCmsDto,
   CreateCompanyMemberDto,
   CreateCompanyRoleDto,
+  CreateDefaultTimesheetLineDto,
   CreateDisputeDto,
   CreateF2FInterviewDirectDto,
   CreateF2FInterviewDto,
@@ -9997,13 +10675,16 @@ export {
   CreateFreelancerDto,
   CreateFreelancerTimesheetDto,
   CreateHiringDto,
+  CreateInterviewBasicInformationDto,
   CreateInvoiceDto,
   CreateJobApplicationDto,
   CreateLeadDto,
+  CreatePayoutDto,
   CreateQuestionDto,
   CreateRatingDto,
   CreateSubAdminDto,
   DISPUTE_PATTERN,
+  DebitCommissionFteHiringDto,
   Dispute,
   DisputeStatusEnum,
   DocumentType,
@@ -10013,10 +10694,13 @@ export {
   EducationDto,
   EmploymentType,
   EmploymentTypeV2,
+  EscrowFundContractDto,
   EscrowWallet,
   EscrowWalletTransaction,
   EscrowWalletTransactionForEnum,
   EscrowWalletTransactionTypeEnum,
+  EsignContractClientDto,
+  EsignContractFreelancerDto,
   ExperienceDto,
   F2FInterview,
   F2FInterviewSchedule,
@@ -10032,6 +10716,8 @@ export {
   FREELANCER_PROJECT_PATTERN,
   FREELANCER_SKILL_PATTERN,
   Feature,
+  FetchClientInfoForChatDto,
+  FetchFreelancerInfoForChatDto,
   ForgotPasswordDto,
   FreelancerAssessment,
   FreelancerAssessmentRequest,
@@ -10043,6 +10729,7 @@ export {
   FreelancerDeclaration,
   FreelancerDeclarationDto,
   FreelancerDevelopmentPreferenceDto,
+  FreelancerESignatureDto,
   FreelancerEducation,
   FreelancerEducationDto,
   FreelancerExperience,
@@ -10064,6 +10751,7 @@ export {
   FreelancerUploadResumeDto,
   FreelancerWorkShowcaseDto,
   FromUsOn,
+  GenerateContractDto,
   HIRING_PATTERN,
   HiredFreelancerNatureOfWorkEnum,
   Hiring,
@@ -10122,6 +10810,8 @@ export {
   LoginViaOtpScopeEnum,
   LogoutDto,
   MAINTENANCE_PATTERN,
+  MarkCandidateStatusBulkDto,
+  MarkCandidateStatusDto,
   McqStatusEnum,
   ModeOfHire,
   ModeOfWork,
@@ -10135,11 +10825,13 @@ export {
   OTP_PATTERN,
   OnboardingStepEnum,
   Otp,
+  OtpType,
   PERMISSION_PATTERN,
   PLAN_PATTERN,
   PROFILE_PATTERN,
   Permission,
   Plan,
+  PreCheckoutCalculationDto,
   ProjectDto,
   Provider,
   Question,
@@ -10150,13 +10842,18 @@ export {
   Rating,
   RatingTypeEnum,
   RecommendationWeightageConfig,
+  RecordAssessmentAnswerDto,
+  RecordAssessmentAnswersDto,
   RefreshDto,
   RefreshToken,
   RejectAIInterviewRescheduleRequestDto,
+  RejectF2FInterviewRescheduleRequestDto,
   ResetPasswordDto,
   ResetPasswordTokenValidationDto,
   ResubmitTimesheetDto,
   ResultStatusEnum,
+  ResumeDataProcessingDto,
+  ResumeParsingByUrlDto,
   SENSELOAF_PATTERN,
   SIGNATURE_PATTERN,
   SKILL_PATTERN,
@@ -10165,8 +10862,10 @@ export {
   STRIPE_PATTERN,
   SUBADMIN_PATTERN,
   SYSTEM_PREFERENCES_PATTERN,
+  SaveSignatureDto,
   ScopeEnum,
   SelectedAnswerTypeEnum,
+  SendAiAssessmentLinkDto,
   SendBackTimesheetsDto,
   SendGuestOtpDto,
   SendGuestOtpPurposeEnum,
@@ -10174,6 +10873,7 @@ export {
   SendLoginOtpDto,
   SendLoginOtpPurposeEnum,
   SendLoginOtpScopeEnum,
+  SendOtpDto,
   SenseloafLog,
   SequenceGenerator,
   SetPasswordDto,
@@ -10182,6 +10882,7 @@ export {
   Signature,
   Skill,
   SkillCatalog,
+  SocialAuthDto,
   State,
   Step,
   StepCompletedEnumV2,
@@ -10195,6 +10896,7 @@ export {
   SystemPreferenceKey,
   TIMESHEET_CLIENT_PATTERN,
   TIMESHEET_FREELANCER_PATTERN,
+  TestNotificationDto,
   Timesheet,
   TimesheetLine,
   TimesheetLineHistory,
@@ -10205,10 +10907,12 @@ export {
   TimesheetSubmissionActionEnum,
   ToggleCompanyMemberVisibilityDto,
   ToggleCompanyRoleVisibilityDto,
+  TransferFundsDto,
   TypeOfEmploymentEnum,
   TypeOfEmploymentEnumDto,
   TypeOfEmploymentEnums,
   UpdateAdminRoleDto,
+  UpdateAssessmentRequestStatusDto,
   UpdateClientAccountStatusDto,
   UpdateClientDto,
   UpdateClientHiringModeEnum,
@@ -10220,14 +10924,19 @@ export {
   UpdateFreelancerDto,
   UpdateFreelancerProfileDto,
   UpdateFreelancerTimesheetDto,
+  UpdateInterviewBasicInformationDto,
   UpdateInvoiceStatusDto,
   UpdateSubAdminAccountStatusDto,
   UpdateSubAdminDto,
   User,
   UserRMQAdapter,
   UserTCPAdapter,
+  ValidateEmailDto,
+  ValidateMobileDto,
   VerifyGuestOtpDto,
   VerifyGuestOtpPurposeEnum,
+  VerifyOnboardingTokenDto,
+  VerifyOtpDto,
   WALLET_ADMIN_PATTERN,
   WALLET_PATTERN,
   Wallet,