import { MicroserviceOptions } from '@nestjs/microservices';

declare const AUTHENTICATION_PATTERN: {
    handleValidateToken: string;
    handleLogin: string;
    handleLoginViaOtp: string;
    handleRefreshToken: string;
    handleLogout: string;
    handleLogoutAll: string;
    fetchSessions: string;
    revokeSession: string;
    handleForgotPassword: string;
    handleResetPassword: string;
    handleValidateResetPasswordToken: string;
    handleSetPassword: string;
};

declare enum ScopeEnum$3 {
    ADMIN = "ADMIN",
    SUB_ADMIN = "SUB_ADMIN",
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class LoginDto {
    email: string;
    password: string;
    scope: ScopeEnum$3;
}

declare enum LoginViaOtpScopeEnum {
    ADMIN = "ADMIN",
    SUB_ADMIN = "SUB_ADMIN",
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class LoginViaOtpDto {
    email: string;
    otp: string;
    scope: LoginViaOtpScopeEnum;
}

declare class RefreshDto {
    refreshToken: string;
}

declare class LogoutDto {
    refreshToken: string;
}

declare enum ScopeEnum$2 {
    ADMIN = "ADMIN",
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class ForgotPasswordDto {
    email: string;
    scope: ScopeEnum$2;
}

declare enum ScopeEnum$1 {
    ADMIN = "ADMIN",
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class ResetPasswordDto {
    token: string;
    password: string;
    scope: ScopeEnum$1;
}

declare class SetPasswordDto {
    token: string;
    password: string;
}

declare enum ScopeEnum {
    ADMIN = "ADMIN",
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class ResetPasswordTokenValidationDto {
    token: string;
    scope: ScopeEnum;
}

declare const OTP_PATTERN: {
    handleSendGuestOtp: string;
    handleSendOtp: string;
    handleSendOtpForLogin: string;
    handleVerifyGuestOtp: string;
    handleVerifyOtp: string;
};

declare enum SendGuestOtpPurposeEnum {
    ACCOUNT_VERIFICATION = "ACCOUNT_VERIFICATION"
}
declare enum SendGuestOtpScopeEnum {
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class SendGuestOtpDto {
    fullName: string;
    target: string;
    fallbackTarget: string;
    purpose: SendGuestOtpPurposeEnum;
    scope: SendGuestOtpScopeEnum;
}

declare enum SendLoginOtpPurposeEnum {
    ACCOUNT_VERIFICATION = "ACCOUNT_VERIFICATION"
}
declare enum SendLoginOtpScopeEnum {
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class SendLoginOtpDto {
    target: string;
    purpose: SendLoginOtpPurposeEnum;
    scope: SendLoginOtpScopeEnum;
}

declare enum VerifyGuestOtpPurposeEnum {
    ACCOUNT_VERIFICATION = "ACCOUNT_VERIFICATION"
}
declare class VerifyGuestOtpDto {
    target: string;
    otp: string;
    purpose: VerifyGuestOtpPurposeEnum;
}

declare const ONBOARDING_PATTERN: {
    handleFreelancerAccountCreation: string;
    handleFreelancerResumeUpload: string;
    handleFreelancerDeveloperPreference: string;
    handleFreelancerProfileQuestion: string;
    handleFreelancerWorkShowcase: string;
    handleClientAccountCreation: string;
    handleClientProfileQuestion: string;
    changeFreelancerPassword: string;
};

declare class FreelancerCreateAccountDto {
    fullName: string;
    email: string;
    mobileCode: string;
    mobile: string;
    onBoardedBy: string;
}

declare class FreelancerUploadResumeDto {
    uuid: string;
}

declare class FreelancerParseResumeDto {
    uuid: string;
}

declare class FreelancerInitiateMcqAssessmentDto {
    uuid: string;
}

declare class FreelancerSkipAiAssessmentDto {
    uuid: string;
}

declare class FreelancerInitiateAiAssessmentDto {
    uuid: string;
}

declare class FreelancerCaptureAiAssessmentStatusDto {
    uuid: string;
    assessmentId: string;
    assessmentStatus: string;
    iframeEventData: object;
}

declare class FreelancerDevelopmentPreferenceDto {
    uuid: string;
    developer: boolean;
}

declare class FreelancerProfileQuestionDto {
    uuid: string;
    question_slug: string;
    answer: any;
    currency?: string;
}

declare class FreelancerWorkShowcaseDto {
    uuid: string;
    linkedinProfileLink: string;
    kaggleProfileLink?: string | null;
    githubProfileLink?: string | null;
    stackOverflowProfileLink?: string | null;
    portfolioLink?: string | null;
}

declare class ClientProfileQuestionDto {
    uuid: string;
    question_slug: string;
    answer: any;
    foundUsOnDetail?: string;
}

declare class ClientCreateAccountDto {
    fullName: string;
    email: string;
    companyName: string;
    onBoardedBy: string;
}

declare const RESUME_PARSER_PATTERN: {
    handleResumeParsing: string;
};

declare const SUBADMIN_PATTERN: {
    fetchSubAdmins: string;
    fetchDeletedSubAdmins: string;
    fetchSubAdminDropdown: string;
    findSubAdminById: string;
    createSubAdmin: string;
    updateSubAdminAccountStatus: string;
    updateSubAdmin: string;
    deleteSubAdmin: string;
};

declare class CreateSubAdminDto {
    userName: string;
    firstName: string;
    lastName: string;
    email: string;
    mobileCode: string;
    mobile: string;
    password: string;
    roleIds: string;
}

declare class UpdateSubAdminAccountStatusDto {
    accountStatus: string;
}

declare class UpdateSubAdminDto {
    userName: string;
    firstName: string;
    lastName: string;
    email: string;
    mobileCode: string;
    mobile: string;
    password?: string;
    roleIds: string;
}

interface IFetchSubAdminQuery {
    page_size?: number;
    page: number;
    searchText?: string;
    username: string;
    right: string;
    sortColumn?: string;
    sortBy?: string;
}
interface IFetchSubAdminResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}
interface IFetchSubAdminByIdQuery {
    permission?: string;
}
interface IFetchSubAdminByIdResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}
interface ICreateSubAdminPayload {
    uniqueId: string;
    username: string;
    firstName: string;
    lastName: string;
    email: string;
    mobile: string;
    password: string;
    accountType: string;
    accountStatus: string;
}
interface ICreateSubAdminResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IUpdateSubAdminPayload {
    uniqueId: string;
    username: string;
    firstName: string;
    lastName: string;
    email: string;
    mobile: string;
    password: string;
    accountType: string;
    accountStatus: string;
}
interface IUpdateSubAdminResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IUpdateSubAdminAccountStatusPayload {
    accountSatus: string;
}
interface IUpdateSubAdminAccountStatusResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IDeleteSubAdminResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IAttachPermissionsToSubAdminResponse {
    statusCode: number;
    status: boolean;
    message: string;
}

declare const CLIENT_PROFILE_PATTERN: {
    fetchClientProfile: string;
    fetchClientPublicProfile: string;
    updateClientProfile: string;
    updateClientLogo: string;
    changeClientPassword: string;
    uploadClientServiceAgreement: string;
};

declare class UpdateCompanyProfileDto {
    companyName?: string;
    webSite?: string;
    companyAddress: string;
    mobileCode: string;
    phoneNumber?: string;
    email?: string;
    aboutCompany?: string;
}

declare class ClientChangePasswordDto {
    newPassword: string;
    confirmPassword: string;
}

interface IFetchClientProfileQuery {
    page_size?: number;
    page: number;
    searchText?: string;
    companyName: string;
    right: string;
    sortColumn?: string;
    sortBy?: string;
}
interface IFetchClientProfileResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}
interface IUpdateClientProfilePayload {
    userId?: number;
    companyName?: string;
    bio?: string;
    webSite?: string;
    isServiceAgreementSigned?: boolean;
    aboutCompany: string;
    companyAddress: string;
    phoneNumber: string;
    skills?: string[];
    requiredFreelancer?: string;
    kindOfHiring?: string;
    modeOfHire?: string;
    foundUsOn?: string;
}
interface IUpdateClientLogoPayload {
    logo: string;
}
interface IUpdateClientLogoResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IUpdateClientPasswordPayload {
    oldPassword: string;
    newPassword: string;
}
interface IUpdateClientProfileResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IUpdateClientProfileResponse {
    statusCode: number;
    status: boolean;
    message: string;
}

declare const ONBOARDING_QUESTION_PATTERN: {
    fetchOnboardingQuestions: string;
};
declare const ASSESSMENT_QUESTION_PATTERN: {
    fetchAssessmentQuestions: string;
};

declare class CreateQuestionDto {
    questionId: string;
    question: string;
    questionFor: string;
    options: string;
    isActive: boolean;
}

interface IFetchQuestionQuery {
    page_size?: number;
    page: number;
    searchText?: string;
    question: string;
    right: string;
    sortColumn?: string;
    sortBy?: string;
    type?: string;
}
interface IFetchQuestionResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}

declare const JOB_ROLE_PATTERN: {
    fetchJobRolesForDropdown: string;
};
declare const JOB_PATTERN: {
    fetchJobs: string;
    fetchJobsPublic: string;
    fetchRecentJobs: string;
    fetchJobCountAsPerStatus: string;
    fetchJobCountPublic: string;
    fetchJobsDropdown: string;
    fetchJobDetail: string;
    fetchJobDetailPublic: string;
    handleJdUpload: string;
    fetchJobBasicInformation: string;
    createJobBasicInformation: string;
    updateJobBasicInformation: string;
    fetchJobAdditionalComments: string;
    updateJobAdditionalComments: string;
    fetchJobDescription: string;
    updateJobDescription: string;
    updateJobStatus: string;
    searchJobsByRoleAndSkills: string;
};

declare enum JobLocation {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    BOTH = "BOTH"
}
declare enum EmploymentType {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare class JobBasicInformationDto {
    isDraft?: boolean;
    jobRole: string;
    note?: string;
    skills: string[];
    openings: number;
    location: JobLocation;
    countryId: number;
    stateId: number;
    cityId: number;
    typeOfEmployment: EmploymentType;
    currency?: string;
    expectedSalaryFrom: number;
    expectedSalaryTo: number;
    tentativeStartDate: string;
    tentativeEndDate: string;
    onboardingTat?: string;
    candidateCommunicationSkills?: string;
    academicQualification?: string;
    yearsOfExperience?: string;
    businessIndustry?: string;
}

declare class JobAdditionalCommentDto {
    additionalComment?: string;
}

declare class JobDescriptionDto {
    description: string;
}

declare enum JobStatus {
    ACTIVE = "ACTIVE",
    OPEN = "OPEN",
    DRAFT = "DRAFT",
    ONHOLD = "ONHOLD",
    CLOSED = "CLOSED"
}
declare class JobStatusDto {
    status: JobStatus;
}

declare class JobIdParamDto {
    id: string;
}

declare const PROFILE_PATTERN: {
    fetchFreelancerProfile: string;
    fetchFreelancerPublicProfile: string;
    fetchFreelancerScreeningResult: string;
    fetchFreelancerScreeningResultPublic: string;
    changeFreelancerPassword: string;
    uploadFreelancerProfilePic: string;
    updateFreelancerProfile: string;
    uploadFreelancerServiceAgreement: string;
};

declare class FreelancerChangePasswordDto {
    oldPassword: string;
    newPassword: string;
}

declare enum NatureOfWorkDto {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare enum ModeOfWorkDto {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    BOTH = "BOTH"
}
declare class UpdateFreelancerProfileDto {
    firstName: string;
    lastName: string;
    designation: string;
    experience: string;
    email: string;
    mobileCode: string;
    mobile: string;
    countryId: number;
    currency: string;
    expectedHourlyCompensation: string;
    natureOfWork: NatureOfWorkDto;
    modeOfWork: ModeOfWorkDto;
    portfolioLink?: string;
    address?: string;
    about?: string;
    linkedinProfileLink?: string;
    kaggleProfileLink?: string;
    githubProfileLink?: string;
    stackOverflowProfileLink?: string;
    resumeUrl?: string;
}

declare const BANK_PATTERN: {
    addFreelancerBankDetails: string;
    fetchFreelancerBankDetails: string;
    updateFreelancerBankDetails: string;
};

declare enum BankAccountScope {
    DOMESTIC = "DOMESTIC",
    INTERNATIONAL = "INTERNATIONAL"
}
declare class FreelancerBankDetailsDto {
    name: string;
    mobile: string;
    email: string;
    address: string;
    accountNumber: string;
    bankName: string;
    branchName: string;
    ifscCode: string;
    routingNo: string;
    abaNumber: string;
    iban: string;
    accountType: string;
    accountScope: BankAccountScope;
}

declare const PLAN_PATTERN: {
    fetchPlans: string;
};

interface IFetchPlanResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}

declare const SYSTEM_PREFERENCES_PATTERN: {
    fetchSystemPreference: string;
    updateSystemPreference: string;
    createSystemPreference: string;
};

declare enum SystemPreferenceKey {
    EMAIL_NOTIFICATION = "EMAIL_NOTIFICATION",
    DARK_MODE = "DARK_MODE"
}
declare class SystemPreferenceDto {
    value: boolean;
    key: SystemPreferenceKey;
}

declare const NOTIFICATION_PATTERN: {
    handleAccountVerificationNotification: string;
    handleResetLinkNotification: string;
};

declare const RATING_PATTERN: {
    addRating: string;
    fetchRating: string;
};

declare abstract class BaseEntity {
    id: number;
    uuid: string;
    createdAt: Date;
    createdBy: number;
    updatedAt: Date;
    updatedBy: number;
    isDeleted: boolean;
    deletedBy: number;
    deletedAt: Date;
}

declare class RefreshToken {
    id: string;
    userId: number;
    tokenId: string;
    deviceInfo: any;
    isRevoked: boolean;
    expiresAt: Date;
    createdAt: Date;
    updatedAt: Date;
    user: User;
}

declare class SenseloafLog {
    id: number;
    userId: number;
    type: string;
    endpoint: string;
    success: boolean;
    request: any;
    response: any;
    errorMessage: string;
    scope: string;
    createdAt: Date;
    user: User;
}

declare class Otp {
    id: number;
    userId: number;
    otp: string;
    otpPurpose: string;
    target: string;
    fallbackTarget: string;
    expiresAt: Date;
    isUsed: boolean;
    isVerified: boolean;
    resendCount: number;
    createdAt: Date;
    user: User;
}

declare class City extends BaseEntity {
    countryId: number;
    country: Country;
    stateId: number;
    state: State;
    cityCode: string;
    cityName: string;
    isActive: boolean;
}

declare class State extends BaseEntity {
    countryId: number;
    country: Country;
    cities: City[];
    stateName: string;
    stateCode: string;
    isActive: boolean;
}

declare class Country extends BaseEntity {
    countryName: string;
    countryIsoCode: string;
    countryPhoneCode: string;
    currency: string;
    isActive: boolean;
    states: State[];
    freelancerProfile: FreelancerProfile[];
}

declare enum NatureOfWork {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare enum ModeOfWork {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    BOTH = "BOTH"
}
declare enum OnboardingStepEnum {
    SIGN_UP = "SIGN_UP",
    UPLOAD_RESUME = "UPLOAD_RESUME",
    PARSE_RESUME = "PARSE_RESUME",
    MCQ_ASSESSMENT_INITIATED = "MCQ_ASSESSMENT_INITIATED",
    MCQ_ASSESSMENT_COMPLETED = "MCQ_ASSESSMENT_COMPLETED",
    AI_ASSESSMENT_INITIATED = "AI_ASSESSMENT_INITIATED",
    AI_ASSESSMENT_COMPLETED = "AI_ASSESSMENT_COMPLETED",
    CODING_CHALLENGE = "CODING_CHALLENGE",
    PROFILE_COMPLETION = "PROFILE_COMPLETION"
}
declare enum McqStatusEnum {
    NOT_ATTEMPTED = "NOT_ATTEMPTED",
    PASSED = "PASSED",
    FAILED = "FAILED"
}
declare enum AiAssessmentStatusEnum {
    NOT_ATTEMPTED = "NOT_ATTEMPTED",
    COMPELETED = "COMPELETED",
    PASSED = "PASSED",
    FAILED = "FAILED",
    SKIPPED = "SKIPPED",
    EXITED = "EXITED"
}
declare class FreelancerProfile extends BaseEntity {
    userId: number;
    user: User;
    countryId: number;
    country: Country;
    talentId: string;
    resumeUrl: string;
    resumeUploadedOn: Date;
    resumeEligibility: string;
    resumeScore: string;
    mcqStatus: McqStatusEnum;
    mcqScore: number;
    isEligibleForAiAssessment: boolean;
    aiAssessmentStatus: AiAssessmentStatusEnum;
    isDeveloper: boolean;
    natureOfWork: NatureOfWork;
    currency: string;
    expectedHourlyCompensation: number;
    modeOfWork: ModeOfWork;
    availabilityToJoin: string;
    isImmediateJoiner: boolean;
    linkedinProfileLink: string;
    kaggleProfileLink: string;
    githubProfileLink: string;
    stackOverflowProfileLink: string;
    portfolioLink: string;
    onboardingStepCompleted: OnboardingStepEnum;
    designation: string;
    experience: string;
    address: string;
    about: string;
    profileCompletedPercentage: Record<string, number>;
    isServiceAgreementSigned: boolean;
    serviceAgreementUrl: string;
    serviceAggrementSignedOn: Date;
    isExpertshubVerified: boolean;
    isFollowedOnLinkedIn: boolean;
}

declare enum KindOfHire {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare enum ModeOfHire {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    BOTH = "BOTH"
}
declare enum FromUsOn {
    LINKEDIN = "LINKEDIN",
    GOOGLE = "GOOGLE",
    REFERRAL = "REFERRAL",
    OTHER = "OTHER"
}
declare enum CompanyOnboardingStepEnum {
    SIGN_UP = "SIGN_UP",
    PROFILE_COMPLETION = "PROFILE_COMPLETION"
}
declare class CompanyProfile extends BaseEntity {
    userId: number;
    user: User;
    companyName: string;
    bio: string;
    webSite: string;
    aboutCompany: string;
    isServiceAgreementSigned: boolean;
    serviceAgreementUrl: string;
    serviceAggrementSignedOn: Date;
    companyAddress: string;
    phoneNumber: string;
    skills: string[];
    requiredFreelancer: string;
    kindOfHiring: KindOfHire;
    modeOfHire: ModeOfHire;
    foundUsOn: FromUsOn;
    foundUsOnDetail: string;
    onboardingStepCompleted: CompanyOnboardingStepEnum;
}

declare class JobSkill extends BaseEntity {
    jobId: number;
    job: Job;
    skillName: string;
}

declare enum ApplicationStatusEnum {
    PENDING = "PENDING",
    SHORTLISTED = "SHORTLISTED",
    INTERVIEW_IN_PROGRESS = "INTERVIEW_IN_PROGRESS",
    INTERVIEWED = "INTERVIEWED",
    OFFERED = "OFFERED",
    HIRED = "HIRED",
    REJECTED_BEFORE_INTERVIEW = "REJECTED_BEFORE_INTERVIEW",
    REJECTED_IN_INTERVIEW = "REJECTED_IN_INTERVIEW",
    REJECTED_AFTER_INTERVIEW = "REJECTED_AFTER_INTERVIEW",
    NOT_SUITABLE = "NOT_SUITABLE",
    WITHDRAWN = "WITHDRAWN"
}
declare class JobApplication extends BaseEntity {
    jobApplicationId: string;
    jobId: number;
    job: Job;
    userId: number;
    user: User;
    status: ApplicationStatusEnum;
    appliedAt: Date;
    shortlistedAt: Date;
    interviewStartedAt: Date;
    interviewCompletedAt: Date;
    offeredAt: Date;
    hiredAt: Date;
    rejectedAt: Date;
    rejectionReason: string;
    withdrawnAt: Date;
    withdrawnReason: string;
}

declare class InterviewSkill extends BaseEntity {
    interviewId: number;
    interview: Interview;
    skill: string;
    description: string;
    isActive: boolean;
}

declare class InterviewQuestion extends BaseEntity {
    interviewId: number;
    interview: Interview;
    question: string;
    isActive: boolean;
}

declare enum InterviewInviteStatusEnum {
    PENDING = "PENDING",
    ACCEPTED = "ACCEPTED",
    REJECTED = "REJECTED",
    EXPIRED = "EXPIRED"
}
declare class InterviewInvite extends BaseEntity {
    interviewId: number;
    interview: Interview;
    userId: number;
    user: User;
    fullName: string;
    email: string;
    status: InterviewInviteStatusEnum;
    sentAt: Date;
    expiresAt: Date;
    respondedAt?: Date;
    token: string;
}

declare enum AiInterviewStatusEnum {
    NOT_ATTEMPTED = "NOT_ATTEMPTED",
    ACTIVE = "ACTIVE",
    COMPELETED = "COMPELETED",
    PASSED = "PASSED",
    FAILED = "FAILED",
    EXPIRED = "EXPIRED",
    POSTPONED = "POSTPONED",
    RESCHEDULED = "RESCHEDULED",
    EXITED = "EXITED"
}
declare class AiInterview extends BaseEntity {
    candidateId: number;
    candidate: User;
    interviwerId: number;
    interviwer: User;
    interviewId: number;
    interview: Interview;
    inviteId: number;
    status: AiInterviewStatusEnum;
    isF2fInterviewScheduled: boolean;
}

declare enum F2fInterviewRescheduleRequestStatusEnum {
    PENDING = "PENDING",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED",
    INPROGRESS = "INPROGRESS",
    AUTOCANCELLED = "AUTOCANCELLED"
}
declare class F2fInterviewRescheduleRequest extends BaseEntity {
    candidateId: number;
    candidate: User;
    f2fInterviewId: number;
    f2fInterview: F2FInterview;
    rescheduledDate: Date;
    rescheduledSlot: string;
    status: F2fInterviewRescheduleRequestStatusEnum;
    clientRejectReason: string;
    freelancerRequestReason: string;
}

declare enum F2fInterviewScheduleStatusEnum {
    ACTIVE = "ACTIVE",
    COMPELETED = "COMPELETED",
    RESCHEDULED = "RESCHEDULED",
    CANCELLED = "CANCELLED"
}
declare class F2FInterviewSchedule extends BaseEntity {
    f2fInterviewId: number;
    f2fInterview: F2FInterview;
    eventId: string;
    meetingZoomLink: string;
    meetingId: string;
    meetingPasscode: string;
    rescheduleUrl: string;
    cancelUrl: string;
    status: F2fInterviewScheduleStatusEnum;
    meetingStartTime: Date;
    meetingEndTime: Date;
}

declare enum F2fInterviewStatusEnum {
    DRAFTED = "DRAFTED",
    NOT_ATTEMPTED = "NOT_ATTEMPTED",
    ACTIVE = "ACTIVE",
    COMPELETED = "COMPELETED",
    EXPIRED = "EXPIRED",
    POSTPONED = "POSTPONED",
    RESCHEDULED = "RESCHEDULED",
    EXITED = "EXITED",
    CANCELLED = "CANCELLED"
}
declare class F2FInterview extends BaseEntity {
    interviewUniqueId: string;
    round: string;
    interviewId: number;
    interview: Interview;
    interviwerId: number;
    interviwer: User;
    candidateId: number;
    candidate: User;
    inviteeEmail: string;
    inviteeName: string;
    eventName: string;
    status: F2fInterviewStatusEnum;
    isRescheduled: boolean;
    lastRescheduledAt: Date;
    cancelledAt: Date;
    cancelReason: string;
    provider: string;
    meetingStartedOn: Date;
    meetingEndedOn: Date;
    schedules: F2FInterviewSchedule[];
    rescheduleRequests: F2fInterviewRescheduleRequest[];
}

declare enum InterviewStatusEnum {
    DRAFTED = "DRAFTED",
    PUBLISHED = "PUBLISHED",
    INACTIVE = "INACTIVE",
    DISCARDED = "DISCARDED",
    ARCHIVED = "ARCHIVED"
}
declare class Interview extends BaseEntity {
    interviewId: string;
    userId: number;
    user: User;
    interviewName: string;
    jobId: number;
    job: Job;
    interviewType: string;
    interviewLanguage: string;
    allowProctoring: boolean;
    status: InterviewStatusEnum;
    interviewSkills: InterviewSkill[];
    interviewQuestions: InterviewQuestion[];
    invites: InterviewInvite[];
    aiInterviews: AiInterview[];
    f2fInterviews: F2FInterview[];
}

declare class JobRecommendation {
    id: number;
    jobId: number;
    job: Job;
    freelancerId: number;
    clientId: number;
    matchScore: number;
    matchScoreSummary?: Record<string, any>;
    matchingSkills: string[];
    matchingSkillsCount: number;
    requiredSkills: string[];
    requiredSkillsCount: number;
    lastCalculatedAt: Date;
}

declare enum ContractStatusEnum {
    ACTIVE = "ACTIVE",
    SENT = "SENT",
    SIGNED = "SIGNED",
    CANCELLED = "CANCELLED",
    DISPUTED = "DISPUTED",
    DRAFTED = "DRAFTED",
    REJECTED = "REJECTED",
    RENEWED = "RENEWED",
    EXPIRED = "EXPIRED"
}
declare enum ContractTypeEnum {
    NDA = "NDA",
    WORK = "WORK"
}
declare class Contract extends BaseEntity {
    contractUniqueId: string;
    jobId: number;
    job: Job;
    clientId: number;
    client: User;
    freelancerId: number;
    freelancer: User;
    duration: number;
    status: ContractStatusEnum;
    type: ContractTypeEnum;
    startDate: Date;
    endDate: Date;
    contractDocumentUrl: string;
    clientSignedAt: Date;
    freelancerSignedAt: Date;
    rejectedAt: Date;
    rejectReason: string;
}

declare enum JobLocationEnum {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    BOTH = "BOTH"
}
declare enum TypeOfEmploymentEnum {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare enum Step {
    BASIC_INFORMATION = "BASIC_INFORMATION",
    ADDITIONAL_COMMENTS = "ADDITIONAL_COMMENTS",
    JOB_DESCRIPTION = "JOB_DESCRIPTION"
}
declare enum JobStatusEnum {
    ACTIVE = "ACTIVE",
    OPEN = "OPEN",
    DRAFT = "DRAFT",
    ONHOLD = "ONHOLD",
    CLOSED = "CLOSED"
}
declare enum DurationTypeEnum {
    DAY = "DAY",
    WEEK = "WEEK",
    MONTH = "MONTH",
    YEAR = "YEAR"
}
declare class Job extends BaseEntity {
    jobId: string;
    userId: number;
    user: User;
    countryId: number;
    country: Country;
    stateId: number;
    state: State;
    cityId: number;
    city: City;
    jobRole: string;
    note: string;
    openings: number;
    location: JobLocationEnum;
    typeOfEmployment: TypeOfEmploymentEnum;
    academicQualification: string;
    yearsOfExperience: string;
    businessIndustry: string;
    currency: string;
    expectedSalaryFrom: number;
    expectedSalaryTo: number;
    tentativeStartDate: Date;
    tentativeEndDate: Date;
    duration: string;
    durationType: DurationTypeEnum;
    description: string;
    additionalComment: string;
    onboardingTat: string;
    candidateCommunicationSkills: string;
    stepCompleted: Step;
    status: JobStatusEnum;
    viewedCount: number;
    applicationCount: number;
    jobSkills: JobSkill[];
    jobApplications: JobApplication[];
    interviews: Interview[];
    recommendations: JobRecommendation[];
    contracts: Contract[];
}

declare enum BankAccountTypeEnum {
    PRIMARY = "PRIMARY",
    SECONDARY = "SECONDARY"
}
declare enum BankAccountScopeEnum {
    DOMESTIC = "DOMESTIC",
    INTERNATIONAL = "INTERNATIONAL"
}
declare class BankDetail extends BaseEntity {
    userId: number;
    user: User;
    name: string;
    mobile: string;
    email: string;
    address: string;
    accountNumber: string;
    bankName: string;
    ifscCode: string;
    branchName: string;
    routingNo: string;
    abaNumber: string;
    iban: string;
    accountType: BankAccountTypeEnum;
    accountScope: BankAccountScopeEnum;
}

declare class SystemPreference extends BaseEntity {
    userId: number;
    user: User;
    key: string;
    value: boolean;
}

declare class FreelancerExperience extends BaseEntity {
    userId: number;
    user: User;
    companyName: string;
    designation: string;
    jobDuration: string;
    description: string;
}

declare class FreelancerEducation extends BaseEntity {
    userId: number;
    user: User;
    degree: string;
    university: string;
    yearOfGraduation: string;
}

declare class FreelancerProject extends BaseEntity {
    userId: number;
    user: User;
    projectName: string;
    startDate: Date;
    endDate: Date;
    clientName: string;
    gitLink: string;
    description: string;
}

declare class FreelancerCaseStudy extends BaseEntity {
    userId: number;
    user: User;
    projectName: string;
    caseStudyLink: string;
    description: string;
}

declare class FreelancerSkill extends BaseEntity {
    userId: number;
    user: User;
    skillName: string;
}

declare class FreelancerTool extends BaseEntity {
    userId: number;
    user: User;
    toolName: string;
}

declare class FreelancerFramework extends BaseEntity {
    userId: number;
    user: User;
    frameworkName: string;
}

declare enum AssessmentStatusEnum {
    NOT_ATTEMPTED = "NOT_ATTEMPTED",
    ACTIVE = "ACTIVE",
    COMPELETED = "COMPELETED",
    PASSED = "PASSED",
    FAILED = "FAILED",
    EXPIRED = "EXPIRED",
    POSTPONED = "POSTPONED",
    RESCHEDULED = "RESCHEDULED",
    EXITED = "EXITED"
}
declare class FreelancerAssessment extends BaseEntity {
    userId: number;
    user: User;
    interviewId: string;
    interviewLink: string;
    recordingLink: string;
    iframeResponse: string;
    interviewSummary: string;
    status: AssessmentStatusEnum;
}

declare enum DocumentType {
    AADHAAR = "AADHAAR_CARD",
    PASSPORT = "PASSPORT",
    DRIVING_LICENSE = "DRIVING_LICENSE",
    PAN_CARD = "PAN_CARD"
}
declare class FreelancerDeclaration extends BaseEntity {
    userId: number;
    user: User;
    documentType: DocumentType;
    frontDocumentUrl: string;
    backDocumentUrl: string;
    declarationAccepted: string;
    digitalSignatureUrl: string;
}

declare class Permission extends BaseEntity {
    name: string;
    slug: string;
    description: string;
    isActive: boolean;
}

declare class CompanyRolePermission extends BaseEntity {
    companyRoleId: number;
    companyRole: CompanyRole;
    permissionId: number;
    permission: Permission;
    assignedBy?: number;
}

declare class CompanyRole extends BaseEntity {
    userId: number;
    user: User;
    name: string;
    slug: string;
    description: string;
    isActive: boolean;
    rolePermissions: CompanyRolePermission[];
}

declare class CompanyMemberRole extends BaseEntity {
    userId: number;
    user: User;
    role: CompanyRole;
    companyRoleId: number;
    assignedBy?: number;
}

declare enum AnswerTypeEnum {
    CORRECT = "CORRECT",
    ACCEPTABLE = "ACCEPTABLE",
    ELIMINATE = "ELIMINATE"
}
declare class AssessmetQuestionOption extends BaseEntity {
    questionId: number;
    question: AssessmetQuestion;
    text: string;
    answerType: AnswerTypeEnum;
    isActive: boolean;
    selectedOptions: AssessmentAnswer[];
}

declare enum QuestionForEnum {
    ASSESSMENT = "ASSESSMENT",
    INTERVIEW = "INTERVIEW"
}
declare class AssessmetQuestion extends BaseEntity {
    text: string;
    questionFor: QuestionForEnum;
    isActive: boolean;
    options: AssessmetQuestionOption[];
    answers: AssessmentAnswer[];
}

declare enum SelectedAnswerTypeEnum {
    CORRECT = "CORRECT",
    ACCEPTABLE = "ACCEPTABLE",
    ELIMINATE = "ELIMINATE"
}
declare class AssessmentAnswer extends BaseEntity {
    userId: number;
    user: User;
    questionId: number;
    question: AssessmetQuestion;
    selectedOptionId: number;
    option: AssessmetQuestionOption;
    selectedAnswerType: SelectedAnswerTypeEnum;
    score: number;
}

declare class CompanySkill extends BaseEntity {
    userId: number;
    user: User;
    skillName: string;
}

declare class AdminPermission extends BaseEntity {
    permissionName: string;
    permissionSlug: string;
    permissionDescription: string;
    module: string;
    isActive: boolean;
    adminRole: AdminRolePermission[];
}

declare class AdminRolePermission extends BaseEntity {
    roleId: number;
    adminRole: AdminRole;
    permissionId: number;
    adminPermissions: AdminPermission;
}

declare class AdminRole extends BaseEntity {
    roleName: string;
    roleSlug: string;
    roleDescription: string;
    isActive: boolean;
    adminRolePermission: AdminRolePermission[];
    userRoles: AdminUserRole[];
}

declare class AdminUserRole extends BaseEntity {
    userId: number;
    user: User;
    roleId: number;
    adminRole: AdminRole;
}

declare class FreelancerResume extends BaseEntity {
    userId: number;
    user: User;
    resumeData: string;
    processedResumeData: string;
}

declare enum StripeWalletTransactionTypeEnum {
    ADD_FUNDS = "ADD_FUNDS",
    TRANSFER = "TRANSFER",
    WITHDRAW = "WITHDRAW",
    INVOICE_PAYMENT = "INVOICE_PAYMENT",
    REFUND = "REFUND"
}
declare enum StripeWalletTransactionStatusEnum {
    PENDING = "PENDING",
    SUCCESS = "SUCCESS",
    FAILED = "FAILED"
}
declare class StripeWalletTransaction extends BaseEntity {
    walletId: number;
    stripeWallet: StripeWallet;
    amount: number;
    currency: string;
    type: StripeWalletTransactionTypeEnum;
    status: StripeWalletTransactionStatusEnum;
    stripeReferenceId: string;
    description: string;
}

declare enum StripeWalletAccountTypeEnum {
    BUSINESS = "BUSINESS",
    FREELANCER = "FREELANCER"
}
declare class StripeWallet extends BaseEntity {
    userId: number;
    user: User;
    accountType: StripeWalletAccountTypeEnum;
    stripeAccountId: string;
    stripeCustomerId: string;
    walletBalance: number;
    stripeMetadata: Record<string, any>;
    transactions: StripeWalletTransaction[];
}

declare enum AccountType {
    ADMIN = "ADMIN",
    SUB_ADMIN = "SUB_ADMIN",
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER",
    CLIENT_EMPLOYEE = "CLIENT_EMPLOYEE"
}
declare enum AccountStatus {
    INACTIVE = "INACTIVE",
    ACTIVE = "ACTIVE",
    SUSPENDED = "SUSPENDED",
    BLOCKED = "BLOCKED"
}
declare enum Provider {
    LINKEDIN = "LINKEDIN",
    GOOGLE = "GOOGLE",
    GITLABS = "GITLABS"
}
declare class User extends BaseEntity {
    uniqueId: string;
    parentId: number;
    parent: User;
    children: User[];
    username: string;
    firstName: string;
    lastName: string;
    dateOfBirth: Date;
    gender: string;
    profilePictureUrl: string;
    email: string;
    mobileCode: string;
    mobile: string;
    password: string;
    accountType: AccountType;
    accountStatus: AccountStatus;
    isEmailVerified: boolean;
    isMobileVerified: boolean;
    isSocial: boolean;
    lastLoginAt: Date;
    lastLoginIp: string;
    resetToken: string | null;
    resetTokenExpireAt: Date | null;
    setPasswordToken: string | null;
    refreshTokens: RefreshToken[];
    provider: Provider;
    providerToken: string;
    linkedInId: string;
    googleId: string;
    gitLabsId: string;
    onBoardedBy: string;
    otps: Otp[];
    senseloafLogs: SenseloafLog[];
    companyProfile: CompanyProfile;
    companySkills: CompanySkill[];
    companyMemberRoles: CompanyMemberRole[];
    companyAiInterview: AiInterview[];
    clientF2FInterviews: F2FInterview[];
    freelancerProfile: FreelancerProfile;
    freelancerResume: FreelancerResume;
    assessments: FreelancerAssessment[];
    assessmentAnswers: AssessmentAnswer[];
    freelancerSkills: FreelancerSkill[];
    freelancerExperience: FreelancerExperience[];
    freelancerEducation: FreelancerEducation[];
    freelancerProject: FreelancerProject[];
    freelancerCaseStudy: FreelancerCaseStudy[];
    freelancerTool: FreelancerTool[];
    freelancerFramework: FreelancerFramework[];
    freelancerDeclaration: FreelancerDeclaration;
    freelancerAiInterview: AiInterview[];
    freelancerF2FInterviews: F2FInterview[];
    freelancerF2FInterviewRescheduleRequests: F2fInterviewRescheduleRequest[];
    jobs: Job[];
    jobApplications: JobApplication[];
    interviews: Interview[];
    bankDetail: BankDetail[];
    systemPreference: SystemPreference[];
    givenRatings: Rating[];
    receivedRatings: Rating[];
    adminUserRoles: AdminUserRole[];
    clientContracts: Contract[];
    freelancerContracts: Contract[];
    stripeWallet: StripeWallet;
}

declare enum RatingTypeEnum {
    FREELANCER_TO_CLIENT = "FREELANCER_TO_CLIENT",
    CLIENT_TO_FREELANCER = "CLIENT_TO_FREELANCER"
}
declare class Rating extends BaseEntity {
    reviewer_id: number;
    reviewer: User;
    reviewee_id: number;
    reviewee: User;
    ratingType: RatingTypeEnum;
    rating: number;
    review: string;
}

declare class CreateRatingDto {
    revieweeId: number;
    ratingType: RatingTypeEnum;
    rating: number;
    review?: string;
}

interface IAddRatingPayload {
    reviewer_id: number;
    reviewee_id: number;
    ratingType: string;
    rating: number;
    review: string;
}
interface ICreateRatingResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IFetchRatingResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}

declare const COMPANY_ROLES_PATTERNS: {
    fetchCompanyRoles: string;
    fetchAllCompanyRolesDropdown: string;
    findCompanyRoleById: string;
    createCompanyRole: string;
    updateCompanyRole: string;
    deleteCompanyRole: string;
    toggleCompanyRoleStatus: string;
    fetchAllDeletedCompanyRoles: string;
};

declare class CreateCompanyRoleDto {
    name: string;
    slug: string;
    description: string;
    permissionIds: number[];
    isActive: boolean;
}

declare class UpdateCompanyRoleDto {
    name: string;
    slug: string;
    description: string;
    permissionIds: number[];
    isActive: boolean;
}

declare class ToggleCompanyRoleVisibilityDto {
    isActive: boolean;
}

interface IFetchCompanyRoleQuery {
    page_size?: number;
    page: number;
    searchText?: string;
    name: string;
    right: string;
    sortColumn?: string;
    sortBy?: string;
}
interface IFetchCompanyRolesResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}
interface IFetchCompanyRoleByIdQuery {
    permission?: string;
}
interface IFetchCompanyRoleByIdResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}
interface ICreateCompanyRolePayload {
    name: string;
    slug: string;
    description: string;
    isActive: boolean;
    permissionIds: number[];
}
interface ICreateCompanyRoleResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IUpdateCompanyRolePayload {
    name: string;
    slug: string;
    description: string;
    isActive: boolean;
    permissionIds: number[];
}
interface IUpdateCompanyRoleResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IToggleCompanyRoleVisibilityPayload {
    isActive: boolean;
}
interface IToggleCompanyRoleVisibilityResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IDeleteCompanyRoleResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IAttachPermissionsToCompanyRoleResponse {
    statusCode: number;
    status: boolean;
    message: string;
}

declare const FREELANCER_EXPERIENCE_PATTERN: {
    fetchFreelancerExperience: string;
    saveFreelancerExperience: string;
};

declare class ExperienceDto {
    uuid?: string;
    companyName: string;
    designation: string;
    jobDuration: string;
    description: string;
}
declare class FreelancerExperienceDto {
    experiences: ExperienceDto[];
}

declare const COMPANY_MEMBERS_PATTERNS: {
    fetchCompanyMembers: string;
    fetchAllCompanyMembersDropdown: string;
    findCompanyMemberById: string;
    createCompanyMember: string;
    updateCompanyMember: string;
    deleteCompanyMember: string;
    toggleCompanyMemberStatus: string;
    fetchAllDeletedCompanyMembers: string;
};

declare class CreateCompanyMemberDto {
    name: string;
    email: string;
    roleIds: number[];
}

declare class UpdateCompanyMemberDto {
    name: string;
    email: string;
    roleIds: number[];
}

declare class ToggleCompanyMemberVisibilityDto {
    isActive: boolean;
}

interface IFetchCompanyMemberQuery {
    page_size?: number;
    page: number;
    searchText?: string;
    name: string;
    right: string;
    sortColumn?: string;
    sortBy?: string;
}
interface IFetchCompanyMembersResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}
interface IFetchCompanyMemberByIdQuery {
    permission?: string;
}
interface IFetchCompanyMemberByIdResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}
interface ICreateCompanyMemberPayload {
    name: string;
    email: string;
    roleIds: number[];
}
interface ICreateCompanyMemberResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IUpdateCompanyMemberPayload {
    name: string;
    email: string;
    roleIds: number[];
}
interface IUpdateCompanyMemberResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IToggleCompanyMemberVisibilityPayload {
    isActive: boolean;
}
interface IToggleCompanyMemberVisibilityResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IDeleteCompanyMemberResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IAttachPermissionsToCompanyMemberResponse {
    statusCode: number;
    status: boolean;
    message: string;
}

declare const FREELANCER_EDUCATION_PATTERN: {
    fetchFreelancerEducation: string;
    saveFreelancerEducation: string;
};

declare class EducationDto {
    uuid?: string;
    degree: string;
    university: string;
    yearOfGraduation: string;
}
declare class FreelancerEducationDto {
    educations: EducationDto[];
}

declare const FREELANCER_PROJECT_PATTERN: {
    fetchFreelancerProject: string;
    saveFreelancerProject: string;
};

declare class ProjectDto {
    uuid?: string;
    projectName: string;
    startDate: string;
    endDate: string;
    clientName?: string;
    gitLink?: string;
    description?: string;
}
declare class CaseStudyDto {
    uuid?: string;
    projectName: string;
    caseStudyLink: string;
    description?: string;
}
declare class FreelancerProjectDto {
    projects: ProjectDto[];
    casestudies: CaseStudyDto[];
}

declare const PERMISSION_PATTERN: {
    fetchAllPermissionsDropdown: string;
};

declare const FREELANCER_SKILL_PATTERN: {
    fetchFreelancerSkill: string;
    saveFreelancerSkill: string;
};

declare class FreelancerSkillDto {
    coreSkills: string[];
    tools: string[];
    frameworks: string[];
}

declare const ADMIN_FREELANCER_PATTERN: {
    adminFetchFreelancers: string;
    adminFreelancerCount: string;
    adminExportFreelancer: string;
    adminFetchFreelancerById: string;
    adminCreateFreelancer: string;
    adminUpdateFreelancer: string;
    adminDeleteFreelancer: string;
    fetchFreelancerGraphCount: string;
};

declare enum NatureOfWorkEnum$1 {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare enum ModeOfWorkEnum$1 {
    REMOTE = "REMOTE",
    ONSITE = "ONSITE",
    BOTH = "BOTH"
}
declare class CreateFreelancerDto {
    fullName: string;
    email: string;
    mobileCode: string;
    mobile: string;
    password: string;
    confirmPassword: string;
    developer: boolean;
    natureOfWork: NatureOfWorkEnum$1;
    expectedHourlyCompensation: number;
    modeOfWork: ModeOfWorkEnum$1;
    isImmediateJoiner: boolean;
    availabilityToJoin: string;
    linkedinProfileLink?: string;
    kaggleProfileLink?: string;
    githubProfileLink?: string;
    stackOverflowProfileLink?: string;
    portfolioLink?: string;
}

declare enum NatureOfWorkEnum {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare enum ModeOfWorkEnum {
    REMOTE = "REMOTE",
    ONSITE = "ONSITE",
    BOTH = "BOTH"
}
declare class UpdateFreelancerDto {
    fullName?: string;
    email?: string;
    mobileCode?: string;
    mobile?: string;
    password?: string;
    developer?: boolean;
    natureOfWork?: NatureOfWorkEnum;
    expectedHourlyCompensation?: number;
    modeOfWork?: ModeOfWorkEnum;
    isImmediateJoiner?: boolean;
    availabilityToJoin?: string;
    linkedinProfileLink?: string;
    kaggleProfileLink?: string;
    githubProfileLink?: string;
    stackOverflowProfileLink?: string;
    portfolioLink?: string;
}

interface IFetchFreelancersResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}
interface ICreateFreelancerPayload {
    firstName: string;
    lastName: string;
    email: string;
    password: string;
    confirmPassword: string;
    skills: string[];
    expectedHourlyCompensation: number;
    modeOfWork: "REMOTE" | "ONSITE" | "HYBRID";
    availabilityToJoin: string;
    isImmediateJoiner: boolean;
    linkedinProfileLink?: string;
    githubProfileLink?: string;
    kaggleProfileLink?: string;
    stackOverflowProfileLink?: string;
    portfolioLink?: string;
    foundUsOn: string;
    OTHER?: string;
    foundUsOnDetail?: string;
    isDeveloper?: boolean;
}
interface ICreateFreelancerResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IUpdateFreelancerPayload {
    firstName?: string;
    lastName?: string;
    email?: string;
    password?: string;
    skills?: string[];
    expectedHourlyCompensation?: number;
    modeOfWork?: string;
    availabilityToJoin?: string;
    isImmediateJoiner?: boolean;
    linkedinProfileLink?: string;
    githubProfileLink?: string;
    kaggleProfileLink?: string;
    stackOverflowProfileLink?: string;
    portfolioLink?: string;
    foundUsOn?: string;
    OTHER?: string;
    foundUsOnDetail?: string;
    isDeveloper?: boolean;
}
interface IUpdateFreelancerResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IDeleteFreelancerResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IAttachPermissionsToFreelancerResponse {
    statusCode: number;
    status: boolean;
    message: string;
}

declare const CLIENT_ADMIN_PATTERNS: {
    fetchAdminClients: string;
    createAdminClients: string;
    updateAdminClient: string;
    fetchAdminClientById: string;
    deleteAdminClient: string;
    exportAdminClients: string;
    fetchClientCount: string;
    fetchClientDropdown: string;
    fetchClientGraphCount: string;
};

declare enum CreateClientHiringModeEnum {
    REMOTE = "REMOTE",
    ONSITE = "ONSITE",
    BOTH = "BOTH"
}
declare enum CreateClientHiringTypeEnum {
    PARTTIME = "PARTTIME",
    FULLTIME = "FULLTIME",
    BOTH = "BOTH"
}
declare class CreateClientDto {
    firstName: string;
    lastName: string;
    email: string;
    password: string;
    confirmPassword: string;
    companyName: string;
    skills: string[];
    requiredFreelancer: string;
    kindOfHiring: string;
    modeOfHire: string;
    foundUsOn: string;
    foundUsOnDetail?: string;
}

declare class UpdateClientAccountStatusDto {
    accountStatus: string;
}

declare enum UpdateClientHiringModeEnum {
    REMOTE = "REMOTE",
    ONSITE = "ONSITE",
    BOTH = "BOTH"
}
declare enum UpdateClientHiringTypeEnum {
    PARTTIME = "PARTTIME",
    FULLTIME = "FULLTIME",
    BOTH = "BOTH"
}
declare class UpdateClientDto {
    firstName: string;
    lastName: string;
    email: string;
    password?: string;
    companyName: string;
    skills: string[];
    requiredFreelancer: string;
    kindOfHiring: string;
    modeOfHire: string;
    foundUsOn: string;
    foundUsOnDetail?: string;
}

interface IFetchClientsResponse {
    statusCode: number;
    status: boolean;
    message: string;
    data: any;
}
interface ICreateClientPayload {
    firstName: string;
    lastName: string;
    email: string;
    password: string;
    confirmPassword: string;
    companyName: string;
    skills: string[];
    requiredFreelancer: string;
    kindOfHiring: string;
    modeOfHire: string;
    foundUsOn: string;
    foundUsOnDetail?: string;
}
interface ICreateClientResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IUpdateClientPayload {
    firstName?: string;
    lastName?: string;
    email?: string;
    password?: string;
    companyName?: string;
    skills?: string[];
    requiredFreelancer?: string;
    kindOfHiring?: string;
    modeOfHire?: string;
    foundUsOn?: string;
    foundUsOnDetail?: string;
}
interface IUpdateClientResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IUpdateClientAccountStatusPayload {
    accountSatus: string;
}
interface IUpdateClientAccountStatusResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IDeleteClientResponse {
    statusCode: number;
    status: boolean;
    message: string;
}
interface IAttachPermissionsToClientResponse {
    statusCode: number;
    status: boolean;
    message: string;
}

declare const FREELANCER_DECLARATION_PATTERN: {
    fetchFreelancerDeclaration: string;
    saveFreelancerDeclaration: string;
};

declare enum DocumentTypeEnum {
    AADHAAR = "AADHAAR_CARD",
    PASSPORT = "PASSPORT",
    DRIVING_LICENSE = "DRIVING_LICENSE",
    PAN_CARD = "PAN_CARD"
}
declare class FreelancerDeclarationDto {
    uuid?: string;
    documentType: DocumentTypeEnum;
    declarationAccepted: string;
}

declare const CMS_PATTERNS: {
    fetchCms: string;
    createCms: string;
    updateCms: string;
    deleteCms: string;
    findCmsById: string;
};

declare class CreateCmsDto {
    title: string;
    content: string;
    isActive: boolean;
}

declare class UpdateCmsDto {
    uuid: string;
    title: string;
    content: string;
    isActive: boolean;
}

interface IFetchCmsQuery {
    page_size?: number;
    page: number;
    searchText?: string;
    sortColumn?: string;
    sortBy?: string;
}

declare const COUNTRY_PATTERN: {
    fetchCountryDropdown: string;
    fetchCountryPhoneCodeDropdown: string;
};
declare const STATE_PATTERN: {
    fetchStateDropdown: string;
};
declare const CITY_PATTERN: {
    fetchCityDropdown: string;
};

declare const ADMIN_JOB_PATTERN: {
    adminFetchJobs: string;
    adminFetchJobById: string;
    adminCreateJob: string;
    adminUpdateJob: string;
    adminDeleteJob: string;
    adminCountJob: string;
    adminFetchGraphCount: string;
};

declare enum JobLocationEnumDto {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    BOTH = "BOTH"
}
declare enum TypeOfEmploymentEnumDto {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare class AdminCreateJobInformationDto {
    jobRole: string;
    note?: string;
    skills: string[];
    openings: number;
    location: JobLocationEnumDto;
    typeOfEmployment: TypeOfEmploymentEnumDto;
    onboardingTat: string;
    candidateCommunicationSkills: string;
    currency: string;
    expectedSalaryFrom: number;
    expectedSalaryTo: number;
    tentativeStartDate: string;
    tentativeEndDate: string;
    additionalComment?: string;
    countryId: number;
    stateId: number;
    cityId: number;
    clientId: number;
}

declare enum JobLocationEnums {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    BOTH = "BOTH"
}
declare enum TypeOfEmploymentEnums {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare class AdminUpdateJobInformationDto {
    jobRole: string;
    note?: string;
    skills: string[];
    openings: number;
    location: JobLocationEnums;
    typeOfEmployment: TypeOfEmploymentEnums;
    onboardingTat: string;
    candidateCommunicationSkills: string;
    currency: string;
    expectedSalaryFrom: number;
    expectedSalaryTo: number;
    tentativeStartDate: string;
    tentativeEndDate: string;
    additionalComment?: string;
    countryId: number;
    stateId: number;
    cityId: number;
    clientId: number;
}

declare const LEAD_PATTERN: {
    fetchLead: string;
    createLead: string;
};

declare enum CategoryEmumDto {
    BUSINESS = "BUSINESS",
    FREELANCER = "FREELANCER"
}
declare class CreateLeadDto {
    name: string;
    email: string;
    mobileCode: string;
    mobile: string;
    description?: string;
    category: CategoryEmumDto;
}

declare const ADMIN_ROLE_PATTERN: {
    adminFetchRoles: string;
    adminFetchRoleById: string;
    adminFetchRolesDropdown: string;
    adminCountRole: string;
    adminCreateRole: string;
    adminUpdateRole: string;
    adminDeleteRole: string;
    attachPermissionsToRole: string;
};

declare class CreateAdminRoleDto {
    roleName: string;
    roleDescription?: string;
}

declare class UpdateAdminRoleDto {
    roleName: string;
    roleDescription?: string;
    isActive?: boolean;
}

declare class AttachPermissionsToRoleDto {
    roleId: string;
    permissionIds?: string;
}

declare const ADMIN_PERMISSION_PATTERN: {
    fetchAdminPermissions: string;
};

declare const INTERVIEW_INVITE_PATTERN: {
    sendInterviewInvite: string;
};
declare const F2F_INTERVIEW_PATTERN: {
    fetchBookings: string;
    fetchBookingById: string;
    fetchInterviewsByInterviewerId: string;
    fetchInterviewsByCandidateId: string;
    createF2FInterview: string;
    createF2FInterviewRescheduleRequest: string;
    rejectF2FInterviewRescheduleRequest: string;
};
declare const CALENDLY_PATTERN: {
    handleCalendlyWebhook: string;
};

declare enum CandidateType {
    SHORTLISTED = "SHORTLISTED",
    APPLICATNTS = "APPLICATNTS",
    RECOMMENDED = "RECOMMENDED",
    NEW = "NEW"
}
declare class ExistingCandidateDto {
    id: string;
    type: CandidateType;
}
declare class NewCandidateDto {
    name: string;
    email: string;
    type: CandidateType;
}
declare class CandidatesDto {
    exixtingCandidates?: ExistingCandidateDto[];
    newCandidates?: NewCandidateDto[];
}
declare class InterviewInviteDto {
    jobId: string;
    candidates: CandidatesDto;
}

declare class CreateF2FInterviewDto {
    inviteeEmail: string;
    inviteeName: string;
    interviewId: number;
    candidateId: number;
}

declare class CreateF2FInterviewRescheduleRequestDto {
    f2FInterviewId: string;
    rescheduledDate: string;
    rescheduledSlot: string;
    freelancerRequestReason: string;
}

declare const CONTRACT_PATTERN: {
    fetchContractsForClient: string;
    fetchContractCountForClientAsPerStatus: string;
    fetchContractsForFreelancer: string;
    fetchContractCountForFreelancerAsPerStatus: string;
    signContractsForClient: string;
    signContractsForFreelancer: string;
    fetchContractDetailsForClient: string;
    fetchContractDetailsForFreelancer: string;
    rejectContractsForFreelancer: string;
    fetchFreelancersForClientContractRepository: string;
    fetchJobsForClientContractRepository: string;
    fetchContractsForClientContractRepository: string;
    fetchClientsForFreelancerContractRepository: string;
    fetchJobsForFreelancerContractRepository: string;
    fetchContractsForFreelancerContractRepository: string;
};

declare const UserTCPAdapter: () => MicroserviceOptions;

declare const JobTCPAdapter: () => MicroserviceOptions;

declare const NotificationTCPAdapter: () => MicroserviceOptions;

declare const UserRMQAdapter: (mode?: string) => MicroserviceOptions;

declare const JobRMQAdapter: (mode?: string) => MicroserviceOptions;

declare const NotificationRMQAdapter: (mode?: string) => MicroserviceOptions;

declare class SequenceGenerator extends BaseEntity {
    module: string;
    prefix: string;
    lastSequence: number;
    year: number | null;
}

declare enum QuestionFor {
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class Question extends BaseEntity {
    question: string;
    hint: string;
    slug: string;
    questionFor: QuestionFor;
    type: string;
    options: {
        label: string;
        hint: string;
        value: string;
    }[];
    isActive: boolean;
}

declare class Skill extends BaseEntity {
    name: string;
    slug: string;
    isActive: boolean;
}

declare class JobRoles extends BaseEntity {
    slug: string;
    name: string;
    isActive: boolean;
}

declare class Feature extends BaseEntity {
    name: string;
    plans: Plan[];
}

declare class Plan extends BaseEntity {
    name: string;
    description: string;
    price: number;
    billingPeriod: string;
    isCurrent: boolean;
    features: Feature[];
}

declare class Cms extends BaseEntity {
    title: string;
    slug: string;
    content: string;
    isActive: boolean;
}

declare enum CategoryEmum {
    BUSINESS = "BUSINESS",
    FREELANCER = "FREELANCER"
}
declare class Lead extends BaseEntity {
    name: string;
    mobileCode: string;
    mobile: string;
    email: string;
    description: string;
    category: CategoryEmum;
}

declare class JobFreelancerRecommendation {
    jobId: number;
    jobUuid: string;
    jobUniqueId: string;
    jobRole: string;
    jobOpenings: number;
    jobLocation: string;
    jobCurrency: string;
    jobSalaryFrom: string;
    jobSalaryTo: string;
    jobEmploymentType: string;
    applicationReceived: number;
    jobPostedAt: Date;
    freelancerId: number;
    freelancerUuid: string;
    freelancerUniqueId: string;
    freelancerFirstName: string;
    freelancerLastName: string;
    freelancerEmail: string;
    freelancerProfilePicture: string;
    freelancerIsSocial: string;
    freelancerCreatedAt: Date;
    freelancerDesignation: string;
    freelancerExperience: string;
    freelancerExpertshubVerified: boolean;
    freelancerHourlyCompensation: number;
    freelancerCountryName: string;
    freelancerCountryIsoCode: string;
    clientId: number;
    clientUuid: string;
    clientFirstName: string;
    clientLastName: string;
    clientEmail: string;
    clientCompanyLogo: string;
    clientCompanyName: string;
    matchingSkills: string[];
    matchingSkillsCount: number;
    requiredSkills: string[];
    requiredSkillsCount: number;
}

declare class JobFreelancerRecommendationV2 {
    jobId: number;
    jobOwnerId: number;
    freelancerId: number;
    matchingSkills: string[];
    matchingSkillsCount: number;
    requiredSkills: string[];
    requiredSkillsCount: number;
}

declare class ClientFreelancerRecommendation {
    clientId: number;
    clientUuid: string;
    freelancerId: number;
    freelancerUuid: string;
    freelancerUniqueId: string;
    freelancerFirstName: string;
    freelancerLastName: string;
    freelancerEmail: string;
    freelancerProfilePicture: string;
    freelancerIsSocial: string;
    freelancerCreatedAt: Date;
    freelancerDesignation: string;
    freelancerExperience: string;
    freelancerExpertshubVerified: boolean;
    freelancerHourlyCompensation: number;
    freelancerCountryName: string;
    freelancerCountryIsoCode: string;
    matchingSkills: string[];
    matchingSkillsCount: number;
    requiredSkills: string[];
    requiredSkillsCount: number;
}

declare enum CommissionTypeEnum {
    PERCENTAGE = "PERCENTAGE",
    FLAT = "FLAT"
}
declare class Commission extends BaseEntity {
    freelancerCommissionType: CommissionTypeEnum;
    freelancerCommission: number;
    clientCommissionType: CommissionTypeEnum;
    clientCommission: number;
}

declare class CalendlyMeetingLog extends BaseEntity {
    calendlyEventId: string;
    calendlyEventType: string;
    rawWebhookData: any;
}

declare class ZoomMeetingLog extends BaseEntity {
    zoomMeetingId: string;
    zoomEventType: string;
    rawWebhookData: any;
}

export { ADMIN_FREELANCER_PATTERN, ADMIN_JOB_PATTERN, ADMIN_PERMISSION_PATTERN, ADMIN_ROLE_PATTERN, ASSESSMENT_QUESTION_PATTERN, AUTHENTICATION_PATTERN, AccountStatus, AccountType, AdminCreateJobInformationDto, AdminPermission, AdminRole, AdminRolePermission, AdminUpdateJobInformationDto, AdminUserRole, AiAssessmentStatusEnum, AiInterview, AiInterviewStatusEnum, AnswerTypeEnum, ApplicationStatusEnum, AssessmentAnswer, AssessmentStatusEnum, AssessmetQuestion, AssessmetQuestionOption, AttachPermissionsToRoleDto, BANK_PATTERN, BankAccountScope, BankAccountScopeEnum, BankAccountTypeEnum, BankDetail, BaseEntity, CALENDLY_PATTERN, CITY_PATTERN, CLIENT_ADMIN_PATTERNS, CLIENT_PROFILE_PATTERN, CMS_PATTERNS, COMPANY_MEMBERS_PATTERNS, COMPANY_ROLES_PATTERNS, CONTRACT_PATTERN, COUNTRY_PATTERN, CalendlyMeetingLog, CandidateType, CaseStudyDto, CategoryEmum, CategoryEmumDto, City, ClientChangePasswordDto, ClientCreateAccountDto, ClientFreelancerRecommendation, ClientProfileQuestionDto, Cms, Commission, CommissionTypeEnum, CompanyMemberRole, CompanyOnboardingStepEnum, CompanyProfile, CompanyRole, CompanyRolePermission, CompanySkill, Contract, ContractStatusEnum, ContractTypeEnum, Country, CreateAdminRoleDto, CreateClientDto, CreateClientHiringModeEnum, CreateClientHiringTypeEnum, CreateCmsDto, CreateCompanyMemberDto, CreateCompanyRoleDto, CreateF2FInterviewDto, CreateF2FInterviewRescheduleRequestDto, CreateFreelancerDto, CreateLeadDto, CreateQuestionDto, CreateRatingDto, CreateSubAdminDto, DocumentType, DocumentTypeEnum, DurationTypeEnum, EducationDto, EmploymentType, ExperienceDto, F2FInterview, F2FInterviewSchedule, F2F_INTERVIEW_PATTERN, F2fInterviewRescheduleRequest, F2fInterviewRescheduleRequestStatusEnum, F2fInterviewScheduleStatusEnum, F2fInterviewStatusEnum, FREELANCER_DECLARATION_PATTERN, FREELANCER_EDUCATION_PATTERN, FREELANCER_EXPERIENCE_PATTERN, FREELANCER_PROJECT_PATTERN, FREELANCER_SKILL_PATTERN, Feature, ForgotPasswordDto, FreelancerAssessment, FreelancerBankDetailsDto, FreelancerCaptureAiAssessmentStatusDto, FreelancerCaseStudy, FreelancerChangePasswordDto, FreelancerCreateAccountDto, FreelancerDeclaration, FreelancerDeclarationDto, FreelancerDevelopmentPreferenceDto, FreelancerEducation, FreelancerEducationDto, FreelancerExperience, FreelancerExperienceDto, FreelancerFramework, FreelancerInitiateAiAssessmentDto, FreelancerInitiateMcqAssessmentDto, FreelancerParseResumeDto, FreelancerProfile, FreelancerProfileQuestionDto, FreelancerProject, FreelancerProjectDto, FreelancerResume, FreelancerSkill, FreelancerSkillDto, FreelancerSkipAiAssessmentDto, FreelancerTool, FreelancerUploadResumeDto, FreelancerWorkShowcaseDto, FromUsOn, type IAddRatingPayload, type IAttachPermissionsToClientResponse, type IAttachPermissionsToCompanyMemberResponse, type IAttachPermissionsToCompanyRoleResponse, type IAttachPermissionsToFreelancerResponse, type IAttachPermissionsToSubAdminResponse, type ICreateClientPayload, type ICreateClientResponse, type ICreateCompanyMemberPayload, type ICreateCompanyMemberResponse, type ICreateCompanyRolePayload, type ICreateCompanyRoleResponse, type ICreateFreelancerPayload, type ICreateFreelancerResponse, type ICreateRatingResponse, type ICreateSubAdminPayload, type ICreateSubAdminResponse, type IDeleteClientResponse, type IDeleteCompanyMemberResponse, type IDeleteCompanyRoleResponse, type IDeleteFreelancerResponse, type IDeleteSubAdminResponse, type IFetchClientProfileQuery, type IFetchClientProfileResponse, type IFetchClientsResponse, type IFetchCmsQuery, type IFetchCompanyMemberByIdQuery, type IFetchCompanyMemberByIdResponse, type IFetchCompanyMemberQuery, type IFetchCompanyMembersResponse, type IFetchCompanyRoleByIdQuery, type IFetchCompanyRoleByIdResponse, type IFetchCompanyRoleQuery, type IFetchCompanyRolesResponse, type IFetchFreelancersResponse, type IFetchPlanResponse, type IFetchQuestionQuery, type IFetchQuestionResponse, type IFetchRatingResponse, type IFetchSubAdminByIdQuery, type IFetchSubAdminByIdResponse, type IFetchSubAdminQuery, type IFetchSubAdminResponse, INTERVIEW_INVITE_PATTERN, type IToggleCompanyMemberVisibilityPayload, type IToggleCompanyMemberVisibilityResponse, type IToggleCompanyRoleVisibilityPayload, type IToggleCompanyRoleVisibilityResponse, type IUpdateClientAccountStatusPayload, type IUpdateClientAccountStatusResponse, type IUpdateClientLogoPayload, type IUpdateClientLogoResponse, type IUpdateClientPasswordPayload, type IUpdateClientPayload, type IUpdateClientProfilePayload, type IUpdateClientProfileResponse, type IUpdateClientResponse, type IUpdateCompanyMemberPayload, type IUpdateCompanyMemberResponse, type IUpdateCompanyRolePayload, type IUpdateCompanyRoleResponse, type IUpdateFreelancerPayload, type IUpdateFreelancerResponse, type IUpdateSubAdminAccountStatusPayload, type IUpdateSubAdminAccountStatusResponse, type IUpdateSubAdminPayload, type IUpdateSubAdminResponse, Interview, InterviewInvite, InterviewInviteDto, InterviewInviteStatusEnum, InterviewQuestion, InterviewSkill, InterviewStatusEnum, JOB_PATTERN, JOB_ROLE_PATTERN, Job, JobAdditionalCommentDto, JobApplication, JobBasicInformationDto, JobDescriptionDto, JobFreelancerRecommendation, JobFreelancerRecommendationV2, JobIdParamDto, JobLocation, JobLocationEnum, JobLocationEnumDto, JobLocationEnums, JobRMQAdapter, JobRecommendation, JobRoles, JobSkill, JobStatus, JobStatusDto, JobStatusEnum, JobTCPAdapter, KindOfHire, LEAD_PATTERN, Lead, LoginDto, LoginViaOtpDto, LoginViaOtpScopeEnum, LogoutDto, McqStatusEnum, ModeOfHire, ModeOfWork, ModeOfWorkDto, NOTIFICATION_PATTERN, NatureOfWork, NatureOfWorkDto, NotificationRMQAdapter, NotificationTCPAdapter, ONBOARDING_PATTERN, ONBOARDING_QUESTION_PATTERN, OTP_PATTERN, OnboardingStepEnum, Otp, PERMISSION_PATTERN, PLAN_PATTERN, PROFILE_PATTERN, Permission, Plan, ProjectDto, Provider, Question, QuestionFor, QuestionForEnum, RATING_PATTERN, RESUME_PARSER_PATTERN, Rating, RatingTypeEnum, RefreshDto, RefreshToken, ResetPasswordDto, ResetPasswordTokenValidationDto, STATE_PATTERN, SUBADMIN_PATTERN, SYSTEM_PREFERENCES_PATTERN, ScopeEnum$3 as ScopeEnum, SelectedAnswerTypeEnum, SendGuestOtpDto, SendGuestOtpPurposeEnum, SendGuestOtpScopeEnum, SendLoginOtpDto, SendLoginOtpPurposeEnum, SendLoginOtpScopeEnum, SenseloafLog, SequenceGenerator, SetPasswordDto, Skill, State, Step, StripeWallet, StripeWalletTransaction, StripeWalletTransactionStatusEnum, StripeWalletTransactionTypeEnum, SystemPreference, SystemPreferenceDto, SystemPreferenceKey, ToggleCompanyMemberVisibilityDto, ToggleCompanyRoleVisibilityDto, TypeOfEmploymentEnum, TypeOfEmploymentEnumDto, TypeOfEmploymentEnums, UpdateAdminRoleDto, UpdateClientAccountStatusDto, UpdateClientDto, UpdateClientHiringModeEnum, UpdateClientHiringTypeEnum, UpdateCmsDto, UpdateCompanyMemberDto, UpdateCompanyProfileDto, UpdateCompanyRoleDto, UpdateFreelancerDto, UpdateFreelancerProfileDto, UpdateSubAdminAccountStatusDto, UpdateSubAdminDto, User, UserRMQAdapter, UserTCPAdapter, VerifyGuestOtpDto, VerifyGuestOtpPurposeEnum, ZoomMeetingLog };