import Transport from 'winston-transport';
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;
    handleAdminResetPassword: string;
    handleValidateResetPasswordToken: string;
    handleVerifyPermission: string;
    handleValidateEmail: string;
    handleValidateEmailForLogin: string;
    handleValidateMobile: string;
    handleAdminLogin: string;
    handleSetPassword: string;
    signUpWithLinkedIn: string;
    loginWithLinkedIn: string;
    signUpWithGoogle: string;
    loginWithGoogle: string;
    validateOnboardingToken: string;
    loginUsingUuid: string;
    handleUserResetPasswordByAdmin: 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;
    ip: string;
}

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

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 enum ScopeEmailEnumDto {
    ADMIN = "ADMIN",
    SUB_ADMIN = "SUB_ADMIN",
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class ValidateEmailDto {
    email: string;
    scope?: ScopeEmailEnumDto;
}

declare enum ScopeEmailForLoginEnumDto {
    ADMIN = "ADMIN",
    SUB_ADMIN = "SUB_ADMIN",
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class ValidateEmailForLoginDto {
    email: string;
    scope: ScopeEmailForLoginEnumDto;
}

declare class ValidateMobileDto {
    mobileCode: string;
    mobile: string;
}

declare class SocialAuthDto {
    accessToken?: string;
    refreshToken?: string;
    profile?: any;
    provider?: string;
    providerId?: string;
}

declare class LoginUsingUuidDTO {
    uuid: string;
}

declare class ResetUserPasswordByAdminDto {
    uuid: string;
    password: string;
}

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

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

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

declare enum VerifyGuestOtpPurposeEnum {
    SIGN_UP = "SIGN_UP",
    LOGIN = "LOGIN"
}
declare class VerifyGuestOtpDto {
    target: string;
    otp: string;
    purpose: VerifyGuestOtpPurposeEnum;
}

declare class SendOtpDto {
    userId: string;
    purpose?: string;
}

declare class VerifyOtpDto {
    userId: string;
    otp: string;
    purpose?: string;
}

declare const ONBOARDING_PATTERN: {
    handleFreelancerAccountCreation: string;
    handleFreelancerResumeUpload: string;
    handleFreelancerDeveloperPreference: string;
    handleFreelancerProfileQuestion: string;
    handleFreelancerWorkShowcase: string;
    verifyOnboardingToken: string;
    handleClientAccountCreation: string;
    handleClientProfileQuestion: string;
    changeFreelancerPassword: string;
    handleFetchClientProfileQuestion: string;
    verifyClientOnboardingToken: string;
    handleFetchFreelancerResume: string;
    handleFreelancerResumeParsing: string;
    initiateFreelancerMcqAssessment: string;
    handleFetchAiAssessmentLink: string;
    skipFreelancerAiAssessment: string;
    initiateFreelancerAiAssessment: string;
    captureAiAssessmentStatus: string;
    handleFetchFreelancerProfileQuestion: string;
    handleFetchFreelancerDetails: string;
};

declare class FreelancerCreateAccountDto {
    fullName: string;
    email: string;
    mobileCode: string;
    mobile: string;
    countryISOCode: string;
    onBoardedBy: string;
    ip: string;
    referralCode?: 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 enum ModeOfWorkEnum$2 {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID",
    BOTH = "BOTH"
}
declare enum NatureOfWorkEnum$2 {
    FREELANCE = "FREELANCE"
}
declare class FreelancerProfileQuestionDto {
    uuid: string;
    modeOfWork: ModeOfWorkEnum$2;
    natureOfWork: NatureOfWorkEnum$2;
    numberOfHours: number;
    isImmediateJoiner: boolean;
    availabilityToJoin?: string;
    currency: string;
    expectedHourlyCompensation: number;
    linkedinProfileLink: string;
    kaggleProfileLink?: string | null;
    githubProfileLink?: string | null;
    stackOverflowProfileLink?: string | null;
    portfolioLink?: string | null;
}

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;
    numberOfHours?: number;
    foundUsOnDetail?: string;
}

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

declare class VerifyOnboardingTokenDto {
    uuid: string;
}

declare const MAINTENANCE_PATTERN: {
    truncateData: string;
};

declare const RESUME_PARSER_PATTERN: {
    handleResumeParsing: string;
    handleResumeParsingByUrl: string;
    handleResumeDataProcessing: string;
    handleCheckResumeEligibility: string;
};

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

declare enum AccountType$2 {
    ADMIN = "ADMIN",
    SUB_ADMIN = "SUB_ADMIN"
}
declare class CreateSubAdminDto {
    userName: string;
    firstName: string;
    lastName: string;
    accountType: AccountType$2;
    email: string;
    mobileCode: string;
    mobile: string;
    password: string;
    roleIds: 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 enum KindOfHire {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH",
    HOURLY = "HOURLY",
    FREELANCE = "FREELANCE",
    FTE = "FTE"
}
declare enum ModeOfHire {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID",
    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 enum HiringCommissionTypeEnum {
    PERCENTAGE = "PERCENTAGE",
    AMOUNT = "AMOUNT"
}
declare class CompanyProfile extends BaseEntity {
    userId: number;
    user: User;
    companyName: string;
    bio: string;
    webSite: string;
    aboutCompany: string;
    isServiceAgreementSigned: boolean;
    skipServiceAgreement: boolean;
    isJobPostingRestricted: boolean;
    originalDocumentUrl: string;
    serviceAgreementUrl: string;
    serviceAggrementSignedOn: Date;
    countryId: number;
    country: Country;
    stateId: number;
    state: State;
    cityId: number;
    city: City;
    companyAddress: string;
    addressLine: string;
    postalCode: string;
    phoneNumber: string;
    skills: string[];
    requiredFreelancer: string;
    kindOfHiring: KindOfHire;
    numberOfHours: number;
    modeOfHire: ModeOfHire;
    foundUsOn: FromUsOn;
    foundUsOnDetail: string;
    onboardingStepCompleted: CompanyOnboardingStepEnum;
    signaturePositions: any;
    hiringCommisionTypeForFte: HiringCommissionTypeEnum;
    hiringCommissionValueForFte: number;
    markupPercentage: number;
    rating: number;
    signatureUrl: string;
}

declare class City extends BaseEntity {
    countryId: number;
    country: Country;
    stateId: number;
    state: State;
    cityCode: string;
    cityName: string;
    isActive: boolean;
    latitude: number;
    longitude: number;
    freelancerProfile: FreelancerProfile[];
    companyProfile: CompanyProfile[];
}

declare class State extends BaseEntity {
    countryId: number;
    country: Country;
    cities: City[];
    stateName: string;
    stateCode: string;
    isActive: boolean;
    centerLatitude: number;
    centerLongitude: number;
    freelancerProfile: FreelancerProfile[];
    companyProfile: CompanyProfile[];
}

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

declare enum NatureOfWork {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH",
    HOURLY = "HOURLY",
    FREELANCE = "FREELANCE",
    FTE = "FTE"
}
declare enum ModeOfWork {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID",
    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;
    stateId: number;
    state: State;
    cityId: number;
    city: City;
    talentId: string;
    resumeUrl: string;
    resumeUploadedOn: Date;
    resumeParsedOn: Date;
    resumeEligibility: string;
    resumeScore: string;
    mcqStatus: McqStatusEnum;
    mcqScore: number;
    mcqInitiatedOn: Date;
    mcqCompletedOn: Date;
    isEligibleForAiAssessment: boolean;
    aiAssessmentStatus: AiAssessmentStatusEnum;
    isDeveloper: boolean;
    natureOfWork: NatureOfWork;
    numberOfHours: number;
    currency: string;
    expectedHourlyCompensation: number;
    expectedAnnualCompensation: number;
    modeOfWork: ModeOfWork;
    availabilityToJoin: string;
    isImmediateJoiner: boolean;
    linkedinProfileLink: string;
    kaggleProfileLink: string;
    githubProfileLink: string;
    stackOverflowProfileLink: string;
    portfolioLink: string;
    onboardingStepCompleted: OnboardingStepEnum;
    designation: string;
    experience: string;
    migratedExperience: string;
    address: string;
    addressLine: string;
    postalCode: string;
    about: string;
    profileCompletedPercentage: Record<string, number>;
    profileQuestionCompletedOn: Date;
    profileCompletedOn: Date;
    originalDocumentUrl: string;
    isServiceAgreementSigned: boolean;
    serviceAgreementUrl: string;
    serviceAggrementSignedOn: Date;
    isExpertshubVerified: boolean;
    isFollowedOnLinkedIn: boolean;
    signaturePositions: any;
    rating: number;
    signatureUrl: string;
}

declare enum JobSkillCategoryEnum {
    GOOD_TO_HAVE = 0,
    MUST_HAVE = 1
}
declare class JobSkill extends BaseEntity {
    jobId: number;
    job: Job;
    skillName: string;
    skillCategory: JobSkillCategoryEnum;
}

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 enum InterviewQuestionType {
    AI = "AI",
    CUSTOM = "CUSTOM"
}
declare class InterviewQuestion extends BaseEntity {
    interviewId: number;
    interview: Interview;
    question: string;
    concepts: string[];
    questionType: InterviewQuestionType;
    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;
    jobId: number;
    job: Job;
    fullName: string;
    email: string;
    mobileCode: string;
    mobile: string;
    status: InterviewInviteStatusEnum;
    sentAt: Date;
    expiresAt: Date;
    respondedAt?: Date;
    token: string;
    talentId: string;
}

declare enum AiInterviewRescheduleRequestStatusEnum {
    PENDING = "PENDING",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED"
}
declare class AiInterviewRescheduleRequest extends BaseEntity {
    candidateId: number;
    candidate: User;
    clientId: number;
    client: User;
    aiInterviewId: number;
    aiInterview: AiInterview;
    interviewId: number;
    rescheduledDate: Date;
    status: AiInterviewRescheduleRequestStatusEnum;
    clientRejectReason: string;
    freelancerRequestReason: string;
}

declare enum AiInterviewStatusEnum {
    NOT_ATTEMPTED = "NOT_ATTEMPTED",
    ATTEMPTED = "ATTEMPTED",
    PENDING = "PENDING",
    ACTIVE = "ACTIVE",
    IN_PROGRESS = "IN_PROGRESS",
    IN_COMPLETE = "IN_COMPLETE",
    COMPELETED = "COMPELETED",
    PASSED = "PASSED",
    FAILED = "FAILED",
    EXPIRED = "EXPIRED",
    POSTPONED = "POSTPONED",
    RESCHEDULED = "RESCHEDULED",
    EXITED = "EXITED"
}
declare enum ResultStatusEnum {
    NOT_EVALUATED = "NOT_EVALUATED",
    EVALUATING = "EVALUATING",
    PASSED = "PASSED",
    FAILED = "FAILED"
}
declare enum RecordingStatusEnum {
    PROCESSING = "PROCESSING",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED"
}
declare class AiInterview extends BaseEntity {
    aiInterviewUniqueId: string;
    candidateId: number;
    candidate: User;
    interviwerId: number;
    interviwer: User;
    interviewId: number;
    interview: Interview;
    inviteId: number;
    candidateInterviewId: string;
    candidateInterviewLink: string;
    hasAttempted: boolean;
    attemptedAt: Date;
    completedAt: Date;
    exitedAt: Date;
    expiredAt: Date;
    status: AiInterviewStatusEnum;
    resultStatus: ResultStatusEnum;
    recordingStatus: RecordingStatusEnum;
    isRescheduled: boolean;
    rescheduledAt: Date;
    recordingLink: string;
    iframeResponse: string;
    interviewInsight: string;
    isF2fInterviewScheduled: boolean;
    isContractSent: boolean;
    attempts: number;
    rescheduleRequests: AiInterviewRescheduleRequest[];
}

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;
    meetingEligibleStartTime: Date;
    meetingEligibleExpiryTime: Date;
    meetingVideoRecordingUrl: string;
    meetingAudioRecordingUrl: string;
    meetingTranscript: any;
    meetingRecordings: any;
}

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;
    jobId?: number;
    job?: Job;
    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;
    isContractSent: boolean;
    feedback: string;
    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;
    interviewDuration: string;
    interviewValidityPeriod: string;
    maximumAttemptsAllowed: string;
    startInterviewPrompt: string;
    endInterviewPrompt: string;
    interviewTemplateId: string;
    status: InterviewStatusEnum;
    interviewSkills: InterviewSkill[];
    interviewQuestions: InterviewQuestion[];
    invites: InterviewInvite[];
    aiInterviews: AiInterview[];
    f2fInterviews: F2FInterview[];
}

declare enum ClientCandidatePreferenceEnum {
    NOT_SUITABLE = "NOT_SUITABLE",
    SHORTLISTED = "SHORTLISTED"
}
declare class ClientCandidatePreference extends BaseEntity {
    clientId: number;
    client: User;
    candidateId: number;
    candidate: User;
    jobId?: number;
    job?: Job;
    recommendationId?: number;
    recommendation?: JobRecommendation;
    preference: ClientCandidatePreferenceEnum;
}

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;
    preference: ClientCandidatePreference[];
}

declare class TimesheetLogs extends BaseEntity {
    timesheetLineId: number;
    timesheetLine: TimesheetLine;
    startDate: Date;
    endDate: Date;
    startTime: string;
    endTime: string;
    workedHours: string;
    taskId: number;
    projectName?: string;
    deliverable?: string;
    taskName: string;
    description: string;
}

declare enum TimesheetLineHistoryStatusEnum {
    DRAFT = "DRAFT",
    SEND = "SEND",
    SEND_BACK = "SEND_BACK",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED",
    PAID = "PAID",
    MISSING = "MISSING",
    ACTIVE = "ACTIVE"
}
declare enum TimesheetSubmissionActionEnum {
    SUBMITTED = "SUBMITTED",
    RESUBMITTED = "RESUBMITTED",
    SEND_BACK = "SEND_BACK",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED",
    PAID = "PAID"
}
declare class TimesheetLineHistory extends BaseEntity {
    timesheetLineId: number;
    timesheetLine: TimesheetLine;
    changedBy: number;
    previousStatus: TimesheetLineHistoryStatusEnum;
    newStatus: TimesheetLineHistoryStatusEnum;
    actionType: TimesheetSubmissionActionEnum;
    remarks: string;
}

declare enum TimesheetLineStatusEnum {
    DRAFT = "DRAFT",
    SEND = "SEND",
    SEND_BACK = "SEND_BACK",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED",
    PAID = "PAID",
    MISSING = "MISSING",
    ACTIVE = "ACTIVE"
}
declare class TimesheetLine extends BaseEntity {
    jobId: number;
    job: Job;
    clientId: number;
    client: User;
    freelancerId: number;
    freelancer: User;
    timesheetLogs: TimesheetLogs[];
    timesheetLineHistory: TimesheetLineHistory[];
    uniqueId: string;
    weekStartDate: Date;
    weekEndDate: Date;
    status: TimesheetLineStatusEnum;
    weeklyHoursSum: string;
    isInvoiceGenrated: boolean;
    isInvoiceApproved: boolean;
    invoice: Invoice[];
}

declare enum ContractSummaryStatusEnum {
    PENDING = "PENDING",
    ACTIVE = "ACTIVE",
    COMPLETED = "COMPLETED",
    CLOSED = "CLOSED"
}
declare enum ContractSummaryPreferredEngagementTypeEnum {
    FREELANCE = "FREELANCE"
}
declare class ContractSummary extends BaseEntity {
    jobId: number;
    job: Job;
    clientId: number;
    client: User;
    freelancerId: number;
    freelancer: User;
    startDate: Date;
    endDate: Date;
    actualStartDate: Date;
    actualEndDate: Date;
    duration: number;
    contractValue: number;
    invoicingCycle: string;
    isMsaSigned: boolean;
    isSowSigned: boolean;
    isEscrowDeposited: boolean;
    escrowDepositeAmount: number;
    status: ContractSummaryStatusEnum;
    preferredEngagementType?: ContractSummaryPreferredEngagementTypeEnum;
    contracts: Contract[];
    hiring: Hiring;
}

declare enum HiredFreelancerNatureOfWorkEnum {
    FTE = "FTE",
    FREELANCE = "FREELANCE"
}
declare class Hiring extends BaseEntity {
    jobId: number;
    job: Job;
    clientId: number;
    client: User;
    freelancerId: number;
    freelancer: User;
    invoiceId?: number;
    invoice?: Invoice;
    contractSummaryId?: number;
    contractSummary?: ContractSummary;
    freelancerNatureOfWork: HiredFreelancerNatureOfWorkEnum;
    isInvoiceGenrated: boolean;
    isClosed?: boolean;
}

declare enum InvoiceTypeEnum {
    WEEKLY = "WEEKLY",
    MONTHLY = "MONTHLY",
    FTE = "FTE"
}
declare enum InvoiceStatusEnum {
    SUBMITTED = "SUBMITTED",
    UNDER_REVIEW = "UNDER_REVIEW",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED"
}
declare enum InvoicePaymentStatusEnum {
    PENDING = "PENDING",
    OVERDUE = "OVERDUE",
    INTRANSACTION = "INTRANSACTION",
    PAID = "PAID",
    REFUNDED = "REFUNDED"
}
declare class Invoice extends BaseEntity {
    timesheetLineId: number;
    timesheetLine: TimesheetLine;
    jobId: number;
    job: Job;
    clientId: number;
    client: User;
    freelancerId: number;
    freelancer: User;
    invoiceUniqueId: string;
    issuedAt: Date;
    dueAt: Date;
    billingCycleFrom: Date;
    billingCycleTo: Date;
    billingHours: string;
    hourlyRate: string;
    billingAmount: string;
    billingMarkUpAmount: string;
    billingMarkUpPercentage: string;
    freelancerBillingAmount: string;
    freelancerCommissionPercentage: string;
    freelancerCommissionAmount: string;
    invoiceType: InvoiceTypeEnum;
    status: InvoiceStatusEnum;
    paymentStatus: InvoicePaymentStatusEnum;
    clientInvoiceUrl: string;
    freelancerInvoiceUrl: string;
    escrowWalletTransaction?: EscrowWalletTransaction;
    hiring?: Hiring;
}

declare enum EscrowWalletTransactionTypeEnum {
    CR = "CR",
    DR = "DR"
}
declare enum EscrowWalletTransactionForEnum {
    CONTRACT = "CONTRACT",
    INVOICE = "INVOICE"
}
declare class EscrowWalletTransaction extends BaseEntity {
    escrowWalletId: number;
    escrowWallet: EscrowWallet;
    invoiceId?: number;
    invoice?: Invoice;
    amount: string;
    escrowType: EscrowWalletTransactionTypeEnum;
    description: string;
    completedAt: Date;
    escrowTransactionFor: EscrowWalletTransactionForEnum;
    metaData: string;
}

declare class EscrowWallet extends BaseEntity {
    jobId: number;
    job?: Job;
    clientId: number;
    client?: User;
    freelancerId: number;
    freelancer?: User;
    contractId?: number;
    contract?: Contract;
    escrowBalance: string;
    metadata: Record<string, any>;
    escrowWalletTransactions: EscrowWalletTransaction[];
}

declare enum ContractStatusEnum {
    GENERATED = "GENERATED",
    DRAFTED = "DRAFTED",
    SENT = "SENT",
    SIGNED = "SIGNED",
    ACTIVE = "ACTIVE",
    CANCELLED = "CANCELLED",
    DISPUTED = "DISPUTED",
    REJECTED = "REJECTED",
    RENEWED = "RENEWED",
    EXPIRED = "EXPIRED",
    CLOSED = "CLOSED"
}
declare enum ContractTypeEnum {
    NDA = "NDA",
    WORK = "WORK",
    SOW = "SOW",
    MSA = "MSA",
    CL_SOW = "CL_SOW",
    FL_SOW = "FL_SOW"
}
declare class Contract extends BaseEntity {
    contractUniqueId: string;
    contractSummaryId: number;
    contractSummary: ContractSummary;
    jobId: number;
    job: Job;
    clientId: number;
    client: User;
    freelancerId: number;
    freelancer: User;
    duration: number;
    status: ContractStatusEnum;
    type: ContractTypeEnum;
    invoicingCycle: string;
    escrowDepositeAmount: number;
    startDate: Date;
    endDate: Date;
    actualStartDate: Date;
    actualEndDate: Date;
    originalDocumentUrl: string;
    contractDocumentUrl: string;
    clientSignedAt: Date;
    freelancerViewed: boolean;
    freelancerViewedAt: Date;
    freelancerSignedAt: Date;
    rejectedAt: Date;
    rejectReason: string;
    resendCount: number;
    isWorkContractSent: boolean;
    isEscrowDeposited: boolean;
    signaturePositions: any;
    signatureUrl: string;
    metaData: any;
    escrowWallet: EscrowWallet;
}

declare enum TaskDeliverableTypeEnum {
    REQUIRED = "REQUIRED",
    NEED_TO_ADD = "NEED_TO_ADD",
    OTHER = "OTHER"
}
declare class TaskDeliverable extends BaseEntity {
    taskId: number;
    task: Task;
    name: string;
    description: string;
    type: TaskDeliverableTypeEnum;
}

declare enum TaskResourceTypeEnum {
    GITHUB = "GITHUB",
    JIRA_TASK = "JIRA_TASK",
    API_DOCUMENTATION = "API_DOCUMENTATION"
}
declare class TaskResource extends BaseEntity {
    taskId: number;
    task: Task;
    resourceType: TaskResourceTypeEnum;
    name: string;
    description: string;
    type: TaskResourceTypeEnum;
    url: string;
}

declare class TaskChecklistItem extends BaseEntity {
    taskId: number;
    task: Task;
    name: string;
    isChecked: boolean;
    note: string;
}

declare enum TaskSubtaskStatusEnum {
    PENDING = "PENDING",
    IN_PROGRESS = "IN_PROGRESS",
    NOT_YET_STARTED = "NOT_YET_STARTED",
    COMPLETED = "COMPLETED",
    CANCELLED = "CANCELLED"
}
declare class TaskSubtask extends BaseEntity {
    taskId: number;
    task: Task;
    subtaskName: string;
    dueDate: Date;
    status: TaskSubtaskStatusEnum;
}

declare class TaskLogTime extends BaseEntity {
    taskId: number;
    task: Task;
    startDate: Date;
    startTime: string;
    endDate: Date;
    endTime: string;
    logHours: string;
    freelancerId: number;
    jobId: number;
}

declare enum TaskQueryMessageUserTypeEnum {
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare class TaskQueryMessage extends BaseEntity {
    taskQueryId: number;
    taskQuery: TaskQuery;
    senderUserId: number;
    senderUser: User;
    senderType: TaskQueryMessageUserTypeEnum;
    message: string;
    attachmentUrl: string;
    attachmentType: string;
    meta: any;
    isRead: boolean;
    readAt: Date;
}

declare enum TaskQueryUserTypeEnum {
    CLIENT = "CLIENT",
    FREELANCER = "FREELANCER"
}
declare enum TaskQueryCategoryEnum {
    DEVELOPMENT_ISSUE = "DEVELOPMENT_ISSUE",
    TESTING_ISSUE = "TESTING_ISSUE",
    OTHER = "OTHER"
}
declare enum TaskQueryStatusEnum {
    OPEN = "OPEN",
    ANSWERED = "ANSWERED",
    CLOSED = "CLOSED"
}
declare class TaskQuery extends BaseEntity {
    taskId: number;
    task: Task;
    raisedByUserId: number;
    raisedByUser: User;
    raisedByType: TaskQueryUserTypeEnum;
    assignedToUserId: number;
    assignedToUser: User;
    assignedToType: TaskQueryUserTypeEnum;
    queryCategory: TaskQueryCategoryEnum;
    subject: string;
    description: string;
    status: TaskQueryStatusEnum;
    lastMessageAt: Date;
    lastMessagePreview: string;
    unreadCountClient: number;
    unreadCountFreelancer: number;
    messages: TaskQueryMessage[];
}

declare enum TaskPriorityEnum {
    LOW = "LOW",
    MEDIUM = "MEDIUM",
    HIGH = "HIGH"
}
declare enum TaskStatusEnum {
    DRAFTED = "DRAFTED",
    SCHEDULED = "SCHEDULED",
    IN_PROGRESS = "IN_PROGRESS",
    SUBMITTED = "SUBMITTED",
    COMPLETED = "COMPLETED",
    CANCELLED = "CANCELLED"
}
declare class Task extends BaseEntity {
    taskUniqueId: string;
    jobId: number;
    job: Job;
    clientId: number;
    client: User;
    freelancerId: number;
    freelancer: User;
    taskName: string;
    status: TaskStatusEnum;
    priority: TaskPriorityEnum;
    description: string;
    dueDate: Date;
    createdOn: Date;
    estimateHours: number;
    clientRemarks: string;
    freelancerWorkNote: string;
    deliverables: TaskDeliverable[];
    resources: TaskResource[];
    checklistItems: TaskChecklistItem[];
    subtasks: TaskSubtask[];
    timesheets: Timesheet[];
    taskLogTimes: TaskLogTime[];
    taskQueries: TaskQuery[];
}

declare enum TimesheetStatusEnum {
    DRAFT = "DRAFT",
    SEND = "SEND",
    SEND_BACK = "SEND_BACK",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED",
    PAID = "PAID"
}
declare class Timesheet extends BaseEntity {
    jobId: number;
    job: Job;
    clientId: number;
    client: User;
    freelancerId: number;
    freelancer: User;
    startDate: Date;
    endDate: Date;
    startTime: string;
    endTime: string;
    workedHours: string;
    taskId: number;
    task: Task;
    taskName: string;
    description: string;
    weekStartDate: Date;
    weekEndDate: Date;
    rejectedAt: Date;
    submittedAt: Date;
    resubmittedAt: Date;
    approvedAt: Date;
    status: TimesheetStatusEnum;
    clientSendBackReason: string;
}

declare class JobLocation extends BaseEntity {
    jobId: number;
    job: Job;
    countryId: number;
    countryName: string;
    country: Country;
    stateId: number;
    stateName: string;
    state: State;
    cityId: number;
    cityName: string;
    city: City;
    locationWiseOpenings: number;
}

declare enum RatingTypeEnum {
    FREELANCER_TO_CLIENT = "FREELANCER_TO_CLIENT",
    CLIENT_TO_FREELANCER = "CLIENT_TO_FREELANCER"
}
declare class Rating extends BaseEntity {
    reviewerId: number;
    reviewer: User;
    revieweeId: number;
    reviewee: User;
    jobId: number;
    job: Job;
    ratingType: RatingTypeEnum;
    reviewerComment: string;
    overAllExperience: number;
    workQuality: number;
    oneTimeDelivery: number;
    understaning: number;
    communication: number;
    skillUtilized: number;
    communicationClarity: number;
    requirementsClarity: number;
    responsiveness: number;
    paymentPromptness: number;
    responsibilitiesAndExpectations: number;
}

declare enum JobLocationEnum$1 {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID",
    BOTH = "BOTH"
}
declare enum typeOfExperienceEnum {
    SINGLE = "SINGLE",
    RANGE = "RANGE"
}
declare enum BillingCycleEnum {
    WEEKLY = "WEEKLY",
    DELIVERABLE = "DELIVERABLE"
}
declare enum TypeOfEmploymentEnum {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH",
    HOURLY = "HOURLY",
    FREELANCE = "FREELANCE",
    FTE = "FTE"
}
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",
    COMPLETED = "COMPLETED"
}
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;
    jobRoleCanonicalName: string;
    projectName: string;
    note: string;
    openings: number;
    utilisedOpenings: number;
    location: JobLocationEnum$1;
    typeOfEmployment: TypeOfEmploymentEnum;
    billingCycle: BillingCycleEnum;
    academicQualification: string;
    typeOfExperience: typeOfExperienceEnum;
    yearsOfExperience: string;
    yearsOfExperienceFrom: string;
    yearsOfExperienceTo: string;
    businessIndustry: string;
    currency: string;
    expectedSalaryFrom: number;
    hideExpectedSalaryFrom: boolean;
    expectedSalaryTo: number;
    hideExpectedSalaryTo: boolean;
    expectedAnnualBudgetFrom: number;
    hideExpectedAnnualBudgetFrom: boolean;
    expectedAnnualBudgetTo: number;
    hideExpectedAnnualBudgetTo: boolean;
    years: string;
    months: string;
    weeks: string;
    days: string;
    tentativeStartDate: Date;
    tentativeEndDate: Date;
    durationType: DurationTypeEnum;
    duration: string;
    numberOfHours: number;
    description: string;
    additionalComment: string;
    onboardingTat: string;
    candidateCommunicationSkills: string;
    dealBreakers: any;
    stepCompleted: Step;
    status: JobStatusEnum;
    viewedCount: number;
    applicationCount: number;
    isContractSigned: boolean;
    isJobCreatedAsIs: boolean;
    isInterviewCreated: boolean;
    isJobCreatedViaAI: boolean;
    interviewInvites: InterviewInvite[];
    jobSkills: JobSkill[];
    jobApplications: JobApplication[];
    interviews: Interview[];
    f2fInterviews: F2FInterview[];
    recommendations: JobRecommendation[];
    contractSummaries: ContractSummary[];
    contracts: Contract[];
    hirings: Hiring[];
    escrowWallets: EscrowWallet[];
    timesheets: Timesheet[];
    timesheetLine: TimesheetLine[];
    invoice: Invoice[];
    clientCandidatePreferences: ClientCandidatePreference[];
    jobLocations: JobLocation[];
    ratings: Rating[];
    tasks: Task[];
}

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;
    mobileCode: 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 enum FreelancerSkillCategoryEnum {
    GOOD_TO_HAVE = 0,
    MUST_HAVE = 1
}
declare class FreelancerSkill extends BaseEntity {
    userId: number;
    user: User;
    skillName: string;
    skillCategory: FreelancerSkillCategoryEnum;
}

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",
    EVALUATING = "EVALUATING",
    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;
    score: number;
    status: AssessmentStatusEnum;
    taskId: string;
    metaData: any;
}

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;
    module: 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 class CompanyMember extends BaseEntity {
    userId: number;
    user: User;
    firstName: string;
    lastName: string;
    email: string;
    isEligibleForPlatformRecruiterAcknowledgement: boolean;
    isPlatformRecruiterAcknowledgementAccepted: boolean;
    platformRecruiterAcknowledgementAcceptedOn: Date;
}

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;
    candidateId: number;
    candidate: User;
    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 class Signature extends BaseEntity {
    userId: number;
    user: User;
    signatureUrl: string;
}

