@experts_hub/shared/dist/index.js

Shared DTOs, interfaces, and utilities for experts hub applications

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __decorateClass = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
  if (kind && result) __defProp(target, key, result);
  return result;
};

// src/index.ts
var index_exports = {};
__export(index_exports, {
  ADMIN_FREELANCER_PATTERN: () => ADMIN_FREELANCER_PATTERN,
  ADMIN_JOB_PATTERN: () => ADMIN_JOB_PATTERN,
  ADMIN_PERMISSION_PATTERN: () => ADMIN_PERMISSION_PATTERN,
  ADMIN_ROLE_PATTERN: () => ADMIN_ROLE_PATTERN,
  ASSESSMENT_QUESTION_PATTERN: () => ASSESSMENT_QUESTION_PATTERN,
  AUTHENTICATION_PATTERN: () => AUTHENTICATION_PATTERN,
  AccountStatus: () => AccountStatus,
  AccountType: () => AccountType,
  AdminCreateJobInformationDto: () => AdminCreateJobInformationDto,
  AdminPermission: () => AdminPermission,
  AdminRole: () => AdminRole,
  AdminRolePermission: () => AdminRolePermission,
  AdminUpdateJobInformationDto: () => AdminUpdateJobInformationDto,
  AdminUserRole: () => AdminUserRole,
  AiAssessmentStatusEnum: () => AiAssessmentStatusEnum,
  AiInterview: () => AiInterview,
  AiInterviewStatusEnum: () => AiInterviewStatusEnum,
  AnswerTypeEnum: () => AnswerTypeEnum,
  ApplicationStatusEnum: () => ApplicationStatusEnum,
  AssessmentAnswer: () => AssessmentAnswer,
  AssessmentStatusEnum: () => AssessmentStatusEnum,
  AssessmetQuestion: () => AssessmetQuestion,
  AssessmetQuestionOption: () => AssessmetQuestionOption,
  AttachPermissionsToRoleDto: () => AttachPermissionsToRoleDto,
  BANK_PATTERN: () => BANK_PATTERN,
  BankAccountScope: () => BankAccountScope,
  BankAccountScopeEnum: () => BankAccountScopeEnum,
  BankAccountTypeEnum: () => BankAccountTypeEnum,
  BankDetail: () => BankDetail,
  BaseEntity: () => BaseEntity,
  CALENDLY_PATTERN: () => CALENDLY_PATTERN,
  CITY_PATTERN: () => CITY_PATTERN,
  CLIENT_ADMIN_PATTERNS: () => CLIENT_ADMIN_PATTERNS,
  CLIENT_PROFILE_PATTERN: () => CLIENT_PROFILE_PATTERN,
  CMS_PATTERNS: () => CMS_PATTERNS,
  COMPANY_MEMBERS_PATTERNS: () => COMPANY_MEMBERS_PATTERNS,
  COMPANY_ROLES_PATTERNS: () => COMPANY_ROLES_PATTERNS,
  CONTRACT_PATTERN: () => CONTRACT_PATTERN,
  COUNTRY_PATTERN: () => COUNTRY_PATTERN,
  CalendlyMeetingLog: () => CalendlyMeetingLog,
  CandidateType: () => CandidateType,
  CaseStudyDto: () => CaseStudyDto,
  CategoryEmum: () => CategoryEmum,
  CategoryEmumDto: () => CategoryEmumDto,
  City: () => City,
  ClientChangePasswordDto: () => ClientChangePasswordDto,
  ClientCreateAccountDto: () => ClientCreateAccountDto,
  ClientFreelancerRecommendation: () => ClientFreelancerRecommendation,
  ClientProfileQuestionDto: () => ClientProfileQuestionDto,
  Cms: () => Cms,
  Commission: () => Commission,
  CommissionTypeEnum: () => CommissionTypeEnum,
  CompanyMemberRole: () => CompanyMemberRole,
  CompanyOnboardingStepEnum: () => CompanyOnboardingStepEnum,
  CompanyProfile: () => CompanyProfile,
  CompanyRole: () => CompanyRole,
  CompanyRolePermission: () => CompanyRolePermission,
  CompanySkill: () => CompanySkill,
  Contract: () => Contract,
  ContractStatusEnum: () => ContractStatusEnum,
  ContractTypeEnum: () => ContractTypeEnum,
  Country: () => Country,
  CreateAdminRoleDto: () => CreateAdminRoleDto,
  CreateClientDto: () => CreateClientDto,
  CreateClientHiringModeEnum: () => CreateClientHiringModeEnum,
  CreateClientHiringTypeEnum: () => CreateClientHiringTypeEnum,
  CreateCmsDto: () => CreateCmsDto,
  CreateCompanyMemberDto: () => CreateCompanyMemberDto,
  CreateCompanyRoleDto: () => CreateCompanyRoleDto,
  CreateF2FInterviewDto: () => CreateF2FInterviewDto,
  CreateF2FInterviewRescheduleRequestDto: () => CreateF2FInterviewRescheduleRequestDto,
  CreateFreelancerDto: () => CreateFreelancerDto,
  CreateLeadDto: () => CreateLeadDto,
  CreateQuestionDto: () => CreateQuestionDto,
  CreateRatingDto: () => CreateRatingDto,
  CreateSubAdminDto: () => CreateSubAdminDto,
  DocumentType: () => DocumentType,
  DocumentTypeEnum: () => DocumentTypeEnum,
  DurationTypeEnum: () => DurationTypeEnum,
  EducationDto: () => EducationDto,
  EmploymentType: () => EmploymentType,
  ExperienceDto: () => ExperienceDto,
  F2FInterview: () => F2FInterview,
  F2FInterviewSchedule: () => F2FInterviewSchedule,
  F2F_INTERVIEW_PATTERN: () => F2F_INTERVIEW_PATTERN,
  F2fInterviewRescheduleRequest: () => F2fInterviewRescheduleRequest,
  F2fInterviewRescheduleRequestStatusEnum: () => F2fInterviewRescheduleRequestStatusEnum,
  F2fInterviewScheduleStatusEnum: () => F2fInterviewScheduleStatusEnum,
  F2fInterviewStatusEnum: () => F2fInterviewStatusEnum,
  FREELANCER_DECLARATION_PATTERN: () => FREELANCER_DECLARATION_PATTERN,
  FREELANCER_EDUCATION_PATTERN: () => FREELANCER_EDUCATION_PATTERN,
  FREELANCER_EXPERIENCE_PATTERN: () => FREELANCER_EXPERIENCE_PATTERN,
  FREELANCER_PROJECT_PATTERN: () => FREELANCER_PROJECT_PATTERN,
  FREELANCER_SKILL_PATTERN: () => FREELANCER_SKILL_PATTERN,
  Feature: () => Feature,
  ForgotPasswordDto: () => ForgotPasswordDto,
  FreelancerAssessment: () => FreelancerAssessment,
  FreelancerBankDetailsDto: () => FreelancerBankDetailsDto,
  FreelancerCaptureAiAssessmentStatusDto: () => FreelancerCaptureAiAssessmentStatusDto,
  FreelancerCaseStudy: () => FreelancerCaseStudy,
  FreelancerChangePasswordDto: () => FreelancerChangePasswordDto,
  FreelancerCreateAccountDto: () => FreelancerCreateAccountDto,
  FreelancerDeclaration: () => FreelancerDeclaration,
  FreelancerDeclarationDto: () => FreelancerDeclarationDto,
  FreelancerDevelopmentPreferenceDto: () => FreelancerDevelopmentPreferenceDto,
  FreelancerEducation: () => FreelancerEducation,
  FreelancerEducationDto: () => FreelancerEducationDto,
  FreelancerExperience: () => FreelancerExperience,
  FreelancerExperienceDto: () => FreelancerExperienceDto,
  FreelancerFramework: () => FreelancerFramework,
  FreelancerInitiateAiAssessmentDto: () => FreelancerInitiateAiAssessmentDto,
  FreelancerInitiateMcqAssessmentDto: () => FreelancerInitiateMcqAssessmentDto,
  FreelancerParseResumeDto: () => FreelancerParseResumeDto,
  FreelancerProfile: () => FreelancerProfile,
  FreelancerProfileQuestionDto: () => FreelancerProfileQuestionDto,
  FreelancerProject: () => FreelancerProject,
  FreelancerProjectDto: () => FreelancerProjectDto,
  FreelancerResume: () => FreelancerResume,
  FreelancerSkill: () => FreelancerSkill,
  FreelancerSkillDto: () => FreelancerSkillDto,
  FreelancerSkipAiAssessmentDto: () => FreelancerSkipAiAssessmentDto,
  FreelancerTool: () => FreelancerTool,
  FreelancerUploadResumeDto: () => FreelancerUploadResumeDto,
  FreelancerWorkShowcaseDto: () => FreelancerWorkShowcaseDto,
  FromUsOn: () => FromUsOn,
  INTERVIEW_INVITE_PATTERN: () => INTERVIEW_INVITE_PATTERN,
  Interview: () => Interview,
  InterviewInvite: () => InterviewInvite,
  InterviewInviteDto: () => InterviewInviteDto,
  InterviewInviteStatusEnum: () => InterviewInviteStatusEnum,
  InterviewQuestion: () => InterviewQuestion,
  InterviewSkill: () => InterviewSkill,
  InterviewStatusEnum: () => InterviewStatusEnum,
  JOB_PATTERN: () => JOB_PATTERN,
  JOB_ROLE_PATTERN: () => JOB_ROLE_PATTERN,
  Job: () => Job,
  JobAdditionalCommentDto: () => JobAdditionalCommentDto,
  JobApplication: () => JobApplication,
  JobBasicInformationDto: () => JobBasicInformationDto,
  JobDescriptionDto: () => JobDescriptionDto,
  JobFreelancerRecommendation: () => JobFreelancerRecommendation,
  JobFreelancerRecommendationV2: () => JobFreelancerRecommendationV2,
  JobIdParamDto: () => JobIdParamDto,
  JobLocation: () => JobLocation,
  JobLocationEnum: () => JobLocationEnum,
  JobLocationEnumDto: () => JobLocationEnumDto,
  JobLocationEnums: () => JobLocationEnums,
  JobRMQAdapter: () => JobRMQAdapter,
  JobRecommendation: () => JobRecommendation,
  JobRoles: () => JobRoles,
  JobSkill: () => JobSkill,
  JobStatus: () => JobStatus,
  JobStatusDto: () => JobStatusDto,
  JobStatusEnum: () => JobStatusEnum,
  JobTCPAdapter: () => JobTCPAdapter,
  KindOfHire: () => KindOfHire,
  LEAD_PATTERN: () => LEAD_PATTERN,
  Lead: () => Lead,
  LoginDto: () => LoginDto,
  LoginViaOtpDto: () => LoginViaOtpDto,
  LoginViaOtpScopeEnum: () => LoginViaOtpScopeEnum,
  LogoutDto: () => LogoutDto,
  McqStatusEnum: () => McqStatusEnum,
  ModeOfHire: () => ModeOfHire,
  ModeOfWork: () => ModeOfWork,
  ModeOfWorkDto: () => ModeOfWorkDto,
  NOTIFICATION_PATTERN: () => NOTIFICATION_PATTERN,
  NatureOfWork: () => NatureOfWork,
  NatureOfWorkDto: () => NatureOfWorkDto,
  NotificationRMQAdapter: () => NotificationRMQAdapter,
  NotificationTCPAdapter: () => NotificationTCPAdapter,
  ONBOARDING_PATTERN: () => ONBOARDING_PATTERN,
  ONBOARDING_QUESTION_PATTERN: () => ONBOARDING_QUESTION_PATTERN,
  OTP_PATTERN: () => OTP_PATTERN,
  OnboardingStepEnum: () => OnboardingStepEnum,
  Otp: () => Otp,
  PERMISSION_PATTERN: () => PERMISSION_PATTERN,
  PLAN_PATTERN: () => PLAN_PATTERN,
  PROFILE_PATTERN: () => PROFILE_PATTERN,
  Permission: () => Permission,
  Plan: () => Plan,
  ProjectDto: () => ProjectDto,
  Provider: () => Provider,
  Question: () => Question,
  QuestionFor: () => QuestionFor,
  QuestionForEnum: () => QuestionForEnum,
  RATING_PATTERN: () => RATING_PATTERN,
  RESUME_PARSER_PATTERN: () => RESUME_PARSER_PATTERN,
  Rating: () => Rating,
  RatingTypeEnum: () => RatingTypeEnum,
  RefreshDto: () => RefreshDto,
  RefreshToken: () => RefreshToken,
  ResetPasswordDto: () => ResetPasswordDto,
  ResetPasswordTokenValidationDto: () => ResetPasswordTokenValidationDto,
  STATE_PATTERN: () => STATE_PATTERN,
  SUBADMIN_PATTERN: () => SUBADMIN_PATTERN,
  SYSTEM_PREFERENCES_PATTERN: () => SYSTEM_PREFERENCES_PATTERN,
  ScopeEnum: () => ScopeEnum,
  SelectedAnswerTypeEnum: () => SelectedAnswerTypeEnum,
  SendGuestOtpDto: () => SendGuestOtpDto,
  SendGuestOtpPurposeEnum: () => SendGuestOtpPurposeEnum,
  SendGuestOtpScopeEnum: () => SendGuestOtpScopeEnum,
  SendLoginOtpDto: () => SendLoginOtpDto,
  SendLoginOtpPurposeEnum: () => SendLoginOtpPurposeEnum,
  SendLoginOtpScopeEnum: () => SendLoginOtpScopeEnum,
  SenseloafLog: () => SenseloafLog,
  SequenceGenerator: () => SequenceGenerator,
  SetPasswordDto: () => SetPasswordDto,
  Skill: () => Skill,
  State: () => State,
  Step: () => Step,
  StripeWallet: () => StripeWallet,
  StripeWalletTransaction: () => StripeWalletTransaction,
  StripeWalletTransactionStatusEnum: () => StripeWalletTransactionStatusEnum,
  StripeWalletTransactionTypeEnum: () => StripeWalletTransactionTypeEnum,
  SystemPreference: () => SystemPreference,
  SystemPreferenceDto: () => SystemPreferenceDto,
  SystemPreferenceKey: () => SystemPreferenceKey,
  ToggleCompanyMemberVisibilityDto: () => ToggleCompanyMemberVisibilityDto,
  ToggleCompanyRoleVisibilityDto: () => ToggleCompanyRoleVisibilityDto,
  TypeOfEmploymentEnum: () => TypeOfEmploymentEnum,
  TypeOfEmploymentEnumDto: () => TypeOfEmploymentEnumDto,
  TypeOfEmploymentEnums: () => TypeOfEmploymentEnums,
  UpdateAdminRoleDto: () => UpdateAdminRoleDto,
  UpdateClientAccountStatusDto: () => UpdateClientAccountStatusDto,
  UpdateClientDto: () => UpdateClientDto,
  UpdateClientHiringModeEnum: () => UpdateClientHiringModeEnum,
  UpdateClientHiringTypeEnum: () => UpdateClientHiringTypeEnum,
  UpdateCmsDto: () => UpdateCmsDto,
  UpdateCompanyMemberDto: () => UpdateCompanyMemberDto,
  UpdateCompanyProfileDto: () => UpdateCompanyProfileDto,
  UpdateCompanyRoleDto: () => UpdateCompanyRoleDto,
  UpdateFreelancerDto: () => UpdateFreelancerDto,
  UpdateFreelancerProfileDto: () => UpdateFreelancerProfileDto,
  UpdateSubAdminAccountStatusDto: () => UpdateSubAdminAccountStatusDto,
  UpdateSubAdminDto: () => UpdateSubAdminDto,
  User: () => User,
  UserRMQAdapter: () => UserRMQAdapter,
  UserTCPAdapter: () => UserTCPAdapter,
  VerifyGuestOtpDto: () => VerifyGuestOtpDto,
  VerifyGuestOtpPurposeEnum: () => VerifyGuestOtpPurposeEnum,
  ZoomMeetingLog: () => ZoomMeetingLog
});
module.exports = __toCommonJS(index_exports);

