@experts_hub/shared/dist/index.js

Shared DTOs, interfaces, and utilities for experts hub applications

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
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,
  AI_INTERVIEW_PATTERN: () => AI_INTERVIEW_PATTERN,
  ASSESSMENT_QUESTION_PATTERN: () => ASSESSMENT_QUESTION_PATTERN,
  AUTHENTICATION_PATTERN: () => AUTHENTICATION_PATTERN,
  AccountStatus: () => AccountStatus,
  AccountType: () => AccountType2,
  AddClientRemarkDto: () => AddClientRemarkDto,
  AddGlobalSettingDto: () => AddGlobalSettingDto,
  AddTaskLogTimeDto: () => AddTaskLogTimeDto,
  AddTaskQueryReplyDto: () => AddTaskQueryReplyDto,
  AddTopupEscrowAmountDto: () => AddTopupEscrowAmountDto,
  AddVendorApiConfigurationDto: () => AddVendorApiConfigurationDto,
  AdminCreateJobInformationDto: () => AdminCreateJobInformationDto,
  AdminExportClientV2OptimisedDto: () => AdminExportClientV2OptimisedDto,
  AdminExportFreelancerV2OptimisedDto: () => AdminExportFreelancerV2OptimisedDto,
  AdminFreelancerCreateAccountDto: () => AdminFreelancerCreateAccountDto,
  AdminJobBasicInformationV2Dto: () => AdminJobBasicInformationV2Dto,
  AdminPermission: () => AdminPermission,
  AdminRole: () => AdminRole,
  AdminRolePermission: () => AdminRolePermission,
  AdminUpdateJobInformationDto: () => AdminUpdateJobInformationDto,
  AdminUserRole: () => AdminUserRole,
  AiAssessmentCreationDto: () => AiAssessmentCreationDto,
  AiAssessmentStatusEnum: () => AiAssessmentStatusEnum,
  AiInterview: () => AiInterview,
  AiInterviewLinkGenerationDto: () => AiInterviewLinkGenerationDto,
  AiInterviewQuestionGenerateDto: () => AiInterviewQuestionGenerateDto,
  AiInterviewRescheduleRequest: () => AiInterviewRescheduleRequest,
  AiInterviewRescheduleRequestStatusEnum: () => AiInterviewRescheduleRequestStatusEnum,
  AiInterviewStatusEnum: () => AiInterviewStatusEnum,
  AiInterviewTemplateGenerationDto: () => AiInterviewTemplateGenerationDto,
  AiQuestionItemDto: () => AiQuestionItemDto,
  AlertBuilder: () => AlertBuilder,
  AlertCategory: () => AlertCategory,
  AlertSeverity: () => AlertSeverity,
  AnswerTypeEnum: () => AnswerTypeEnum,
  ApplicationStatusEnum: () => ApplicationStatusEnum,
  ApproveTimesheetsDto: () => ApproveTimesheetsDto,
  ArchiveSubmissionDto: () => ArchiveSubmissionDto,
  AssessmentAnswer: () => AssessmentAnswer,
  AssessmentRequestStatusEnum: () => AssessmentRequestStatusEnum,
  AssessmentStatusEnum: () => AssessmentStatusEnum,
  AssessmetQuestion: () => AssessmetQuestion,
  AssessmetQuestionOption: () => AssessmetQuestionOption,
  AttachPermissionsToRoleDto: () => AttachPermissionsToRoleDto,
  BANK_PATTERN: () => BANK_PATTERN,
  BankAccountScopeEnum: () => BankAccountScopeEnum,
  BankAccountTypeEnum: () => BankAccountTypeEnum,
  BankDetail: () => BankDetail,
  BaseEntity: () => BaseEntity,
  BillingCycleEnum: () => BillingCycleEnum,
  CALENDLY_PATTERN: () => CALENDLY_PATTERN,
  CITY_PATTERN: () => CITY_PATTERN,
  CLIENT_ADMIN_PATTERNS: () => CLIENT_ADMIN_PATTERNS,
  CLIENT_CANDIDATE_PREFERENCE_PATTERN: () => CLIENT_CANDIDATE_PREFERENCE_PATTERN,
  CLIENT_PROFILE_PATTERN: () => CLIENT_PROFILE_PATTERN,
  CMS_PATTERNS: () => CMS_PATTERNS,
  COMMISSION_PATTERN: () => COMMISSION_PATTERN,
  COMPANY_MEMBERS_PATTERNS: () => COMPANY_MEMBERS_PATTERNS,
  COMPANY_ROLES_PATTERNS: () => COMPANY_ROLES_PATTERNS,
  CONTRACT_PATTERN: () => CONTRACT_PATTERN,
  COUNTRY_PATTERN: () => COUNTRY_PATTERN,
  CalendlyMeetingLog: () => CalendlyMeetingLog,
  CaptureAiAssessmentResultDto: () => CaptureAiAssessmentResultDto,
  CaptureAiInterviewResultPublicDto: () => CaptureAiInterviewResultPublicDto,
  CaseStudyDto: () => CaseStudyDto,
  CategoryEmum: () => CategoryEmum,
  ChangeJobApplicationStatusBulkDto: () => ChangeJobApplicationStatusBulkDto,
  ChangeJobApplicationStatusDto: () => ChangeJobApplicationStatusDto,
  ChatRMQAdapter: () => ChatRMQAdapter,
  ChatTCPAdapter: () => ChatTCPAdapter,
  CheckResumeEligibilityDto: () => CheckResumeEligibilityDto,
  City: () => City,
  ClientAddFundDto: () => ClientAddFundDto,
  ClientCandidatePreference: () => ClientCandidatePreference,
  ClientCandidatePreferenceEnum: () => ClientCandidatePreferenceEnum,
  ClientChangePasswordDto: () => ClientChangePasswordDto,
  ClientCreateAccountDto: () => ClientCreateAccountDto,
  ClientESignatureDto: () => ClientESignatureDto,
  ClientFreelancerRecommendation: () => ClientFreelancerRecommendation,
  ClientProfileQuestionDto: () => ClientProfileQuestionDto,
  ClientServiceAgreementUploadDto: () => ClientServiceAgreementUploadDto,
  CloseJobDto: () => CloseJobDto,
  Cms: () => Cms,
  Commission: () => Commission,
  CommissionTypeEnum: () => CommissionTypeEnum,
  CompanyMember: () => CompanyMember,
  CompanyMemberRole: () => CompanyMemberRole,
  CompanyOnboardingStepEnum: () => CompanyOnboardingStepEnum,
  CompanyProfile: () => CompanyProfile,
  CompanyRole: () => CompanyRole,
  CompanyRolePermission: () => CompanyRolePermission,
  CompanySkill: () => CompanySkill,
  ContactDetailsDto: () => ContactDetailsDto,
  Contract: () => Contract,
  ContractRMQAdapter: () => ContractRMQAdapter,
  ContractStatusEnum: () => ContractStatusEnum,
  ContractSummary: () => ContractSummary,
  ContractSummaryPreferredEngagementTypeEnum: () => ContractSummaryPreferredEngagementTypeEnum,
  ContractSummaryStatusEnum: () => ContractSummaryStatusEnum,
  ContractTCPAdapter: () => ContractTCPAdapter,
  ContractTypeEnum: () => ContractTypeEnum,
  Country: () => Country,
  CreateAIInterviewRescheduleRequestDto: () => CreateAIInterviewRescheduleRequestDto,
  CreateAdminRoleDto: () => CreateAdminRoleDto,
  CreateCheckoutSessionDto: () => CreateCheckoutSessionDto,
  CreateClientDto: () => CreateClientDto,
  CreateCmsDto: () => CreateCmsDto,
  CreateCompanyMemberDto: () => CreateCompanyMemberDto,
  CreateCompanyRoleDto: () => CreateCompanyRoleDto,
  CreateDefaultTimesheetLineDto: () => CreateDefaultTimesheetLineDto,
  CreateDisputeDto: () => CreateDisputeDto,
  CreateEkycSessionDto: () => CreateEkycSessionDto,
  CreateF2FInterviewDirectDto: () => CreateF2FInterviewDirectDto,
  CreateF2FInterviewDto: () => CreateF2FInterviewDto,
  CreateF2FInterviewRescheduleRequestDto: () => CreateF2FInterviewRescheduleRequestDto,
  CreateFreelancerDto: () => CreateFreelancerDto,
  CreateFreelancerTimesheetDto: () => CreateFreelancerTimesheetDto,
  CreateHiringDto: () => CreateHiringDto,
  CreateInAppNotificationDto: () => CreateInAppNotificationDto,
  CreateInterviewBasicInformationDto: () => CreateInterviewBasicInformationDto,
  CreateInterviewQuestionsDto: () => CreateInterviewQuestionsDto,
  CreateInterviewSkillsDto: () => CreateInterviewSkillsDto,
  CreateInvoiceDto: () => CreateInvoiceDto,
  CreateJobApplicationDto: () => CreateJobApplicationDto,
  CreateJobAsIsDto: () => CreateJobAsIsDto,
  CreateJobViaAIDto: () => CreateJobViaAIDto,
  CreateLeadDto: () => CreateLeadDto,
  CreateQuestionDto: () => CreateQuestionDto,
  CreateRatingDto: () => CreateRatingDto,
  CreateSubAdminDto: () => CreateSubAdminDto,
  CreateTaskDto: () => CreateTaskDto,
  CreateTaskQueryDto: () => CreateTaskQueryDto,
  CreateUserSigningDto: () => CreateUserSigningDto,
  CustomQuestionItemDto: () => CustomQuestionItemDto,
  DIDIT_PATTERN: () => DIDIT_PATTERN,
  DISPUTE_PATTERN: () => DISPUTE_PATTERN,
  DOCUSEAL_PATTERN: () => DOCUSEAL_PATTERN,
  DebitCommissionFteHiringDto: () => DebitCommissionFteHiringDto,
  DiscordAlertService: () => DiscordAlertService,
  DiscordTransport: () => DiscordTransport,
  Dispute: () => Dispute,
  DisputeStatusEnum: () => DisputeStatusEnum,
  DocuSeal: () => DocuSeal,
  DocuSealMessageDto: () => DocuSealMessageDto,
  DocuSealSubmitterDto: () => DocuSealSubmitterDto,
  DocuSealTypeEnum: () => DocuSealTypeEnum,
  DocumentType: () => DocumentType,
  DurationTypeEnum: () => DurationTypeEnum,
  EMAIL_PATTERN: () => EMAIL_PATTERN,
  EducationDto: () => EducationDto,
  EkycVerificationLog: () => EkycVerificationLog,
  EkycVerificationLogStatusEnum: () => EkycVerificationLogStatusEnum,
  EkycVerificationSession: () => EkycVerificationSession,
  EkycVerificationSessionStatusEnum: () => EkycVerificationSessionStatusEnum,
  EscrowFundContractDto: () => EscrowFundContractDto,
  EscrowWallet: () => EscrowWallet,
  EscrowWalletTransaction: () => EscrowWalletTransaction,
  EscrowWalletTransactionForEnum: () => EscrowWalletTransactionForEnum,
  EscrowWalletTransactionTypeEnum: () => EscrowWalletTransactionTypeEnum,
  EsignContractClientDto: () => EsignContractClientDto,
  EsignContractFreelancerDto: () => EsignContractFreelancerDto,
  ExistingCandidateDto: () => ExistingCandidateDto2,
  ExpectedDetailsDto: () => ExpectedDetailsDto,
  ExperienceDto: () => ExperienceDto,
  F2FInterview: () => F2FInterview,
  F2FInterviewSchedule: () => F2FInterviewSchedule,
  F2F_INTERVIEW_PATTERN: () => F2F_INTERVIEW_PATTERN,
  F2fInterviewRescheduleRequest: () => F2fInterviewRescheduleRequest,
  F2fInterviewRescheduleRequestStatusEnum: () => F2fInterviewRescheduleRequestStatusEnum,
  F2fInterviewScheduleStatusEnum: () => F2fInterviewScheduleStatusEnum,
  F2fInterviewStatusEnum: () => F2fInterviewStatusEnum,
  FREELANCER_ASSESSMENT_REQUEST_PATTERN: () => FREELANCER_ASSESSMENT_REQUEST_PATTERN,
  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,
  FetchClientInfoForChatDto: () => FetchClientInfoForChatDto,
  FetchFreelancerInfoForChatDto: () => FetchFreelancerInfoForChatDto,
  ForgotPasswordDto: () => ForgotPasswordDto,
  FreelancerAssessment: () => FreelancerAssessment,
  FreelancerAssessmentRequest: () => FreelancerAssessmentRequest,
  FreelancerBankDetailsDto: () => FreelancerBankDetailsDto,
  FreelancerCaptureAiAssessmentStatusDto: () => FreelancerCaptureAiAssessmentStatusDto,
  FreelancerCaseStudy: () => FreelancerCaseStudy,
  FreelancerChangePasswordDto: () => FreelancerChangePasswordDto,
  FreelancerCreateAccountDto: () => FreelancerCreateAccountDto,
  FreelancerDeclaration: () => FreelancerDeclaration,
  FreelancerDeclarationDto: () => FreelancerDeclarationDto,
  FreelancerDevelopmentPreferenceDto: () => FreelancerDevelopmentPreferenceDto,
  FreelancerESignatureDto: () => FreelancerESignatureDto,
  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,
  FreelancerSkillCategoryEnum: () => FreelancerSkillCategoryEnum,
  FreelancerSkillDto: () => FreelancerSkillDto,
  FreelancerSkipAiAssessmentDto: () => FreelancerSkipAiAssessmentDto,
  FreelancerTool: () => FreelancerTool,
  FreelancerUploadResumeDto: () => FreelancerUploadResumeDto,
  FreelancerWorkShowcaseDto: () => FreelancerWorkShowcaseDto,
  FromUsOn: () => FromUsOn,
  GLOBAL_SETTING_PATTERN: () => GLOBAL_SETTING_PATTERN,
  GenerateContractDto: () => GenerateContractDto,
  GetSubmissionDto: () => GetSubmissionDto,
  GetSubmitterDto: () => GetSubmitterDto,
  GetTemplateDto: () => GetTemplateDto,
  GlobalSetting: () => GlobalSetting,
  HIRING_PATTERN: () => HIRING_PATTERN,
  HiredFreelancerNatureOfWorkEnum: () => HiredFreelancerNatureOfWorkEnum,
  Hiring: () => Hiring,
  HiringCommissionTypeEnum: () => HiringCommissionTypeEnum,
  INTERVIEW_INVITE_PATTERN: () => INTERVIEW_INVITE_PATTERN,
  INTERVIEW_PATTERN: () => INTERVIEW_PATTERN,
  INVOICE_PATTERN: () => INVOICE_PATTERN,
  IN_APP_NOTIFICATION_PATTERN: () => IN_APP_NOTIFICATION_PATTERN,
  InAppNotification: () => InAppNotification,
  InitiatorTypeEnum: () => InitiatorTypeEnum,
  Interview: () => Interview,
  InterviewInvite: () => InterviewInvite,
  InterviewInviteDto: () => InterviewInviteDto,
  InterviewInviteStatusEnum: () => InterviewInviteStatusEnum,
  InterviewQuestion: () => InterviewQuestion,
  InterviewQuestionType: () => InterviewQuestionType,
  InterviewSkill: () => InterviewSkill,
  InterviewSkillItemDto: () => InterviewSkillItemDto,
  InterviewStatusEnum: () => InterviewStatusEnum,
  Invoice: () => Invoice,
  InvoicePaymentStatusEnum: () => InvoicePaymentStatusEnum,
  InvoiceStatusEnum: () => InvoiceStatusEnum,
  InvoiceTypeEnum: () => InvoiceTypeEnum,
  JOB_APPLICATION_PATTERN: () => JOB_APPLICATION_PATTERN,
  JOB_PATTERN: () => JOB_PATTERN,
  JOB_ROLE_PATTERN: () => JOB_ROLE_PATTERN,
  Job: () => Job,
  JobAdditionalCommentDto: () => JobAdditionalCommentDto,
  JobApplication: () => JobApplication,
  JobApplicationStatus: () => JobApplicationStatus,
  JobBasicInformationDto: () => JobBasicInformationDto,
  JobBasicInformationV2Dto: () => JobBasicInformationV2Dto,
  JobDescriptionDto: () => JobDescriptionDto,
  JobFreelancerRecommendation: () => JobFreelancerRecommendation,
  JobFreelancerRecommendationV2: () => JobFreelancerRecommendationV2,
  JobIdParamDto: () => JobIdParamDto,
  JobLocation: () => JobLocation,
  JobLocationAdminDto: () => JobLocationAdminDto,
  JobLocationDto: () => JobLocationDto3,
  JobLocationEnum: () => JobLocationEnum,
  JobRMQAdapter: () => JobRMQAdapter,
  JobRecommendation: () => JobRecommendation,
  JobRoles: () => JobRoles,
  JobSkill: () => JobSkill,
  JobSkillCategoryEnum: () => JobSkillCategoryEnum,
  JobStatus: () => JobStatus,
  JobStatusDto: () => JobStatusDto,
  JobStatusEnum: () => JobStatusEnum,
  JobTCPAdapter: () => JobTCPAdapter,
  KindOfHire: () => KindOfHire,
  LEAD_PATTERN: () => LEAD_PATTERN,
  LLM_PATTERN: () => LLM_PATTERN,
  Lead: () => Lead,
  LoginDto: () => LoginDto,
  LoginUsingUuidDTO: () => LoginUsingUuidDTO,
  LoginViaOtpDto: () => LoginViaOtpDto,
  LogoutDto: () => LogoutDto,
  MAINTENANCE_PATTERN: () => MAINTENANCE_PATTERN,
  MarkCandidateStatusBulkDto: () => MarkCandidateStatusBulkDto,
  MarkCandidateStatusDto: () => MarkCandidateStatusDto,
  MarkTaskAsCompletedDto: () => MarkTaskAsCompletedDto,
  MarkTaskQueryMessagesReadDto: () => MarkTaskQueryMessagesReadDto,
  McqStatusEnum: () => McqStatusEnum,
  MetadataDto: () => MetadataDto,
  ModeOfHire: () => ModeOfHire,
  ModeOfWork: () => ModeOfWork,
  NOTIFICATION_PATTERN: () => NOTIFICATION_PATTERN,
  NatureOfWork: () => NatureOfWork,
  NewCandidateDto: () => NewCandidateDto2,
  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,
  PlanFeature: () => PlanFeature,
  PlanPricing: () => PlanPricing,
  PlanPricingBillingCycleEnum: () => PlanPricingBillingCycleEnum,
  PlanTypeEnum: () => PlanTypeEnum,
  PreCheckoutCalculationDto: () => PreCheckoutCalculationDto,
  ProjectDto: () => ProjectDto,
  Provider: () => Provider,
  Question: () => Question,
  QuestionFor: () => QuestionFor,
  QuestionForEnum: () => QuestionForEnum,
  RATING_PATTERN: () => RATING_PATTERN,
  REFERRAL_PATTERN: () => REFERRAL_PATTERN,
  RESUME_PARSER_PATTERN: () => RESUME_PARSER_PATTERN,
  RateLimiter: () => RateLimiter,
  Rating: () => Rating,
  RatingTypeEnum: () => RatingTypeEnum,
  RecommendationWeightageConfig: () => RecommendationWeightageConfig,
  RecordAssessmentAnswerDto: () => RecordAssessmentAnswerDto,
  RecordAssessmentAnswersDto: () => RecordAssessmentAnswersDto,
  RecordingStatusEnum: () => RecordingStatusEnum,
  RefreshDto: () => RefreshDto,
  RefreshToken: () => RefreshToken,
  RejectAIInterviewRescheduleRequestDto: () => RejectAIInterviewRescheduleRequestDto,
  RejectContractDto: () => RejectContractDto,
  RejectF2FInterviewRescheduleRequestDto: () => RejectF2FInterviewRescheduleRequestDto,
  RemoveGlobalSettingDto: () => RemoveGlobalSettingDto,
  RequestPasswordChangeOtpForClientDto: () => RequestPasswordChangeOtpForClientDto,
  RequestPasswordChangeOtpForFreelancerDto: () => RequestPasswordChangeOtpForFreelancerDto,
  ResetPasswordDto: () => ResetPasswordDto,
  ResetPasswordTokenValidationDto: () => ResetPasswordTokenValidationDto,
  ResetUserPasswordByAdminDto: () => ResetUserPasswordByAdminDto,
  ResubmitTimesheetDto: () => ResubmitTimesheetDto,
  ResultStatusEnum: () => ResultStatusEnum,
  ResumeDataProcessingDto: () => ResumeDataProcessingDto,
  ResumeParsingByUrlDto: () => ResumeParsingByUrlDto,
  SENSELOAF_PATTERN: () => SENSELOAF_PATTERN,
  SIGNATURE_PATTERN: () => SIGNATURE_PATTERN,
  SKILL_PATTERN: () => SKILL_PATTERN,
  SMS_PATTERN: () => SMS_PATTERN,
  STATE_PATTERN: () => STATE_PATTERN,
  STRIPE_PATTERN: () => STRIPE_PATTERN,
  SUBADMIN_PATTERN: () => SUBADMIN_PATTERN,
  SYSTEM_PREFERENCES_PATTERN: () => SYSTEM_PREFERENCES_PATTERN,
  SaveSignatureDto: () => SaveSignatureDto,
  SelectedAnswerTypeEnum: () => SelectedAnswerTypeEnum,
  SendAiAssessmentLinkDto: () => SendAiAssessmentLinkDto,
  SendBackTimesheetsDto: () => SendBackTimesheetsDto,
  SendGuestOtpDto: () => SendGuestOtpDto,
  SendInterviewInviteDto: () => SendInterviewInviteDto,
  SendLoginOtpDto: () => SendLoginOtpDto,
  SendNdaContractToFreelancerDto: () => SendNdaContractToFreelancerDto,
  SendOtpDto: () => SendOtpDto,
  SendReferralInviteDto: () => SendReferralInviteDto,
  SenseloafLog: () => SenseloafLog,
  SequenceGenerator: () => SequenceGenerator,
  SetPasswordDto: () => SetPasswordDto,
  SignContractForClientDto: () => SignContractForClientDto,
  SignContractForFreelancerDto: () => SignContractForFreelancerDto,
  Signature: () => Signature,
  Skill: () => Skill,
  SkillCatalog: () => SkillCatalog,
  SkipServiceAgreementFlowDto: () => SkipServiceAgreementFlowDto,
  SocialAuthDto: () => SocialAuthDto,
  State: () => State,
  Step: () => Step,
  StripeLog: () => StripeLog,
  StripeTransaction: () => StripeTransaction,
  StripeTransactionStatusEnum: () => StripeTransactionStatusEnum,
  StripeTransactionTypeEnum: () => StripeTransactionTypeEnum,
  SubmitTimesheetDto: () => SubmitTimesheetDto,
  SubscriptionFeature: () => SubscriptionFeature,
  SystemPreference: () => SystemPreference,
  SystemPreferenceDto: () => SystemPreferenceDto,
  TASK_PATTERN: () => TASK_PATTERN,
  TIMESHEET_CLIENT_PATTERN: () => TIMESHEET_CLIENT_PATTERN,
  TIMESHEET_FREELANCER_PATTERN: () => TIMESHEET_FREELANCER_PATTERN,
  Task: () => Task,
  TaskChecklistItem: () => TaskChecklistItem,
  TaskDeliverable: () => TaskDeliverable,
  TaskDeliverableTypeEnum: () => TaskDeliverableTypeEnum,
  TaskLogTime: () => TaskLogTime,
  TaskPriorityEnum: () => TaskPriorityEnum,
  TaskQuery: () => TaskQuery,
  TaskQueryCategoryEnum: () => TaskQueryCategoryEnum,
  TaskQueryMessage: () => TaskQueryMessage,
  TaskQueryMessageUserTypeEnum: () => TaskQueryMessageUserTypeEnum,
  TaskQueryStatusEnum: () => TaskQueryStatusEnum,
  TaskQueryUserTypeEnum: () => TaskQueryUserTypeEnum,
  TaskResource: () => TaskResource,
  TaskResourceTypeEnum: () => TaskResourceTypeEnum,
  TaskStatusEnum: () => TaskStatusEnum,
  TaskSubtask: () => TaskSubtask,
  TaskSubtaskStatusEnum: () => TaskSubtaskStatusEnum,
  TaskUuidParamDto: () => TaskUuidParamDto,
  TestNotificationDto: () => TestNotificationDto,
  Timesheet: () => Timesheet,
  TimesheetLine: () => TimesheetLine,
  TimesheetLineHistory: () => TimesheetLineHistory,
  TimesheetLineHistoryStatusEnum: () => TimesheetLineHistoryStatusEnum,
  TimesheetLineStatusEnum: () => TimesheetLineStatusEnum,
  TimesheetLogs: () => TimesheetLogs,
  TimesheetStatusEnum: () => TimesheetStatusEnum,
  TimesheetSubmissionActionEnum: () => TimesheetSubmissionActionEnum,
  ToggleCompanyMemberVisibilityDto: () => ToggleCompanyMemberVisibilityDto,
  ToggleCompanyRoleVisibilityDto: () => ToggleCompanyRoleVisibilityDto,
  TransferFundsDto: () => TransferFundsDto,
  TypeOfEmploymentEnum: () => TypeOfEmploymentEnum,
  UpdateAdminClientAccountStatusDto: () => UpdateAdminClientAccountStatusDto,
  UpdateAdminClientJobPostingRestrictionDto: () => UpdateAdminClientJobPostingRestrictionDto,
  UpdateAdminFreelancerAccountStatusDto: () => UpdateAdminFreelancerAccountStatusDto,
  UpdateAdminRoleDto: () => UpdateAdminRoleDto,
  UpdateAdminRoleStatusDto: () => UpdateAdminRoleStatusDto,
  UpdateAssessmentRequestStatusDto: () => UpdateAssessmentRequestStatusDto,
  UpdateClientAccountStatusDto: () => UpdateClientAccountStatusDto,
  UpdateClientDto: () => UpdateClientDto,
  UpdateCmsDto: () => UpdateCmsDto,
  UpdateCmsStatusDto: () => UpdateCmsStatusDto,
  UpdateCompanyMemberDto: () => UpdateCompanyMemberDto,
  UpdateCompanyProfileDto: () => UpdateCompanyProfileDto,
  UpdateCompanyRoleDto: () => UpdateCompanyRoleDto,
  UpdateEstimateTimeDto: () => UpdateEstimateTimeDto,
  UpdateFreelancerDto: () => UpdateFreelancerDto,
  UpdateFreelancerProfileDto: () => UpdateFreelancerProfileDto,
  UpdateFreelancerTimesheetDto: () => UpdateFreelancerTimesheetDto,
  UpdateInterviewBasicInformationDto: () => UpdateInterviewBasicInformationDto,
  UpdateInterviewSettingDto: () => UpdateInterviewSettingDto,
  UpdateInterviewTypeInformationDto: () => UpdateInterviewTypeInformationDto,
  UpdateInvoiceStatusDto: () => UpdateInvoiceStatusDto,
  UpdateIsReadDto: () => UpdateIsReadDto,
  UpdateSubAdminAccountStatusDto: () => UpdateSubAdminAccountStatusDto,
  UpdateSubAdminDto: () => UpdateSubAdminDto,
  UpdateTaskDto: () => UpdateTaskDto,
  User: () => User,
  UserRMQAdapter: () => UserRMQAdapter,
  UserSubscription: () => UserSubscription,
  UserSubscriptionPlan: () => UserSubscriptionPlan,
  UserSubscriptionPlanFeature: () => UserSubscriptionPlanFeature,
  UserSubscriptionPlanPricing: () => UserSubscriptionPlanPricing,
  UserSubscriptionPlanPricingBillingCycleEnum: () => UserSubscriptionPlanPricingBillingCycleEnum,
  UserSubscriptionPlanTypeEnum: () => UserSubscriptionPlanTypeEnum,
  UserSubscriptionStatusEnum: () => UserSubscriptionStatusEnum,
  UserSubscriptionTransaction: () => UserSubscriptionTransaction,
  UserSubscriptionTransactionStatusEnum: () => UserSubscriptionTransactionStatusEnum,
  UserSubscriptionTransactionTypeEnum: () => UserSubscriptionTransactionTypeEnum,
  UserTCPAdapter: () => UserTCPAdapter,
  VENDOR_API_CONFIGURATION_PATTERN: () => VENDOR_API_CONFIGURATION_PATTERN,
  ValidateEmailDto: () => ValidateEmailDto,
  ValidateEmailForLoginDto: () => ValidateEmailForLoginDto,
  ValidateMobileDto: () => ValidateMobileDto,
  VendorApiConfiguration: () => VendorApiConfiguration,
  VendorDetailDto: () => VendorDetailDto,
  VerifyGuestOtpDto: () => VerifyGuestOtpDto,
  VerifyOnboardingTokenDto: () => VerifyOnboardingTokenDto,
  VerifyOtpDto: () => VerifyOtpDto,
  VerifyPasswordChangeOtpForClientDto: () => VerifyPasswordChangeOtpForClientDto,
  VerifyPasswordChangeOtpForFreelancerDto: () => VerifyPasswordChangeOtpForFreelancerDto,
  WALLET_ADMIN_PATTERN: () => WALLET_ADMIN_PATTERN,
  WALLET_PATTERN: () => WALLET_PATTERN,
  Wallet: () => Wallet,
  WalletAccountTypeEnum: () => WalletAccountTypeEnum,
  WalletOnboardingStatusEnum: () => WalletOnboardingStatusEnum,
  WalletTransaction: () => WalletTransaction,
  WalletTransactionStatusEnum: () => WalletTransactionStatusEnum,
  WalletTransactionTypeEnum: () => WalletTransactionTypeEnum,
  ZOOM_PATTERN: () => ZOOM_PATTERN,
  ZoomMeetingLog: () => ZoomMeetingLog,
  createDiscordTransport: () => createDiscordTransport,
  typeOfExperienceEnum: () => typeOfExperienceEnum
});
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",
  handleAdminResetPassword: "handle.admin.reset.password",
  handleValidateResetPasswordToken: "handle.validate.reset.password.token",
  handleVerifyPermission: "handle.verify.permission",
  handleValidateEmail: "handle.validate.email",
  handleValidateEmailForLogin: "handle.validate.email.for.login",
  handleValidateMobile: "handle.validate.mobile",
  handleAdminLogin: "handle.admin.login",
  handleSetPassword: "handle.set.password",
  signUpWithLinkedIn: "signup.with.linkedin",
  loginWithLinkedIn: "login.with.linkedin",
  signUpWithGoogle: "signup.with.google",
  loginWithGoogle: "login.with.google",
  validateOnboardingToken: "validate.onboarding.token",
  loginUsingUuid: "login.using.uuid",
  handleUserResetPasswordByAdmin: "handle.user.reset.password.by.admin"
};