declare enum DisputeStatusEnum {
    OPEN = "OPEN",
    IN_REVIEW = "IN_REVIEW",
    PENDING_RESPONSE = "PENDING_RESPONSE",
    UNDER_INVESTIGATION = "UNDER_INVESTIGATION",
    RESOLVED = "RESOLVED",
    CLOSED = "CLOSED",
    ESCALATED = "ESCALATED",
    CANCELLED = "CANCELLED",
    REOPENED = "REOPENED"
}
declare enum InitiatorTypeEnum {
    FREELANCER = "FREELANCER",
    CLIENT = "CLIENT"
}
declare class Dispute extends BaseEntity {
    clientId: number;
    client: User;
    freelancerId: number;
    freelancer: User;
    disputeUniqueId: string;
    disputeType: string;
    description: string;
    comment: string;
    status: DisputeStatusEnum;
    initiatorType: DisputeStatusEnum;
    initiatorId: number;
    initiator: User;
    respondentId: number;
    respondent: User;
    attachments: any[];
    dynamicFields: Record<string, any>;
}

declare enum StripeTransactionTypeEnum {
    ADD_FUNDS = "ADD_FUNDS",
    TRANSFER = "TRANSFER",
    WITHDRAW = "WITHDRAW",
    INVOICE_PAYMENT = "INVOICE_PAYMENT",
    REFUND = "REFUND"
}
declare enum StripeTransactionStatusEnum {
    PENDING = "PENDING",
    PROCESSING = "PROCESSING",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED",
    EXPIRED = "EXPIRED",
    CANCELLED = "CANCELLED"
}
declare class StripeTransaction extends BaseEntity {
    userId: number;
    user: User;
    stripeSessionId: string;
    stripePaymentIntentId: string;
    stripeChargeId: string;
    stripeReceiptUrl: string;
    stripeBalanceTransactionId: string;
    stripePaymentMethod: string | null;
    stripePaymentStatus: string | null;
    type: StripeTransactionTypeEnum;
    currency: string;
    desiredDepositCents: number;
    platformFeeCents: number;
    taxCents: number | null;
    estimatedStripeFee: number | null;
    estimatedTotalCents: number | null;
    actualStripeFee: number | null;
    actualTotalPaidCents: number | null;
    netReceivedCents: number | null;
    description: string;
    status: StripeTransactionStatusEnum;
    checkoutSessionCompletedAt: Date;
    completedAt: Date;
    billingDetails: Record<string, any> | null;
    paymentMethodDetails: Record<string, any> | null;
    rawSessionPayload: Record<string, any> | null;
    rawSessionResponse: Record<string, any> | null;
}