// src/modules/authentication/pattern/pattern.ts
var AUTHENTICATION_PATTERN = {
  handleValidateToken: "handle.validate.token",
  handleLogin: "handle.login",
  handleLoginViaOtp: "handle.login.via.otp",
  handleRefreshToken: "handle.refresh.token",
  handleLogout: "handle.logout",
  handleLogoutAll: "handle.logout.all",
  fetchSessions: "fetch.sessions",
  revokeSession: "revoke.session",
  handleForgotPassword: "handle.forgot.password",
  handleResetPassword: "handle.reset.password",
  handleValidateResetPasswordToken: "handle.validate.reset.password.token",
  handleSetPassword: "handle.set.password"
};

// src/modules/authentication/dto/login.dto.ts
var import_class_validator = require("class-validator");
var ScopeEnum = /* @__PURE__ */ ((ScopeEnum5) => {
  ScopeEnum5["ADMIN"] = "ADMIN";
  ScopeEnum5["SUB_ADMIN"] = "SUB_ADMIN";
  ScopeEnum5["CLIENT"] = "CLIENT";
  ScopeEnum5["FREELANCER"] = "FREELANCER";
  return ScopeEnum5;
})(ScopeEnum || {});
var LoginDto = class {
};
__decorateClass([
  (0, import_class_validator.IsNotEmpty)({ message: "Please enter email." })
], LoginDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator.IsNotEmpty)({ message: "Please enter password." })
], LoginDto.prototype, "password", 2);
__decorateClass([
  (0, import_class_validator.IsEnum)(ScopeEnum, {
    message: `Scope must be one of: ${Object.values(ScopeEnum).join(", ")}`
  })
], LoginDto.prototype, "scope", 2);