// 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);
__decorateClass([
  (0, import_class_validator.IsOptional)()
], LoginDto.prototype, "ip", 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);
__decorateClass([
  (0, import_class_validator2.IsOptional)()
], LoginViaOtpDto.prototype, "ip", 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/authentication/dto/validate-email.dto.ts
var import_class_validator9 = require("class-validator");
var ScopeEmailEnumDto = /* @__PURE__ */ ((ScopeEmailEnumDto2) => {
  ScopeEmailEnumDto2["ADMIN"] = "ADMIN";
  ScopeEmailEnumDto2["SUB_ADMIN"] = "SUB_ADMIN";
  ScopeEmailEnumDto2["CLIENT"] = "CLIENT";
  ScopeEmailEnumDto2["FREELANCER"] = "FREELANCER";
  return ScopeEmailEnumDto2;
})(ScopeEmailEnumDto || {});
var ValidateEmailDto = class {
};
__decorateClass([
  (0, import_class_validator9.IsNotEmpty)({ message: "Email is required" }),
  (0, import_class_validator9.IsEmail)({}, { message: "Email must be valid" })
], ValidateEmailDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator9.IsOptional)(),
  (0, import_class_validator9.IsEnum)(ScopeEmailEnumDto, {
    message: `Scope must be one of: ${Object.values(ScopeEmailEnumDto).join(", ")}`
  })
], ValidateEmailDto.prototype, "scope", 2);