declare enum WalletTransactionTypeEnum {
    CR = "CR",
    DR = "DR"
}
declare enum WalletTransactionStatusEnum {
    PENDING = "PENDING",
    PROCESSING = "PROCESSING",
    SUCCESS = "SUCCESS",
    FAILED = "FAILED",
    EXPIRED = "EXPIRED"
}
declare class WalletTransaction extends BaseEntity {
    walletId: number;
    wallet: Wallet;
    fromUserId: number;
    fromUser: User;
    amount: number;
    markUpAmount: number;
    balanceBefore: number;
    balanceAfter: number;
    type: WalletTransactionTypeEnum;
    status: WalletTransactionStatusEnum;
    description: string;
    completedAt: Date;
    transactionFor: string;
    metaData: string;
    stripeTransactionId: number;
}

declare enum WalletAccountTypeEnum {
    ADMIN = "ADMIN",
    BUSINESS = "BUSINESS",
    FREELANCER = "FREELANCER"
}
declare enum WalletOnboardingStatusEnum {
    PENDING = "PENDING",
    COMPLETED = "COMPLETED"
}
declare class Wallet extends BaseEntity {
    userId: number;
    user: User;
    accountType: WalletAccountTypeEnum;
    stripeAccountId: string;
    stripeCustomerId: string;
    walletBalance: string;
    walletBalanceCents: number;
    onboardingStatus: WalletOnboardingStatusEnum;
    stripeMetadata: Record<string, any>;
    walletTransactions: WalletTransaction[];
}

declare enum AssessmentRequestStatusEnum {
    PENDING = "PENDING",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED"
}
declare class FreelancerAssessmentRequest extends BaseEntity {
    freelancerId: number;
    freelancer: User;
    approvedById: number;
    approvedBy: User;
    status: AssessmentRequestStatusEnum;
    assessmentLink?: string;
}

declare class InAppNotification extends BaseEntity {
    userId: number;
    user: User;
    event: string;
    title: string;
    message: string;
    redirectUrl: string;
    isRead: boolean;
    metaData: any;
}

declare class UserSubscriptionPlanFeature extends BaseEntity {
    userSubscriptionPlanId: number;
    userSubscriptionPlan: UserSubscriptionPlan;
    planFeatureId: number;
    name: string;
    slug: string;
    tooltip: string | null;
    sortOrder: number;
    isActive: boolean;
}

declare enum UserSubscriptionPlanPricingBillingCycleEnum {
    MONTHLY = "MONTHLY",
    YEARLY = "YEARLY"
}
declare class UserSubscriptionPlanPricing extends BaseEntity {
    userSubscriptionPlanId: number;
    userSubscriptionPlan: UserSubscriptionPlan;
    planPricingId: number;
    billingCycle: UserSubscriptionPlanPricingBillingCycleEnum;
    price: number;
    originalPrice: number | null;
    discountPct: number | null;
    currency: string;
    isFree: boolean;
    stripePriceId: string | null;
    isActive: boolean;
}

declare enum UserSubscriptionPlanTypeEnum {
    FREELANCER = "FREELANCER",
    BUSINESS = "BUSINESS"
}
declare class UserSubscriptionPlan extends BaseEntity {
    userSubscriptionId: number;
    userSubscription: UserSubscription;
    planId: number;
    name: string;
    slug: string;
    badgeLabel: string | null;
    sortOrder: number;
    isActive: boolean;
    planType: UserSubscriptionPlanTypeEnum;
    metadata: Record<string, unknown>;
    userSubscriptionPlanFeatures: UserSubscriptionPlanFeature[];
    userSubscriptionPlanPricing: UserSubscriptionPlanPricing[];
}

declare enum UserSubscriptionStatusEnum {
    INCOMPLETE = "INCOMPLETE",
    INCOMPLETE_EXPIRED = "INCOMPLETE_EXPIRED",
    TRIALING = "TRIALING",
    ACTIVE = "ACTIVE",
    PAST_DUE = "PAST_DUE",
    CANCELED = "CANCELED",
    UNPAID = "UNPAID",
    EXPIRED = "EXPIRED"
}
declare class UserSubscription extends BaseEntity {
    userId: number;
    user: User;
    userSubscriptionPlans: UserSubscriptionPlan[];
    subscriptionAmount: number;
    totalTaxAmount: number;
    totalAmount: number;
    status: UserSubscriptionStatusEnum;
    subscriptionStartDate: Date | null;
    subscriptionStartDateTimestamp: number | null;
    subscriptionEndDate: Date | null;
    subscriptionEndDateTimestamp: number | null;
    stripePriceId: string | null;
    stripeProductId: string | null;
    stripeCustomerId: string | null;
    stripeSubscriptionId: string | null;
    stripeCheckoutSessionId: string | null;
}

declare enum EkycVerificationSessionStatusEnum {
    NOT_STARTED = "NOT_STARTED",
    NOT_FINISHED = "NOT_FINISHED",
    IN_PROGRESS = "IN_PROGRESS",
    APPROVED = "APPROVED",
    DECLINED = "DECLINED",
    IN_REVIEW = "IN_REVIEW",
    EXPIRED = "EXPIRED",
    KYC_EXPIRED = "KYC_EXPIRED",
    ABANDONED = "ABANDONED",
    RESUBMITTED = "RESUBMITTED",
    AWAITING_USER = "AWAITING_USER"
}
declare class EkycVerificationSession extends BaseEntity {
    userId: number;
    user: User;
    sessionId: string;
    sessionNumber: number;
    token: string;
    url: string;
    vendorData: string;
    metaData: any;
    decisionData: any;
    status: EkycVerificationSessionStatusEnum;
    callBackUrl: string;
    workflowId: string;
    workflowVersion: string;
    expiresAt: Date;
}

declare enum EkycVerificationLogStatusEnum {
    NOT_STARTED = "NOT_STARTED",
    NOT_FINISHED = "NOT_FINISHED",
    IN_PROGRESS = "IN_PROGRESS",
    APPROVED = "APPROVED",
    DECLINED = "DECLINED",
    IN_REVIEW = "IN_REVIEW",
    EXPIRED = "EXPIRED",
    KYC_EXPIRED = "KYC_EXPIRED",
    ABANDONED = "ABANDONED",
    RESUBMITTED = "RESUBMITTED",
    AWAITING_USER = "AWAITING_USER"
}
declare class EkycVerificationLog {
    id: number;
    userId: number;
    user: User;
    sessionId: string;
    workflowId: string;
    callBackUrl: string;
    status: EkycVerificationLogStatusEnum;
    signatureMethod?: string;
    isSignatureValid: boolean;
    rawPayload?: any;
    headers?: Record<string, any>;
    errorMessage?: string;
    createdAt: Date;
}

declare enum AccountType$1 {
    SUPER_ADMIN = "SUPER_ADMIN",
    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;
    presignedProfilePictureUrl: string;
    presignedProfilePictureUrlExpiresAt: Date;
    email: string;
    mobileCode: string;
    mobile: string;
    password: string;
    accountType: AccountType$1;
    accountStatus: AccountStatus;
    isEmailVerified: boolean;
    isMobileVerified: boolean;
    isSocial: boolean;
    isReferralUser: boolean;
    isEkycVerified: boolean;
    ekycVerifiedAt: Date | null;
    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;
    ip: string;
    otps: Otp[];
    senseloafLogs: SenseloafLog[];
    companyProfile: CompanyProfile;
    companySkills: CompanySkill[];
    companyMemberRoles: CompanyMemberRole[];
    companyMember: CompanyMember;
    companyAiInterview: AiInterview[];
    clientF2FInterviews: F2FInterview[];
    freelancerProfile: FreelancerProfile;
    freelancerResume: FreelancerResume;
    freelancerAssessmentRequests: FreelancerAssessmentRequest[];
    assessmentRequests: FreelancerAssessmentRequest[];
    assessments: FreelancerAssessment[];
    assessmentAnswers: AssessmentAnswer[];
    freelancerSkills: FreelancerSkill[];
    freelancerExperience: FreelancerExperience[];
    freelancerEducation: FreelancerEducation[];
    freelancerProject: FreelancerProject[];
    freelancerCaseStudy: FreelancerCaseStudy[];
    freelancerTool: FreelancerTool[];
    freelancerFramework: FreelancerFramework[];
    freelancerDeclaration: FreelancerDeclaration;
    freelancerMcq: AssessmetQuestion[];
    freelancerAiInterview: AiInterview[];
    freelancerF2FInterviews: F2FInterview[];
    freelancerF2FInterviewRescheduleRequests: F2fInterviewRescheduleRequest[];
    freelancerAiInterviewRescheduleRequests: AiInterviewRescheduleRequest[];
    clientAiInterviewRescheduleRequests: AiInterviewRescheduleRequest[];
    jobs: Job[];
    clientTasks: Task[];
    freelancerTasks: Task[];
    raisedTaskQueries: TaskQuery[];
    assignedTaskQueries: TaskQuery[];
    taskQueryMessages: TaskQueryMessage[];
    jobApplications: JobApplication[];
    interviews: Interview[];
    bankDetail: BankDetail[];
    systemPreference: SystemPreference[];
    givenRatings: Rating[];
    receivedRatings: Rating[];
    adminUserRoles: AdminUserRole[];
    clientContractSummaries: ContractSummary[];
    clientContracts: Contract[];
    clientHirings: Hiring[];
    clientEscrowWallets: EscrowWallet[];
    freelancerContractSummaries: ContractSummary[];
    freelancerContracts: Contract[];
    freelancerHirings: Hiring[];
    freelancerEscrowWallets: EscrowWallet[];
    signatures: Signature;
    clientTimesheets: Timesheet[];
    freelancerTimesheets: Timesheet[];
    clientTimesheetLine: TimesheetLine[];
    clientInvoice: Invoice[];
    freelancerTimesheetLine: TimesheetLine[];
    freelancerInvoice: Invoice[];
    clientPreferencesGiven: ClientCandidatePreference[];
    clientPreferencesReceived: ClientCandidatePreference[];
    initiatedDisputes: Dispute[];
    respondentDisputes: Dispute[];
    wallet: Wallet;
    stripeTransactions: StripeTransaction[];
    clientDisputes: Dispute[];
    freelancerDisputes: Dispute[];
    inAppNotifications: InAppNotification[];
    userSubscriptions: UserSubscription[];
    ekycVerificationSessions: EkycVerificationSession[];
    ekycVerificationLogs: EkycVerificationLog[];
    sentTransactions: WalletTransaction[];
}

declare class UpdateSubAdminAccountStatusDto {
    accountStatus: AccountStatus;
}