// src/modules/authentication/dto/login-via-otp.dto.ts
var import_class_validator2 = require("class-validator");
var LoginViaOtpScopeEnum = /* @__PURE__ */ ((LoginViaOtpScopeEnum2) => {
  LoginViaOtpScopeEnum2["ADMIN"] = "ADMIN";
  LoginViaOtpScopeEnum2["SUB_ADMIN"] = "SUB_ADMIN";
  LoginViaOtpScopeEnum2["CLIENT"] = "CLIENT";
  LoginViaOtpScopeEnum2["FREELANCER"] = "FREELANCER";
  return LoginViaOtpScopeEnum2;
})(LoginViaOtpScopeEnum || {});
var LoginViaOtpDto = class {
};
__decorateClass([
  (0, import_class_validator2.IsNotEmpty)({ message: "Please enter email." })
], LoginViaOtpDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator2.IsNotEmpty)({ message: "Please enter otp." })
], LoginViaOtpDto.prototype, "otp", 2);
__decorateClass([
  (0, import_class_validator2.IsEnum)(LoginViaOtpScopeEnum, {
    message: `Scope must be one of: ${Object.values(LoginViaOtpScopeEnum).join(", ")}`
  })
], LoginViaOtpDto.prototype, "scope", 2);

// src/modules/authentication/dto/refresh.dto.ts
var import_class_validator3 = require("class-validator");
var RefreshDto = class {
};
__decorateClass([
  (0, import_class_validator3.IsNotEmpty)({ message: "Please provide refresh token." })
], RefreshDto.prototype, "refreshToken", 2);

// src/modules/authentication/dto/logout.dto.ts
var import_class_validator4 = require("class-validator");
var LogoutDto = class {
};
__decorateClass([
  (0, import_class_validator4.IsNotEmpty)({ message: "Please provide refresh token." })
], LogoutDto.prototype, "refreshToken", 2);

// src/modules/authentication/dto/forgot-password.dto.ts
var import_class_validator5 = require("class-validator");
var ScopeEnum2 = /* @__PURE__ */ ((ScopeEnum5) => {
  ScopeEnum5["ADMIN"] = "ADMIN";
  ScopeEnum5["CLIENT"] = "CLIENT";
  ScopeEnum5["FREELANCER"] = "FREELANCER";
  return ScopeEnum5;
})(ScopeEnum2 || {});
var ForgotPasswordDto = class {
};
__decorateClass([
  (0, import_class_validator5.IsNotEmpty)({ message: "Please enter email." }),
  (0, import_class_validator5.IsEmail)({}, { message: "Please enter a valid email." })
], ForgotPasswordDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator5.IsEnum)(ScopeEnum2, {
    message: `Scope must be one of: ${Object.values(ScopeEnum2).join(", ")}`
  })
], ForgotPasswordDto.prototype, "scope", 2);

// src/modules/authentication/dto/reset-password.dto.ts
var import_class_validator6 = require("class-validator");
var ScopeEnum3 = /* @__PURE__ */ ((ScopeEnum5) => {
  ScopeEnum5["ADMIN"] = "ADMIN";
  ScopeEnum5["CLIENT"] = "CLIENT";
  ScopeEnum5["FREELANCER"] = "FREELANCER";
  return ScopeEnum5;
})(ScopeEnum3 || {});
var ResetPasswordDto = class {
};
__decorateClass([
  (0, import_class_validator6.IsNotEmpty)({ message: "Please enter token." })
], ResetPasswordDto.prototype, "token", 2);
__decorateClass([
  (0, import_class_validator6.IsNotEmpty)({ message: "Please enter password." }),
  (0, import_class_validator6.MinLength)(6),
  (0, import_class_validator6.MaxLength)(32),
  (0, import_class_validator6.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
    message: "Password must include letters, numbers and symbols."
  })
], ResetPasswordDto.prototype, "password", 2);
__decorateClass([
  (0, import_class_validator6.IsEnum)(ScopeEnum3, {
    message: `Scope must be one of: ${Object.values(ScopeEnum3).join(", ")}`
  })
], ResetPasswordDto.prototype, "scope", 2);