// src/modules/authentication/dto/validate-email-for-login.dto.ts
var import_class_validator10 = require("class-validator");
var ScopeEmailForLoginEnumDto = /* @__PURE__ */ ((ScopeEmailForLoginEnumDto2) => {
  ScopeEmailForLoginEnumDto2["ADMIN"] = "ADMIN";
  ScopeEmailForLoginEnumDto2["SUB_ADMIN"] = "SUB_ADMIN";
  ScopeEmailForLoginEnumDto2["CLIENT"] = "CLIENT";
  ScopeEmailForLoginEnumDto2["FREELANCER"] = "FREELANCER";
  return ScopeEmailForLoginEnumDto2;
})(ScopeEmailForLoginEnumDto || {});
var ValidateEmailForLoginDto = class {
};
__decorateClass([
  (0, import_class_validator10.IsNotEmpty)({ message: "Email is required" }),
  (0, import_class_validator10.IsEmail)({}, { message: "Email must be valid" })
], ValidateEmailForLoginDto.prototype, "email", 2);
__decorateClass([
  (0, import_class_validator10.IsNotEmpty)({ message: "Scope is required" }),
  (0, import_class_validator10.IsEnum)(ScopeEmailForLoginEnumDto, {
    message: `Scope must be one of: ${Object.values(ScopeEmailForLoginEnumDto).join(", ")}`
  })
], ValidateEmailForLoginDto.prototype, "scope", 2);