declare enum AccountType {
    ADMIN = "ADMIN",
    SUB_ADMIN = "SUB_ADMIN"
}
declare class UpdateSubAdminDto {
    userName: string;
    firstName: string;
    lastName: string;
    accountType: AccountType;
    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: {
    fetchClientProfileQuestions: string;
    fetchClientProfile: string;
    fetchClientPublicProfile: string;
    updateClientProfile: string;
    updateClientLogo: string;
    changeClientPassword: string;
    uploadClientServiceAgreement: string;
    fetchClientServiceAgreement: string;
    generateClientServiceAgreement: string;
    esignClientServiceAgreementForClient: string;
    fetchClientServiceAgreementStatus: string;
    fetchRecommendedFreelancers: string;
    fetchRecommendedFreelancersV2: string;
    fetchRecommendedFreelancersDropdownV2: string;
    clientDataAlteration: string;
    fetchFreelancersForComparison: string;
    deleteClientProfilePic: string;
    fetchFreelancerInfoForChat: string;
    fetchClientAndFreelancerDetailsForChatChannelCreation: string;
    fetchCustomeResume: string;
    requestPasswordChangeOtpForClient: string;
    verifyPasswordChangeOtpForClient: string;
    isPasswordSetForClient: string;
};

declare class UpdateCompanyProfileDto {
    companyName?: string;
    webSite?: string;
    countryId: number;
    stateId: number;
    cityId: number;
    companyAddress: string;
    addressLine: string;
    postalCode: string;
    mobileCode: string;
    phoneNumber?: string;
    email?: string;
    aboutCompany?: string;
}

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

declare class ClientServiceAgreementUploadDto {
    serviceAgreementSignedOn?: string;
}

declare class ClientESignatureDto {
    uuid: string;
}

declare class FetchFreelancerInfoForChatDto {
    freelancerId: number;
}

declare class RequestPasswordChangeOtpForClientDto {
    currentPassword: string;
    newPassword: string;
}

declare class VerifyPasswordChangeOtpForClientDto {
    newPassword: string;
    otp: 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;
    handleAssessmentQuestionImport: string;
    handelAssessmentRecordAnswer: string;
    handelAssessmentRecordAnswers: string;
    fetchAssessmentSummary: string;
};

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

declare class RecordAssessmentAnswerDto {
    questionId: string;
    answer: any;
    assessmentId?: string;
    userId?: string;
}

declare class RecordAssessmentAnswersDto {
    answers: any[];
    assessmentId?: string;
    userId?: string;
}

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;
    createJobViaAI: string;
    createJobAsIs: string;
    updateJobStatus: string;
    closeJob: string;
    searchJobsByRoleAndSkills: string;
    handleBulkRecommendationAdjustment: string;
    refreshJobFreelancerRecommendationView: string;
    fetchJobConfig: string;
    fetchJobRoleSuggestions: string;
    fetchJobCount: string;
    fetchJobsDropdownForFilters: string;
    fetchJobsDropdownForInterview: string;
    fetchJobsDropdownForFreelancer: string;
    fetchJobDetailForFreelancer: string;
    fetchJobBasicInformationV2: string;
    createJobBasicInformationV2: string;
    updateJobBasicInformationV2: string;
    deleteJob: string;
    fetchRecommendedFreelancersForJobs: string;
    fetchRecommendedFreelancersForJob: string;
    fetchRecommendedFreelancersForJobV2: string;
    handleJobViwedCountIncrement: string;
    fetchJobByIdForTimesheet: string;
    jobDataSetup: string;
    fetchJobsForComparison: string;
    fetchJobSkillDropdownForClient: string;
    createJobDealBreakers: string;
    getJobStatus: string;
};
declare const JOB_APPLICATION_PATTERN: {
    fetchJobApplicationCountAsPerStatusByJobId: string;
    fetchJobApplicationsByJobId: string;
    fetchJobApplicants: string;
    createJobApplication: string;
    changeJobApplicationStatus: string;
    changeJobApplicationStatusInBulk: string;
};

declare enum JobLocationEnum {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID"
}
declare enum EmploymentType {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH",
    HOURLY = "HOURLY",
    FREELANCE = "FREELANCE",
    FTE = "FTE"
}
declare class JobBasicInformationDto {
    isDraft?: boolean;
    jobRole: string;
    jobRoleCanonicalName?: string;
    projectName?: string;
    note?: string;
    skills: string[];
    goodToHaveSkills: string[];
    openings: number;
    location: JobLocationEnum;
    countryId: number;
    stateId: number;
    cityId: number;
    typeOfEmployment: EmploymentType;
    currency?: string;
    expectedSalaryFrom: number;
    hideExpectedSalaryFrom: boolean;
    expectedSalaryTo: number;
    hideExpectedSalaryTo: boolean;
    years: string;
    months: string;
    weeks: string;
    days: string;
    numberOfHours: number;
    candidateCommunicationSkills?: string;
    academicQualification?: string;
    yearsOfExperience?: string;
    businessIndustry?: string;
    additionalComment?: string;
}

declare class JobAdditionalCommentDto {
    additionalComment?: string;
}

declare class JobDescriptionDto {
    isDraft?: boolean;
    description: string;
}

declare enum JobLocationEnumV2$2 {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID"
}
declare enum EmploymentTypeV2$2 {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH",
    HOURLY = "HOURLY",
    FREELANCE = "FREELANCE",
    FTE = "FTE"
}
declare enum BillingCycleEnumV2$3 {
    WEEKLY = "WEEKLY",
    DELIVERABLE = "DELIVERABLE"
}
declare enum StepCompletedEnumV2$2 {
    BASIC_INFORMATION = "BASIC_INFORMATION",
    JOB_DESCRIPTION = "JOB_DESCRIPTION"
}
declare class JobLocationDto$2 {
    countryId: number | null;
    stateId: number | null;
    cityId: number | null;
    countryName?: string | null;
    stateName?: string | null;
    cityName?: string | null;
}
declare class CreateJobViaAIDto {
    userId: number;
    isDraft?: boolean;
    jobRole: string;
    jobRoleCanonicalName?: string;
    projectName?: string;
    note?: string;
    skills: string[];
    goodToHaveSkills: string[];
    openings: number;
    locationMode: JobLocationEnumV2$2;
    locations: JobLocationDto$2[];
    typeOfEmployment: EmploymentTypeV2$2;
    billingCycle: BillingCycleEnumV2$3;
    currency?: string;
    expectedSalaryFrom: number;
    hideExpectedSalaryFrom: boolean;
    expectedSalaryTo: number;
    hideExpectedSalaryTo: boolean;
    expectedAnnualBudgetFrom: number;
    hideExpectedAnnualBudgetFrom: boolean;
    expectedAnnualBudgetTo: number;
    hideExpectedAnnualBudgetTo: boolean;
    years: string;
    months: string;
    weeks: string;
    days: string;
    numberOfHours: number;
    candidateCommunicationSkills?: string;
    academicQualification?: string;
    yearsOfExperienceFrom?: string;
    yearsOfExperienceTo?: string;
    businessIndustry?: string;
    stepCompleted?: StepCompletedEnumV2$2;
    additionalComment?: string;
    description: string;
    dealBreakers: object;
}

declare enum JobLocationEnumV2$1 {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID"
}
declare enum EmploymentTypeV2$1 {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH",
    HOURLY = "HOURLY",
    FREELANCE = "FREELANCE",
    FTE = "FTE"
}
declare enum BillingCycleEnumV2$2 {
    WEEKLY = "WEEKLY",
    DELIVERABLE = "DELIVERABLE"
}
declare enum StepCompletedEnumV2$1 {
    BASIC_INFORMATION = "BASIC_INFORMATION",
    JOB_DESCRIPTION = "JOB_DESCRIPTION"
}
declare class JobLocationDto$1 {
    countryId?: number | null;
    stateId?: number | null;
    cityId?: number | null;
    countryName?: string | null;
    stateName?: string | null;
    cityName?: string | null;
}
declare class CreateJobAsIsDto {
    openings: number;
    jobRole: string;
    yearsOfExperienceFrom: string;
    yearsOfExperienceTo: string;
    jobRoleCanonicalName?: string;
    projectName?: string;
    note?: string;
    skills: string[];
    goodToHaveSkills?: string[];
    locationMode: JobLocationEnumV2$1;
    locations: JobLocationDto$1[];
    typeOfEmployment: EmploymentTypeV2$1;
    billingCycle?: BillingCycleEnumV2$2;
    currency?: string;
    expectedSalaryFrom: number;
    hideExpectedSalaryFrom?: boolean;
    expectedSalaryTo: number;
    hideExpectedSalaryTo?: boolean;
    expectedAnnualBudgetFrom?: number;
    hideExpectedAnnualBudgetFrom?: boolean;
    expectedAnnualBudgetTo?: number;
    hideExpectedAnnualBudgetTo?: boolean;
    years?: string;
    months?: string;
    weeks?: string;
    days?: string;
    numberOfHours?: number;
    candidateCommunicationSkills?: string;
    academicQualification?: string;
    businessIndustry?: string;
    stepCompleted?: StepCompletedEnumV2$1;
    additionalComment?: string;
    description: string;
}

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

declare class JobIdParamDto {
    id: string;
}

declare enum JobLocationEnumV2 {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID"
}
declare enum EmploymentTypeV2 {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH",
    HOURLY = "HOURLY",
    FREELANCE = "FREELANCE",
    FTE = "FTE"
}
declare enum StepCompletedEnumV2 {
    BASIC_INFORMATION = "BASIC_INFORMATION",
    JOB_DESCRIPTION = "JOB_DESCRIPTION"
}
declare enum BillingCycleEnumV2$1 {
    WEEKLY = "WEEKLY",
    DELIVERABLE = "DELIVERABLE"
}
declare class JobLocationDto {
    countryId: number | null;
    stateId: number | null;
    cityId: number | null;
    countryName?: string | null;
    stateName?: string | null;
    cityName?: string | null;
}
declare class JobBasicInformationV2Dto {
    isDraft?: boolean;
    jobRole: string;
    jobRoleCanonicalName?: string;
    projectName?: string;
    note?: string;
    skills: string[];
    goodToHaveSkills: string[];
    openings: number;
    locationMode: JobLocationEnumV2;
    locations: JobLocationDto[];
    typeOfEmployment: EmploymentTypeV2;
    billingCycle: BillingCycleEnumV2$1;
    currency?: string;
    expectedSalaryFrom: number;
    hideExpectedSalaryFrom: boolean;
    expectedSalaryTo: number;
    hideExpectedSalaryTo: boolean;
    expectedAnnualBudgetFrom: number;
    hideExpectedAnnualBudgetFrom: boolean;
    expectedAnnualBudgetTo: number;
    hideExpectedAnnualBudgetTo: boolean;
    years: string;
    months: string;
    weeks: string;
    days: string;
    numberOfHours: number;
    candidateCommunicationSkills?: string;
    academicQualification?: string;
    yearsOfExperienceFrom?: string;
    yearsOfExperienceTo?: string;
    businessIndustry?: string;
    stepCompleted?: StepCompletedEnumV2;
    additionalComment?: string;
    onboardingTat?: string;
}

declare class CloseJobDto {
    reason?: string;
}

declare class CreateJobApplicationDto {
    jobId: string;
    isCta?: boolean;
}

declare enum JobApplicationStatus {
    PENDING = "PENDING",
    SHORTLISTED = "SHORTLISTED",
    REJECTED = "REJECTED",
    HIRED = "HIRED",
    WITHDRAWN = "WITHDRAWN"
}
declare class ChangeJobApplicationStatusDto {
    status: JobApplicationStatus;
}

declare class ChangeJobApplicationStatusBulkDto {
    jobApplicationIds: number[];
    status: JobApplicationStatus;
}

declare const PROFILE_PATTERN: {
    fetchFreelancerProfile: string;
    fetchFreelancerPublicProfile: string;
    fetchFreelancerScreeningResult: string;
    fetchFreelancerScreeningResultPublic: string;
    changeFreelancerPassword: string;
    uploadFreelancerProfilePic: string;
    updateFreelancerProfile: string;
    uploadFreelancerServiceAgreement: string;
    fetchFreelancerServiceAgreement: string;
    generateFreelancerServiceAgreement: string;
    esignFreelancerServiceAgreementForClient: string;
    freelancerResumeDataMappingDev: string;
    freelancerMcqScoreMappingDev: string;
    fetchFreelancerDropdown: string;
    fetchFreelancerDesignationDropdown: string;
    deleteFreelancerProfilePic: string;
    fetchRecommendedJobsForFreelancer: string;
    fetchRecommendedClientsDropdownForFreelancerV2: string;
    fetchRecommendedJobsDropdownForFreelancerV2: string;
    fetchRecommendedJobsForFreelancerV2: string;
    fetchAppliedJobsOfFreelancer: string;
    fetchAppliedJobsDropdownForFreelancer: string;
    countOfActiveFreelancers: string;
    findUsersByUuids: string;
    markFollowedOnLinkedIn: string;
    fetchFreelancerResumeByUuId: string;
    fetchClientByIdForContract: string;
    fetchFreelancerByIdForContract: string;
    freelancerDataSetup: string;
    freelancerEmailAndMobileMasking: string;
    fetchClientInfoForChat: string;
    fetchAiAssessmentDetails: string;
    captureAiAssessmentResult: string;
    requestPasswordChangeOtpForFreelancer: string;
    verifyPasswordChangeOtpForFreelancer: string;
    isPasswordSetForFreelancer: string;
};
declare const FREELANCER_ASSESSMENT_REQUEST_PATTERN: {
    fetchAssessmentRequestsForFreelancer: string;
    createFreelancerAssessmentRequest: string;
};

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

declare enum NatureOfWorkDto {
    FREELANCE = "FREELANCE",
    FTE = "FTE",
    BOTH = "BOTH"
}
declare enum ModeOfWorkDto {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID"
}
declare class UpdateFreelancerProfileDto {
    firstName: string;
    lastName: string;
    designation: string;
    experience: string;
    email: string;
    mobileCode: string;
    mobile: string;
    countryId: number;
    stateId: number;
    cityId: number;
    expectedHourlyCompensation: string;
    expectedAnnualCompensation: string;
    numberOfHours?: number;
    natureOfWork: NatureOfWorkDto;
    modeOfWork: ModeOfWorkDto;
    portfolioLink?: string;
    address: string;
    addressLine?: string;
    postalCode: string;
    about?: string;
    linkedinProfileLink?: string;
    kaggleProfileLink?: string;
    githubProfileLink?: string;
    stackOverflowProfileLink?: string;
    resumeUrl?: string;
}

declare class FreelancerESignatureDto {
    uuid: string;
}

declare class FetchClientInfoForChatDto {
    clientId: number;
}

declare class CaptureAiAssessmentResultDto {
    aiAssessmentUuid: string;
    result?: any;
    status?: string;
}

declare class RequestPasswordChangeOtpForFreelancerDto {
    currentPassword: string;
    newPassword: string;
}

declare class VerifyPasswordChangeOtpForFreelancerDto {
    newPassword: string;
    otp: string;
}

declare const BANK_PATTERN: {
    addFreelancerBankDetails: string;
    fetchFreelancerBankDetails: string;
    updateFreelancerBankDetails: string;
    deleteBankAccount: string;
    fetchBankAccounts: string;
    setBankAccountPrimary: string;
};

