@experts_hub/shared/dist/index.d.mts

Shared DTOs, interfaces, and utilities for experts hub applications

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 {