@experts_hub/shared 1.0.517 → 1.0.519

package/dist/index.mjs

@@ -7033,6 +7033,8 @@ var ADMIN_JOB_PATTERN = {
   adminFetchJobById: "admin.fetch.job.by.id",
   adminCreateJob: "admin.create.job",
   adminUpdateJob: "admin.update.job",
+  adminCreateJobV2: "admin.create.job.v2",
+  adminUpdateJobV2: "admin.update.job.v2",
   adminDeleteJob: "admin.delete.job",
   adminCountJob: "admin.count.job",
   adminFetchGraphCount: "admin.fetch.graph.count"
@@ -7254,6 +7256,208 @@ __decorateClass([
   IsInt8({ message: "Client ID must be a valid integer." })
 ], AdminUpdateJobInformationDto.prototype, "clientId", 2);
 
+// src/modules/job-admin/dto/admin-job-basic-information-v2.dto.ts
+import {
+  IsString as IsString36,
+  IsNotEmpty as IsNotEmpty55,
+  IsArray as IsArray14,
+  ArrayNotEmpty as ArrayNotEmpty9,
+  IsNumber as IsNumber9,
+  IsOptional as IsOptional36,
+  IsEnum as IsEnum24,
+  Min as Min8,
+  ValidateIf as ValidateIf9,
+  MaxLength as MaxLength20,
+  Max as Max4,
+  ValidateNested as ValidateNested6,
+  IsInt as IsInt9
+} from "class-validator";
+import { Type as Type12 } from "class-transformer";
+var JobLocationAdminEnumDto = /* @__PURE__ */ ((JobLocationAdminEnumDto2) => {
+  JobLocationAdminEnumDto2["ONSITE"] = "ONSITE";
+  JobLocationAdminEnumDto2["REMOTE"] = "REMOTE";
+  JobLocationAdminEnumDto2["HYBRID"] = "HYBRID";
+  return JobLocationAdminEnumDto2;
+})(JobLocationAdminEnumDto || {});
+var EmploymentTypeAdminEnumDto = /* @__PURE__ */ ((EmploymentTypeAdminEnumDto2) => {
+  EmploymentTypeAdminEnumDto2["FULLTIME"] = "FULLTIME";
+  EmploymentTypeAdminEnumDto2["PARTTIME"] = "PARTTIME";
+  EmploymentTypeAdminEnumDto2["BOTH"] = "BOTH";
+  EmploymentTypeAdminEnumDto2["HOURLY"] = "HOURLY";
+  EmploymentTypeAdminEnumDto2["FREELANCE"] = "FREELANCE";
+  EmploymentTypeAdminEnumDto2["FTE"] = "FTE";
+  return EmploymentTypeAdminEnumDto2;
+})(EmploymentTypeAdminEnumDto || {});
+var typeOfExperienceAdminEnumDto = /* @__PURE__ */ ((typeOfExperienceAdminEnumDto2) => {
+  typeOfExperienceAdminEnumDto2["SINGLE"] = "SINGLE";
+  typeOfExperienceAdminEnumDto2["RANGE"] = "RANGE";
+  return typeOfExperienceAdminEnumDto2;
+})(typeOfExperienceAdminEnumDto || {});
+var JobLocationAdminDto = class {
+};
+__decorateClass([
+  IsOptional36(),
+  IsNumber9()
+], JobLocationAdminDto.prototype, "countryId", 2);
+__decorateClass([
+  IsOptional36(),
+  IsNumber9()
+], JobLocationAdminDto.prototype, "stateId", 2);
+__decorateClass([
+  IsOptional36(),
+  IsNumber9()
+], JobLocationAdminDto.prototype, "cityId", 2);
+var AdminJobBasicInformationV2Dto = class {
+  constructor() {
+    this.isDraft = false;
+  }
+};
+__decorateClass([
+  IsInt9({ message: "Client ID must be a valid integer." })
+], AdminJobBasicInformationV2Dto.prototype, "clientId", 2);
+__decorateClass([
+  IsOptional36(),
+  Type12(() => Boolean)
+], AdminJobBasicInformationV2Dto.prototype, "isDraft", 2);
+__decorateClass([
+  IsNotEmpty55({ message: "Please enter job role" }),
+  IsString36({ message: "Job role must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "jobRole", 2);
+__decorateClass([
+  IsOptional36()
+], AdminJobBasicInformationV2Dto.prototype, "jobRoleCanonicalName", 2);
+__decorateClass([
+  IsOptional36(),
+  IsString36({ message: "Project name must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "projectName", 2);
+__decorateClass([
+  IsOptional36(),
+  IsString36({ message: "Note must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "note", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsOptional36(),
+  IsArray14({ message: "Skills must be an array" }),
+  ArrayNotEmpty9({ message: "Please select at least one skill" }),
+  IsString36({ each: true, message: "Each skill must be a string" }),
+  Type12(() => String)
+], AdminJobBasicInformationV2Dto.prototype, "skills", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsArray14({ message: "Good to have skills must be an array" }),
+  IsString36({ each: true, message: "Each skill must be a string" }),
+  IsOptional36(),
+  Type12(() => String)
+], AdminJobBasicInformationV2Dto.prototype, "goodToHaveSkills", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsArray14({ message: "locations must be an array" }),
+  ArrayNotEmpty9({ message: "Please select at least one location" }),
+  ValidateNested6({ each: true }),
+  Type12(() => JobLocationAdminDto),
+  IsOptional36()
+], AdminJobBasicInformationV2Dto.prototype, "locations", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsNumber9({}, { 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),
+  IsEnum24(JobLocationAdminEnumDto, {
+    message: `Location must be one of: ${Object.values(JobLocationAdminEnumDto).join(
+      ", "
+    )}`
+  })
+], AdminJobBasicInformationV2Dto.prototype, "location", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsEnum24(EmploymentTypeAdminEnumDto, {
+    message: `Type of employment must be one of: ${Object.values(
+      EmploymentTypeAdminEnumDto
+    ).join(", ")}`
+  })
+], AdminJobBasicInformationV2Dto.prototype, "typeOfEmployment", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsString36({ message: "Currency must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "currency", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsNumber9({}, { message: "Expected salary (from) must be a number" }),
+  Min8(0, { message: "Expected salary (from) cannot be negative" }),
+  Type12(() => Number)
+], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryFrom", 2);
+__decorateClass([
+  IsOptional36()
+], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryFrom", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsNumber9({}, { message: "Expected salary (to) must be a number" }),
+  Min8(0, { message: "Expected salary (to) cannot be negative" }),
+  Type12(() => Number)
+], AdminJobBasicInformationV2Dto.prototype, "expectedSalaryTo", 2);
+__decorateClass([
+  IsOptional36()
+], AdminJobBasicInformationV2Dto.prototype, "hideExpectedSalaryTo", 2);
+__decorateClass([
+  IsOptional36()
+], AdminJobBasicInformationV2Dto.prototype, "years", 2);
+__decorateClass([
+  IsOptional36()
+], AdminJobBasicInformationV2Dto.prototype, "months", 2);
+__decorateClass([
+  IsOptional36()
+], AdminJobBasicInformationV2Dto.prototype, "weeks", 2);
+__decorateClass([
+  IsOptional36()
+], AdminJobBasicInformationV2Dto.prototype, "days", 2);
+__decorateClass([
+  IsOptional36(),
+  IsNumber9({}, { 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([
+  ValidateIf9((o) => !o.isDraft),
+  IsString36({ message: "Candidate communication skills must be a string" }),
+  IsOptional36()
+], AdminJobBasicInformationV2Dto.prototype, "candidateCommunicationSkills", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsNotEmpty55({ message: "Please enter the academic qualification" }),
+  IsString36({ message: "Academic qualification must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "academicQualification", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsEnum24(typeOfExperienceAdminEnumDto, {
+    message: `Type of experience must be one of: ${Object.values(
+      typeOfExperienceAdminEnumDto
+    ).join(", ")}`
+  })
+], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceType", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsNotEmpty55({ message: "Please enter the years of experience" }),
+  IsString36({ message: "Years of experience must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceFrom", 2);
+__decorateClass([
+  ValidateIf9((o) => !o.isDraft),
+  IsNotEmpty55({ message: "Please enter the years of experience upto" }),
+  IsString36({ message: "Years of experience must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "yearsOfExperienceTo", 2);
+__decorateClass([
+  IsOptional36(),
+  IsString36({ message: "Business industry must be a string" })
+], AdminJobBasicInformationV2Dto.prototype, "businessIndustry", 2);
+__decorateClass([
+  IsOptional36(),
+  IsString36({ message: "Additional comment must be a string" }),
+  MaxLength20(500, { message: "Additional comment must not exceed 500 characters" })
+], AdminJobBasicInformationV2Dto.prototype, "additionalComment", 2);
+
 // src/modules/lead/pattern/pattern.ts
 var LEAD_PATTERN = {
   fetchLead: "fetch.lead",
@@ -7261,7 +7465,7 @@ var LEAD_PATTERN = {
 };
 
 // src/modules/lead/dto/create-lead.dto.ts
-import { IsString as IsString36, IsEmail as IsEmail14, IsOptional as IsOptional36, IsEnum as IsEnum24 } from "class-validator";
+import { IsString as IsString37, IsEmail as IsEmail14, IsOptional as IsOptional37, IsEnum as IsEnum25 } from "class-validator";
 var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
   CategoryEmumDto2["BUSINESS"] = "BUSINESS";
   CategoryEmumDto2["FREELANCER"] = "FREELANCER";
@@ -7270,23 +7474,23 @@ var CategoryEmumDto = /* @__PURE__ */ ((CategoryEmumDto2) => {
 var CreateLeadDto = class {
 };
 __decorateClass([
-  IsString36({ message: "Name must be a string" })
+  IsString37({ message: "Name must be a string" })
 ], CreateLeadDto.prototype, "name", 2);
 __decorateClass([
   IsEmail14({}, { message: "Invalid email address" })
 ], CreateLeadDto.prototype, "email", 2);
 __decorateClass([
-  IsString36({ message: "Mobile code must be a string (e.g., +1)" })
+  IsString37({ message: "Mobile code must be a string (e.g., +1)" })
 ], CreateLeadDto.prototype, "mobileCode", 2);
 __decorateClass([
-  IsString36({ message: "Mobile must be a string (e.g., 1243253534)" })
+  IsString37({ message: "Mobile must be a string (e.g., 1243253534)" })
 ], CreateLeadDto.prototype, "mobile", 2);
 __decorateClass([
-  IsOptional36(),
-  IsString36({ message: "Description must be a string" })
+  IsOptional37(),
+  IsString37({ message: "Description must be a string" })
 ], CreateLeadDto.prototype, "description", 2);
 __decorateClass([
-  IsEnum24(CategoryEmumDto, {
+  IsEnum25(CategoryEmumDto, {
     message: `Type of category must be one of: ${Object.values(
       CategoryEmumDto
     ).join(", ")}`
@@ -7306,46 +7510,46 @@ var ADMIN_ROLE_PATTERN = {
 };
 
 // src/modules/admin-role/dto/create-admin-role.dto.ts
-import { IsNotEmpty as IsNotEmpty55, IsOptional as IsOptional37, IsString as IsString37 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty56, IsOptional as IsOptional38, IsString as IsString38 } from "class-validator";
 var CreateAdminRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty55({ message: "Please enter admin role name." }),
-  IsString37({ message: "Role name must be a string." })
+  IsNotEmpty56({ message: "Please enter admin role name." }),
+  IsString38({ message: "Role name must be a string." })
 ], CreateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  IsOptional37(),
-  IsString37({ message: "Role description must be a string." })
+  IsOptional38(),
+  IsString38({ message: "Role description must be a string." })
 ], CreateAdminRoleDto.prototype, "roleDescription", 2);
 
 // src/modules/admin-role/dto/update-admin-role.dto.ts
-import { IsBoolean as IsBoolean15, IsNotEmpty as IsNotEmpty56, IsOptional as IsOptional38, IsString as IsString38 } from "class-validator";
+import { IsBoolean as IsBoolean15, IsNotEmpty as IsNotEmpty57, IsOptional as IsOptional39, IsString as IsString39 } from "class-validator";
 var UpdateAdminRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty56({ message: "Please enter admin role name." }),
-  IsString38({ message: "Role name must be a string." })
+  IsNotEmpty57({ message: "Please enter admin role name." }),
+  IsString39({ message: "Role name must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleName", 2);
 __decorateClass([
-  IsOptional38(),
-  IsString38({ message: "Role description must be a string." })
+  IsOptional39(),
+  IsString39({ message: "Role description must be a string." })
 ], UpdateAdminRoleDto.prototype, "roleDescription", 2);
 __decorateClass([
-  IsOptional38(),
+  IsOptional39(),
   IsBoolean15({ 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 IsNotEmpty57, IsString as IsString39 } from "class-validator";
+import { IsNotEmpty as IsNotEmpty58, IsString as IsString40 } from "class-validator";
 var AttachPermissionsToRoleDto = class {
 };
 __decorateClass([
-  IsNotEmpty57({ message: "Please enter admin role ID." }),
-  IsString39({ message: "Role ID must be a string." })
+  IsNotEmpty58({ message: "Please enter admin role ID." }),
+  IsString40({ message: "Role ID must be a string." })
 ], AttachPermissionsToRoleDto.prototype, "roleId", 2);
 __decorateClass([
-  IsNotEmpty57({ message: "Please enter permission IDs." }),
-  IsString39({ message: "Permission IDs must be a comma-separated string." })
+  IsNotEmpty58({ message: "Please enter permission IDs." }),
+  IsString40({ message: "Permission IDs must be a comma-separated string." })
 ], AttachPermissionsToRoleDto.prototype, "permissionIds", 2);
 
 // src/modules/admin-permission/pattern/pattern.ts
@@ -7372,17 +7576,17 @@ var CALENDLY_PATTERN = {
 
 // src/modules/interview/dto/interview-invite.dto.ts
 import {
-  IsString as IsString40,
-  IsNotEmpty as IsNotEmpty58,
-  IsArray as IsArray14,
-  ArrayNotEmpty as ArrayNotEmpty9,
+  IsString as IsString41,
+  IsNotEmpty as IsNotEmpty59,
+  IsArray as IsArray15,
+  ArrayNotEmpty as ArrayNotEmpty10,
   IsEmail as IsEmail15,
   IsUUID as IsUUID12,
-  IsEnum as IsEnum25,
-  ValidateIf as ValidateIf9,
-  ValidateNested as ValidateNested6
+  IsEnum as IsEnum26,
+  ValidateIf as ValidateIf10,
+  ValidateNested as ValidateNested7
 } from "class-validator";
-import { Type as Type12 } from "class-transformer";
+import { Type as Type13 } from "class-transformer";
 var CandidateType = /* @__PURE__ */ ((CandidateType2) => {
   CandidateType2["SHORTLISTED"] = "SHORTLISTED";
   CandidateType2["APPLICATNTS"] = "APPLICATNTS";
@@ -7396,39 +7600,39 @@ __decorateClass([
   IsUUID12()
 ], ExistingCandidateDto.prototype, "id", 2);
 __decorateClass([
-  IsEnum25(CandidateType, {
+  IsEnum26(CandidateType, {
     message: "type must be one of SHORTLISTED, APPLICATNTS, or RECOMMENDED"
   })
 ], ExistingCandidateDto.prototype, "type", 2);
 var NewCandidateDto = class {
 };
 __decorateClass([
-  IsNotEmpty58({ message: "Please enter the candidate name" }),
-  IsString40({ message: "Name must be a string" })
+  IsNotEmpty59({ message: "Please enter the candidate name" }),
+  IsString41({ message: "Name must be a string" })
 ], NewCandidateDto.prototype, "name", 2);
 __decorateClass([
   IsEmail15({}, { message: "Please enter a valid email." })
 ], NewCandidateDto.prototype, "email", 2);
 __decorateClass([
-  IsEnum25(CandidateType, {
+  IsEnum26(CandidateType, {
     message: "type must be NEW"
   })
 ], NewCandidateDto.prototype, "type", 2);
 var CandidatesDto = class {
 };
 __decorateClass([
-  ValidateIf9((o) => o.exixtingCandidates?.length > 0),
-  IsArray14({ message: "Existing candidates should be an array." }),
-  ArrayNotEmpty9({ message: "Please select at least one candidate." }),
-  ValidateNested6({ each: true }),
-  Type12(() => ExistingCandidateDto)
+  ValidateIf10((o) => o.exixtingCandidates?.length > 0),
+  IsArray15({ message: "Existing candidates should be an array." }),
+  ArrayNotEmpty10({ message: "Please select at least one candidate." }),
+  ValidateNested7({ each: true }),
+  Type13(() => ExistingCandidateDto)
 ], CandidatesDto.prototype, "exixtingCandidates", 2);
 __decorateClass([
-  ValidateIf9((o) => o.newCandidates?.length > 0),
-  IsArray14({ message: "New candidates should be an array." }),
-  ArrayNotEmpty9({ message: "Please add at least one candidate." }),
-  ValidateNested6({ each: true }),
-  Type12(() => NewCandidateDto)
+  ValidateIf10((o) => o.newCandidates?.length > 0),
+  IsArray15({ message: "New candidates should be an array." }),
+  ArrayNotEmpty10({ message: "Please add at least one candidate." }),
+  ValidateNested7({ each: true }),
+  Type13(() => NewCandidateDto)
 ], CandidatesDto.prototype, "newCandidates", 2);
 var InterviewInviteDto = class {
 };
@@ -7436,77 +7640,77 @@ __decorateClass([
   IsUUID12()
 ], InterviewInviteDto.prototype, "jobId", 2);
 __decorateClass([
-  ValidateNested6({ each: true }),
-  Type12(() => CandidatesDto)
+  ValidateNested7({ each: true }),
+  Type13(() => CandidatesDto)
 ], InterviewInviteDto.prototype, "candidates", 2);
 
 // src/modules/interview/dto/create-f2f-interview.dto.ts
 import {
-  IsString as IsString41,
-  IsNotEmpty as IsNotEmpty59,
+  IsString as IsString42,
+  IsNotEmpty as IsNotEmpty60,
   IsEmail as IsEmail16,
-  IsNumber as IsNumber9
+  IsNumber as IsNumber10
 } from "class-validator";
 var CreateF2FInterviewDto = class {
 };
 __decorateClass([
   IsEmail16({}, { message: "Please enter a valid email address." }),
-  IsNotEmpty59({ message: "Invitee email is required." })
+  IsNotEmpty60({ message: "Invitee email is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  IsString41({ message: "Invitee name must be a string." }),
-  IsNotEmpty59({ message: "Invitee name is required." })
+  IsString42({ message: "Invitee name must be a string." }),
+  IsNotEmpty60({ message: "Invitee name is required." })
 ], CreateF2FInterviewDto.prototype, "inviteeName", 2);
 __decorateClass([
-  IsNumber9({}, { message: "Interview ID must be a number." })
+  IsNumber10({}, { message: "Interview ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "interviewId", 2);
 __decorateClass([
-  IsNumber9({}, { message: "Candidate ID must be a number." })
+  IsNumber10({}, { message: "Candidate ID must be a number." })
 ], CreateF2FInterviewDto.prototype, "candidateId", 2);
 
 // src/modules/interview/dto/create-f2f-interview-direct.dto.ts
 import {
-  IsString as IsString42,
-  IsNotEmpty as IsNotEmpty60,
+  IsString as IsString43,
+  IsNotEmpty as IsNotEmpty61,
   IsEmail as IsEmail17,
-  IsNumber as IsNumber10
+  IsNumber as IsNumber11
 } from "class-validator";
 var CreateF2FInterviewDirectDto = class {
 };
 __decorateClass([
   IsEmail17({}, { message: "Please enter a valid email address." }),
-  IsNotEmpty60({ message: "Invitee email is required." })
+  IsNotEmpty61({ message: "Invitee email is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeEmail", 2);
 __decorateClass([
-  IsString42({ message: "Invitee name must be a string." }),
-  IsNotEmpty60({ message: "Invitee name is required." })
+  IsString43({ message: "Invitee name must be a string." }),
+  IsNotEmpty61({ message: "Invitee name is required." })
 ], CreateF2FInterviewDirectDto.prototype, "inviteeName", 2);
 __decorateClass([
-  IsNumber10({}, { message: "Job ID must be a number." })
+  IsNumber11({}, { message: "Job ID must be a number." })
 ], CreateF2FInterviewDirectDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNumber10({}, { message: "Candidate ID must be a number." })
+  IsNumber11({}, { 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 IsString43,
-  IsNotEmpty as IsNotEmpty61
+  IsString as IsString44,
+  IsNotEmpty as IsNotEmpty62
 } from "class-validator";
 var CreateF2FInterviewRescheduleRequestDto = class {
 };
 __decorateClass([
-  IsNotEmpty61({ message: "F2F Interview ID is required." })
+  IsNotEmpty62({ message: "F2F Interview ID is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "f2FInterviewId", 2);
 __decorateClass([
-  IsNotEmpty61({ message: "Rescheduled date is required." })
+  IsNotEmpty62({ message: "Rescheduled date is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledDate", 2);
 __decorateClass([
-  IsString43({ message: "Rescheduled slot must be a string." }),
-  IsNotEmpty61({ message: "Rescheduled slot is required." })
+  IsString44({ message: "Rescheduled slot must be a string." }),
+  IsNotEmpty62({ message: "Rescheduled slot is required." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "rescheduledSlot", 2);
 __decorateClass([
-  IsString43({ message: "Freelancer reason must be a string." })
+  IsString44({ message: "Freelancer reason must be a string." })
 ], CreateF2FInterviewRescheduleRequestDto.prototype, "freelancerRequestReason", 2);
 
 // src/modules/contract/pattern/pattern.ts
@@ -7530,43 +7734,43 @@ var CONTRACT_PATTERN = {
 };
 
 // src/modules/contract/dto/sign-contract-for-client.dto.ts
-import { IsEnum as IsEnum26, IsNotEmpty as IsNotEmpty62, IsNumber as IsNumber11 } from "class-validator";
-import { Type as Type13 } from "class-transformer";
+import { IsEnum as IsEnum27, IsNotEmpty as IsNotEmpty63, IsNumber as IsNumber12 } from "class-validator";
+import { Type as Type14 } from "class-transformer";
 var SignContractForClientDto = class {
 };
 __decorateClass([
-  IsNotEmpty62({ message: "Job Id is required." }),
-  Type13(() => Number),
-  IsNumber11({}, { message: "Job ID must be a number." })
+  IsNotEmpty63({ message: "Job Id is required." }),
+  Type14(() => Number),
+  IsNumber12({}, { message: "Job ID must be a number." })
 ], SignContractForClientDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty62({ message: "Freelancer ID is required." }),
-  Type13(() => Number),
-  IsNumber11({}, { message: "Freelancer ID must be a number." })
+  IsNotEmpty63({ message: "Freelancer ID is required." }),
+  Type14(() => Number),
+  IsNumber12({}, { message: "Freelancer ID must be a number." })
 ], SignContractForClientDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsNotEmpty62({ message: "Contract type is required." }),
-  IsEnum26(ContractTypeEnum)
+  IsNotEmpty63({ message: "Contract type is required." }),
+  IsEnum27(ContractTypeEnum)
 ], SignContractForClientDto.prototype, "contractType", 2);
 
 // src/modules/contract/dto/sign-contract-for-freelancer.dto.ts
-import { IsEnum as IsEnum27, IsNotEmpty as IsNotEmpty63, IsNumber as IsNumber12 } from "class-validator";
-import { Type as Type14 } from "class-transformer";
+import { IsEnum as IsEnum28, IsNotEmpty as IsNotEmpty64, IsNumber as IsNumber13 } from "class-validator";
+import { Type as Type15 } from "class-transformer";
 var SignContractForFreelancerDto = class {
 };
 __decorateClass([
-  IsNotEmpty63({ message: "Job Id is required." }),
-  Type14(() => Number),
-  IsNumber12({}, { message: "Job ID must be a number." })
+  IsNotEmpty64({ message: "Job Id is required." }),
+  Type15(() => Number),
+  IsNumber13({}, { message: "Job ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty63({ message: "Client ID is required." }),
-  Type14(() => Number),
-  IsNumber12({}, { message: "Client ID must be a number." })
+  IsNotEmpty64({ message: "Client ID is required." }),
+  Type15(() => Number),
+  IsNumber13({}, { message: "Client ID must be a number." })
 ], SignContractForFreelancerDto.prototype, "clientId", 2);
 __decorateClass([
-  IsNotEmpty63({ message: "Contract type is required." }),
-  IsEnum27(ContractTypeEnum)
+  IsNotEmpty64({ message: "Contract type is required." }),
+  IsEnum28(ContractTypeEnum)
 ], SignContractForFreelancerDto.prototype, "contractType", 2);
 
 // src/modules/stripe/pattern/pattern.ts
@@ -7585,12 +7789,12 @@ var STRIPE_PATTERN = {
 
 // src/modules/stripe/dto/create-checkout-session.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty64
+  IsNotEmpty as IsNotEmpty65
 } from "class-validator";
 var CreateCheckoutSessionDto = class {
 };
 __decorateClass([
-  IsNotEmpty64({ message: "Amount is required" })
+  IsNotEmpty65({ message: "Amount is required" })
 ], CreateCheckoutSessionDto.prototype, "amount", 2);
 
 // src/modules/timesheet/pattern/pattern.ts
@@ -7613,113 +7817,113 @@ var TIMESHEET_CLIENT_PATTERN = {
 // src/modules/timesheet/dto/create-freelancer-timesheet.dto.ts
 import {
   IsDateString as IsDateString6,
-  IsInt as IsInt9,
-  IsNotEmpty as IsNotEmpty65,
-  IsOptional as IsOptional41,
-  IsString as IsString44,
+  IsInt as IsInt10,
+  IsNotEmpty as IsNotEmpty66,
+  IsOptional as IsOptional42,
+  IsString as IsString45,
   Matches as Matches13,
-  IsNumber as IsNumber13
+  IsNumber as IsNumber14
 } from "class-validator";
 var CreateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty65({ message: "Job id is required" }),
-  IsNumber13({}, { message: "Job id must be a number" })
+  IsNotEmpty66({ message: "Job id is required" }),
+  IsNumber14({}, { message: "Job id must be a number" })
 ], CreateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty65({ message: "start date is required" }),
+  IsNotEmpty66({ message: "start date is required" }),
   IsDateString6()
 ], CreateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  IsNotEmpty65({ message: "end date is required" }),
+  IsNotEmpty66({ message: "end date is required" }),
   IsDateString6()
 ], CreateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  IsNotEmpty65({ message: "start time is required" }),
+  IsNotEmpty66({ 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([
-  IsNotEmpty65({ message: "end time is required" }),
+  IsNotEmpty66({ 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([
-  IsOptional41(),
-  IsInt9()
+  IsOptional42(),
+  IsInt10()
 ], CreateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  IsOptional41(),
-  IsString44()
+  IsOptional42(),
+  IsString45()
 ], CreateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional41(),
-  IsString44()
+  IsOptional42(),
+  IsString45()
 ], CreateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  IsOptional41(),
-  IsString44()
+  IsOptional42(),
+  IsString45()
 ], CreateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  IsNotEmpty65({ message: "Description is required" })
+  IsNotEmpty66({ message: "Description is required" })
 ], CreateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/timesheet/dto/update-freelancer-timesheet.dto.ts
 import {
   IsDateString as IsDateString7,
-  IsInt as IsInt10,
-  IsNotEmpty as IsNotEmpty66,
-  IsOptional as IsOptional42,
-  IsString as IsString45,
+  IsInt as IsInt11,
+  IsNotEmpty as IsNotEmpty67,
+  IsOptional as IsOptional43,
+  IsString as IsString46,
   Matches as Matches14,
-  IsNumber as IsNumber14
+  IsNumber as IsNumber15
 } from "class-validator";
 var UpdateFreelancerTimesheetDto = class {
 };
 __decorateClass([
-  IsNotEmpty66({ message: "Job id is required" }),
-  IsNumber14({}, { message: "Job id must be a number" })
+  IsNotEmpty67({ message: "Job id is required" }),
+  IsNumber15({}, { message: "Job id must be a number" })
 ], UpdateFreelancerTimesheetDto.prototype, "jobId", 2);
 __decorateClass([
-  IsNotEmpty66({ message: "start date is required" }),
+  IsNotEmpty67({ message: "start date is required" }),
   IsDateString7()
 ], UpdateFreelancerTimesheetDto.prototype, "startDate", 2);
 __decorateClass([
-  IsNotEmpty66({ message: "end date is required" }),
+  IsNotEmpty67({ message: "end date is required" }),
   IsDateString7()
 ], UpdateFreelancerTimesheetDto.prototype, "endDate", 2);
 __decorateClass([
-  IsNotEmpty66({ message: "start time is required" }),
+  IsNotEmpty67({ 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([
-  IsNotEmpty66({ message: "end time is required" }),
+  IsNotEmpty67({ 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([
-  IsOptional42(),
-  IsInt10()
+  IsOptional43(),
+  IsInt11()
 ], UpdateFreelancerTimesheetDto.prototype, "taskId", 2);
 __decorateClass([
-  IsOptional42(),
-  IsString45()
+  IsOptional43(),
+  IsString46()
 ], UpdateFreelancerTimesheetDto.prototype, "projectName", 2);
 __decorateClass([
-  IsOptional42(),
-  IsString45()
+  IsOptional43(),
+  IsString46()
 ], UpdateFreelancerTimesheetDto.prototype, "deliverable", 2);
 __decorateClass([
-  IsOptional42(),
-  IsString45()
+  IsOptional43(),
+  IsString46()
 ], UpdateFreelancerTimesheetDto.prototype, "taskName", 2);
 __decorateClass([
-  IsNotEmpty66({ message: "Description is required" })
+  IsNotEmpty67({ message: "Description is required" })
 ], UpdateFreelancerTimesheetDto.prototype, "description", 2);
 
 // src/modules/invoice/pattern/pattern.ts
@@ -7734,61 +7938,61 @@ var INVOICE_PATTERN = {
 };
 
 // src/modules/invoice/dto/update-invoice-status.dto.ts
-import { IsEnum as IsEnum30, IsNotEmpty as IsNotEmpty67 } from "class-validator";
+import { IsEnum as IsEnum31, IsNotEmpty as IsNotEmpty68 } from "class-validator";
 var UpdateInvoiceStatusDto = class {
 };
 __decorateClass([
-  IsNotEmpty67({ message: "Please provide invoice status." }),
-  IsEnum30(InvoiceStatusEnum, {
+  IsNotEmpty68({ message: "Please provide invoice status." }),
+  IsEnum31(InvoiceStatusEnum, {
     message: "Status must be one of: APPROVED, REJECTED"
   })
 ], UpdateInvoiceStatusDto.prototype, "status", 2);
 
 // src/modules/dispute/dto/create-dispute.dto.ts
 import {
-  IsString as IsString46,
-  IsNotEmpty as IsNotEmpty68,
+  IsString as IsString47,
+  IsNotEmpty as IsNotEmpty69,
   IsIn as IsIn4,
-  IsOptional as IsOptional43,
-  MaxLength as MaxLength20,
+  IsOptional as IsOptional44,
+  MaxLength as MaxLength21,
   IsObject,
-  IsNumber as IsNumber15,
-  ValidateIf as ValidateIf10
+  IsNumber as IsNumber16,
+  ValidateIf as ValidateIf11
 } from "class-validator";
-import { Transform as Transform4, Type as Type15 } from "class-transformer";
+import { Transform as Transform4, Type as Type16 } from "class-transformer";
 var CreateDisputeDto = class {
 };
 __decorateClass([
-  ValidateIf10((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
-  IsNumber15({}, { message: "Client id must be a number" }),
-  Type15(() => Number)
+  ValidateIf11((o) => o.initiatorType === "FREELANCER" /* FREELANCER */),
+  IsNumber16({}, { message: "Client id must be a number" }),
+  Type16(() => Number)
 ], CreateDisputeDto.prototype, "clientId", 2);
 __decorateClass([
-  ValidateIf10((o) => o.initiatorType === "CLIENT" /* CLIENT */),
-  IsNumber15({}, { message: "Freelancer id must be a number" }),
-  Type15(() => Number)
+  ValidateIf11((o) => o.initiatorType === "CLIENT" /* CLIENT */),
+  IsNumber16({}, { message: "Freelancer id must be a number" }),
+  Type16(() => Number)
 ], CreateDisputeDto.prototype, "freelancerId", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please select dispute type." }),
-  IsString46(),
+  IsNotEmpty69({ message: "Please select dispute type." }),
+  IsString47(),
   IsIn4(["JOB", "INVOICE"])
 ], CreateDisputeDto.prototype, "disputeType", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please provide initiator type." }),
-  IsString46()
+  IsNotEmpty69({ message: "Please provide initiator type." }),
+  IsString47()
 ], CreateDisputeDto.prototype, "initiatorType", 2);
 __decorateClass([
-  IsNotEmpty68({ message: "Please enter description." }),
-  IsString46({ message: "Description must be a string" }),
-  MaxLength20(500, { message: "Description must not exceed 500 characters" })
+  IsNotEmpty69({ message: "Please enter description." }),
+  IsString47({ message: "Description must be a string" }),
+  MaxLength21(500, { message: "Description must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "description", 2);
 __decorateClass([
-  IsOptional43(),
-  IsString46({ message: "Comment must be a string" }),
-  MaxLength20(500, { message: "Comment must not exceed 500 characters" })
+  IsOptional44(),
+  IsString47({ message: "Comment must be a string" }),
+  MaxLength21(500, { message: "Comment must not exceed 500 characters" })
 ], CreateDisputeDto.prototype, "comment", 2);
 __decorateClass([
-  IsOptional43(),
+  IsOptional44(),
   IsObject({ message: "Dynamic fields must be a valid object" }),
   Transform4(({ value }) => {
     if (typeof value === "string") {
@@ -7804,15 +8008,15 @@ __decorateClass([
 
 // src/modules/senseloaf/dto/ai-interview-question-generate.dto.ts
 import {
-  IsNotEmpty as IsNotEmpty69
+  IsNotEmpty as IsNotEmpty70
 } from "class-validator";
 var AiInterviewQuestionGenerateDto = class {
 };
 __decorateClass([
-  IsNotEmpty69({ message: "Please enter job description." })
+  IsNotEmpty70({ message: "Please enter job description." })
 ], AiInterviewQuestionGenerateDto.prototype, "jobDescription", 2);
 __decorateClass([
-  IsNotEmpty69({ message: "Please enter number of questions." })
+  IsNotEmpty70({ message: "Please enter number of questions." })
 ], AiInterviewQuestionGenerateDto.prototype, "numQuestions", 2);
 
 // src/adapters/tcp/user.tcp.adapter.ts
@@ -8833,6 +9037,7 @@ export {
   AccountStatus,
   AccountType,
   AdminCreateJobInformationDto,
+  AdminJobBasicInformationV2Dto,
   AdminPermission,
   AdminRole,
   AdminRolePermission,
@@ -8995,6 +9200,7 @@ export {
   JobFreelancerRecommendationV2,
   JobIdParamDto,
   JobLocation,
+  JobLocationAdminDto,
   JobLocationDto,
   JobLocationEnum2 as JobLocationEnum,
   JobLocationEnumDto,