declare enum BankAccountScope {
    DOMESTIC = "DOMESTIC",
    INTERNATIONAL = "INTERNATIONAL"
}
declare class FreelancerBankDetailsDto {
    name: string;
    mobileCode: 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;
};

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 GLOBAL_SETTING_PATTERN: {
    addGlobalSetting: string;
    removeGlobalSetting: string;
};

declare class AddGlobalSettingDto {
    key: string;
    value: string;
}

declare class RemoveGlobalSettingDto {
    uuid?: string;
    key?: string;
}

declare const NOTIFICATION_PATTERN: {
    handleAccountVerificationNotification: string;
    handleResetLinkNotification: string;
    handleBusinessAccountCreatedNotification: string;
    handleBusinessAccountSetPasswordNotification: string;
    handleFreelancerAccountSetPasswordNotification: string;
    handleSendBulkInterviewInvites: string;
    handleFreelancerAccountCreatedNotification: string;
    handleSetPasswordLinkNotification: string;
    handleLeadNotificationToAdmin: string;
    handleDailyFreelancerReportToStakeHolders: string;
    handleDailyFreelancerProfileReminderNotification: string;
    handleAiAssessmentLinkNotification: string;
    handleRecordingProcessingErrorNotification: string;
    handleResumeParserErrorNotification: string;
    handleFreelancerExportReadyNotification: string;
    handleFreelancerExportFailedNotification: string;
    handleClientExportReadyNotification: string;
    handleClientExportFailedNotification: string;
    handleAiInterviewResultErrorNotification: string;
    handleAiInterviewRecordingErrorNotification: string;
    handleAiAssessmentInterviewResultErrorNotification: string;
    handleAiAssessmentInterviewRecordingErrorNotification: string;
    handleSubAdminAccountCreatedNotification: string;
    handleUserResetPasswordByAdminNotification: string;
    handlePasswordChangeNotification: string;
};
declare const SMS_PATTERN: {
    sendTest: string;
    queueStats: string;
    cleanQueue: string;
    status: string;
    accountInfo: string;
};
declare const EMAIL_PATTERN: {
    sendTest: string;
    send: string;
    sendTemplate: string;
    getQueueStats: string;
    cleanQueue: string;
};

declare class TestNotificationDto {
    email?: string;
    phone?: string;
    message?: string;
    data?: any;
    type?: string;
}

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

declare class CreateRatingDto {
    revieweeId: number;
    reviewerId: number;
    jobId: number;
    ratingType: RatingTypeEnum;
    reviewerComment?: string;
    overallExperience?: number;
    workQuality?: number;
    oneTimeDelivery?: number;
    understaning?: number;
    communication?: number;
    skillUtilized?: number;
    communicationClarity?: number;
    requirementsClarity?: number;
    responsiveness?: number;
    paymentPromptness?: number;
    responsibilitiesAndExpectations?: number;
}

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;
    recruiterAcknowledgementAccept: 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;
    fetchFreelancersSkillDropdown: string;
};

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

declare const ADMIN_FREELANCER_PATTERN: {
    adminFetchFreelancers: string;
    adminFreelancerCount: string;
    adminExportFreelancer: string;
    adminFetchFreelancerById: string;
    adminFetchFreelancerSkillsById: string;
    adminFetchFreelancerProjectsById: string;
    adminFetchFreelancerExperiencesById: string;
    adminFetchFreelancerEducationsById: string;
    adminFetchFreelancerAgreementById: string;
    adminCreateFreelancer: string;
    adminUpdateFreelancer: string;
    adminDeleteFreelancer: string;
    fetchFreelancerGraphCount: string;
    adminExportFreelancerV2: string;
    adminExportFreelancerV2Optimised: string;
    sendAiAssessmentLink: string;
    fetchAIassessmentsForAdmin: string;
    fetchAiAssessmentRequestsForAdmin: string;
    updateAssessmentRequestStatus: string;
    fetchAIassessmentResultForFreelancerAdmin: string;
    deleteAIassessmentForAdminFreelancer: string;
    fetchAppliedJobsOfAdminFreelancer: string;
    updateAdminFreelancerAccountStatus: string;
    downloadAllFreelancerResumes: string;
    fetchFreelancerResumeStats: string;
    adminFreelancerAccountCreation: string;
};

declare enum NatureOfWorkEnum$1 {
    FTE = "FTE",
    FREELANCE = "FREELANCE",
    BOTH = "BOTH"
}
declare enum ModeOfWorkEnum$1 {
    REMOTE = "REMOTE",
    ONSITE = "ONSITE",
    HYBRID = "HYBRID"
}
declare class CreateFreelancerDto {
    fullName?: string;
    email?: string;
    mobileCode?: string;
    mobile?: string;
    address: string;
    addressLine?: string;
    countryId?: number;
    stateId?: number;
    cityId?: number;
    postalCode?: string;
    about?: string;
    designation?: string;
    experience?: number;
    password?: string;
    confirmPassword: string;
    developer?: boolean;
    natureOfWork?: NatureOfWorkEnum$1;
    expectedHourlyCompensation?: number;
    expectedAnnualCompensation?: number;
    numberOfHours?: number;
    modeOfWork?: ModeOfWorkEnum$1;
    isImmediateJoiner?: boolean;
    availabilityToJoin?: string;
    linkedinProfileLink?: string;
    kaggleProfileLink?: string;
    githubProfileLink?: string;
    stackOverflowProfileLink?: string;
    portfolioLink?: string;
    file?: any;
}

declare enum NatureOfWorkEnum {
    FTE = "FTE",
    FREELANCE = "FREELANCE",
    BOTH = "BOTH"
}
declare enum ModeOfWorkEnum {
    REMOTE = "REMOTE",
    ONSITE = "ONSITE",
    HYBRID = "HYBRID"
}
declare class UpdateFreelancerDto {
    fullName?: string;
    email?: string;
    mobileCode?: string;
    mobile?: string;
    address: string;
    addressLine?: string;
    countryId?: number;
    stateId?: number;
    cityId?: number;
    postalCode?: string;
    about?: string;
    designation?: string;
    experience?: number;
    password?: string;
    developer?: boolean;
    natureOfWork?: NatureOfWorkEnum;
    expectedHourlyCompensation?: number;
    expectedAnnualCompensation?: number;
    numberOfHours?: number;
    modeOfWork?: ModeOfWorkEnum;
    isImmediateJoiner?: boolean;
    availabilityToJoin?: string;
    linkedinProfileLink?: string;
    kaggleProfileLink?: string;
    githubProfileLink?: string;
    stackOverflowProfileLink?: string;
    portfolioLink?: string;
    file?: any;
}

declare class SendAiAssessmentLinkDto {
    uuid: string;
}

declare enum AssessmentRequestStatus {
    PENDING = "PENDING",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED",
    EXPIRED = "EXPIRED"
}
declare class UpdateAssessmentRequestStatusDto {
    status: AssessmentRequestStatus;
    remarks?: string;
}

declare class AdminExportFreelancerV2OptimisedDto {
    customEmails?: string[];
}

declare class UpdateAdminFreelancerAccountStatusDto {
    accountStatus: AccountStatus;
}

declare class AdminFreelancerCreateAccountDto {
    fullName: string;
    email: string;
    mobileCode: string;
    mobile: string;
    countryISOCode: 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;
    adminExportClientV2Optimised: string;
    updateAdminClientAccountStatus: string;
    skipServiceAgreementFlow: string;
    updateAdminClientJobPostingRestrictionStatus: string;
};

declare class CreateClientDto {
    firstName: string;
    lastName: string;
    email: string;
    mobileCode: string;
    phoneNumber: string;
    password: string;
    confirmPassword: string;
    companyName: string;
    foundUsOn: string;
    foundUsOnDetail?: string;
    about?: string;
    webSite?: string;
    companyAddress?: string;
    addressLine?: string;
    postalCode?: string;
    countryId?: number;
    stateId?: number;
    cityId?: number;
    markupPercentage?: number;
}

declare class UpdateClientAccountStatusDto {
    accountStatus: AccountStatus;
}

declare class UpdateClientDto {
    firstName: string;
    lastName: string;
    email: string;
    mobileCode?: string;
    phoneNumber?: string;
    password?: string;
    companyName: string;
    foundUsOn: string;
    foundUsOnDetail?: string;
    about?: string;
    webSite?: string;
    companyAddress?: string;
    addressLine?: string;
    postalCode?: string;
    countryId: number | null;
    stateId: number | null;
    cityId: number | null;
    markupPercentage?: number | null;
}

declare class AdminExportClientV2OptimisedDto {
    customEmails?: string[];
}

declare class UpdateAdminClientAccountStatusDto {
    accountStatus: AccountStatus;
}

declare class UpdateAdminClientJobPostingRestrictionDto {
    isJobPostingRestricted: boolean;
}

declare class SkipServiceAgreementFlowDto {
    skipServiceAgreement: boolean;
}

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 CLIENT_CANDIDATE_PREFERENCE_PATTERN: {
    fetchClientPreferredCandidate: string;
    markCandidateAsNotSuitable: string;
    markCandidateAsNotSuitableInBulk: string;
    markCandidateAsShortlisted: string;
    markCandidateAsShortlistedInBulk: string;
};

declare class MarkCandidateStatusDto {
    candidateId: number;
    jobId?: number;
}

declare class MarkCandidateStatusBulkDto {
    candidateIds: number[];
    jobId?: number;
}

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

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

declare class UpdateCmsStatusDto {
    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;
    adminCreateJobV2: string;
    adminUpdateJobV2: string;
    adminDeleteJob: string;
    adminCountJob: string;
    adminFetchGraphCount: string;
    adminFetchJobByIdV2: string;
    adminExportJobsToCSV: string;
    adminFetchJobDescription: string;
    adminUpdateJobDescription: string;
    adminFetchJobsPostedByClient: string;
    adminExportJobV2: 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 enum JobLocationAdminEnumDto {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    HYBRID = "HYBRID"
}
declare enum EmploymentTypeAdminEnumDto {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH",
    HOURLY = "HOURLY",
    FREELANCE = "FREELANCE",
    FTE = "FTE"
}
declare enum typeOfExperienceAdminEnumDto {
    SINGLE = "SINGLE",
    RANGE = "RANGE"
}
declare enum AdminStepCompletedEnumV2 {
    BASIC_INFORMATION = "BASIC_INFORMATION",
    JOB_DESCRIPTION = "JOB_DESCRIPTION"
}
declare enum BillingCycleEnumV2 {
    WEEKLY = "WEEKLY",
    DELIVERABLE = "DELIVERABLE"
}
declare class JobLocationAdminDto {
    countryId: number;
    stateId: number;
    cityId: number;
}
declare class AdminJobBasicInformationV2Dto {
    isDraft?: boolean;
    clientId: number;
    jobRole: string;
    note?: string;
    skills: string[];
    openings: number;
    location: JobLocationAdminEnumDto;
    typeOfEmployment: EmploymentTypeAdminEnumDto;
    billingCycle: BillingCycleEnumV2;
    expectedSalaryFrom?: number;
    expectedSalaryTo?: number;
    locations: JobLocationAdminDto[];
    academicQualification?: string;
    yearsOfExperienceType: typeOfExperienceAdminEnumDto;
    yearsOfExperienceFrom?: string;
    yearsOfExperienceTo?: string;
    businessIndustry?: string;
    projectName?: string;
    hideExpectedSalaryFrom: boolean;
    hideExpectedSalaryTo: boolean;
    expectedAnnualBudgetFrom: number;
    hideExpectedAnnualBudgetFrom: boolean;
    expectedAnnualBudgetTo: number;
    hideExpectedAnnualBudgetTo: boolean;
    numberOfHours: number;
    years: string;
    months: string;
    weeks: string;
    days: string;
    additionalComment?: string;
    goodToHaveSkills: string[];
    jobRoleCanonicalName?: string;
    stepCompleted?: AdminStepCompletedEnumV2;
}

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;
    fetchAdminRolePermissions: string;
    updateAdminRoleStatus: string;
};

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

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

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

declare class UpdateAdminRoleStatusDto {
    isActive: boolean;
}

declare const ADMIN_PERMISSION_PATTERN: {
    fetchAdminPermissions: string;
};

declare const INTERVIEW_INVITE_PATTERN: {
    sendInterviewInvite: string;
    fetchInvitedFreelancerForClient: string;
    fetchInterviewInvite: string;
};
declare const F2F_INTERVIEW_PATTERN: {
    fetchBookings: string;
    fetchBookingById: string;
    fetchInterviewsByInterviewerId: string;
    fetchInterviewsByCandidateId: string;
    createF2FInterview: string;
    createF2FInterviewRescheduleRequest: string;
    rejectF2FInterviewRescheduleRequest: string;
    fetchF2FInterviewsForClient: string;
    fetchInterviewedFreelancerForClient: string;
    createF2FInterviewDirect: string;
    approveF2FInterviewRescheduleRequest: string;
    fetchF2FInterviewByUuidWithJobDetailsForClient: string;
    fetchF2FInterviewByUuidWithJobDetailsForFreelancer: string;
    fetchF2FInterviewByUuidWithJobDetails: string;
};
declare const AI_INTERVIEW_PATTERN: {
    fetchAiInterviewDetailPublic: string;
    markAiInterviewAsInProgressPublic: string;
    markAiInterviewAsExpiredPublic: string;
    captureAiInterviewResultPublic: string;
    fetchAiInterviewforClient: string;
    fetchAiInterviewforFreelancer: string;
    fetchAiInterviewByUuidWithJobDetailsForFreelancer: string;
    fetchRescheduleRequestsForFreelancerAiInterview: string;
    fetchRescheduleRequestsForClientAiInterview: string;
    fetchAiInterviewAnalysisForClient: string;
    fetchAiInterviewRescheduleRequestsForClient: string;
    createAiInterviewRescheduleRequest: string;
    approveAiInterviewRescheduleRequest: string;
    rejectAiInterviewRescheduleRequest: string;
    handleAiInterviewAuthentication: string;
    handleAiInterviewQuestionGeneration: string;
    handleAiInterviewTemplateGeneration: string;
    handleAiInterviewLinkGeneration: string;
    handleAiInterviewInsights: string;
};
declare const CALENDLY_PATTERN: {
    handleCalendlyWebhook: string;
};
declare const ZOOM_PATTERN: {
    handleZoomWebhook: string;
    handleTestZoomWebhook: string;
    handleZoomRecordingSettlement: string;
};
declare const INTERVIEW_PATTERN: {
    fetchInterviews: string;
    fetchInterviewDetail: string;
    fetchInterviewType: string;
    fetchInterviewBasicInformation: string;
    createInterviewBasicInformation: string;
    updateInterviewBasicInformation: string;
    fetchInterviewTypeInformation: string;
    updateInterviewTypeInformation: string;
    fetchInterviewSkills: string;
    createInterviewSkills: string;
    fetchInterviewQuestions: string;
    createInterviewQuestions: string;
    fetchInterviewSetting: string;
    updateInterviewSetting: string;
    markInterviewAsPublished: string;
    deleteInterview: string;
    fetchInterviewCountAsPerStatus: string;
    fetchCompletedAiAndF2FInterviewForClient: string;
};

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