// src/modules/authentication/dto/set-password.dto.ts
var import_class_validator7 = require("class-validator");
var SetPasswordDto = class {
};
__decorateClass([
  (0, import_class_validator7.IsNotEmpty)({ message: "Please enter token." })
], SetPasswordDto.prototype, "token", 2);
__decorateClass([
  (0, import_class_validator7.IsNotEmpty)({ message: "Please enter password." }),
  (0, import_class_validator7.MinLength)(6),
  (0, import_class_validator7.MaxLength)(32),
  (0, import_class_validator7.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
    message: "Password must include letters, numbers and symbols."
  })
], SetPasswordDto.prototype, "password", 2);

// src/modules/authentication/dto/reset-password-token-validation.dto.ts
var import_class_validator8 = require("class-validator");
var ScopeEnum4 = /* @__PURE__ */ ((ScopeEnum5) => {
  ScopeEnum5["ADMIN"] = "ADMIN";
  ScopeEnum5["CLIENT"] = "CLIENT";
  ScopeEnum5["FREELANCER"] = "FREELANCER";
  return ScopeEnum5;
})(ScopeEnum4 || {});
var ResetPasswordTokenValidationDto = class {
};
__decorateClass([
  (0, import_class_validator8.IsNotEmpty)({ message: "Please enter token." })
], ResetPasswordTokenValidationDto.prototype, "token", 2);
__decorateClass([
  (0, import_class_validator8.IsEnum)(ScopeEnum4, {
    message: `Scope must be one of: ${Object.values(ScopeEnum4).join(", ")}`
  })
], ResetPasswordTokenValidationDto.prototype, "scope", 2);

// src/modules/otp/pattern/pattern.ts
var OTP_PATTERN = {
  handleSendGuestOtp: "handle.send.guest.otp",
  handleSendOtp: "handle.send.otp",
  handleSendOtpForLogin: "handle.send.otp.for.login",
  handleVerifyGuestOtp: "handle.verify.guest.otp",
  handleVerifyOtp: "handle.verify.otp"
};

// src/modules/otp/dto/send-guest-otp.dto.ts
var import_class_validator9 = require("class-validator");
var SendGuestOtpPurposeEnum = /* @__PURE__ */ ((SendGuestOtpPurposeEnum2) => {
  SendGuestOtpPurposeEnum2["ACCOUNT_VERIFICATION"] = "ACCOUNT_VERIFICATION";
  return SendGuestOtpPurposeEnum2;
})(SendGuestOtpPurposeEnum || {});
var SendGuestOtpScopeEnum = /* @__PURE__ */ ((SendGuestOtpScopeEnum2) => {
  SendGuestOtpScopeEnum2["CLIENT"] = "CLIENT";
  SendGuestOtpScopeEnum2["FREELANCER"] = "FREELANCER";
  return SendGuestOtpScopeEnum2;
})(SendGuestOtpScopeEnum || {});
var SendGuestOtpDto = class {
};
__decorateClass([
  (0, import_class_validator9.IsNotEmpty)({ message: "Please enter full name." }),
  (0, import_class_validator9.IsString)({ message: "Please enter valid full name." })
], SendGuestOtpDto.prototype, "fullName", 2);
__decorateClass([
  (0, import_class_validator9.IsNotEmpty)({ message: "Please enter target." }),
  (0, import_class_validator9.IsString)({ message: "Please enter valid target." })
], SendGuestOtpDto.prototype, "target", 2);
__decorateClass([
  (0, import_class_validator9.IsOptional)(),
  (0, import_class_validator9.IsString)({ message: "Please enter valid fallback target." })
], SendGuestOtpDto.prototype, "fallbackTarget", 2);
__decorateClass([
  (0, import_class_validator9.IsNotEmpty)({ message: "Please enter OTP purpose." }),
  (0, import_class_validator9.IsEnum)(SendGuestOtpPurposeEnum, { message: "Purpose must be a valid OTP purpose" })
], SendGuestOtpDto.prototype, "purpose", 2);
__decorateClass([
  (0, import_class_validator9.IsNotEmpty)({ message: "Please enter scope." }),
  (0, import_class_validator9.IsEnum)(SendGuestOtpScopeEnum, { message: "scope must be a valid" })
], SendGuestOtpDto.prototype, "scope", 2);

// src/modules/otp/dto/send-login-otp.dto.ts
var import_class_validator10 = require("class-validator");
var SendLoginOtpPurposeEnum = /* @__PURE__ */ ((SendLoginOtpPurposeEnum2) => {
  SendLoginOtpPurposeEnum2["ACCOUNT_VERIFICATION"] = "ACCOUNT_VERIFICATION";
  return SendLoginOtpPurposeEnum2;
})(SendLoginOtpPurposeEnum || {});
var SendLoginOtpScopeEnum = /* @__PURE__ */ ((SendLoginOtpScopeEnum2) => {
  SendLoginOtpScopeEnum2["CLIENT"] = "CLIENT";
  SendLoginOtpScopeEnum2["FREELANCER"] = "FREELANCER";
  return SendLoginOtpScopeEnum2;
})(SendLoginOtpScopeEnum || {});
var SendLoginOtpDto = class {
};
__decorateClass([
  (0, import_class_validator10.IsNotEmpty)({ message: "Please enter target." }),
  (0, import_class_validator10.IsString)({ message: "Please enter valid target." })
], SendLoginOtpDto.prototype, "target", 2);
__decorateClass([
  (0, import_class_validator10.IsNotEmpty)({ message: "Please enter OTP purpose." }),
  (0, import_class_validator10.IsEnum)(SendLoginOtpPurposeEnum, { message: "Purpose must be a valid OTP purpose" })
], SendLoginOtpDto.prototype, "purpose", 2);
__decorateClass([
  (0, import_class_validator10.IsNotEmpty)({ message: "Please enter scope." }),
  (0, import_class_validator10.IsEnum)(SendLoginOtpScopeEnum, { message: "scope must be a valid" })
], SendLoginOtpDto.prototype, "scope", 2);