// src/modules/authentication/dto/validate-mobile.dto.ts
var import_class_validator11 = require("class-validator");
var ValidateMobileDto = class {
};
__decorateClass([
  (0, import_class_validator11.IsNotEmpty)({ message: "Mobile code is required" }),
  (0, import_class_validator11.IsString)({ message: "Mobile code must be a string" })
], ValidateMobileDto.prototype, "mobileCode", 2);
__decorateClass([
  (0, import_class_validator11.IsNotEmpty)({ message: "Mobile number is required" }),
  (0, import_class_validator11.IsString)({ message: "Mobile number must be a string" })
], ValidateMobileDto.prototype, "mobile", 2);

// src/modules/authentication/dto/social-auth.dto.ts
var import_class_validator12 = require("class-validator");
var SocialAuthDto = class {
};
__decorateClass([
  (0, import_class_validator12.IsOptional)(),
  (0, import_class_validator12.IsString)()
], SocialAuthDto.prototype, "accessToken", 2);
__decorateClass([
  (0, import_class_validator12.IsOptional)(),
  (0, import_class_validator12.IsString)()
], SocialAuthDto.prototype, "refreshToken", 2);
__decorateClass([
  (0, import_class_validator12.IsOptional)(),
  (0, import_class_validator12.IsObject)()
], SocialAuthDto.prototype, "profile", 2);
__decorateClass([
  (0, import_class_validator12.IsOptional)(),
  (0, import_class_validator12.IsString)()
], SocialAuthDto.prototype, "provider", 2);
__decorateClass([
  (0, import_class_validator12.IsOptional)(),
  (0, import_class_validator12.IsString)()
], SocialAuthDto.prototype, "providerId", 2);