declare enum InterviewInviteCandidateType {
    SHORTLISTED = "SHORTLISTED",
    APPLICANTS = "APPLICANTS",
    RECOMMENDED = "RECOMMENDED",
    NEW = "NEW"
}
declare class ExistingCandidateDto {
    id: string;
    type: InterviewInviteCandidateType;
}
declare class NewCandidateDto {
    name: string;
    email: string;
    type: InterviewInviteCandidateType;
}
declare class SendInterviewInviteDto {
    jobId: string;
    existingCandidates?: ExistingCandidateDto[];
    newCandidates?: NewCandidateDto[];
}

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

declare class CreateF2FInterviewDirectDto {
    inviteeEmail: string;
    inviteeName: string;
    jobId: number;
    candidateId: number;
}

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

declare class CreateAIInterviewRescheduleRequestDto {
    aiInterviewId: string;
    freelancerRequestReason: string;
}

declare class RejectAIInterviewRescheduleRequestDto {
    clientRejectReason: string;
}

declare class RejectF2FInterviewRescheduleRequestDto {
    clientRejectReason?: string;
}

declare class CaptureAiInterviewResultPublicDto {
    aiInterviewUuid: string;
    result?: any;
    status?: string;
}

declare class CreateInterviewBasicInformationDto {
    jobId: number;
    interviewName: string;
}

declare class UpdateInterviewBasicInformationDto {
    title?: string;
    description?: string;
    scheduledAt?: string;
    duration?: number;
    skillIds?: number[];
    location?: string;
}

declare class InterviewSkillItemDto {
    uuid?: string;
    skill: string;
    description?: string;
}
declare class CreateInterviewSkillsDto {
    skills: InterviewSkillItemDto[];
}

declare class CustomQuestionItemDto {
    uuid?: string;
    question: string;
}
declare class AiQuestionItemDto {
    uuid?: string;
    question: string;
    concepts?: string[];
}
declare class CreateInterviewQuestionsDto {
    questions?: CustomQuestionItemDto[];
    aiQuestions?: AiQuestionItemDto[];
}

declare class UpdateInterviewSettingDto {
    interviewLanguage?: string;
    allowProctoring?: boolean;
    interviewDuration?: string;
    interviewValidityPeriod?: string;
    maximumAttemptsAllowed?: string;
    startInterviewMessage?: string;
    endInterviewMessage?: string;
}

declare class UpdateInterviewTypeInformationDto {
    interviewType?: string;
}

declare const CONTRACT_PATTERN: {
    generateContract: string;
    fetchHiredFreelancerForClient: string;
    esignContractForClient: string;
    markContractViewedByFreelancer: string;
    esignContractForFreelancer: string;
    fetchFreelancerDropdownForClient: string;
    fetchClientDropdownForFreelancer: string;
    escrowFundForContract: string;
    markContractAsActive: string;
    handleContractManualClosure: string;
    fetchActiveContractsForFreelancer: string;
    fetchHiredFreelancerForGroupCreation: string;
    fetchActiveContractFreelancerCount: string;
    fetchJobsDropDownForContractFilters: string;
    fetchJobsDropDownFortaskFilters: string;
    fetchOfferedJobsForFreelancer: string;
    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;
    resendContractForFreelancer: string;
};

declare class SignContractForClientDto {
    jobId: number;
    freelancerId: number;
    contractType: ContractTypeEnum;
}

declare class SignContractForFreelancerDto {
    jobId: number;
    clientId: number;
    contractType: ContractTypeEnum;
}

declare enum ContractSourceEnum$1 {
    AI_INTERVIEW = "AI_INTERVIEW",
    F2F_INTERVIEW = "F2F_INTERVIEW",
    JOB = "JOB"
}
declare enum ContractTypeEnumDto {
    NDA = "NDA",
    WORK = "WORK",
    SOW = "SOW",
    MSA = "MSA"
}
declare enum PreferredEngagementTypeEnum$1 {
    FREELANCE = "FREELANCE"
}
declare class GenerateContractDto {
    jobId: number;
    freelancerId: number;
    contractType?: ContractTypeEnumDto;
    contractStartDate?: string;
    contractEndDate?: string;
    contractInvoicingCycle?: string;
    preferredEngagementType?: PreferredEngagementTypeEnum$1;
    source?: ContractSourceEnum$1;
    sourceUuid?: string;
}

declare class EsignContractClientDto {
    contractUuid: string;
}

declare class EsignContractFreelancerDto {
    contractUuid: string;
}

declare class EscrowFundContractDto {
    contractId: string;
}

declare enum ContractSourceEnum {
    AI_INTERVIEW = "AI_INTERVIEW",
    F2F_INTERVIEW = "F2F_INTERVIEW",
    JOB = "JOB"
}
declare class SendNdaContractToFreelancerDto {
    contractUuid: string;
    source?: ContractSourceEnum;
    sourceUuid?: string;
}

declare class RejectContractDto {
    rejectReason?: string;
}

declare const STRIPE_PATTERN: {
    handleStripeWebhookEvent: string;
    createConnectAccount: string;
    fetchConnectAccountDetails: string;
    createCheckoutSession: string;
    transferFunds: string;
    getAccountBalance: string;
    createPayout: string;
    getConnectedAccounts: string;
    getTransferHistory: string;
    fetchTransactions: string;
    handleStripeWebhookTestEvent: string;
    createClientCustomerAccount: string;
    preCheckoutCalculation: string;
    clientAddFund: string;
    getFreelancerAccountBalance: string;
    getBalanceTransactionsForFreelancer: string;
};

declare class CreateCheckoutSessionDto {
    amount: number;
}

declare class PreCheckoutCalculationDto {
    amount: number;
    currency?: string;
    description?: string;
}

declare class ClientAddFundDto {
    amount: number;
    currency?: string;
    description?: string;
}

declare class TransferFundsDto {
    invoiceUuid: string;
}

declare const TIMESHEET_FREELANCER_PATTERN: {
    fetchTimesheetsByDateRangeForFreelancer: string;
    createTimesheetForFreelancer: string;
    updateTimesheetForFreelancer: string;
    findTimesheetByIdForFreelancer: string;
    deleteTimesheetForFreelancer: string;
    submitTimesheetForFreelancer: string;
    fetchMissingTimesheetsForFreelancer: string;
    fetchSubmitedTimesheetsForFreelancer: string;
    fetchTimesheetsForResubmitForFreelancer: string;
    fetchTimesheetsByDateRangeAndJobIdForFreelancer: string;
    fetchWeeklyCardSummeryByJobIdForFreelancer: string;
    fetchCardSummeryByTimesheetLineIdForFreelancer: string;
    fetchApprovedTimesheetsForFreelancer: string;
    fetchPendingApprovalTimesheetsForFreelancer: string;
    fetchAllSubmittedTimesheetsForFreelancer: string;
    checkTimesheetSubmissionStatusForFreelancer: string;
    fetchSubmissionHistoryForFreelancer: string;
    resubmitTimesheetForFreelancer: string;
    createMissingTimesheetLine: string;
    fetchClientDropDownForFreelancer: string;
    fetchJobsDropDownForFreelancer: string;
};
declare const TIMESHEET_CLIENT_PATTERN: {
    approveFreelancerTimesheetForClient: string;
    rejectFreelancerTimesheetForClient: string;
    fetchAllSubmittedTimesheetsForClient: string;
    fetchAllSendBackTimesheetsForClient: string;
    fetchAllPendingApprovalTimesheetsForClient: string;
    fetchAllApprovedTimesheetsForClient: string;
    fetchFreelancerWeeklyCardSummeryForClient: string;
    fetchFreelancerCardSummeryByTimesheetLineIdForClient: string;
    fetchFreelancerTimesheetsByDateRangeForClient: string;
    sendBackFreelancerTimesheetForClient: string;
    fetchSubmissionHistoryForClient: string;
    fetchFreelancerDropDownForClient: string;
    createDefaultTimesheetLineOnContractSigned: string;
};

declare class CreateFreelancerTimesheetDto {
    jobId: number;
    startDate?: string;
    endDate?: string;
    startTime?: string;
    endTime?: string;
    taskId: number;
    projectName?: string;
    deliverable?: string;
    taskName?: string;
    description?: string;
    skipTaskLogSync?: boolean;
}

declare class UpdateFreelancerTimesheetDto {
    jobId: number;
    startDate?: string;
    endDate?: string;
    startTime?: string;
    endTime?: string;
    taskId: number;
    projectName?: string;
    deliverable?: string;
    taskName?: string;
    description?: string;
}

declare class SubmitTimesheetDto {
    timesheetLineId: number;
}

declare class ResubmitTimesheetDto {
    timesheetLineId: number;
}

declare class ApproveTimesheetsDto {
    timesheetLineId: number;
}

declare class SendBackTimesheetsDto {
    timesheetLineId: number;
    clientSendBackReason?: string;
}

declare class CreateDefaultTimesheetLineDto {
    contractId: number;
    freelancerId: number;
    clientId: number;
}

declare const INVOICE_PATTERN: {
    createInvoice: string;
    generateWeeklyInvoice: string;
    generateHiringInvoiceOfFTE: string;
    fetchInvoicesForFreelancer: string;
    fetchInvoicesForClient: string;
    fetchInvoiceById: string;
    updateInvoiceStatus: string;
    fetchAnalyticsForClient: string;
    fetchAnalyticsForFreelancer: string;
    fetchFreelancerDropdownForClient: string;
    fetchInvoicesSummeryForClient: string;
    fetchDashboardAnalyticsForClient: string;
    fetchPaymentDetailsByInvoiceId: string;
    fetchInvoiceReportsForClient: string;
};

declare class UpdateInvoiceStatusDto {
    status: InvoiceStatusEnum;
}

declare class CreateInvoiceDto {
    timeSheetLineId: number;
}

declare const DISPUTE_PATTERN: {
    fetchDisputes: string;
    fetchDisputeById: string;
    createDispute: string;
};

declare class CreateDisputeDto {
    clientId: number;
    freelancerId: number;
    disputeType: string;
    initiatorType: string;
    description: any;
    comment?: string;
    dynamicFields?: Record<string, any>;
}

declare const SENSELOAF_PATTERN: {
    handleAiAssessmentDetails: string;
    handelAiAssessmentCreation: string;
    handleJdParsing: string;
};

declare class AiInterviewQuestionGenerateDto {
    jobDescription: string;
    numQuestions: number;
}

declare class ResumeParsingByUrlDto {
    resumeUrl: string;
    fileName?: string;
}

declare class ResumeDataProcessingDto {
    resumeData: any;
    userId?: string;
    processingType?: string;
}

declare class CheckResumeEligibilityDto {
    resumeData: any;
    jobId?: string;
    userId?: string;
}

declare class AiInterviewTemplateGenerationDto {
    jobId: string;
    skills?: string[];
    numberOfQuestions?: number;
    difficulty?: string;
}

declare class AiInterviewLinkGenerationDto {
    templateId: string;
    freelancerId: string;
    jobId?: string;
    expiryHours?: number;
}

declare class AiAssessmentCreationDto {
    userId: string;
    assessmentType?: string;
    numberOfQuestions?: number;
    difficulty?: string;
}

declare const COMMISSION_PATTERN: {
    fetchCommission: string;
};

declare const HIRING_PATTERN: {
    fetchAllHiredFreelancerForClient: string;
    fetchAllHiredClientForFreelancer: string;
    createHiring: string;
};

declare enum PreferredEngagementTypeEnum {
    FTE = "FTE",
    FREELANCE = "FREELANCE"
}
declare class CreateHiringDto {
    freelancerId: number;
    jobId: number;
    preferredEngagementType?: PreferredEngagementTypeEnum;
}

declare const LLM_PATTERN: {
    handleMcqGeneration: string;
};

declare const SKILL_PATTERN: {
    fetchSkillsDropdown: string;
    fetchSkillsDropdownV2: string;
};

declare const SIGNATURE_PATTERN: {
    fetchSignatures: string;
    saveSignature: string;
};

declare class SaveSignatureDto {
    signatureType?: string;
    description?: string;
}

declare const WALLET_PATTERN: {
    fetchConnectAccountDetails: string;
    fetchWalletTransactions: string;
    escrowFund: string;
    transferEscrowAmountToFreelancerFromClient: string;
    addTopupEscrowAmount: string;
    debitCommissionFromClientForFTEHiring: string;
};
declare const WALLET_ADMIN_PATTERN: {
    fetchAdminWalletBalance: string;
    fetchAdminWalletTransactions: string;
};

declare class AddTopupEscrowAmountDto {
    amount: number;
    escrowWalletUuid: string;
}

declare class DebitCommissionFteHiringDto {
    invoiceUuid: string;
}

declare enum AlertSeverity {
    CRITICAL = "CRITICAL",
    ERROR = "ERROR",
    WARNING = "WARNING",
    SECURITY = "SECURITY",
    INFO = "INFO",
    SUCCESS = "SUCCESS"
}
declare enum AlertCategory {
    CRITICAL_ERROR = "CRITICAL_ERROR",
    DATABASE = "DATABASE",
    PAYMENT = "PAYMENT",
    SECURITY = "SECURITY",
    PERFORMANCE = "PERFORMANCE",
    BUSINESS_EVENT = "BUSINESS_EVENT"
}
interface DiscordAlertOptions {
    severity: AlertSeverity;
    category: AlertCategory;
    title: string;
    description: string;
    fields?: Record<string, string | number | boolean>;
    metadata?: {
        microservice?: string;
        environment?: string;
        correlationId?: string;
        userId?: string;
        requestPath?: string;
        requestMethod?: string;
        errorStack?: string;
        hostname?: string;
        [key: string]: any;
    };
}
interface DiscordWebhookConfig {
    errorWebhookUrl?: string;
    securityWebhookUrl?: string;
    businessWebhookUrl?: string;
    performanceWebhookUrl?: string;
    enabled?: boolean;
    rateLimitPerMinute?: number;
    environment?: string;
    microserviceName?: string;
}
interface DiscordEmbedField {
    name: string;
    value: string;
    inline?: boolean;
}
interface DiscordEmbedFooter {
    text: string;
    icon_url?: string;
}
interface DiscordEmbed {
    title: string;
    description: string;
    color: number;
    fields: DiscordEmbedField[];
    footer?: DiscordEmbedFooter;
    timestamp: string;
    thumbnail?: {
        url: string;
    };
    author?: {
        name: string;
        icon_url?: string;
    };
}
interface DiscordWebhookPayload {
    content?: string;
    embeds: DiscordEmbed[];
    username?: string;
    avatar_url?: string;
}
interface RateLimitState {
    webhookUrl: string;
    timestamps: number[];
}
interface AlertKeyComponents {
    severity: AlertSeverity;
    category: AlertCategory;
    title: string;
    microservice?: string;
}