// src/modules/otp/dto/verify-guest-otp.dto.ts
var import_class_validator11 = require("class-validator");
var VerifyGuestOtpPurposeEnum = /* @__PURE__ */ ((VerifyGuestOtpPurposeEnum2) => {
  VerifyGuestOtpPurposeEnum2["ACCOUNT_VERIFICATION"] = "ACCOUNT_VERIFICATION";
  return VerifyGuestOtpPurposeEnum2;
})(VerifyGuestOtpPurposeEnum || {});
var VerifyGuestOtpDto = class {
};
__decorateClass([
  (0, import_class_validator11.IsNotEmpty)({ message: "Please enter target." }),
  (0, import_class_validator11.IsString)({ message: "Please enter valid target." })
], VerifyGuestOtpDto.prototype, "target", 2);
__decorateClass([
  (0, import_class_validator11.IsNotEmpty)({ message: "Please enter otp." }),
  (0, import_class_validator11.IsString)({ message: "Please enter valid otp." }),
  (0, import_class_validator11.Length)(4, 6, { message: "OTP must be between 4 and 6 characters" })
], VerifyGuestOtpDto.prototype, "otp", 2);
__decorateClass([
  (0, import_class_validator11.IsNotEmpty)({ message: "Please enter OTP purpose." }),
  (0, import_class_validator11.IsEnum)(VerifyGuestOtpPurposeEnum, {
    message: "Purpose must be a valid OTP purpose"
  })
], VerifyGuestOtpDto.prototype, "purpose", 2);

// src/modules/onboarding/pattern/pattern.ts
var ONBOARDING_PATTERN = {
  handleFreelancerAccountCreation: "handle.freelancer.account.creation",
  handleFreelancerResumeUpload: "handle.freelancer.resume.upload",
  handleFreelancerDeveloperPreference: "handle.freelancer.developer.preference",
  handleFreelancerProfileQuestion: "handle.freelancer.profile.question",
  handleFreelancerWorkShowcase: "handle.freelancer.work.showcase",
  handleClientAccountCreation: "handle.client.account.creation",
  handleClientProfileQuestion: "handle.client.profile.question",
  changeFreelancerPassword: "change.freelancer.password"
};

// src/modules/onboarding/dto/freelancer-create-account.dto.ts
var import_class_validator15 = require("class-validator");

// src/decorators/match.decorator.ts
var import_class_validator12 = require("class-validator");
function Match(property, validationOptions) {
  return function(object, propertyName) {
    (0, import_class_validator12.registerDecorator)({
      name: "Match",
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [property],
      validator: {
        validate(value, args) {
          const [relatedPropertyName] = args.constraints;
          const relatedValue = args.object[relatedPropertyName];
          return value === relatedValue;
        },
        defaultMessage(args) {
          const [relatedPropertyName] = args.constraints;
          return `${propertyName} must match ${relatedPropertyName}`;
        }
      }
    });
  };
}
var IfscOrOtherFieldsConstraint = class {
  validate(value, args) {
    const [relatedFields] = args.constraints;
    const dto = args.object;
    if (!value) {
      return relatedFields.some((field) => !!dto[field]);
    }
    return true;
  }
  defaultMessage(args) {
    const [relatedFields] = args.constraints;
    const fieldNames = relatedFields.join(", ");
    return `IFSC Code is required .`;
  }
};
IfscOrOtherFieldsConstraint = __decorateClass([
  (0, import_class_validator12.ValidatorConstraint)({ async: false })
], IfscOrOtherFieldsConstraint);

// src/decorators/is-valid-mobile-number.decorator.ts
var import_class_validator13 = require("class-validator");
var import_libphonenumber_js = require("libphonenumber-js");
var IsValidMobileNumberConstraint = class {
  validate(mobile, args) {
    const object = args.object;
    const mobileCode = object.mobileCode;
    if (!mobileCode || !mobile) return false;
    try {
      const phoneNumber = (0, import_libphonenumber_js.parsePhoneNumberFromString)(mobileCode + mobile);
      return phoneNumber?.isValid() ?? false;
    } catch {
      return false;
    }
  }
  defaultMessage(args) {
    return "Please enter a valid mobile number for the selected country code.";
  }
};
IsValidMobileNumberConstraint = __decorateClass([
  (0, import_class_validator13.ValidatorConstraint)({ name: "isValidMobileNumber", async: false })
], IsValidMobileNumberConstraint);
function IsValidMobileNumber(validationOptions) {
  return function(object, propertyName) {
    (0, import_class_validator13.registerDecorator)({
      name: "isValidMobileNumber",
      target: object.constructor,
      propertyName,
      options: validationOptions,
      validator: IsValidMobileNumberConstraint
    });
  };
}

// src/decorators/is-business-email.decorator.ts
var import_class_validator14 = require("class-validator");
var IsBusinessEmailConstraint = class {
  constructor() {
    this.blockedDomains = [
      "aol.com",
      "att.net",
      "comcast.net",
      "facebook.com",
      "gmail.com",
      "gmx.com",
      "gmx.net",
      "gmx.de",
      "googlemail.com",
      "google.com",
      "hotmail.com",
      "hotmail.co.uk",
      "icloud.com",
      "live.com",
      "live.in",
      "live.co.uk",
      "mail.com",
      "msn.com",
      "outlook.com",
      "protonmail.com",
      "protonmail.ch",
      "proton.me",
      "tutanota.com",
      "tutanota.de",
      "tutanota.org",
      "tuta.io",
      "yahoo.com",
      "yahoo.co.uk",
      "yahoo.co.in",
      "yahoo.co.jp",
      "yahoo.co.kr",
      "yahoo.co.id",
      "yahoo.com.sg",
      "yahoo.com.ph",
      "zoho.com",
      "yandex.com",
      "mail.ru",
      "fastmail.fm",
      "hushmail.com",
      "qq.com",
      "163.com",
      "126.com",
      "rediffmail.com",
      "naver.com",
      "daum.net",
      "seznam.cz",
      "web.de",
      "libero.it",
      "mailfence.com",
      "yopmail.com"
    ];
  }
  validate(value) {
    if (typeof value !== "string") return false;
    const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
    if (!emailRegex.test(value)) return false;
    const domain = value.split("@")[1].toLowerCase();
    return !this.blockedDomains.includes(domain);
  }
  defaultMessage(args) {
    return "Please enter a valid business email address. Personal email domains are not allowed.";
  }
};
IsBusinessEmailConstraint = __decorateClass([
  (0, import_class_validator14.ValidatorConstraint)({ async: false })
], IsBusinessEmailConstraint);
function IsBusinessEmail(validationOptions) {
  return function(object, propertyName) {
    (0, import_class_validator14.registerDecorator)({
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [],
      validator: IsBusinessEmailConstraint
    });
  };
}

// src/modules/onboarding/dto/freelancer-create-account.dto.ts
var FreelancerCreateAccountDto = class {
};
__decorateClass([
  (0, import_class_validator15.IsNotEmpty)({ message: "Please enter full name." }),
  (0, import_class_validator15.IsString)({ message: "Please enter valid full name." })
], FreelancerCreateAccountDto.prototype, "fullName", 2);
__decorateClass([
  (0, import_class_validator15.IsNotEmpty)({ message: "Please enter email." }),
  (0, import_class_validator15.IsEmail)()
], FreelancerCreateAccountDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator15.IsNotEmpty)({ message: "Please enter mobile code." }),
  (0, import_class_validator15.Matches)(/^\+\d{1,4}$/, {
    message: "Please enter a valid country mobile code (e.g., +91, +1, +44)."
  })
], FreelancerCreateAccountDto.prototype, "mobileCode", 2);
__decorateClass([
  (0, import_class_validator15.IsNotEmpty)({ message: "Please enter mobile number." }),
  IsValidMobileNumber({ message: "Mobile number is not valid for the selected country code." })
], FreelancerCreateAccountDto.prototype, "mobile", 2);
__decorateClass([
  (0, import_class_validator15.IsOptional)()
], FreelancerCreateAccountDto.prototype, "onBoardedBy", 2);

