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

Shared DTOs, interfaces, and utilities for experts hub applications

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

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

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

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

declare class RefreshDto {
    refreshToken: string;
}

declare class LogoutDto {
    refreshToken: string;
}

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

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

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

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

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

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

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

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

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

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

declare class FreelancerUploadResumeDto {
    uuid: string;
}

declare class FreelancerParseResumeDto {
    uuid: string;
}

declare class FreelancerInitiateMcqAssessmentDto {
    uuid: string;
}

declare class FreelancerSkipAiAssessmentDto {
    uuid: string;
}

declare class FreelancerInitiateAiAssessmentDto {
    uuid: string;
}

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

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

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

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

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

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

declare const RESUME_PARSER_PATTERN: {
    handleResumeParsing: string;
};

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

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

declare class UpdateSubAdminAccountStatusDto {
    accountStatus: string;
}

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

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

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

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

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

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

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

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

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

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

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

declare class JobAdditionalCommentDto {
    additionalComment?: string;
}

declare class JobDescriptionDto {
    description: string;
}

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

declare class JobIdParamDto {
    id: string;
}

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

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

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

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

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

declare const PLAN_PATTERN: {
    fetchPlans: string;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare class ToggleCompanyRoleVisibilityDto {
    isActive: boolean;
}

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

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

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

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

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

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

declare class ToggleCompanyMemberVisibilityDto {
    isActive: boolean;
}

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

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

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

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

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

declare const PERMISSION_PATTERN: {
    fetchAllPermissionsDropdown: string;
};

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

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

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

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

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

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

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

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

declare class UpdateClientAccountStatusDto {
    accountStatus: string;
}

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

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

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

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

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

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

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

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

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

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

declare enum JobLocationEnumDto {
    ONSITE = "ONSITE",
    REMOTE = "REMOTE",
    BOTH = "BOTH"
}
declare enum TypeOfEmploymentEnumDto {
    FULLTIME = "FULLTIME",
    PARTTIME = "PARTTIME",
    BOTH = "BOTH"
}
declare class AdminCreateJobInfo