// src/modules/authentication/dto/login-using-uuid.dto.ts
var import_class_validator13 = require("class-validator");
var LoginUsingUuidDTO = class {
};
__decorateClass([
  (0, import_class_validator13.IsNotEmpty)({ message: "Uuid is required" }),
  (0, import_class_validator13.IsString)({ message: "uuid must be a string." })
], LoginUsingUuidDTO.prototype, "uuid", 2);

// src/modules/authentication/dto/reset-password-by-admin.dto.ts
var import_class_validator14 = require("class-validator");
var ResetUserPasswordByAdminDto = class {
};
__decorateClass([
  (0, import_class_validator14.IsNotEmpty)({ message: "User UUID is required." }),
  (0, import_class_validator14.IsUUID)("4", { message: "User UUID must be a valid UUID." })
], ResetUserPasswordByAdminDto.prototype, "uuid", 2);
__decorateClass([
  (0, import_class_validator14.IsNotEmpty)({ message: "Password is required." }),
  (0, import_class_validator14.IsString)({ message: "Password must be a string." }),
  (0, import_class_validator14.MinLength)(6, { message: "Password must be at least 6 characters long." })
], ResetUserPasswordByAdminDto.prototype, "password", 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_validator15 = require("class-validator");
var SendGuestOtpPurposeEnum = /* @__PURE__ */ ((SendGuestOtpPurposeEnum2) => {
  SendGuestOtpPurposeEnum2["SIGN_UP"] = "SIGN_UP";
  SendGuestOtpPurposeEnum2["LOGIN"] = "LOGIN";
  return SendGuestOtpPurposeEnum2;
})(SendGuestOtpPurposeEnum || {});
var SendGuestOtpScopeEnum = /* @__PURE__ */ ((SendGuestOtpScopeEnum2) => {
  SendGuestOtpScopeEnum2["CLIENT"] = "CLIENT";
  SendGuestOtpScopeEnum2["FREELANCER"] = "FREELANCER";
  return SendGuestOtpScopeEnum2;
})(SendGuestOtpScopeEnum || {});
var SendGuestOtpDto = class {
};
__decorateClass([
  (0, import_class_validator15.IsNotEmpty)({ message: "Please enter full name." }),
  (0, import_class_validator15.IsString)({ message: "Please enter valid full name." })
], SendGuestOtpDto.prototype, "fullName", 2);
__decorateClass([
  (0, import_class_validator15.IsNotEmpty)({ message: "Please enter target." }),
  (0, import_class_validator15.IsString)({ message: "Please enter valid target." })
], SendGuestOtpDto.prototype, "target", 2);
__decorateClass([
  (0, import_class_validator15.IsOptional)(),
  (0, import_class_validator15.IsString)({ message: "Please enter valid fallback target." })
], SendGuestOtpDto.prototype, "fallbackTarget", 2);
__decorateClass([
  (0, import_class_validator15.IsNotEmpty)({ message: "Please enter OTP purpose." }),
  (0, import_class_validator15.IsEnum)(SendGuestOtpPurposeEnum, { message: "Purpose must be a valid OTP purpose" })
], SendGuestOtpDto.prototype, "purpose", 2);
__decorateClass([
  (0, import_class_validator15.IsNotEmpty)({ message: "Please enter scope." }),
  (0, import_class_validator15.IsEnum)(SendGuestOtpScopeEnum, { message: "scope must be a valid" })
], SendGuestOtpDto.prototype, "scope", 2);

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

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

// src/modules/otp/dto/send-otp.dto.ts
var import_class_validator18 = require("class-validator");
var SendOtpDto = class {
};
__decorateClass([
  (0, import_class_validator18.IsUUID)("4", { message: "User ID must be a valid UUID." }),
  (0, import_class_validator18.IsNotEmpty)({ message: "User ID is required." })
], SendOtpDto.prototype, "userId", 2);
__decorateClass([
  (0, import_class_validator18.IsOptional)(),
  (0, import_class_validator18.IsString)({ message: "Purpose must be a string." })
], SendOtpDto.prototype, "purpose", 2);

// src/modules/otp/dto/verify-otp.dto.ts
var import_class_validator19 = require("class-validator");
var VerifyOtpDto = class {
};
__decorateClass([
  (0, import_class_validator19.IsUUID)("4", { message: "User ID must be a valid UUID." }),
  (0, import_class_validator19.IsNotEmpty)({ message: "User ID is required." })
], VerifyOtpDto.prototype, "userId", 2);
__decorateClass([
  (0, import_class_validator19.IsNotEmpty)({ message: "OTP code is required." }),
  (0, import_class_validator19.IsString)({ message: "OTP code must be a string." })
], VerifyOtpDto.prototype, "otp", 2);
__decorateClass([
  (0, import_class_validator19.IsOptional)(),
  (0, import_class_validator19.IsString)({ message: "Purpose must be a string." })
], VerifyOtpDto.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",
  verifyOnboardingToken: "verify.onboarding.token",
  handleClientAccountCreation: "handle.client.account.creation",
  handleClientProfileQuestion: "handle.client.profile.question",
  changeFreelancerPassword: "change.freelancer.password",
  handleFetchClientProfileQuestion: "handle.fetch.client.profile.question",
  verifyClientOnboardingToken: "verify.client.onboarding.token",
  handleFetchFreelancerResume: "handle.fetch.freelancer.resume",
  handleFreelancerResumeParsing: "handle.freelancer.resume.parsing",
  initiateFreelancerMcqAssessment: "initiate.freelancer.mcq.assessment",
  handleFetchAiAssessmentLink: "handle.fetch.ai.assessment.link",
  skipFreelancerAiAssessment: "skip.freelancer.ai.assessment",
  initiateFreelancerAiAssessment: "initiate.freelancer.ai.assessment",
  captureAiAssessmentStatus: "capture.ai.assessment.status",
  handleFetchFreelancerProfileQuestion: "handle.fetch.freelancer.profile.question",
  handleFetchFreelancerDetails: "handle.fetch.freelancer.details"
};

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

// src/decorators/match.decorator.ts
var import_class_validator20 = require("class-validator");
function Match(property, validationOptions) {
  return function(object, propertyName) {
    (0, import_class_validator20.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_validator20.ValidatorConstraint)({ async: false })
], IfscOrOtherFieldsConstraint);

// src/decorators/is-valid-mobile-number.decorator.ts
var import_class_validator21 = 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_validator21.ValidatorConstraint)({ name: "isValidMobileNumber", async: false })
], IsValidMobileNumberConstraint);
function IsValidMobileNumber(validationOptions) {
  return function(object, propertyName) {
    (0, import_class_validator21.registerDecorator)({
      name: "isValidMobileNumber",
      target: object.constructor,
      propertyName,
      options: validationOptions,
      validator: IsValidMobileNumberConstraint
    });
  };
}

// src/decorators/is-business-email.decorator.ts
var import_class_validator22 = 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_validator22.ValidatorConstraint)({ async: false })
], IsBusinessEmailConstraint);
function IsBusinessEmail(validationOptions) {
  return function(object, propertyName) {
    (0, import_class_validator22.registerDecorator)({
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [],
      validator: Is