// src/modules/onboarding/dto/freelancer-upload-resume.dto.ts
var import_class_validator16 = require("class-validator");
var FreelancerUploadResumeDto = class {
};
__decorateClass([
  (0, import_class_validator16.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator16.IsUUID)()
], FreelancerUploadResumeDto.prototype, "uuid", 2);

// src/modules/onboarding/dto/freelancer-parse-resume.dto.ts
var import_class_validator17 = require("class-validator");
var FreelancerParseResumeDto = class {
};
__decorateClass([
  (0, import_class_validator17.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator17.IsUUID)()
], FreelancerParseResumeDto.prototype, "uuid", 2);

// src/modules/onboarding/dto/freelancer-initiate-mcq-assessment.dto.ts
var import_class_validator18 = require("class-validator");
var FreelancerInitiateMcqAssessmentDto = class {
};
__decorateClass([
  (0, import_class_validator18.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator18.IsUUID)()
], FreelancerInitiateMcqAssessmentDto.prototype, "uuid", 2);

// src/modules/onboarding/dto/freelancer-skip-ai-assessment.dto.ts
var import_class_validator19 = require("class-validator");
var FreelancerSkipAiAssessmentDto = class {
};
__decorateClass([
  (0, import_class_validator19.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator19.IsUUID)()
], FreelancerSkipAiAssessmentDto.prototype, "uuid", 2);

// src/modules/onboarding/dto/freelancer-initiate-ai-assessment.dto.ts
var import_class_validator20 = require("class-validator");
var FreelancerInitiateAiAssessmentDto = class {
};
__decorateClass([
  (0, import_class_validator20.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator20.IsUUID)()
], FreelancerInitiateAiAssessmentDto.prototype, "uuid", 2);

// src/modules/onboarding/dto/freelancer-capture-ai-assessment-status.dto.ts
var import_class_validator21 = require("class-validator");
var FreelancerCaptureAiAssessmentStatusDto = class {
};
__decorateClass([
  (0, import_class_validator21.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator21.IsUUID)()
], FreelancerCaptureAiAssessmentStatusDto.prototype, "uuid", 2);
__decorateClass([
  (0, import_class_validator21.IsNotEmpty)({ message: "Please enter assessment id." })
], FreelancerCaptureAiAssessmentStatusDto.prototype, "assessmentId", 2);
__decorateClass([
  (0, import_class_validator21.IsNotEmpty)({ message: "Please enter assessment status." })
], FreelancerCaptureAiAssessmentStatusDto.prototype, "assessmentStatus", 2);
__decorateClass([
  (0, import_class_validator21.IsOptional)()
], FreelancerCaptureAiAssessmentStatusDto.prototype, "iframeEventData", 2);

// src/modules/onboarding/dto/freelancer-development-preference.dto.ts
var import_class_validator22 = require("class-validator");
var FreelancerDevelopmentPreferenceDto = class {
};
__decorateClass([
  (0, import_class_validator22.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator22.IsUUID)()
], FreelancerDevelopmentPreferenceDto.prototype, "uuid", 2);
__decorateClass([
  (0, import_class_validator22.IsNotEmpty)({ message: "Please select development flag." }),
  (0, import_class_validator22.IsBoolean)()
], FreelancerDevelopmentPreferenceDto.prototype, "developer", 2);

// src/modules/onboarding/dto/freelancer-profile-question.dto.ts
var import_class_validator23 = require("class-validator");
var FreelancerProfileQuestionDto = class {
};
__decorateClass([
  (0, import_class_validator23.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator23.IsUUID)()
], FreelancerProfileQuestionDto.prototype, "uuid", 2);
__decorateClass([
  (0, import_class_validator23.IsNotEmpty)({ message: "Please enter question slug." }),
  (0, import_class_validator23.IsString)(),
  (0, import_class_validator23.IsIn)([
    "natureOfWork",
    "expectedHourlyCompensation",
    "modeOfWork",
    "availabilityToJoin",
    "isImmediateJoiner"
  ])
], FreelancerProfileQuestionDto.prototype, "question_slug", 2);
__decorateClass([
  (0, import_class_validator23.IsNotEmpty)({ message: "Please enter answer." })
], FreelancerProfileQuestionDto.prototype, "answer", 2);
__decorateClass([
  (0, import_class_validator23.IsOptional)()
], FreelancerProfileQuestionDto.prototype, "currency", 2);

// src/modules/onboarding/dto/freelancer-work-showcase.dto.ts
var import_class_validator24 = require("class-validator");
var FreelancerWorkShowcaseDto = class {
};
__decorateClass([
  (0, import_class_validator24.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator24.IsUUID)()
], FreelancerWorkShowcaseDto.prototype, "uuid", 2);
__decorateClass([
  (0, import_class_validator24.IsNotEmpty)({ message: "Please enter likedin profile url." }),
  (0, import_class_validator24.IsString)(),
  (0, import_class_validator24.IsUrl)(
    { require_protocol: false },
    {
      message: "linkedinProfileLink must be a valid URL with protocol (e.g. https://)"
    }
  )
], FreelancerWorkShowcaseDto.prototype, "linkedinProfileLink", 2);
__decorateClass([
  (0, import_class_validator24.IsOptional)(),
  (0, import_class_validator24.IsUrl)(
    { require_protocol: false },
    {
      message: "kaggleProfileLink must be a valid URL with protocol (e.g. https://)"
    }
  )
], FreelancerWorkShowcaseDto.prototype, "kaggleProfileLink", 2);
__decorateClass([
  (0, import_class_validator24.IsOptional)(),
  (0, import_class_validator24.IsUrl)(
    { require_protocol: false },
    {
      message: "githubProfileLink must be a valid URL with protocol (e.g. https://)"
    }
  )
], FreelancerWorkShowcaseDto.prototype, "githubProfileLink", 2);
__decorateClass([
  (0, import_class_validator24.IsOptional)(),
  (0, import_class_validator24.IsUrl)(
    { require_protocol: false },
    {
      message: "stackOverflowProfileLink must be a valid URL with protocol (e.g. https://)"
    }
  )
], FreelancerWorkShowcaseDto.prototype, "stackOverflowProfileLink", 2);
__decorateClass([
  (0, import_class_validator24.IsOptional)(),
  (0, import_class_validator24.IsUrl)(
    { require_protocol: false },
    {
      message: "portfolioLink must be a valid URL with protocol (e.g. https://)"
    }
  )
], FreelancerWorkShowcaseDto.prototype, "portfolioLink", 2);

