@experts_hub/shared 1.0.585 → 1.0.587

package/dist/index.js

@@ -373,6 +373,7 @@ __export(index_exports, {
   TypeOfEmploymentEnumDto: () => TypeOfEmploymentEnumDto,
   TypeOfEmploymentEnums: () => TypeOfEmploymentEnums,
   UpdateAdminRoleDto: () => UpdateAdminRoleDto,
+  UpdateAdminRoleStatusDto: () => UpdateAdminRoleStatusDto,
   UpdateAssessmentRequestStatusDto: () => UpdateAssessmentRequestStatusDto,
   UpdateClientAccountStatusDto: () => UpdateClientAccountStatusDto,
   UpdateClientDto: () => UpdateClientDto,
@@ -8517,7 +8518,8 @@ var ADMIN_ROLE_PATTERN = {
   adminUpdateRole: "admin.update.role",
   adminDeleteRole: "admin.delete.role",
   attachPermissionsToRole: "attach.permissions.to.role",
-  fetchAdminRolePermissions: "fetch.admin.role.permissions"
+  fetchAdminRolePermissions: "fetch.admin.role.permissions",
+  updateAdminRoleStatus: "update.admin.role.status"
 };
 
 // src/modules/admin-role/dto/create-admin-role.dto.ts
@@ -8532,6 +8534,10 @@ __decorateClass([
   (0, import_class_validator89.IsOptional)(),
   (0, import_class_validator89.IsString)({ message: "Role description must be a string." })
 ], CreateAdminRoleDto.prototype, "roleDescription", 2);
+__decorateClass([
+  (0, import_class_validator89.IsOptional)(),
+  (0, import_class_validator89.IsBoolean)({ message: "Is active must be a boolean value" })
+], CreateAdminRoleDto.prototype, "isActive", 2);
 
 // src/modules/admin-role/dto/update-admin-role.dto.ts
 var import_class_validator90 = require("class-validator");
@@ -8563,6 +8569,15 @@ __decorateClass([
   (0, import_class_validator91.IsString)({ message: "Permission IDs must be a comma-separated string." })
 ], AttachPermissionsToRoleDto.prototype, "permissionIds", 2);
 
+// src/modules/admin-role/dto/update-admin-role-status.dto.ts
+var import_class_validator92 = require("class-validator");
+var UpdateAdminRoleStatusDto = class {
+};
+__decorateClass([
+  (0, import_class_validator92.IsNotEmpty)({ message: "Please specify admin role status." }),
+  (0, import_class_validator92.IsBoolean)({ message: "Is active must be a boolean value" })
+], UpdateAdminRoleStatusDto.prototype, "isActive", 2);
+
 // src/modules/admin-permission/pattern/pattern.ts
 var ADMIN_PERMISSION_PATTERN = {
   fetchAdminPermissions: "fetch.admin.permissions"
@@ -8640,7 +8655,7 @@ var INTERVIEW_PATTERN = {
 };
 
 // src/modules/interview/dto/interview-invite.dto.ts
-var import_class_validator92 = require("class-validator");
+var import_class_validator93 = require("class-validator");
 var import_class_transformer15 = require("class-transformer");
 var CandidateType = /* @__PURE__ */ ((CandidateType2) => {
   CandidateType2["SHORTLISTED"] = "SHORTLISTED";
@@ -8652,195 +8667,195 @@ var CandidateType = /* @__PURE__ */ ((CandidateType2) => {
 var ExistingCandidateDto = class {
 };
 __decorateClass([
-  (0, import_class_validator92.IsUUID)()
+  (0, import_class_validator93.IsUUID)()
 ], ExistingCandidateDto.prototype, "id", 2);
 __decorateClass([
-  (0, import_class_validator92.IsEnum)(CandidateType, {
+  (0, import_class_validator93.IsEnum)(CandidateType, {
     message: "type must be one of SHORTLISTED, APPLICATNTS, or RECOMMENDED"
   })
 ], ExistingCandidateDto.prototype, "type", 2);
 var NewCandidateDto = class {
 };
 __decorateClass([
-  (0, import_class_validator92.IsNotEmpty)({ message: "Please enter the candidate name" }),
-  (0, import_class_validator92.IsString)({ message: "Name must be a string" })
+  (0, import_class_validator93.IsNotEmpty)({ message: "Please enter the candidate name" }),
+  (0, import_class_validator93.IsString)({ message: "Name must be a string" })
 ], NewCandidateDto.prototype, "name", 2);
 __decorateClass([
-  (0, import_class_validator92.IsEmail)({}, { message: "Please enter a valid email." })
+  (0, import_class_validator93.IsEmail)({}, { message: "Please enter a valid email." })
 ], NewCandidateDto.prototype, "email", 2);
 __decorateClass([
-  (0, import_class_validator92.IsEnum)(CandidateType, {
+  (0, import_class_validator93.IsEnum)(CandidateType, {
     message: "type must be NEW"
   })
 ], NewCandidateDto.prototype, "type", 2);
 var CandidatesDto = class {
 };
 __decorateClass([
-  (0, import_class_validator92.ValidateIf)((o) => o.exixtingCandidates?.length > 0),
-  (0, import_class_validator92.IsArray)({ message: "Existing candidates should be an array." }),
-  (0, import_class_validator92.ArrayNotEmpty)({ message: "Please select at least one candidate." }),
-  (0, import_class_validator92.ValidateNested)({ each: true }),
+  (0, import_class_validator93.ValidateIf)((o) => o.exixtingCandidates?.length > 0),
+  (0, import_class_validator93.IsArray)({ message: "Existing candidates should be an array." }),
+  (0, import_class_validator93.ArrayNotEmpty)({ message: "Please select at least one candidate." }),
+  (0, import_class_validator93.ValidateNested)({ each: true }),
   (0, import_class_transformer15.Type)(() => ExistingCandidateDto)
 ], CandidatesDto.prototype, "exixtingCandidates", 2);
 __decorateClass([
-  (0, import_class_validator92.ValidateIf)((o) => o.newCandidates?.length > 0),
-  (0, import_class_validator92.IsArray)({ message: "New candidates should be an array." }),
-  (0, import_class_validator92.ArrayNotEmpty)({ message: "Please add at least one candidate." }),
-  (0, import_class_validator92.ValidateNested)({ each: true }),
+  (0, import_class_validator93.ValidateIf)((o) => o.newCandidates?.length > 0),
+  (0, import_class_validator93.IsArray)({ message: "New candidates should be an array." }),
+  (0, import_class_validator93.ArrayNotEmpty)({ message: "Please add at least one candidate." }),
+  (0, import_class_validator93.ValidateNested)({ each: true }),
   (0, import_class_transformer15.Type)(() => NewCandidateDto)
 ], CandidatesDto.prototype, "newCandidates", 2);
 var InterviewInviteDto = class {
 };
 __decorateClass([
-  (0, import_class_validator92.IsUUID)()
+  (0, import_class_validator93.IsUUID)()
 ], InterviewInviteDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator92.ValidateNested)({ each: true }),
+  (0, import_class_validator93.ValidateNested)({ each: true }),
   (0, import_class_transformer15.Type)(() => CandidatesDto)
 ], InterviewInviteDto.prototype, "candidates", 2);
 
 // src/modules/interview/dto/create-f2f-interview.dto.ts
-var import_class_validator93 = require("class-validator");
+var import_class_validator94 = require("class-validator");
 var CreateF2FInterviewDto = class {
 };
 __decorateClass([
-  (0, import_class_validator93.IsEmail)({}, { message: "Please enter a valid email address." }),
-  (0, import_class_validator93.IsNotEmpty)({ message: "Invitee email is required." })
+  (0, import_class_validator94.IsEmail)({}, { message: "Please enter a valid email address." }),
+  (0, import_class_validator94.IsNotEmpty)({ message: "Invitee email is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  (0, import_class_validator93.IsString)({ message: "Invitee name must be a string." }),
-  (0, import_class_validator93.IsNotEmpty)({ message: "Invitee name is required." })
+  (0, import_class_validator94.IsString)({ message: "Invitee name must be a string." }),
+  (0, import_class_validator94.IsNotEmpty)({ message: "Invitee name is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeName", 2);
 __decorateClass([
-  (0, import_class_validator93.IsNumber)({}, { message: "Interview ID must be a number." })
+  (0, import_class_validator94.IsNumber)({}, { message: "Interview ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "interviewId", 2);
 __decorateClass([
-  (0, import_class_validator93.IsNumber)({}, { message: "Candidate ID must be a number." })
+  (0, import_class_validator94.IsNumber)({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-direct.dto.ts
-var import_class_validator94 = require("class-validator");
+var import_class_validator95 = require("class-validator");
 var CreateF2FInterviewDirectDto = class {
 };
 __decorateClass([
-  (0, import_class_validator94.IsEmail)({}, { message: "Please enter a valid email address." }),
-  (0, import_class_validator94.IsNotEmpty)({ message: "Invitee email is required." })
+  (0, import_class_validator95.IsEmail)({}, { message: "Please enter a valid email address." }),
+  (0, import_class_validator95.IsNotEmpty)({ message: "Invitee email is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  (0, import_class_validator94.IsString)({ message: "Invitee name must be a string." }),
-  (0, import_class_validator94.IsNotEmpty)({ message: "Invitee name is required." })
+  (0, import_class_validator95.IsString)({ message: "Invitee name must be a string." }),
+  (0, import_class_validator95.IsNotEmpty)({ message: "Invitee name is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeName", 2);
 __decorateClass([
-  (0, import_class_validator94.IsNumber)({}, { message: "Job ID must be a number." })
+  (0, import_class_validator95.IsNumber)({}, { message: "Job ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator94.IsNumber)({}, { message: "Candidate ID must be a number." })
+  (0, import_class_validator95.IsNumber)({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-reschedule-request.dto.ts
-var import_class_validator95 = require("class-validator");
+var import_class_validator96 = require("class-validator");
 var CreateF2FInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  (0, import_class_validator95.IsNotEmpty)({ message: "F2F Interview ID is required." })
+  (0, import_class_validator96.IsNotEmpty)({ message: "F2F Interview ID is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "f2FInterviewId", 2);
 __decorateClass([
-  (0, import_class_validator95.IsNotEmpty)({ message: "Rescheduled date is required." })
+  (0, import_class_validator96.IsNotEmpty)({ message: "Rescheduled date is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledDate", 2);
 __decorateClass([
-  (0, import_class_validator95.IsString)({ message: "Rescheduled slot must be a string." }),
-  (0, import_class_validator95.IsNotEmpty)({ message: "Rescheduled slot is required." })
+  (0, import_class_validator96.IsString)({ message: "Rescheduled slot must be a string." }),
+  (0, import_class_validator96.IsNotEmpty)({ message: "Rescheduled slot is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledSlot", 2);
 __decorateClass([
-  (0, import_class_validator95.IsString)({ message: "Freelancer reason must be a string." })
+  (0, import_class_validator96.IsString)({ message: "Freelancer reason must be a string." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/interview/dto/create-ai-interview-reschedule-request.dto.ts
-var import_class_validator96 = require("class-validator");
+var import_class_validator97 = require("class-validator");
 var CreateAIInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  (0, import_class_validator96.IsNotEmpty)({ message: "AI Interview ID is required." })
+  (0, import_class_validator97.IsNotEmpty)({ message: "AI Interview ID is required." })
 ], CreateAIInterviewRescheduleRequestDto.prototype, "aiInterviewId", 2);
 __decorateClass([
-  (0, import_class_validator96.IsString)({ message: "Freelancer reason must be a string." })
+  (0, import_class_validator97.IsString)({ message: "Freelancer reason must be a string." })
 ], CreateAIInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/interview/dto/reject-ai-interview-reschedule-request.dto.ts
-var import_class_validator97 = require("class-validator");
+var import_class_validator98 = require("class-validator");
 var RejectAIInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  (0, import_class_validator97.IsString)({ message: "Client reject reason must be a string." })
+  (0, import_class_validator98.IsString)({ message: "Client reject reason must be a string." })
 ], RejectAIInterviewRescheduleRequestDto.prototype, "clientRejectReason", 2);
 
 // src/modules/interview/dto/reject-f2f-interview-reschedule-request.dto.ts
-var import_class_validator98 = require("class-validator");
+var import_class_validator99 = require("class-validator");
 var RejectF2FInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  (0, import_class_validator98.IsOptional)(),
-  (0, import_class_validator98.IsString)()
+  (0, import_class_validator99.IsOptional)(),
+  (0, import_class_validator99.IsString)()
 ], RejectF2FInterviewRescheduleRequestDto.prototype, "reason", 2);
 
 // src/modules/interview/dto/capture-ai-interview-result-public.dto.ts
-var import_class_validator99 = require("class-validator");
+var import_class_validator100 = require("class-validator");
 var CaptureAiInterviewResultPublicDto = class {
 };
 __decorateClass([
-  (0, import_class_validator99.IsNotEmpty)({ message: "AI Interview UUID is required" }),
-  (0, import_class_validator99.IsString)({ message: "AI Interview UUID must be a string" })
+  (0, import_class_validator100.IsNotEmpty)({ message: "AI Interview UUID is required" }),
+  (0, import_class_validator100.IsString)({ message: "AI Interview UUID must be a string" })
 ], CaptureAiInterviewResultPublicDto.prototype, "aiInterviewUuid", 2);
 __decorateClass([
-  (0, import_class_validator99.IsOptional)(),
-  (0, import_class_validator99.IsObject)()
+  (0, import_class_validator100.IsOptional)(),
+  (0, import_class_validator100.IsObject)()
 ], CaptureAiInterviewResultPublicDto.prototype, "result", 2);
 __decorateClass([
-  (0, import_class_validator99.IsOptional)(),
-  (0, import_class_validator99.IsString)()
+  (0, import_class_validator100.IsOptional)(),
+  (0, import_class_validator100.IsString)()
 ], CaptureAiInterviewResultPublicDto.prototype, "status", 2);
 
 // src/modules/interview/dto/create-interview-basic-information.dto.ts
-var import_class_validator100 = require("class-validator");
+var import_class_validator101 = require("class-validator");
 var CreateInterviewBasicInformationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator100.IsNotEmpty)({ message: "Job ID is required" }),
-  (0, import_class_validator100.IsNumber)({}, { message: "Job ID must be a number" })
+  (0, import_class_validator101.IsNotEmpty)({ message: "Job ID is required" }),
+  (0, import_class_validator101.IsNumber)({}, { message: "Job ID must be a number" })
 ], CreateInterviewBasicInformationDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator100.IsNotEmpty)({ message: "Interview name is required" }),
-  (0, import_class_validator100.IsString)({ message: "Interview name must be a string" })
+  (0, import_class_validator101.IsNotEmpty)({ message: "Interview name is required" }),
+  (0, import_class_validator101.IsString)({ message: "Interview name must be a string" })
 ], CreateInterviewBasicInformationDto.prototype, "interviewName", 2);
 
 // src/modules/interview/dto/update-interview-basic-information.dto.ts
-var import_class_validator101 = require("class-validator");
+var import_class_validator102 = require("class-validator");
 var UpdateInterviewBasicInformationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator101.IsOptional)(),
-  (0, import_class_validator101.IsString)()
+  (0, import_class_validator102.IsOptional)(),
+  (0, import_class_validator102.IsString)()
 ], UpdateInterviewBasicInformationDto.prototype, "title", 2);
 __decorateClass([
-  (0, import_class_validator101.IsOptional)(),
-  (0, import_class_validator101.IsString)()
+  (0, import_class_validator102.IsOptional)(),
+  (0, import_class_validator102.IsString)()
 ], UpdateInterviewBasicInformationDto.prototype, "description", 2);
 __decorateClass([
-  (0, import_class_validator101.IsOptional)(),
-  (0, import_class_validator101.IsDateString)()
+  (0, import_class_validator102.IsOptional)(),
+  (0, import_class_validator102.IsDateString)()
 ], UpdateInterviewBasicInformationDto.prototype, "scheduledAt", 2);
 __decorateClass([
-  (0, import_class_validator101.IsOptional)(),
-  (0, import_class_validator101.IsNumber)({}, { message: "Duration must be a number" })
+  (0, import_class_validator102.IsOptional)(),
+  (0, import_class_validator102.IsNumber)({}, { message: "Duration must be a number" })
 ], UpdateInterviewBasicInformationDto.prototype, "duration", 2);
 __decorateClass([
-  (0, import_class_validator101.IsOptional)(),
-  (0, import_class_validator101.IsArray)(),
-  (0, import_class_validator101.IsNumber)({}, { each: true, message: "Each skill ID must be a number" })
+  (0, import_class_validator102.IsOptional)(),
+  (0, import_class_validator102.IsArray)(),
+  (0, import_class_validator102.IsNumber)({}, { each: true, message: "Each skill ID must be a number" })
 ], UpdateInterviewBasicInformationDto.prototype, "skillIds", 2);
 __decorateClass([
-  (0, import_class_validator101.IsOptional)(),
-  (0, import_class_validator101.IsString)()
+  (0, import_class_validator102.IsOptional)(),
+  (0, import_class_validator102.IsString)()
 ], UpdateInterviewBasicInformationDto.prototype, "location", 2);
 
 // src/modules/contract/pattern/pattern.ts
@@ -8878,99 +8893,99 @@ var CONTRACT_PATTERN = {
 };
 
 // src/modules/contract/dto/sign-contract-for-client.dto.ts
-var import_class_validator102 = require("class-validator");
+var import_class_validator103 = require("class-validator");
 var import_class_transformer16 = require("class-transformer");
 var SignContractForClientDto = class {
 };
 __decorateClass([
-  (0, import_class_validator102.IsNotEmpty)({ message: "Job Id is required." }),
+  (0, import_class_validator103.IsNotEmpty)({ message: "Job Id is required." }),
   (0, import_class_transformer16.Type)(() => Number),
-  (0, import_class_validator102.IsNumber)({}, { message: "Job ID must be a number." })
+  (0, import_class_validator103.IsNumber)({}, { message: "Job ID must be a number." })
 ], SignContractForClientDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator102.IsNotEmpty)({ message: "Freelancer ID is required." }),
+  (0, import_class_validator103.IsNotEmpty)({ message: "Freelancer ID is required." }),
   (0, import_class_transformer16.Type)(() => Number),
-  (0, import_class_validator102.IsNumber)({}, { message: "Freelancer ID must be a number." })
+  (0, import_class_validator103.IsNumber)({}, { message: "Freelancer ID must be a number." })
 ], SignContractForClientDto.prototype, "freelancerId", 2);
 __decorateClass([
-  (0, import_class_validator102.IsNotEmpty)({ message: "Contract type is required." }),
-  (0, import_class_validator102.IsEnum)(ContractTypeEnum)
+  (0, import_class_validator103.IsNotEmpty)({ message: "Contract type is required." }),
+  (0, import_class_validator103.IsEnum)(ContractTypeEnum)
 ], SignContractForClientDto.prototype, "contractType", 2);
 
 // src/modules/contract/dto/sign-contract-for-freelancer.dto.ts
-var import_class_validator103 = require("class-validator");
+var import_class_validator104 = require("class-validator");
 var import_class_transformer17 = require("class-transformer");
 var SignContractForFreelancerDto = class {
 };
 __decorateClass([
-  (0, import_class_validator103.IsNotEmpty)({ message: "Job Id is required." }),
+  (0, import_class_validator104.IsNotEmpty)({ message: "Job Id is required." }),
   (0, import_class_transformer17.Type)(() => Number),
-  (0, import_class_validator103.IsNumber)({}, { message: "Job ID must be a number." })
+  (0, import_class_validator104.IsNumber)({}, { message: "Job ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator103.IsNotEmpty)({ message: "Client ID is required." }),
+  (0, import_class_validator104.IsNotEmpty)({ message: "Client ID is required." }),
   (0, import_class_transformer17.Type)(() => Number),
-  (0, import_class_validator103.IsNumber)({}, { message: "Client ID must be a number." })
+  (0, import_class_validator104.IsNumber)({}, { message: "Client ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "clientId", 2);
 __decorateClass([
-  (0, import_class_validator103.IsNotEmpty)({ message: "Contract type is required." }),
-  (0, import_class_validator103.IsEnum)(ContractTypeEnum)
+  (0, import_class_validator104.IsNotEmpty)({ message: "Contract type is required." }),
+  (0, import_class_validator104.IsEnum)(ContractTypeEnum)
 ], SignContractForFreelancerDto.prototype, "contractType", 2);
 
 // src/modules/contract/dto/generate-contract.dto.ts
-var import_class_validator104 = require("class-validator");
+var import_class_validator105 = require("class-validator");
 var GenerateContractDto = class {
 };
 __decorateClass([
-  (0, import_class_validator104.IsNotEmpty)({ message: "Hiring ID is required" }),
-  (0, import_class_validator104.IsNumber)({}, { message: "Hiring ID must be a number" })
+  (0, import_class_validator105.IsNotEmpty)({ message: "Hiring ID is required" }),
+  (0, import_class_validator105.IsNumber)({}, { message: "Hiring ID must be a number" })
 ], GenerateContractDto.prototype, "hiringId", 2);
 __decorateClass([
-  (0, import_class_validator104.IsOptional)(),
-  (0, import_class_validator104.IsString)()
+  (0, import_class_validator105.IsOptional)(),
+  (0, import_class_validator105.IsString)()
 ], GenerateContractDto.prototype, "contractType", 2);
 __decorateClass([
-  (0, import_class_validator104.IsOptional)(),
-  (0, import_class_validator104.IsString)()
+  (0, import_class_validator105.IsOptional)(),
+  (0, import_class_validator105.IsString)()
 ], GenerateContractDto.prototype, "templateId", 2);
 
 // src/modules/contract/dto/esign-contract-client.dto.ts
-var import_class_validator105 = require("class-validator");
+var import_class_validator106 = require("class-validator");
 var EsignContractClientDto = class {
 };
 __decorateClass([
-  (0, import_class_validator105.IsNotEmpty)({ message: "Contract UUID is required" }),
-  (0, import_class_validator105.IsString)({ message: "Contract UUID must be a string" })
+  (0, import_class_validator106.IsNotEmpty)({ message: "Contract UUID is required" }),
+  (0, import_class_validator106.IsString)({ message: "Contract UUID must be a string" })
 ], EsignContractClientDto.prototype, "contractUuid", 2);
 
 // src/modules/contract/dto/esign-contract-freelancer.dto.ts
-var import_class_validator106 = require("class-validator");
+var import_class_validator107 = require("class-validator");
 var EsignContractFreelancerDto = class {
 };
 __decorateClass([
-  (0, import_class_validator106.IsNotEmpty)({ message: "Contract UUID is required" }),
-  (0, import_class_validator106.IsString)({ message: "Contract UUID must be a string" })
+  (0, import_class_validator107.IsNotEmpty)({ message: "Contract UUID is required" }),
+  (0, import_class_validator107.IsString)({ message: "Contract UUID must be a string" })
 ], EsignContractFreelancerDto.prototype, "contractUuid", 2);
 
 // src/modules/contract/dto/escrow-fund-contract.dto.ts
-var import_class_validator107 = require("class-validator");
+var import_class_validator108 = require("class-validator");
 var EscrowFundContractDto = class {
 };
 __decorateClass([
-  (0, import_class_validator107.IsNotEmpty)({ message: "Contract ID is required" }),
-  (0, import_class_validator107.IsNumber)({}, { message: "Contract ID must be a number" })
+  (0, import_class_validator108.IsNotEmpty)({ message: "Contract ID is required" }),
+  (0, import_class_validator108.IsNumber)({}, { message: "Contract ID must be a number" })
 ], EscrowFundContractDto.prototype, "contractId", 2);
 __decorateClass([
-  (0, import_class_validator107.IsNotEmpty)({ message: "Amount is required" }),
-  (0, import_class_validator107.IsNumber)({}, { message: "Amount must be a number" })
+  (0, import_class_validator108.IsNotEmpty)({ message: "Amount is required" }),
+  (0, import_class_validator108.IsNumber)({}, { message: "Amount must be a number" })
 ], EscrowFundContractDto.prototype, "amount", 2);
 __decorateClass([
-  (0, import_class_validator107.IsOptional)(),
-  (0, import_class_validator107.IsString)()
+  (0, import_class_validator108.IsOptional)(),
+  (0, import_class_validator108.IsString)()
 ], EscrowFundContractDto.prototype, "currency", 2);
 __decorateClass([
-  (0, import_class_validator107.IsOptional)(),
-  (0, import_class_validator107.IsString)()
+  (0, import_class_validator108.IsOptional)(),
+  (0, import_class_validator108.IsString)()
 ], EscrowFundContractDto.prototype, "description", 2);
 
 // src/modules/stripe/pattern/pattern.ts
@@ -8994,83 +9009,83 @@ var STRIPE_PATTERN = {
 };
 
 // src/modules/stripe/dto/create-checkout-session.dto.ts
-var import_class_validator108 = require("class-validator");
+var import_class_validator109 = require("class-validator");
 var CreateCheckoutSessionDto = class {
 };
 __decorateClass([
-  (0, import_class_validator108.IsNotEmpty)({ message: "Amount is required" })
+  (0, import_class_validator109.IsNotEmpty)({ message: "Amount is required" })
 ], CreateCheckoutSessionDto.prototype, "amount", 2);
 
 // src/modules/stripe/dto/pre-checkout-calculation.dto.ts
-var import_class_validator109 = require("class-validator");
+var import_class_validator110 = require("class-validator");
 var PreCheckoutCalculationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator109.IsNotEmpty)({ message: "Amount is required" }),
-  (0, import_class_validator109.IsNumber)({}, { message: "Amount must be a number" })
+  (0, import_class_validator110.IsNotEmpty)({ message: "Amount is required" }),
+  (0, import_class_validator110.IsNumber)({}, { message: "Amount must be a number" })
 ], PreCheckoutCalculationDto.prototype, "amount", 2);
 __decorateClass([
-  (0, import_class_validator109.IsOptional)(),
-  (0, import_class_validator109.IsString)()
+  (0, import_class_validator110.IsOptional)(),
+  (0, import_class_validator110.IsString)()
 ], PreCheckoutCalculationDto.prototype, "currency", 2);
 __decorateClass([
-  (0, import_class_validator109.IsOptional)(),
-  (0, import_class_validator109.IsString)()
+  (0, import_class_validator110.IsOptional)(),
+  (0, import_class_validator110.IsString)()
 ], PreCheckoutCalculationDto.prototype, "description", 2);
 
 // src/modules/stripe/dto/client-add-fund.dto.ts
-var import_class_validator110 = require("class-validator");
+var import_class_validator111 = require("class-validator");
 var ClientAddFundDto = class {
 };
 __decorateClass([
-  (0, import_class_validator110.IsNotEmpty)({ message: "Amount is required" }),
-  (0, import_class_validator110.IsNumber)({}, { message: "Amount must be a number" })
+  (0, import_class_validator111.IsNotEmpty)({ message: "Amount is required" }),
+  (0, import_class_validator111.IsNumber)({}, { message: "Amount must be a number" })
 ], ClientAddFundDto.prototype, "amount", 2);
 __decorateClass([
-  (0, import_class_validator110.IsOptional)(),
-  (0, import_class_validator110.IsString)()
+  (0, import_class_validator111.IsOptional)(),
+  (0, import_class_validator111.IsString)()
 ], ClientAddFundDto.prototype, "currency", 2);
 __decorateClass([
-  (0, import_class_validator110.IsOptional)(),
-  (0, import_class_validator110.IsString)()
+  (0, import_class_validator111.IsOptional)(),
+  (0, import_class_validator111.IsString)()
 ], ClientAddFundDto.prototype, "description", 2);
 
 // src/modules/stripe/dto/transfer-funds.dto.ts
-var import_class_validator111 = require("class-validator");
+var import_class_validator112 = require("class-validator");
 var TransferFundsDto = class {
 };
 __decorateClass([
-  (0, import_class_validator111.IsNotEmpty)({ message: "Amount is required" }),
-  (0, import_class_validator111.IsNumber)({}, { message: "Amount must be a number" })
+  (0, import_class_validator112.IsNotEmpty)({ message: "Amount is required" }),
+  (0, import_class_validator112.IsNumber)({}, { message: "Amount must be a number" })
 ], TransferFundsDto.prototype, "amount", 2);
 __decorateClass([
-  (0, import_class_validator111.IsNotEmpty)({ message: "Connected account ID is required" }),
-  (0, import_class_validator111.IsString)({ message: "Connected account ID must be a string" })
+  (0, import_class_validator112.IsNotEmpty)({ message: "Connected account ID is required" }),
+  (0, import_class_validator112.IsString)({ message: "Connected account ID must be a string" })
 ], TransferFundsDto.prototype, "connectedAccountId", 2);
 __decorateClass([
-  (0, import_class_validator111.IsOptional)(),
-  (0, import_class_validator111.IsString)()
+  (0, import_class_validator112.IsOptional)(),
+  (0, import_class_validator112.IsString)()
 ], TransferFundsDto.prototype, "description", 2);
 
 // src/modules/stripe/dto/create-payout.dto.ts
-var import_class_validator112 = require("class-validator");
+var import_class_validator113 = require("class-validator");
 var CreatePayoutDto = class {
 };
 __decorateClass([
-  (0, import_class_validator112.IsNotEmpty)({ message: "Amount is required" }),
-  (0, import_class_validator112.IsNumber)({}, { message: "Amount must be a number" })
+  (0, import_class_validator113.IsNotEmpty)({ message: "Amount is required" }),
+  (0, import_class_validator113.IsNumber)({}, { message: "Amount must be a number" })
 ], CreatePayoutDto.prototype, "amount", 2);
 __decorateClass([
-  (0, import_class_validator112.IsNotEmpty)({ message: "Connected account ID is required" }),
-  (0, import_class_validator112.IsString)({ message: "Connected account ID must be a string" })
+  (0, import_class_validator113.IsNotEmpty)({ message: "Connected account ID is required" }),
+  (0, import_class_validator113.IsString)({ message: "Connected account ID must be a string" })
 ], CreatePayoutDto.prototype, "connectedAccountId", 2);
 __decorateClass([
-  (0, import_class_validator112.IsOptional)(),
-  (0, import_class_validator112.IsString)()
+  (0, import_class_validator113.IsOptional)(),
+  (0, import_class_validator113.IsString)()
 ], CreatePayoutDto.prototype, "method", 2);
 __decorateClass([
-  (0, import_class_validator112.IsOptional)(),
-  (0, import_class_validator112.IsString)()
+  (0, import_class_validator113.IsOptional)(),
+  (0, import_class_validator113.IsString)()
 ], CreatePayoutDto.prototype, "description", 2);
 
 // src/modules/timesheet/pattern/pattern.ts
@@ -9114,158 +9129,158 @@ var TIMESHEET_CLIENT_PATTERN = {
 };
 
 // src/modules/timesheet/dto/create-freelancer-timesheet.dto.ts
-var import_class_validator113 = require("class-validator");
+var import_class_validator114 = require("class-validator");
 var CreateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  (0, import_class_validator113.IsNotEmpty)({ message: "Job id is required" }),
-  (0, import_class_validator113.IsNumber)({}, { message: "Job id must be a number" })
+  (0, import_class_validator114.IsNotEmpty)({ message: "Job id is required" }),
+  (0, import_class_validator114.IsNumber)({}, { message: "Job id must be a number" })
 ], CreateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator113.IsNotEmpty)({ message: "start date is required" }),
-  (0, import_class_validator113.IsDateString)()
+  (0, import_class_validator114.IsNotEmpty)({ message: "start date is required" }),
+  (0, import_class_validator114.IsDateString)()
 ], CreateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  (0, import_class_validator113.IsNotEmpty)({ message: "end date is required" }),
-  (0, import_class_validator113.IsDateString)()
+  (0, import_class_validator114.IsNotEmpty)({ message: "end date is required" }),
+  (0, import_class_validator114.IsDateString)()
 ], CreateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  (0, import_class_validator113.IsNotEmpty)({ message: "start time is required" }),
-  (0, import_class_validator113.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator114.IsNotEmpty)({ message: "start time is required" }),
+  (0, import_class_validator114.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "startTime must be in HH:mm:ss format"
   })
 ], CreateFreelancerTimesheetDto.prototype, "startTime", 2);
 __decorateClass([
-  (0, import_class_validator113.IsNotEmpty)({ message: "end time is required" }),
-  (0, import_class_validator113.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator114.IsNotEmpty)({ message: "end time is required" }),
+  (0, import_class_validator114.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "endTime must be in HH:mm:ss format"
   })
 ], CreateFreelancerTimesheetDto.prototype, "endTime", 2);
 __decorateClass([
-  (0, import_class_validator113.IsOptional)(),
-  (0, import_class_validator113.IsInt)()
+  (0, import_class_validator114.IsOptional)(),
+  (0, import_class_validator114.IsInt)()
 ], CreateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  (0, import_class_validator113.IsOptional)(),
-  (0, import_class_validator113.IsString)()
+  (0, import_class_validator114.IsOptional)(),
+  (0, import_class_validator114.IsString)()
 ], CreateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  (0, import_class_validator113.IsOptional)(),
-  (0, import_class_validator113.IsString)()
+  (0, import_class_validator114.IsOptional)(),
+  (0, import_class_validator114.IsString)()
 ], CreateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  (0, import_class_validator113.IsOptional)(),
-  (0, import_class_validator113.IsString)()
+  (0, import_class_validator114.IsOptional)(),
+  (0, import_class_validator114.IsString)()
 ], CreateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  (0, import_class_validator113.IsNotEmpty)({ message: "Description is required" })
+  (0, import_class_validator114.IsNotEmpty)({ message: "Description is required" })
 ], CreateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/timesheet/dto/update-freelancer-timesheet.dto.ts
-var import_class_validator114 = require("class-validator");
+var import_class_validator115 = require("class-validator");
 var UpdateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  (0, import_class_validator114.IsNotEmpty)({ message: "Job id is required" }),
-  (0, import_class_validator114.IsNumber)({}, { message: "Job id must be a number" })
+  (0, import_class_validator115.IsNotEmpty)({ message: "Job id is required" }),
+  (0, import_class_validator115.IsNumber)({}, { message: "Job id must be a number" })
 ], UpdateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator114.IsNotEmpty)({ message: "start date is required" }),
-  (0, import_class_validator114.IsDateString)()
+  (0, import_class_validator115.IsNotEmpty)({ message: "start date is required" }),
+  (0, import_class_validator115.IsDateString)()
 ], UpdateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  (0, import_class_validator114.IsNotEmpty)({ message: "end date is required" }),
-  (0, import_class_validator114.IsDateString)()
+  (0, import_class_validator115.IsNotEmpty)({ message: "end date is required" }),
+  (0, import_class_validator115.IsDateString)()
 ], UpdateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  (0, import_class_validator114.IsNotEmpty)({ message: "start time is required" }),
-  (0, import_class_validator114.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator115.IsNotEmpty)({ message: "start time is required" }),
+  (0, import_class_validator115.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "startTime must be in HH:mm:ss format"
   })
 ], UpdateFreelancerTimesheetDto.prototype, "startTime", 2);
 __decorateClass([
-  (0, import_class_validator114.IsNotEmpty)({ message: "end time is required" }),
-  (0, import_class_validator114.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
+  (0, import_class_validator115.IsNotEmpty)({ message: "end time is required" }),
+  (0, import_class_validator115.Matches)(/^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/, {
     message: "endTime must be in HH:mm:ss format"
   })
 ], UpdateFreelancerTimesheetDto.prototype, "endTime", 2);
 __decorateClass([
-  (0, import_class_validator114.IsOptional)(),
-  (0, import_class_validator114.IsInt)()
+  (0, import_class_validator115.IsOptional)(),
+  (0, import_class_validator115.IsInt)()
 ], UpdateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  (0, import_class_validator114.IsOptional)(),
-  (0, import_class_validator114.IsString)()
+  (0, import_class_validator115.IsOptional)(),
+  (0, import_class_validator115.IsString)()
 ], UpdateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  (0, import_class_validator114.IsOptional)(),
-  (0, import_class_validator114.IsString)()
+  (0, import_class_validator115.IsOptional)(),
+  (0, import_class_validator115.IsString)()
 ], UpdateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  (0, import_class_validator114.IsOptional)(),
-  (0, import_class_validator114.IsString)()
+  (0, import_class_validator115.IsOptional)(),
+  (0, import_class_validator115.IsString)()
 ], UpdateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  (0, import_class_validator114.IsNotEmpty)({ message: "Description is required" })
+  (0, import_class_validator115.IsNotEmpty)({ message: "Description is required" })
 ], UpdateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/timesheet/dto/submit-timesheet.dto.ts
-var import_class_validator115 = require("class-validator");
+var import_class_validator116 = require("class-validator");
 var SubmitTimesheetDto = class {
 };
 __decorateClass([
-  (0, import_class_validator115.IsNotEmpty)({ message: "Timesheet line ID is required" }),
-  (0, import_class_validator115.IsNumber)({}, { message: "Timesheet line ID must be a number" })
+  (0, import_class_validator116.IsNotEmpty)({ message: "Timesheet line ID is required" }),
+  (0, import_class_validator116.IsNumber)({}, { message: "Timesheet line ID must be a number" })
 ], SubmitTimesheetDto.prototype, "timesheetLineId", 2);
 
 // src/modules/timesheet/dto/resubmit-timesheet.dto.ts
-var import_class_validator116 = require("class-validator");
+var import_class_validator117 = require("class-validator");
 var ResubmitTimesheetDto = class {
 };
 __decorateClass([
-  (0, import_class_validator116.IsNotEmpty)({ message: "Timesheet line ID is required" }),
-  (0, import_class_validator116.IsNumber)({}, { message: "Timesheet line ID must be a number" })
+  (0, import_class_validator117.IsNotEmpty)({ message: "Timesheet line ID is required" }),
+  (0, import_class_validator117.IsNumber)({}, { message: "Timesheet line ID must be a number" })
 ], ResubmitTimesheetDto.prototype, "timesheetLineId", 2);
 
 // src/modules/timesheet/dto/approve-timesheets.dto.ts
-var import_class_validator117 = require("class-validator");
+var import_class_validator118 = require("class-validator");
 var ApproveTimesheetsDto = class {
 };
 __decorateClass([
-  (0, import_class_validator117.IsArray)({ message: "Timesheet line IDs must be an array" }),
-  (0, import_class_validator117.ArrayNotEmpty)({ message: "At least one timesheet line ID is required" }),
-  (0, import_class_validator117.IsNumber)({}, { each: true, message: "Each timesheet line ID must be a number" })
+  (0, import_class_validator118.IsArray)({ message: "Timesheet line IDs must be an array" }),
+  (0, import_class_validator118.ArrayNotEmpty)({ message: "At least one timesheet line ID is required" }),
+  (0, import_class_validator118.IsNumber)({}, { each: true, message: "Each timesheet line ID must be a number" })
 ], ApproveTimesheetsDto.prototype, "timesheetLineIds", 2);
 
 // src/modules/timesheet/dto/send-back-timesheets.dto.ts
-var import_class_validator118 = require("class-validator");
+var import_class_validator119 = require("class-validator");
 var SendBackTimesheetsDto = class {
 };
 __decorateClass([
-  (0, import_class_validator118.IsArray)({ message: "Timesheet line IDs must be an array" }),
-  (0, import_class_validator118.ArrayNotEmpty)({ message: "At least one timesheet line ID is required" }),
-  (0, import_class_validator118.IsNumber)({}, { each: true, message: "Each timesheet line ID must be a number" })
+  (0, import_class_validator119.IsArray)({ message: "Timesheet line IDs must be an array" }),
+  (0, import_class_validator119.ArrayNotEmpty)({ message: "At least one timesheet line ID is required" }),
+  (0, import_class_validator119.IsNumber)({}, { each: true, message: "Each timesheet line ID must be a number" })
 ], SendBackTimesheetsDto.prototype, "timesheetLineIds", 2);
 __decorateClass([
-  (0, import_class_validator118.IsOptional)(),
-  (0, import_class_validator118.IsString)()
+  (0, import_class_validator119.IsOptional)(),
+  (0, import_class_validator119.IsString)()
 ], SendBackTimesheetsDto.prototype, "reason", 2);
 
 // src/modules/timesheet/dto/create-default-timesheet-line.dto.ts
-var import_class_validator119 = require("class-validator");
+var import_class_validator120 = require("class-validator");
 var CreateDefaultTimesheetLineDto = class {
 };
 __decorateClass([
-  (0, import_class_validator119.IsNotEmpty)({ message: "Contract ID is required" }),
-  (0, import_class_validator119.IsNumber)({}, { message: "Contract ID must be a number" })
+  (0, import_class_validator120.IsNotEmpty)({ message: "Contract ID is required" }),
+  (0, import_class_validator120.IsNumber)({}, { message: "Contract ID must be a number" })
 ], CreateDefaultTimesheetLineDto.prototype, "contractId", 2);
 __decorateClass([
-  (0, import_class_validator119.IsNotEmpty)({ message: "Freelancer ID is required" }),
-  (0, import_class_validator119.IsNumber)({}, { message: "Freelancer ID must be a number" })
+  (0, import_class_validator120.IsNotEmpty)({ message: "Freelancer ID is required" }),
+  (0, import_class_validator120.IsNumber)({}, { message: "Freelancer ID must be a number" })
 ], CreateDefaultTimesheetLineDto.prototype, "freelancerId", 2);
 __decorateClass([
-  (0, import_class_validator119.IsNotEmpty)({ message: "Client ID is required" }),
-  (0, import_class_validator119.IsNumber)({}, { message: "Client ID must be a number" })
+  (0, import_class_validator120.IsNotEmpty)({ message: "Client ID is required" }),
+  (0, import_class_validator120.IsNumber)({}, { message: "Client ID must be a number" })
 ], CreateDefaultTimesheetLineDto.prototype, "clientId", 2);
 
 // src/modules/invoice/pattern/pattern.ts
@@ -9287,23 +9302,23 @@ var INVOICE_PATTERN = {
 };
 
 // src/modules/invoice/dto/update-invoice-status.dto.ts
-var import_class_validator120 = require("class-validator");
+var import_class_validator121 = require("class-validator");
 var UpdateInvoiceStatusDto = class {
 };
 __decorateClass([
-  (0, import_class_validator120.IsNotEmpty)({ message: "Please provide invoice status." }),
-  (0, import_class_validator120.IsEnum)(InvoiceStatusEnum, {
+  (0, import_class_validator121.IsNotEmpty)({ message: "Please provide invoice status." }),
+  (0, import_class_validator121.IsEnum)(InvoiceStatusEnum, {
     message: "Status must be one of: APPROVED, REJECTED"
   })
 ], UpdateInvoiceStatusDto.prototype, "status", 2);
 
 // src/modules/invoice/dto/create-invoice.dto.ts
-var import_class_validator121 = require("class-validator");
+var import_class_validator122 = require("class-validator");
 var CreateInvoiceDto = class {
 };
 __decorateClass([
-  (0, import_class_validator121.IsNotEmpty)({ message: "Timesheet line ID is required" }),
-  (0, import_class_validator121.IsNumber)({}, { message: "Timesheet line ID must be a number" })
+  (0, import_class_validator122.IsNotEmpty)({ message: "Timesheet line ID is required" }),
+  (0, import_class_validator122.IsNumber)({}, { message: "Timesheet line ID must be a number" })
 ], CreateInvoiceDto.prototype, "timeSheetLineId", 2);
 
 // src/modules/dispute/pattern/pattern.ts
@@ -9314,42 +9329,42 @@ var DISPUTE_PATTERN = {
 };
 
 // src/modules/dispute/dto/create-dispute.dto.ts
-var import_class_validator122 = require("class-validator");
+var import_class_validator123 = require("class-validator");
 var import_class_transformer18 = require("class-transformer");
 var CreateDisputeDto = class {
 };
 __decorateClass([
-  (0, import_class_validator122.ValidateIf)((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
-  (0, import_class_validator122.IsNumber)({}, { message: "Client id must be a number" }),
+  (0, import_class_validator123.ValidateIf)((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
+  (0, import_class_validator123.IsNumber)({}, { message: "Client id must be a number" }),
   (0, import_class_transformer18.Type)(() => Number)
 ], CreateDisputeDto.prototype, "clientId", 2);
 __decorateClass([
-  (0, import_class_validator122.ValidateIf)((o) => o.initiatorType === "CLIENT" /* CLIENT */),
-  (0, import_class_validator122.IsNumber)({}, { message: "Freelancer id must be a number" }),
+  (0, import_class_validator123.ValidateIf)((o) => o.initiatorType === "CLIENT" /* CLIENT */),
+  (0, import_class_validator123.IsNumber)({}, { message: "Freelancer id must be a number" }),
   (0, import_class_transformer18.Type)(() => Number)
 ], CreateDisputeDto.prototype, "freelancerId", 2);
 __decorateClass([
-  (0, import_class_validator122.IsNotEmpty)({ message: "Please select dispute type." }),
-  (0, import_class_validator122.IsString)(),
-  (0, import_class_validator122.IsIn)(["JOB", "INVOICE"])
+  (0, import_class_validator123.IsNotEmpty)({ message: "Please select dispute type." }),
+  (0, import_class_validator123.IsString)(),
+  (0, import_class_validator123.IsIn)(["JOB", "INVOICE"])
 ], CreateDisputeDto.prototype, "disputeType", 2);
 __decorateClass([
-  (0, import_class_validator122.IsNotEmpty)({ message: "Please provide initiator type." }),
-  (0, import_class_validator122.IsString)()
+  (0, import_class_validator123.IsNotEmpty)({ message: "Please provide initiator type." }),
+  (0, import_class_validator123.IsString)()
 ], CreateDisputeDto.prototype, "initiatorType", 2);
 __decorateClass([
-  (0, import_class_validator122.IsNotEmpty)({ message: "Please enter description." }),
-  (0, import_class_validator122.IsString)({ message: "Description must be a string" }),
-  (0, import_class_validator122.MaxLength)(500, { message: "Description must not exceed 500 characters" })
+  (0, import_class_validator123.IsNotEmpty)({ message: "Please enter description." }),
+  (0, import_class_validator123.IsString)({ message: "Description must be a string" }),
+  (0, import_class_validator123.MaxLength)(500, { message: "Description must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "description", 2);
 __decorateClass([
-  (0, import_class_validator122.IsOptional)(),
-  (0, import_class_validator122.IsString)({ message: "Comment must be a string" }),
-  (0, import_class_validator122.MaxLength)(500, { message: "Comment must not exceed 500 characters" })
+  (0, import_class_validator123.IsOptional)(),
+  (0, import_class_validator123.IsString)({ message: "Comment must be a string" }),
+  (0, import_class_validator123.MaxLength)(500, { message: "Comment must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "comment", 2);
 __decorateClass([
-  (0, import_class_validator122.IsOptional)(),
-  (0, import_class_validator122.IsObject)({ message: "Dynamic fields must be a valid object" }),
+  (0, import_class_validator123.IsOptional)(),
+  (0, import_class_validator123.IsObject)({ message: "Dynamic fields must be a valid object" }),
   (0, import_class_transformer18.Transform)(({ value }) => {
     if (typeof value === "string") {
       try {
@@ -9370,125 +9385,125 @@ var SENSELOAF_PATTERN = {
 };
 
 // src/modules/senseloaf/dto/ai-interview-question-generate.dto.ts
-var import_class_validator123 = require("class-validator");
+var import_class_validator124 = require("class-validator");
 var AiInterviewQuestionGenerateDto = class {
 };
 __decorateClass([
-  (0, import_class_validator123.IsNotEmpty)({ message: "Please enter job description." })
+  (0, import_class_validator124.IsNotEmpty)({ message: "Please enter job description." })
 ], AiInterviewQuestionGenerateDto.prototype, "jobDescription", 2);
 __decorateClass([
-  (0, import_class_validator123.IsNotEmpty)({ message: "Please enter number of questions." })
+  (0, import_class_validator124.IsNotEmpty)({ message: "Please enter number of questions." })
 ], AiInterviewQuestionGenerateDto.prototype, "numQuestions", 2);
 
 // src/modules/senseloaf/dto/resume-parsing-by-url.dto.ts
-var import_class_validator124 = require("class-validator");
+var import_class_validator125 = require("class-validator");
 var ResumeParsingByUrlDto = class {
 };
 __decorateClass([
-  (0, import_class_validator124.IsNotEmpty)({ message: "Resume URL is required" }),
-  (0, import_class_validator124.IsString)({ message: "Resume URL must be a string" })
+  (0, import_class_validator125.IsNotEmpty)({ message: "Resume URL is required" }),
+  (0, import_class_validator125.IsString)({ message: "Resume URL must be a string" })
 ], ResumeParsingByUrlDto.prototype, "resumeUrl", 2);
 __decorateClass([
-  (0, import_class_validator124.IsOptional)(),
-  (0, import_class_validator124.IsString)()
+  (0, import_class_validator125.IsOptional)(),
+  (0, import_class_validator125.IsString)()
 ], ResumeParsingByUrlDto.prototype, "fileName", 2);
 
 // src/modules/senseloaf/dto/resume-data-processing.dto.ts
-var import_class_validator125 = require("class-validator");
+var import_class_validator126 = require("class-validator");
 var ResumeDataProcessingDto = class {
 };
 __decorateClass([
-  (0, import_class_validator125.IsNotEmpty)({ message: "Resume data is required" }),
-  (0, import_class_validator125.IsObject)()
+  (0, import_class_validator126.IsNotEmpty)({ message: "Resume data is required" }),
+  (0, import_class_validator126.IsObject)()
 ], ResumeDataProcessingDto.prototype, "resumeData", 2);
 __decorateClass([
-  (0, import_class_validator125.IsOptional)(),
-  (0, import_class_validator125.IsString)()
+  (0, import_class_validator126.IsOptional)(),
+  (0, import_class_validator126.IsString)()
 ], ResumeDataProcessingDto.prototype, "userId", 2);
 __decorateClass([
-  (0, import_class_validator125.IsOptional)(),
-  (0, import_class_validator125.IsString)()
+  (0, import_class_validator126.IsOptional)(),
+  (0, import_class_validator126.IsString)()
 ], ResumeDataProcessingDto.prototype, "processingType", 2);
 
 // src/modules/senseloaf/dto/check-resume-eligibility.dto.ts
-var import_class_validator126 = require("class-validator");
+var import_class_validator127 = require("class-validator");
 var CheckResumeEligibilityDto = class {
 };
 __decorateClass([
-  (0, import_class_validator126.IsNotEmpty)({ message: "Resume data is required" }),
-  (0, import_class_validator126.IsObject)()
+  (0, import_class_validator127.IsNotEmpty)({ message: "Resume data is required" }),
+  (0, import_class_validator127.IsObject)()
 ], CheckResumeEligibilityDto.prototype, "resumeData", 2);
 __decorateClass([
-  (0, import_class_validator126.IsOptional)(),
-  (0, import_class_validator126.IsString)()
+  (0, import_class_validator127.IsOptional)(),
+  (0, import_class_validator127.IsString)()
 ], CheckResumeEligibilityDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator126.IsOptional)(),
-  (0, import_class_validator126.IsString)()
+  (0, import_class_validator127.IsOptional)(),
+  (0, import_class_validator127.IsString)()
 ], CheckResumeEligibilityDto.prototype, "userId", 2);
 
 // src/modules/senseloaf/dto/ai-interview-template-generation.dto.ts
-var import_class_validator127 = require("class-validator");
+var import_class_validator128 = require("class-validator");
 var AiInterviewTemplateGenerationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator127.IsNotEmpty)({ message: "Job ID is required" }),
-  (0, import_class_validator127.IsString)({ message: "Job ID must be a string" })
+  (0, import_class_validator128.IsNotEmpty)({ message: "Job ID is required" }),
+  (0, import_class_validator128.IsString)({ message: "Job ID must be a string" })
 ], AiInterviewTemplateGenerationDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator127.IsOptional)(),
-  (0, import_class_validator127.IsArray)(),
-  (0, import_class_validator127.IsString)({ each: true, message: "Each skill must be a string" })
+  (0, import_class_validator128.IsOptional)(),
+  (0, import_class_validator128.IsArray)(),
+  (0, import_class_validator128.IsString)({ each: true, message: "Each skill must be a string" })
 ], AiInterviewTemplateGenerationDto.prototype, "skills", 2);
 __decorateClass([
-  (0, import_class_validator127.IsOptional)(),
-  (0, import_class_validator127.IsNumber)({}, { message: "Number of questions must be a number" })
+  (0, import_class_validator128.IsOptional)(),
+  (0, import_class_validator128.IsNumber)({}, { message: "Number of questions must be a number" })
 ], AiInterviewTemplateGenerationDto.prototype, "numberOfQuestions", 2);
 __decorateClass([
-  (0, import_class_validator127.IsOptional)(),
-  (0, import_class_validator127.IsString)()
+  (0, import_class_validator128.IsOptional)(),
+  (0, import_class_validator128.IsString)()
 ], AiInterviewTemplateGenerationDto.prototype, "difficulty", 2);
 
 // src/modules/senseloaf/dto/ai-interview-link-generation.dto.ts
-var import_class_validator128 = require("class-validator");
+var import_class_validator129 = require("class-validator");
 var AiInterviewLinkGenerationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator128.IsNotEmpty)({ message: "Template ID is required" }),
-  (0, import_class_validator128.IsString)({ message: "Template ID must be a string" })
+  (0, import_class_validator129.IsNotEmpty)({ message: "Template ID is required" }),
+  (0, import_class_validator129.IsString)({ message: "Template ID must be a string" })
 ], AiInterviewLinkGenerationDto.prototype, "templateId", 2);
 __decorateClass([
-  (0, import_class_validator128.IsNotEmpty)({ message: "Freelancer ID is required" }),
-  (0, import_class_validator128.IsString)({ message: "Freelancer ID must be a string" })
+  (0, import_class_validator129.IsNotEmpty)({ message: "Freelancer ID is required" }),
+  (0, import_class_validator129.IsString)({ message: "Freelancer ID must be a string" })
 ], AiInterviewLinkGenerationDto.prototype, "freelancerId", 2);
 __decorateClass([
-  (0, import_class_validator128.IsOptional)(),
-  (0, import_class_validator128.IsString)()
+  (0, import_class_validator129.IsOptional)(),
+  (0, import_class_validator129.IsString)()
 ], AiInterviewLinkGenerationDto.prototype, "jobId", 2);
 __decorateClass([
-  (0, import_class_validator128.IsOptional)(),
-  (0, import_class_validator128.IsNumber)({}, { message: "Expiry hours must be a number" })
+  (0, import_class_validator129.IsOptional)(),
+  (0, import_class_validator129.IsNumber)({}, { message: "Expiry hours must be a number" })
 ], AiInterviewLinkGenerationDto.prototype, "expiryHours", 2);
 
 // src/modules/senseloaf/dto/ai-assessment-creation.dto.ts
-var import_class_validator129 = require("class-validator");
+var import_class_validator130 = require("class-validator");
 var AiAssessmentCreationDto = class {
 };
 __decorateClass([
-  (0, import_class_validator129.IsNotEmpty)({ message: "User ID is required" }),
-  (0, import_class_validator129.IsString)({ message: "User ID must be a string" })
+  (0, import_class_validator130.IsNotEmpty)({ message: "User ID is required" }),
+  (0, import_class_validator130.IsString)({ message: "User ID must be a string" })
 ], AiAssessmentCreationDto.prototype, "userId", 2);
 __decorateClass([
-  (0, import_class_validator129.IsOptional)(),
-  (0, import_class_validator129.IsString)()
+  (0, import_class_validator130.IsOptional)(),
+  (0, import_class_validator130.IsString)()
 ], AiAssessmentCreationDto.prototype, "assessmentType", 2);
 __decorateClass([
-  (0, import_class_validator129.IsOptional)(),
-  (0, import_class_validator129.IsNumber)({}, { message: "Number of questions must be a number" })
+  (0, import_class_validator130.IsOptional)(),
+  (0, import_class_validator130.IsNumber)({}, { message: "Number of questions must be a number" })
 ], AiAssessmentCreationDto.prototype, "numberOfQuestions", 2);
 __decorateClass([
-  (0, import_class_validator129.IsOptional)(),
-  (0, import_class_validator129.IsString)()
+  (0, import_class_validator130.IsOptional)(),
+  (0, import_class_validator130.IsString)()
 ], AiAssessmentCreationDto.prototype, "difficulty", 2);
 
 // src/modules/commission/pattern/pattern.ts
@@ -9504,16 +9519,16 @@ var HIRING_PATTERN = {
 };
 
 // src/modules/hiring/dto/create-hiring.dto.ts
-var import_class_validator130 = require("class-validator");
+var import_class_validator131 = require("class-validator");
 var CreateHiringDto = class {
 };
 __decorateClass([
-  (0, import_class_validator130.IsNotEmpty)({ message: "Freelancer ID is required" }),
-  (0, import_class_validator130.IsNumber)({}, { message: "Freelancer ID must be a number" })
+  (0, import_class_validator131.IsNotEmpty)({ message: "Freelancer ID is required" }),
+  (0, import_class_validator131.IsNumber)({}, { message: "Freelancer ID must be a number" })
 ], CreateHiringDto.prototype, "freelancerId", 2);
 __decorateClass([
-  (0, import_class_validator130.IsNotEmpty)({ message: "Job ID is required" }),
-  (0, import_class_validator130.IsNumber)({}, { message: "Job ID must be a number" })
+  (0, import_class_validator131.IsNotEmpty)({ message: "Job ID is required" }),
+  (0, import_class_validator131.IsNumber)({}, { message: "Job ID must be a number" })
 ], CreateHiringDto.prototype, "jobId", 2);
 
 // src/modules/llm/pattern/pattern.ts
@@ -9534,16 +9549,16 @@ var SIGNATURE_PATTERN = {
 };
 
 // src/modules/user/signature/dto/save-signature.dto.ts
-var import_class_validator131 = require("class-validator");
+var import_class_validator132 = require("class-validator");
 var SaveSignatureDto = class {
 };
 __decorateClass([
-  (0, import_class_validator131.IsOptional)(),
-  (0, import_class_validator131.IsString)()
+  (0, import_class_validator132.IsOptional)(),
+  (0, import_class_validator132.IsString)()
 ], SaveSignatureDto.prototype, "signatureType", 2);
 __decorateClass([
-  (0, import_class_validator131.IsOptional)(),
-  (0, import_class_validator131.IsString)()
+  (0, import_class_validator132.IsOptional)(),
+  (0, import_class_validator132.IsString)()
 ], SaveSignatureDto.prototype, "description", 2);
 
 // src/modules/wallet/pattern/pattern.ts
@@ -9561,25 +9576,25 @@ var WALLET_ADMIN_PATTERN = {
 };
 
 // src/modules/wallet/dto/add-topup-escrow-amount.dto.ts
-var import_class_validator132 = require("class-validator");
+var import_class_validator133 = require("class-validator");
 var AddTopupEscrowAmountDto = class {
 };
 __decorateClass([
-  (0, import_class_validator132.IsNotEmpty)({ message: "Amount is required" }),
-  (0, import_class_validator132.IsNumber)({}, { message: "Amount must be a number" })
+  (0, import_class_validator133.IsNotEmpty)({ message: "Amount is required" }),
+  (0, import_class_validator133.IsNumber)({}, { message: "Amount must be a number" })
 ], AddTopupEscrowAmountDto.prototype, "amount", 2);
 
 // src/modules/wallet/dto/debit-commission-fte-hiring.dto.ts
-var import_class_validator133 = require("class-validator");
+var import_class_validator134 = require("class-validator");
 var DebitCommissionFteHiringDto = class {
 };
 __decorateClass([
-  (0, import_class_validator133.IsNotEmpty)({ message: "Hiring ID is required" }),
-  (0, import_class_validator133.IsNumber)({}, { message: "Hiring ID must be a number" })
+  (0, import_class_validator134.IsNotEmpty)({ message: "Hiring ID is required" }),
+  (0, import_class_validator134.IsNumber)({}, { message: "Hiring ID must be a number" })
 ], DebitCommissionFteHiringDto.prototype, "hiringId", 2);
 __decorateClass([
-  (0, import_class_validator133.IsNotEmpty)({ message: "Amount is required" }),
-  (0, import_class_validator133.IsNumber)({}, { message: "Amount must be a number" })
+  (0, import_class_validator134.IsNotEmpty)({ message: "Amount is required" }),
+  (0, import_class_validator134.IsNumber)({}, { message: "Amount must be a number" })
 ], DebitCommissionFteHiringDto.prototype, "amount", 2);
 
 // src/adapters/tcp/user.tcp.adapter.ts
@@ -10919,6 +10934,7 @@ RecommendationWeightageConfig = __decorateClass([
   TypeOfEmploymentEnumDto,
   TypeOfEmploymentEnums,
   UpdateAdminRoleDto,
+  UpdateAdminRoleStatusDto,
   UpdateAssessmentRequestStatusDto,
   UpdateClientAccountStatusDto,
   UpdateClientDto,