declare class RateLimiter {
    private readonly maxAlertsPerMinute;
    private alertCounts;
    private recentAlerts;
    private readonly deduplicationWindow;
    private readonly cleanupInterval;
    private cleanupTimer?;
    constructor(maxAlertsPerMinute?: number);
    canSendAlert(webhookUrl: string): boolean;
    recordAlert(webhookUrl: string): void;
    isDuplicate(alertKey: string): boolean;
    generateAlertKey(components: AlertKeyComponents): string;
    getStats(): {
        totalWebhooks: number;
        totalUniqueAlerts: number;
        webhookStats: Array<{
            webhook: string;
            alertsInLastMinute: number;
            remainingCapacity: number;
        }>;
    };
    private maskWebhookUrl;
    clear(): void;
    private startCleanup;
    private cleanup;
    destroy(): void;
    getDeduplicationWindow(): number;
    getMaxAlertsPerMinute(): number;
    isRateLimited(webhookUrl: string): boolean;
    getRemainingCapacity(webhookUrl: string): number;
}

declare class DiscordAlertService {
    private readonly rateLimiter;
    private readonly config;
    private alertsSent;
    private alertsFailed;
    constructor(config: DiscordWebhookConfig);
    sendAlert(options: DiscordAlertOptions): Promise<void>;
    sendCriticalError(error: Error, context?: Record<string, any>): Promise<void>;
    sendDatabaseError(message: string, context?: Record<string, any>): Promise<void>;
    sendSecurityAlert(title: string, description: string, context?: Record<string, any>): Promise<void>;
    sendPaymentError(message: string, context?: Record<string, any>): Promise<void>;
    sendBusinessEvent(title: string, description: string, context?: Record<string, any>): Promise<void>;
    sendPerformanceWarning(title: string, description: string, metrics?: Record<string, any>): Promise<void>;
    private getWebhookUrl;
    private sendToWebhook;
    private httpPost;
    private getHostname;
    private log;
    private logError;
    getStats(): {
        alertsSent: number;
        alertsFailed: number;
        successRate: number;
        rateLimiterStats: ReturnType<RateLimiter['getStats']>;
    };
    resetStats(): void;
    isConfigured(): boolean;
    getConfig(): Omit<Required<DiscordWebhookConfig>, 'errorWebhookUrl' | 'securityWebhookUrl' | 'businessWebhookUrl' | 'performanceWebhookUrl'> & {
        webhooksConfigured: {
            error: boolean;
            security: boolean;
            business: boolean;
            performance: boolean;
        };
    };
    destroy(): void;
}

interface DiscordTransportOptions {
    level?: string;
    webhookUrl: string;
    microserviceName: string;
    environment: string;
    enabled?: boolean;
    category?: AlertCategory;
    severity?: AlertSeverity;
}
interface WinstonLogInfo {
    level: string;
    message: string;
    timestamp?: string;
    stack?: string;
    correlationId?: string;
    context?: string;
    error?: string;
    [key: string]: any;
}
declare class DiscordTransport extends Transport {
    private readonly discordService;
    private readonly transportOptions;
    private logsSent;
    constructor(options: DiscordTransportOptions);
    log(info: WinstonLogInfo, callback: () => void): void;
    private shouldLog;
    private sendLogToDiscord;
    private mapLogLevelToSeverity;
    private buildTitle;
    getStats(): {
        logsSent: number;
        discordStats: ReturnType<DiscordAlertService['getStats']>;
    };
    close(): void;
}
declare function createDiscordTransport(options: DiscordTransportOptions): DiscordTransport;

declare class AlertBuilder {
    private static readonly COLORS;
    private static readonly SEVERITY_EMOJIS;
    static buildEmbed(options: DiscordAlertOptions): DiscordEmbed;
    private static formatTitle;
    private static formatEnvironment;
    private static formatTimestamp;
    private static formatValue;
    private static shouldBeInline;
    private static looksLikeCode;
    private static truncateStack;
    private static truncateDescription;
    private static buildFooter;
    static validateEmbed(embed: DiscordEmbed): string[];
}

declare class CreateInAppNotificationDto {
    userId: number;
    event?: string;
    title?: string;
    message: string;
    redirectUrl?: string;
    metaData?: any;
}

declare class UpdateIsReadDto {
    id?: number;
    ids?: number[];
    isRead: boolean;
}

declare const IN_APP_NOTIFICATION_PATTERN: {
    createInAppNotification: string;
    fetchInAppNotification: string;
    updateInAppNotificationAsRead: string;
};

declare const DOCUSEAL_PATTERN: {
    createUserSigning: string;
    getSubmission: string;
    getSubmitter: string;
    getTemplates: string;
    getTemplate: string;
    archiveSubmission: string;
    processWebhook: string;
};

declare enum DocuSealOrderEnum {
    PRESERVED = "preserved",
    RANDOM = "random"
}
declare class DocuSealSubmitterDto {
    email: string;
    name?: string;
    phone?: string;
    fields?: Record<string, unknown>[];
}
declare class DocuSealMessageDto {
    subject?: string;
    body?: string;
}
declare class CreateUserSigningDto {
    templateId: number;
    sendEmail?: boolean;
    order?: DocuSealOrderEnum;
    submitters: DocuSealSubmitterDto[];
    message?: DocuSealMessageDto;
    completedRedirectUrl?: string;
    expireAt?: string;
}

declare class GetSubmissionDto {
    submissionId: number;
}

declare class GetSubmitterDto {
    submitterId: number;
}

declare class GetTemplateDto {
    templateId: number;
}

declare class ArchiveSubmissionDto {
    submissionId: number;
}

declare const TASK_PATTERN: {
    createTask: string;
    fetchTaskForBusiness: string;
    fetchTaskForFreelancer: string;
    fetchTaskDetail: string;
    updateTask: string;
    deleteTask: string;
    addClientRemark: string;
    markTaskAsCompleted: string;
    markTaskAsSubmitted: string;
    updateEstimateTime: string;
    addTaskQuery: string;
    fetchTaskQueriesWithDetails: string;
    addTaskQueryReply: string;
    markTaskQueryMessagesRead: string;
    addTaskLogTime: string;
    syncTaskLogTimeFromTimesheet: string;
};

declare class TaskDeliverableDto$1 {
    name: string;
    description?: string;
    type?: string;
}
declare class TaskResourceDto$1 {
    name: string;
    description?: string;
    type?: string;
    url?: string;
}
declare class TaskChecklistItemDto$1 {
    item: string;
    notes?: string;
}
declare class TaskSubtaskDto$1 {
    name: string;
    status?: string;
    description?: string;
}
declare class CreateTaskDto {
    title?: string;
    dueDate?: string;
    jobId?: string;
    freelancerId?: string;
    status?: string;
    description?: string;
    priority?: string;
    createdOn?: string;
    deliverables?: TaskDeliverableDto$1[];
    resources?: TaskResourceDto$1[];
    checklist?: TaskChecklistItemDto$1[];
    subtasks?: TaskSubtaskDto$1[];
}

declare class TaskDeliverableDto {
    name: string;
    description?: string;
    type?: string;
}
declare class TaskResourceDto {
    name: string;
    description?: string;
    type?: string;
    url?: string;
}
declare class TaskChecklistItemDto {
    item: string;
    notes?: string;
}
declare class TaskSubtaskDto {
    name: string;
    status?: string;
    description?: string;
}
declare class UpdateTaskDto {
    title?: string;
    dueDate?: string;
    jobId?: string;
    freelancerId?: string;
    status?: string;
    description?: string;
    priority?: string;
    createdOn?: string;
    deliverables?: TaskDeliverableDto[];
    resources?: TaskResourceDto[];
    checklist?: TaskChecklistItemDto[];
    subtasks?: TaskSubtaskDto[];
}

declare class TaskUuidParamDto {
    uuid: string;
}

declare class AddClientRemarkDto {
    remark: string;
}

declare class MarkTaskAsCompletedDto {
    status: string;
}

declare class UpdateEstimateTimeDto {
    estimateHours: number;
    additionalWorkNote: string;
}

declare class CreateTaskQueryDto {
    queryCategory: TaskQueryCategoryEnum;
    subject?: string;
    description?: string;
    message?: string;
    file?: any;
}

declare class AddTaskQueryReplyDto {
    message?: string;
    file?: any;
}

declare class MarkTaskQueryMessagesReadDto {
    messageUuid?: string;
    messageUuids?: string[];
}

declare class AddTaskLogTimeDto {
    startDate: string;
    endDate: string;
    startTime: string;
    endTime: string;
}

declare const REFERRAL_PATTERN: {
    sendReferralInvite: string;
};

declare class SendReferralInviteDto {
    email: string[];
    referralCode: string;
    referralUrl: string;
}

declare const VENDOR_API_CONFIGURATION_PATTERN: {
    fetchVendorApiConfiguration: string;
    addVendorApiConfiguration: string;
    toggleStausVendorApiConfiguration: string;
    deletVendorApiConfiguration: string;
};

declare class VendorDetailDto {
    id?: number;
    vendorName: string;
    vendorApiKey: string;
    vendorApiSecretKey: string;
    isActive?: boolean;
}
declare class AddVendorApiConfigurationDto {
    vendorDetails: VendorDetailDto[];
}

declare const DIDIT_PATTERN: {
    handleEkycCreateSession: string;
    handleEkycWebhook: string;
};

declare class ContactDetailsDto {
    email?: string;
    email_lang?: string;
    send_notification_emails?: boolean;
    phone?: string;
}
declare class ExpectedDetailsDto {
    first_name?: string;
    last_name?: string;
    date_of_birth?: string;
    expected_document_types?: string[];
}
declare class MetadataDto {
    plan?: string;
    signup_source?: string;
}
declare class CreateEkycSessionDto {
    workflowId: string;
    callback: string;
    vendor_data?: string;
    metadata?: MetadataDto;
    contact_details?: ContactDetailsDto;
    expected_details?: ExpectedDetailsDto;
}

declare const UserTCPAdapter: () => MicroserviceOptions;

declare const JobTCPAdapter: () => MicroserviceOptions;

declare const ContractTCPAdapter: () => MicroserviceOptions;

declare const NotificationTCPAdapter: () => MicroserviceOptions;

declare const ChatTCPAdapter: () => MicroserviceOptions;

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

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

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

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

declare const ChatRMQAdapter: (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 SkillCatalog extends BaseEntity {
    canonicalName: string;
    aliases: string[];
    variations: Record<string, number>;
    category: string;
    parentSkill: string;
    relatedSkills: string[];
    usageCount: number;
    isVerified: boolean;
    firstSeenDate: Date;
    lastUpdatedDate: Date;
    searchVector: any;
}

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

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;
}

declare enum DocuSealTypeEnum {
    FREELANCER_SERVICE_AGGREMENT = "FREELANCER_SERVICE_AGGREMENT",
    CLIENT_SERVICE_AGGREMENT = "CLIENT_SERVICE_AGGREMENT",
    CONTRACT = "CONTRACT"
}
declare class DocuSeal extends BaseEntity {
    referenceId: number;
    submitterId: number;
    submitterResponse: any;
    webhookResponse: any;
    type: DocuSealTypeEnum;
}

declare class StripeLog extends BaseEntity {
    stripeEventId: string;
    eventType: string;
    stripeAccountId: string;
    rawWebhookData: string;
}

declare class RecommendationWeightageConfig extends BaseEntity {
    key: string;
    value: Record<string, any>;
    isActive: boolean;
}

declare class GlobalSetting extends BaseEntity {
    key: string;
    value: string;
}

declare class PlanFeature extends BaseEntity {
    planId: number;
    plan: Plan;
    name: string;
    slug: string;
    tooltip: string | null;
    sortOrder: number;
    isActive: boolean;
}

declare enum PlanPricingBillingCycleEnum {
    MONTHLY = "monthly",
    YEARLY = "yearly"
}
declare class PlanPricing extends BaseEntity {
    planId: number;
    plan: Plan;
    billingCycle: PlanPricingBillingCycleEnum;
    price: number;
    originalPrice: number | null;
    discountPct: number | null;
    currency: string;
    isFree: boolean;
    stripePriceId: string | null;
    trialDays: number;
    isActive: boolean;
    sanitize(): void;
    get monthlyEquivalent(): number | null;
    get savingsAmount(): number | null;
}

declare enum PlanTypeEnum {
    FREELANCER = "FREELANCER",
    BUSINESS = "BUSINESS"
}
declare class Plan extends BaseEntity {
    name: string;
    slug: string;
    badgeLabel: string | null;
    sortOrder: number;
    isActive: boolean;
    planType: PlanTypeEnum;
    metadata: Record<string, unknown>;
    stripeProductId: string | null;
    createSlug(): void;
    features: PlanFeature[];
    pricing: PlanPricing[];
}

declare class SubscriptionFeature extends BaseEntity {
    private toSlug;
    name: string;
    slug: string;
    tooltip: string | null;
    sortOrder: number;
    isActive: boolean;
    createSlug(): void;
}

declare enum UserSubscriptionTransactionTypeEnum {
    SUBSCRIPTION_INITIATED = "SUBSCRIPTION_INITIATED",
    CHECKOUT_SESSION_CREATED = "CHECKOUT_SESSION_CREATED",
    WEBHOOK_SUBSCRIPTION_SYNC = "WEBHOOK_SUBSCRIPTION_SYNC",
    SUBSCRIPTION_CANCELLED = "SUBSCRIPTION_CANCELLED"
}
declare enum UserSubscriptionTransactionStatusEnum {
    PENDING = "PENDING",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED",
    INFO = "INFO"
}
declare class UserSubscriptionTransaction extends BaseEntity {
    userSubscriptionId: number;
    userSubscription: UserSubscription;
    userId: number;
    type: UserSubscriptionTransactionTypeEnum;
    status: UserSubscriptionTransactionStatusEnum;
    planName: string | null;
    amountMinor: number | null;
    currency: string | null;
    stripeEventId: string | null;
    stripeEventType: string | null;
    stripeSubscriptionId: string | null;
    stripeInvoiceId: string | null;
    description: string | null;
    invoiceUrl: string | null;
    checkoutRequestPayload: Record<string, unknown> | null;
    checkoutResponsePayload: Record<string, unknown> | null;
    webhookPayload: Record<string, unknown> | null;
    metadata: Record<string, unknown> | null;
}