// src/modules/onboarding/dto/client-profile-question.dto.ts
var import_class_validator25 = require("class-validator");
var ClientProfileQuestionDto = class {
};
__decorateClass([
  (0, import_class_validator25.IsNotEmpty)({ message: "Please enter uuid." }),
  (0, import_class_validator25.IsUUID)()
], ClientProfileQuestionDto.prototype, "uuid", 2);
__decorateClass([
  (0, import_class_validator25.IsNotEmpty)({ message: "Please enter question slug." }),
  (0, import_class_validator25.IsString)(),
  (0, import_class_validator25.IsIn)([
    "skills",
    "requiredFreelancer",
    "kindOfHiring",
    "modeOfHire",
    "foundUsOn"
  ])
], ClientProfileQuestionDto.prototype, "question_slug", 2);
__decorateClass([
  (0, import_class_validator25.IsNotEmpty)({ message: "Please enter answer." })
], ClientProfileQuestionDto.prototype, "answer", 2);
__decorateClass([
  (0, import_class_validator25.ValidateIf)((o) => o.questionSlug === "foundUsOn" && o.answer === "OTHER"),
  (0, import_class_validator25.IsNotEmpty)({ message: "Please enter foundUsOnDetail if answer is OTHER." }),
  (0, import_class_validator25.IsString)()
], ClientProfileQuestionDto.prototype, "foundUsOnDetail", 2);

// src/modules/onboarding/dto/client-create-account.dto.ts
var import_class_validator26 = require("class-validator");
var ClientCreateAccountDto = class {
};
__decorateClass([
  (0, import_class_validator26.IsNotEmpty)({ message: "Please enter full name." }),
  (0, import_class_validator26.IsString)({ message: "Please enter valid full name." })
], ClientCreateAccountDto.prototype, "fullName", 2);
__decorateClass([
  (0, import_class_validator26.IsNotEmpty)({ message: "Please enter email." }),
  (0, import_class_validator26.IsEmail)(),
  IsBusinessEmail()
], ClientCreateAccountDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator26.IsNotEmpty)({ message: "Please enter company name." }),
  (0, import_class_validator26.IsString)({ message: "Please enter valid company name." })
], ClientCreateAccountDto.prototype, "companyName", 2);
__decorateClass([
  (0, import_class_validator26.IsOptional)()
], ClientCreateAccountDto.prototype, "onBoardedBy", 2);

// src/modules/resume-parser/pattern/pattern.ts
var RESUME_PARSER_PATTERN = {
  handleResumeParsing: "handle.resume.parsing"
};

// src/modules/user/subadmin/pattern/pattern.ts
var SUBADMIN_PATTERN = {
  fetchSubAdmins: "fetch.subadmins",
  fetchDeletedSubAdmins: "fetch.deleted.subadmins",
  fetchSubAdminDropdown: "fetch.subadmin.dropdown",
  findSubAdminById: "fetch.subadmin.by.id",
  createSubAdmin: "create.subadmin",
  updateSubAdminAccountStatus: "update.subadmin.account.status",
  updateSubAdmin: "update.subadmin",
  deleteSubAdmin: "delete.subadmin"
};

// src/modules/user/subadmin/dto/create-subadmin.dto.ts
var import_class_validator27 = require("class-validator");
var CreateSubAdminDto = class {
};
__decorateClass([
  (0, import_class_validator27.IsNotEmpty)({ message: "Please enter username." })
], CreateSubAdminDto.prototype, "userName", 2);
__decorateClass([
  (0, import_class_validator27.IsNotEmpty)({ message: "Please enter first name." })
], CreateSubAdminDto.prototype, "firstName", 2);
__decorateClass([
  (0, import_class_validator27.IsNotEmpty)({ message: "Please enter last name." })
], CreateSubAdminDto.prototype, "lastName", 2);
__decorateClass([
  (0, import_class_validator27.IsNotEmpty)({ message: "Please enter email." })
], CreateSubAdminDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator27.IsNotEmpty)({ message: "Please enter mobile Code." })
], CreateSubAdminDto.prototype, "mobileCode", 2);
__decorateClass([
  (0, import_class_validator27.IsNotEmpty)({ message: "Please enter mobile number." })
], CreateSubAdminDto.prototype, "mobile", 2);
__decorateClass([
  (0, import_class_validator27.IsNotEmpty)({ message: "Please enter the password." })
], CreateSubAdminDto.prototype, "password", 2);
__decorateClass([
  (0, import_class_validator27.IsNotEmpty)({ message: "Please Select Roles." })
], CreateSubAdminDto.prototype, "roleIds", 2);

// src/modules/user/subadmin/dto/update-subadmin-status.dto.ts
var import_class_validator28 = require("class-validator");
var UpdateSubAdminAccountStatusDto = class {
};
__decorateClass([
  (0, import_class_validator28.IsString)()
], UpdateSubAdminAccountStatusDto.prototype, "accountStatus", 2);

// src/modules/user/subadmin/dto/update-subadmin.dto.ts
var import_class_transformer = require("class-transformer");
var import_class_validator29 = require("class-validator");
var UpdateSubAdminDto = class {
};
__decorateClass([
  (0, import_class_validator29.IsNotEmpty)({ message: "Please enter username." })
], UpdateSubAdminDto.prototype, "userName", 2);
__decorateClass([
  (0, import_class_validator29.IsNotEmpty)({ message: "Please enter first name." })
], UpdateSubAdminDto.prototype, "firstName", 2);
__decorateClass([
  (0, import_class_validator29.IsNotEmpty)({ message: "Please enter last name." })
], UpdateSubAdminDto.prototype, "lastName", 2);
__decorateClass([
  (0, import_class_validator29.IsNotEmpty)({ message: "Please enter email." })
], UpdateSubAdminDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator29.IsNotEmpty)({ message: "Please enter mobile Code." })
], UpdateSubAdminDto.prototype, "mobileCode", 2);
__decorateClass([
  (0, import_class_validator29.IsNotEmpty)({ message: "Please enter mobile number." })
], UpdateSubAdminDto.prototype, "mobile", 2);
__decorateClass([
  (0, import_class_validator29.IsOptional)(),
  (0, import_class_transformer.Transform)(({ value }) => value === null || value === "" ? void 0 : value),
  (0, import_class_validator29.MinLength)(6, { message: "Password must be at least 6 characters." }),
  (0, import_class_validator29.MaxLength)(32, { message: "Password must not exceed 32 characters." }),
  (0, import_class_validator29.Matches)(/^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])/, {
    message: "Password must include letters, numbers and symbols."
  })
], UpdateSubAdminDto.prototype, "password", 2);
__decorateClass([
  (0, import_class_validator29.IsNotEmpty)({ message: "Please Select Roles." })
], UpdateSubAdminDto.prototype, "roleIds", 2);

// src/modules/user/client-profile/pattern/pattern.ts
var CLIENT_PROFILE_PATTERN = {
  fetchClientProfile: "fetch.client.profile",
  fetchClientPublicProfile: "fetch.client.public.profile",
  updateClientProfile: "update.client.profile",
  updateClientLogo: "update.client.logo",
  changeClientPassword: "change.client.password",
  uploadClientServiceAgreement: "upload.client.service.agreement"
};

