import { CreateEmployeeDto } from "./dto/create-employee.dto";
import { UpdateEmployeeDto } from "./dto/update-employee.dto";
import { UpdateLeaveBalancesDto } from "./dto/update-leave-balances.dto";
import { EmployeeRepository } from "./repositories/employee.repository";
import { EmployeeSalaryDetailRepository } from "./repositories/employee-salary-detail.repository";
import { EmployeeInformationRepository } from "./repositories/employee-information.repository";
import { SalarySettingRepository } from "../salary-settings/repositories/salary-setting.repository";
import { AuthRepository } from "../auth/repositories/auth.repository";
import { AuthService } from "../auth/auth.service";
import { LeaveType } from "../leave-types/entities/leave-type.entity";
import { Repository, DataSource } from "typeorm";
import { EmployeeLeaveBalanceRepository } from "../employee-leave-balances/repositories/employee-leave-balance.repository";
import { EmployeeSalaryHistoryRepository } from "./repositories/employee-salary-history.repository";
import { CompanySettingsRepository } from "../company/repositories/company-settings.repository";
import { UpdateSalaryHistoryDto } from "./dto/update-salary-dto";
import { TimeTrackingRepository } from "../time-tracking/repositories/time-tracking.repository";
import { RoleRepository } from "../role/repositories/role.repository";
import { DepartmentRepository } from "../departments/repositories/department.repository";
import { ProjectEmployee } from "../projects/entities/project-employee.entity";
import { EmployeeTechnologyRepository } from "./repositories/employee-technology.repository";
import { EmployeeTechnologyAssignmentRepository } from "./repositories/employee-technology-assignment.repository";
import { CreateEmployeeTechnologyDto } from "./dto/create-employee-technology.dto";
import { UpdateEmployeeTechnologyDto } from "./dto/update-employee-technology.dto";
import { AssignTechnologyEmployeesDto } from "./dto/assign-technology-employees.dto";
import { FilterEmployeeTechnologyDto } from "./dto/filter-employee-technology.dto";
export declare enum EmployeeType {
    EMPLOYEE = "employee",
    TRAINEE = "trainee",
    CONTRACT = "contract"
}
export declare class EmployeesService {
    private readonly employeeRepository;
    private readonly employeeSalaryDetailRepository;
    private readonly employeeInformationRepository;
    private readonly salarySettingRepository;
    private readonly authRepository;
    private readonly authService;
    private readonly leaveTypeEntityRepository;
    private readonly employeeLeaveBalanceRepository;
    private readonly employeeSalaryHistoryRepository;
    private readonly companySettingsRepository;
    private readonly timeTrackingRepository;
    private readonly roleRepository;
    private readonly departmentRepository;
    private readonly projectEmployeeEntityRepository;
    private readonly dataSource;
    private readonly employeeTechnologyRepository;
    private readonly employeeTechnologyAssignmentRepository;
    constructor(employeeRepository: EmployeeRepository, employeeSalaryDetailRepository: EmployeeSalaryDetailRepository, employeeInformationRepository: EmployeeInformationRepository, salarySettingRepository: SalarySettingRepository, authRepository: AuthRepository, authService: AuthService, leaveTypeEntityRepository: Repository<LeaveType>, employeeLeaveBalanceRepository: EmployeeLeaveBalanceRepository, employeeSalaryHistoryRepository: EmployeeSalaryHistoryRepository, companySettingsRepository: CompanySettingsRepository, timeTrackingRepository: TimeTrackingRepository, roleRepository: RoleRepository, departmentRepository: DepartmentRepository, projectEmployeeEntityRepository: Repository<ProjectEmployee>, dataSource: DataSource, employeeTechnologyRepository: EmployeeTechnologyRepository, employeeTechnologyAssignmentRepository: EmployeeTechnologyAssignmentRepository);
    private resolveFileUrl;
    create(createEmployeeDto: CreateEmployeeDto, token: string, files?: Record<string, any[]>): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    findAll(query: any, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    findOne(id: number): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    update(id: number, updateEmployeeDto: UpdateEmployeeDto, token: string, files?: Record<string, any[]>): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    remove(id: number, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    checkEmployeeExist(email: string, companyId: number): Promise<boolean>;
    private calculateAmount;
    calculateBasicSalary(grossSalary: number, companyId: number): Promise<number>;
    private calculateSalaryComponents;
    private createSalaryHistory;
    getMyLeaveBalances(token: string, query?: any): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    private createEmployeeLeaveBalances;
    private createEmployeeLeaveBalancesWithTransaction;
    createLeaveBalancesForEmployee(employeeId: number, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    findSalaryDetailsByEmployeeId(employeeId: number): Promise<number | import("./entities/employee-salary-detail.entity").EmployeeSalaryDetail | import("../../common/interfaces/pagination-result.interface").PaginatedResult<import("./entities/employee-salary-detail.entity").EmployeeSalaryDetail> | import("./entities/employee-salary-detail.entity").EmployeeSalaryDetail[]>;
    findProjectDetailsByEmployeeId(employeeId: number): Promise<ProjectEmployee[]>;
    getEmployeeProjects(employeeId: number): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    saveSalaryDetail(data: any): Promise<import("./entities/employee-salary-detail.entity").EmployeeSalaryDetail>;
    removeSalaryDetail(data: any): Promise<import("typeorm").DeleteResult | import("./entities/employee-salary-detail.entity").EmployeeSalaryDetail>;
    private updateTimeTrackingCostsAfterSalaryChange;
    private calculateUpdatedCost;
    private getApplicableSalaryForTimeEntry;
    private getCurrentSalaryRecord;
    private closeCurrentSalaryRecord;
    private getSalaryHistoryForEmployee;
    getSalaryHistory(employeeId: number, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    updateSalaryHistory(id: number, updateSalaryHistoryDto: UpdateSalaryHistoryDto, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    activeInactiveEmployee(id: number, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    private parseExcelFile;
    private generateErrorExcel;
    private lookupRoleByName;
    private lookupDepartmentByName;
    bulkUploadEmployees(fileBuffer: Buffer, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    private calculateCarryForwardDays;
    processYearEndCarryForward(year: number, systemUserId?: number): Promise<{
        success: boolean;
        message: any;
        data: {
            processedCompanies: number;
            totalProcessed: number;
            totalErrors: number;
        };
    }>;
    private createSalaryBreakdownForTds;
    assignProjects(employeeId: number, projectIds: number[], authorizationHeader: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    getAllEmployees(company_id: number): Promise<string | any[]>;
    updateLeaveBalances(updateLeaveBalancesDto: UpdateLeaveBalancesDto, employee_id: number, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    findAllTechnologies(query: FilterEmployeeTechnologyDto, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    createTechnology(dto: CreateEmployeeTechnologyDto, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    updateTechnology(id: number, dto: UpdateEmployeeTechnologyDto, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
    assignTechnologyEmployees(dto: AssignTechnologyEmployeesDto, token: string): Promise<{
        success: boolean;
        code: number;
        message: string;
    }>;
}