declare class VendorApiConfiguration extends BaseEntity {
    vendorName: string;
    vendorApiKey: string;
    vendorApiSecretKey: string;
    slug: string;
    isActive: boolean;
}

export { ADMIN_FREELANCER_PATTERN, ADMIN_JOB_PATTERN, ADMIN_PERMISSION_PATTERN, ADMIN_ROLE_PATTERN, AI_INTERVIEW_PATTERN, ASSESSMENT_QUESTION_PATTERN, AUTHENTICATION_PATTERN, AccountStatus, AccountType$1 as AccountType, AddClientRemarkDto, AddGlobalSettingDto, AddTaskLogTimeDto, AddTaskQueryReplyDto, AddTopupEscrowAmountDto, AddVendorApiConfigurationDto, AdminCreateJobInformationDto, AdminExportClientV2OptimisedDto, AdminExportFreelancerV2OptimisedDto, AdminFreelancerCreateAccountDto, AdminJobBasicInformationV2Dto, AdminPermission, AdminRole, AdminRolePermission, AdminUpdateJobInformationDto, AdminUserRole, AiAssessmentCreationDto, AiAssessmentStatusEnum, AiInterview, AiInterviewLinkGenerationDto, AiInterviewQuestionGenerateDto, AiInterviewRescheduleRequest, AiInterviewRescheduleRequestStatusEnum, AiInterviewStatusEnum, AiInterviewTemplateGenerationDto, AiQuestionItemDto, AlertBuilder, AlertCategory, type AlertKeyComponents, AlertSeverity, AnswerTypeEnum, ApplicationStatusEnum, ApproveTimesheetsDto, ArchiveSubmissionDto, AssessmentAnswer, AssessmentRequestStatusEnum, AssessmentStatusEnum, AssessmetQuestion, AssessmetQuestionOption, AttachPermissionsToRoleDto, BANK_PATTERN, BankAccountScopeEnum, BankAccountTypeEnum, BankDetail, BaseEntity, BillingCycleEnum, CALENDLY_PATTERN, CITY_PATTERN, CLIENT_ADMIN_PATTERNS, CLIENT_CANDIDATE_PREFERENCE_PATTERN, CLIENT_PROFILE_PATTERN, CMS_PATTERNS, COMMISSION_PATTERN, COMPANY_MEMBERS_PATTERNS, COMPANY_ROLES_PATTERNS, CONTRACT_PATTERN, COUNTRY_PATTERN, CalendlyMeetingLog, CaptureAiAssessmentResultDto, CaptureAiInterviewResultPublicDto, CaseStudyDto, CategoryEmum, ChangeJobApplicationStatusBulkDto, ChangeJobApplicationStatusDto, ChatRMQAdapter, ChatTCPAdapter, CheckResumeEligibilityDto, City, ClientAddFundDto, ClientCandidatePreference, ClientCandidatePreferenceEnum, ClientChangePasswordDto, ClientCreateAccountDto, ClientESignatureDto, ClientFreelancerRecommendation, ClientProfileQuestionDto, ClientServiceAgreementUploadDto, CloseJobDto, Cms, Commission, CommissionTypeEnum, CompanyMember, CompanyMemberRole, CompanyOnboardingStepEnum, CompanyProfile, CompanyRole, CompanyRolePermission, CompanySkill, ContactDetailsDto, Contract, ContractRMQAdapter, ContractStatusEnum, ContractSummary, ContractSummaryPreferredEngagementTypeEnum, ContractSummaryStatusEnum, ContractTCPAdapter, ContractTypeEnum, Country, CreateAIInterviewRescheduleRequestDto, CreateAdminRoleDto, CreateCheckoutSessionDto, CreateClientDto, CreateCmsDto, CreateCompanyMemberDto, CreateCompanyRoleDto, CreateDefaultTimesheetLineDto, CreateDisputeDto, CreateEkycSessionDto, CreateF2FInterviewDirectDto, CreateF2FInterviewDto, CreateF2FInterviewRescheduleRequestDto, CreateFreelancerDto, CreateFreelancerTimesheetDto, CreateHiringDto, CreateInAppNotificationDto, CreateInterviewBasicInformationDto, CreateInterviewQuestionsDto, CreateInterviewSkillsDto, CreateInvoiceDto, CreateJobApplicationDto, CreateJobAsIsDto, CreateJobViaAIDto, CreateLeadDto, CreateQuestionDto, CreateRatingDto, CreateSubAdminDto, CreateTaskDto, CreateTaskQueryDto, CreateUserSigningDto, CustomQuestionItemDto, DIDIT_PATTERN, DISPUTE_PATTERN, DOCUSEAL_PATTERN, DebitCommissionFteHiringDto, type DiscordAlertOptions, DiscordAlertService, type DiscordEmbed, type DiscordEmbedField, type DiscordEmbedFooter, DiscordTransport, type DiscordTransportOptions, type DiscordWebhookConfig, type DiscordWebhookPayload, Dispute, DisputeStatusEnum, DocuSeal, DocuSealMessageDto, DocuSealSubmitterDto, DocuSealTypeEnum, DocumentType, DurationTypeEnum, EMAIL_PATTERN, EducationDto, EkycVerificationLog, EkycVerificationLogStatusEnum, EkycVerificationSession, EkycVerificationSessionStatusEnum, EscrowFundContractDto, EscrowWallet, EscrowWalletTransaction, EscrowWalletTransactionForEnum, EscrowWalletTransactionTypeEnum, EsignContractClientDto, EsignContractFreelancerDto, ExistingCandidateDto, ExpectedDetailsDto, ExperienceDto, F2FInterview, F2FInterviewSchedule, F2F_INTERVIEW_PATTERN, F2fInterviewRescheduleRequest, F2fInterviewRescheduleRequestStatusEnum, F2fInterviewScheduleStatusEnum, F2fInterviewStatusEnum, FREELANCER_ASSESSMENT_REQUEST_PATTERN, FREELANCER_DECLARATION_PATTERN, FREELANCER_EDUCATION_PATTERN, FREELANCER_EXPERIENCE_PATTERN, FREELANCER_PROJECT_PATTERN, FREELANCER_SKILL_PATTERN, FetchClientInfoForChatDto, FetchFreelancerInfoForChatDto, ForgotPasswordDto, FreelancerAssessment, FreelancerAssessmentRequest, FreelancerBankDetailsDto, FreelancerCaptureAiAssessmentStatusDto, FreelancerCaseStudy, FreelancerChangePasswordDto, FreelancerCreateAccountDto, FreelancerDeclaration, FreelancerDeclarationDto, FreelancerDevelopmentPreferenceDto, FreelancerESignatureDto, FreelancerEducation, FreelancerEducationDto, FreelancerExperience, FreelancerExperienceDto, FreelancerFramework, FreelancerInitiateAiAssessmentDto, FreelancerInitiateMcqAssessmentDto, FreelancerParseResumeDto, FreelancerProfile, FreelancerProfileQuestionDto, FreelancerProject, FreelancerProjectDto, FreelancerResume, FreelancerSkill, FreelancerSkillCategoryEnum, FreelancerSkillDto, FreelancerSkipAiAssessmentDto, FreelancerTool, FreelancerUploadResumeDto, FreelancerWorkShowcaseDto, FromUsOn, GLOBAL_SETTING_PATTERN, GenerateContractDto, GetSubmissionDto, GetSubmitterDto, GetTemplateDto, GlobalSetting, HIRING_PATTERN, HiredFreelancerNatureOfWorkEnum, Hiring, HiringCommissionTypeEnum, 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 IFetchQuestionQuery, type IFetchQuestionResponse, type IFetchRatingResponse, type IFetchSubAdminByIdQuery, type IFetchSubAdminByIdResponse, type IFetchSubAdminQuery, type IFetchSubAdminResponse, INTERVIEW_INVITE_PATTERN, INTERVIEW_PATTERN, INVOICE_PATTERN, IN_APP_NOTIFICATION_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, InAppNotification, InitiatorTypeEnum, Interview, InterviewInvite, InterviewInviteDto, InterviewInviteStatusEnum, InterviewQuestion, InterviewQuestionType, InterviewSkill, InterviewSkillItemDto, InterviewStatusEnum, Invoice, InvoicePaymentStatusEnum, InvoiceStatusEnum, InvoiceTypeEnum, JOB_APPLICATION_PATTERN, JOB_PATTERN, JOB_ROLE_PATTERN, Job, JobAdditionalCommentDto, JobApplication, JobApplicationStatus, JobBasicInformationDto, JobBasicInformationV2Dto, JobDescriptionDto, JobFreelancerRecommendation, JobFreelancerRecommendationV2, JobIdParamDto, JobLocation, JobLocationAdminDto, JobLocationDto, JobLocationEnum$1 as JobLocationEnum, JobRMQAdapter, JobRecommendation, JobRoles, JobSkill, JobSkillCategoryEnum, JobStatus, JobStatusDto, JobStatusEnum, JobTCPAdapter, KindOfHire, LEAD_PATTERN, LLM_PATTERN, Lead, LoginDto, LoginUsingUuidDTO, LoginViaOtpDto, LogoutDto, MAINTENANCE_PATTERN, MarkCandidateStatusBulkDto, MarkCandidateStatusDto, MarkTaskAsCompletedDto, MarkTaskQueryMessagesReadDto, McqStatusEnum, MetadataDto, ModeOfHire, ModeOfWork, NOTIFICATION_PATTERN, NatureOfWork, NewCandidateDto, NotificationRMQAdapter, NotificationTCPAdapter, ONBOARDING_PATTERN, ONBOARDING_QUESTION_PATTERN, OTP_PATTERN, OnboardingStepEnum, Otp, PERMISSION_PATTERN, PLAN_PATTERN, PROFILE_PATTERN, Permission, Plan, PlanFeature, PlanPricing, PlanPricingBillingCycleEnum, PlanTypeEnum, PreCheckoutCalculationDto, ProjectDto, Provider, Question, QuestionFor, QuestionForEnum, RATING_PATTERN, REFERRAL_PATTERN, RESUME_PARSER_PATTERN, type RateLimitState, RateLimiter, Rating, RatingTypeEnum, RecommendationWeightageConfig, RecordAssessmentAnswerDto, RecordAssessmentAnswersDto, RecordingStatusEnum, RefreshDto, RefreshToken, RejectAIInterviewRescheduleRequestDto, RejectContractDto, RejectF2FInterviewRescheduleRequestDto, RemoveGlobalSettingDto, RequestPasswordChangeOtpForClientDto, RequestPasswordChangeOtpForFreelancerDto, ResetPasswordDto, ResetPasswordTokenValidationDto, ResetUserPasswordByAdminDto, ResubmitTimesheetDto, ResultStatusEnum, ResumeDataProcessingDto, ResumeParsingByUrlDto, SENSELOAF_PATTERN, SIGNATURE_PATTERN, SKILL_PATTERN, SMS_PATTERN, STATE_PATTERN, STRIPE_PATTERN, SUBADMIN_PATTERN, SYSTEM_PREFERENCES_PATTERN, SaveSignatureDto, SelectedAnswerTypeEnum, SendAiAssessmentLinkDto, SendBackTimesheetsDto, SendGuestOtpDto, SendInterviewInviteDto, SendLoginOtpDto, SendNdaContractToFreelancerDto, SendOtpDto, SendReferralInviteDto, SenseloafLog, SequenceGenerator, SetPasswordDto, SignContractForClientDto, SignContractForFreelancerDto, Signature, Skill, SkillCatalog, SkipServiceAgreementFlowDto, SocialAuthDto, State, Step, StripeLog, StripeTransaction, StripeTransactionStatusEnum, StripeTransactionTypeEnum, SubmitTimesheetDto, SubscriptionFeature, SystemPreference, SystemPreferenceDto, TASK_PATTERN, TIMESHEET_CLIENT_PATTERN, TIMESHEET_FREELANCER_PATTERN, Task, TaskChecklistItem, TaskDeliverable, TaskDeliverableTypeEnum, TaskLogTime, TaskPriorityEnum, TaskQuery, TaskQueryCategoryEnum, TaskQueryMessage, TaskQueryMessageUserTypeEnum, TaskQueryStatusEnum, TaskQueryUserTypeEnum, TaskResource, TaskResourceTypeEnum, TaskStatusEnum, TaskSubtask, TaskSubtaskStatusEnum, TaskUuidParamDto, TestNotificationDto, Timesheet, TimesheetLine, TimesheetLineHistory, TimesheetLineHistoryStatusEnum, TimesheetLineStatusEnum, TimesheetLogs, TimesheetStatusEnum, TimesheetSubmissionActionEnum, ToggleCompanyMemberVisibilityDto, ToggleCompanyRoleVisibilityDto, TransferFundsDto, TypeOfEmploymentEnum, UpdateAdminClientAccountStatusDto, UpdateAdminClientJobPostingRestrictionDto, UpdateAdminFreelancerAccountStatusDto, UpdateAdminRoleDto, UpdateAdminRoleStatusDto, UpdateAssessmentRequestStatusDto, UpdateClientAccountStatusDto, UpdateClientDto, UpdateCmsDto, UpdateCmsStatusDto, UpdateCompanyMemberDto, UpdateCompanyProfileDto, UpdateCompanyRoleDto, UpdateEstimateTimeDto, UpdateFreelancerDto, UpdateFreelancerProfileDto, UpdateFreelancerTimesheetDto, UpdateInterviewBasicInformationDto, UpdateInterviewSettingDto, UpdateInterviewTypeInformationDto, UpdateInvoiceStatusDto, UpdateIsReadDto, UpdateSubAdminAccountStatusDto, UpdateSubAdminDto, UpdateTaskDto, User, UserRMQAdapter, UserSubscription, UserSubscriptionPlan, UserSubscriptionPlanFeature, UserSubscriptionPlanPricing, UserSubscriptionPlanPricingBillingCycleEnum, UserSubscriptionPlanTypeEnum, UserSubscriptionStatusEnum, UserSubscriptionTransaction, UserSubscriptionTransactionStatusEnum, UserSubscriptionTransactionTypeEnum, UserTCPAdapter, VENDOR_API_CONFIGURATION_PATTERN, ValidateEmailDto, ValidateEmailForLoginDto, ValidateMobileDto, VendorApiConfiguration, VendorDetailDto, VerifyGuestOtpDto, VerifyOnboardingTokenDto, VerifyOtpDto, VerifyPasswordChangeOtpForClientDto, VerifyPasswordChangeOtpForFreelancerDto, WALLET_ADMIN_PATTERN, WALLET_PATTERN, Wallet, WalletAccountTypeEnum, WalletOnboardingStatusEnum, WalletTransaction, WalletTransactionStatusEnum, WalletTransactionTypeEnum, ZOOM_PATTERN, ZoomMeetingLog, createDiscordTransport, typeOfExperienceEnum };