// src/modules/user/client-profile/dto/update-client-profile.dto.ts
var import_class_validator30 = require("class-validator");
var UpdateCompanyProfileDto = class {
};
__decorateClass([
  (0, import_class_validator30.IsNotEmpty)({ message: "Please enter company name." }),
  (0, import_class_validator30.IsString)({ message: "Company name must be a string." }),
  (0, import_class_validator30.Length)(2, 255, {
    message: "Company name must be between 2 and 255 characters"
  })
], UpdateCompanyProfileDto.prototype, "companyName", 2);
__decorateClass([
  (0, import_class_validator30.IsOptional)(),
  (0, import_class_validator30.ValidateIf)((o) => o.webSite !== ""),
  (0, import_class_validator30.IsUrl)({}, { message: "Invalid website URL format" })
], UpdateCompanyProfileDto.prototype, "webSite", 2);
__decorateClass([
  (0, import_class_validator30.IsNotEmpty)({ message: "Please enter company address." }),
  (0, import_class_validator30.IsString)({ message: "Company address must be a string" }),
  (0, import_class_validator30.Length)(5, 1e3, { message: "Address must be between 5 and 1000 characters" })
], UpdateCompanyProfileDto.prototype, "companyAddress", 2);
__decorateClass([
  (0, import_class_validator30.IsNotEmpty)({ message: "Please enter mobile code." }),
  (0, import_class_validator30.IsString)({ message: "Mobile Code must be a string" })
], UpdateCompanyProfileDto.prototype, "mobileCode", 2);
// @Matches(/^(\+1\s?)?(\(?\d{3}\)?[\s.-]?)?\d{3}[\s.-]?\d{4}$/, {
//   message: "Please enter a valid US phone number",
// })
__decorateClass([
  (0, import_class_validator30.IsNotEmpty)({ message: "Please enter phone number." }),
  (0, import_class_validator30.IsString)({ message: "Please enter valid phone number." })
], UpdateCompanyProfileDto.prototype, "phoneNumber", 2);
__decorateClass([
  (0, import_class_validator30.IsNotEmpty)({ message: "Please enter email." }),
  (0, import_class_validator30.IsEmail)()
], UpdateCompanyProfileDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator30.IsOptional)(),
  (0, import_class_validator30.IsString)({ message: "About company must be a string." })
], UpdateCompanyProfileDto.prototype, "aboutCompany", 2);

// src/modules/user/client-profile/dto/client-change-password.dto.ts
var import_class_validator31 = require("class-validator");
var ClientChangePasswordDto = class {
};
__decorateClass([
  (0, import_class_validator31.IsString)(),
  (0, import_class_validator31.MinLength)(8, { message: "Password must be at least 8 characters long." }),
  (0, import_class_validator31.Matches)(/^(?=.*[A-Z])(?=.*\d).+$/, {
    message: "Password must contain at least one uppercase letter and one number."
  })
], ClientChangePasswordDto.prototype, "newPassword", 2);
__decorateClass([
  (0, import_class_validator31.IsNotEmpty)({ message: "Please enter confirm password." }),
  Match("newPassword", { message: "Passwords do not match" })
], ClientChangePasswordDto.prototype, "confirmPassword", 2);

// src/modules/question/pattern/pattern.ts
var ONBOARDING_QUESTION_PATTERN = {
  fetchOnboardingQuestions: "fetch.onboarding.questions"
};
var ASSESSMENT_QUESTION_PATTERN = {
  fetchAssessmentQuestions: "fetch.assessment.questions"
};

// src/modules/question/dto/create-question.dto.ts
var import_class_validator32 = require("class-validator");
var CreateQuestionDto = class {
};
__decorateClass([
  (0, import_class_validator32.IsNotEmpty)({ message: "Please enter unique id." })
], CreateQuestionDto.prototype, "questionId", 2);
__decorateClass([
  (0, import_class_validator32.IsNotEmpty)({ message: "Please enter question." })
], CreateQuestionDto.prototype, "question", 2);
__decorateClass([
  (0, import_class_validator32.IsNotEmpty)({ message: "Please enter for whom the question is." })
], CreateQuestionDto.prototype, "questionFor", 2);
__decorateClass([
  (0, import_class_validator32.IsNotEmpty)({ message: "Please enter options." })
], CreateQuestionDto.prototype, "options", 2);
__decorateClass([
  (0, import_class_validator32.IsOptional)(),
  (0, import_class_validator32.IsBoolean)({ message: "Whether the question status active" })
], CreateQuestionDto.prototype, "isActive", 2);

// src/modules/job/pattern/pattern.ts
var JOB_ROLE_PATTERN = {
  fetchJobRolesForDropdown: "fetch.job.roles.for.dropdown"
};
var JOB_PATTERN = {
  fetchJobs: "fetch.jobs",
  fetchJobsPublic: "fetch.jobs.public",
  fetchRecentJobs: "fetch.recent.jobs",
  fetchJobCountAsPerStatus: "fetch.job.count.as.per.status",
  fetchJobCountPublic: "fetch.job.count.public",
  fetchJobsDropdown: "fetch.jobs.dropdown",
  fetchJobDetail: "fetch.job.details",
  fetchJobDetailPublic: "fetch.job.details.public",
  handleJdUpload: "handle.jd.upload",
  fetchJobBasicInformation: "fetch.job.basic.information",
  createJobBasicInformation: "create.job.basic.information",
  updateJobBasicInformation: "update.job.basic.information",
  fetchJobAdditionalComments: "fetch.job.additional.comments",
  updateJobAdditionalComments: "update.job.additional.comments",
  fetchJobDescription: "fetch.job.description",
  updateJobDescription: "update.job.description",
  updateJobStatus: "update.job.status",
  searchJobsByRoleAndSkills: "search.jobs.by.role.and.skills"
};

// src/modules/job/dto/job-basic-information.dto.ts
var import_class_validator33 = require("class-validator");
var import_class_transformer2 = require("class-transformer");
var JobLocation = /* @__PURE__ */ ((JobLocation2) => {
  JobLocation2["ONSITE"] = "ONSITE";
  JobLocation2["REMOTE"] = "REMOTE";
  JobLocation2["BOTH"] = "BOTH";
  return JobLocation2;
})(JobLocation || {});
var EmploymentType = /* @__PURE__ */ ((EmploymentType2) => {
  EmploymentType2["FULLTIME"] = "FULLTIME";
  EmploymentType2["PARTTIME"] = "PARTTIME";
  EmploymentType2["BOTH"] = "BOTH";
  return EmploymentType2;
})(EmploymentType || {});
var JobBasicInformationDto = class {
  constructor() {
    this.isDraft = false;
  }
};
__decorateClass([
  (0, import_class_validator33.IsOptional)(),
  (0, import_class_transformer2.Type)(() => Boolean)
], JobBasicInformationDto.prototype, "isDraft", 2);
__decorateClass([
  (0, import_class_validator33.IsNotEmpty)({ message: "Please enter job role" }),
  (0, import_class_validator33.IsString)({ message: "Job role must be a string" })
], JobBasicInformationDto.prototype, "jobRole", 2);
__decorateClass([
  (0, import_class_validator33.IsOptional)(),
  (0, import_class_validator33.IsString)({ message: "Note must be a string" })
], JobBasicInformationDto.prototype, "note", 2);
__decorateClass([
  (0, import_class_validator33.ValidateIf)((o) => !o.isDraft),
  (0, import_class_validator33.IsArray)({ message: "Skills must be an array" }),
  (0, import_class_validato