import type { Request, Response } from 'express';
import { PrismaService } from "../../../core/database/prisma/prisma.service";
import { DingtalkAuthService } from './sdk/dingtalk-auth.service';
import { DingtalkHrmService } from './sdk/dingtalk-hrm.service';
import { DingtalkAttendanceService } from './sdk/dingtalk-attendance.service';
import { DingtalkYidaService } from './sdk/dingtalk-yida.service';
import { DingtalkSchedulerService } from './dingtalk-scheduler.service';
import { AnnualLeavePlanSettingsQueryDto, ApprovalCancellationDto, ExecutionQueryDto, ManualTriggerDto, PaginationQueryDto, UpdateAnnualLeaveQuotaDto, UpdateAnnualLeavePlanSettingsDto } from './dto/dingtalk-sync.dto';
import { DingtalkRepairService } from './dingtalk-repair.service';
import { AnnualLeaveInsightService } from './annual-leave-insight.service';
import { AnnualLeavePlanAdminService } from './annual-leave-plan-admin.service';
import { EmployeeManagementService } from './employee-management.service';
import { PurchaseSapSyncService } from './sync/purchase-sap-sync.service';
export declare class DingtalkController {
    private prisma;
    private authService;
    private hrmService;
    private attendanceService;
    private yidaService;
    private schedulerService;
    private repairService;
    private annualLeaveInsightService;
    private annualLeavePlanAdminService;
    private employeeManagementService;
    private purchaseSapSyncService;
    private readonly logger;
    private employeeCache;
    constructor(prisma: PrismaService, authService: DingtalkAuthService, hrmService: DingtalkHrmService, attendanceService: DingtalkAttendanceService, yidaService: DingtalkYidaService, schedulerService: DingtalkSchedulerService, repairService: DingtalkRepairService, annualLeaveInsightService: AnnualLeaveInsightService, annualLeavePlanAdminService: AnnualLeavePlanAdminService, employeeManagementService: EmployeeManagementService, purchaseSapSyncService: PurchaseSapSyncService);
    getOverview(): Promise<{
        totalTasks: number;
        registeredTasks: number;
        running: number;
        todaySuccess: number;
        todayFailed: number;
        isEnabled: boolean;
    }>;
    getTasks(): Promise<{
        status: import("@prisma/client").$Enums.AutomationTaskStatus;
        lastRunAt: Date | null;
        lastStatus: import("@prisma/client").$Enums.AutomationExecutionStatus | null;
        totalRuns: number;
        successRuns: number;
        failedRuns: number;
        name: string;
        description: string;
        group: string;
        schedule: string;
        code: string;
    }[]>;
    triggerTask(code: string, dto: ManualTriggerDto): Promise<{
        success: boolean;
        error: string;
    } | {
        taskCode: string;
        taskName: string;
        success: boolean;
        processedCount: number;
        errors: string[];
        duration: number;
        logs?: string;
        details?: Record<string, any>;
        error?: undefined;
    }>;
    triggerTaskStream(code: string, req: Request, res: Response, fromTime?: string, toTime?: string, userId?: string): Promise<void>;
    getTaskExecutions(code: string, query: PaginationQueryDto): Promise<{
        items: {
            error: string | null;
            id: string;
            createdAt: Date;
            result: import("@prisma/client/runtime/library").JsonValue | null;
            status: import("@prisma/client").$Enums.AutomationExecutionStatus;
            duration: number | null;
            logs: string | null;
            startedAt: Date;
            completedAt: Date | null;
            triggerType: string;
            triggeredBy: string | null;
            taskId: string;
        }[];
        total: number;
        page: number;
        limit: number;
    }>;
    getRecentExecutions(query: ExecutionQueryDto): Promise<{
        items: {
            id: string;
            taskCode: string;
            taskName: string;
            status: import("@prisma/client").$Enums.AutomationExecutionStatus;
            startedAt: Date;
            completedAt: Date | null;
            duration: number | null;
            triggerType: string;
            error: string | null;
            result: import("@prisma/client/runtime/library").JsonValue;
            logs: string | null;
        }[];
        total: number;
        page: number;
        limit: number;
    }>;
    getEmployeeList(keyword?: string, status?: string, page?: string, pageSize?: string): Promise<{
        items: any[];
        total: number;
        page: number;
        pageSize: number;
    }>;
    updateEmployee(userId: string, body: {
        status?: string;
    }): Promise<any>;
    getEmploymentPeriods(userId: string): Promise<any>;
    addEmploymentPeriod(userId: string, body: {
        joinDate: string;
        leaveDate?: string | null;
        countInTenure?: boolean;
        note?: string;
    }): Promise<any>;
    updateEmploymentPeriod(id: string, body: {
        joinDate?: string;
        leaveDate?: string | null;
        countInTenure?: boolean;
        note?: string;
    }): Promise<any>;
    deleteEmploymentPeriod(id: string): Promise<any>;
    getTenure(userId: string): Promise<{
        totalDays: number;
        periods: Array<{
            joinDate: Date;
            leaveDate: Date | null;
            days: number;
            countInTenure: boolean;
            note: string;
        }>;
        source: "periods" | "joinDate";
    }>;
    initEmploymentPeriods(): Promise<{
        created: number;
        skipped: number;
    }>;
    recalculateTenure(): Promise<{
        updated: number;
    }>;
    getSuspensionPeriods(userId: string): Promise<any>;
    addSuspensionPeriod(userId: string, body: {
        startDate: string;
        endDate?: string | null;
        reason?: string;
        note?: string;
    }): Promise<any>;
    updateSuspensionPeriod(id: string, body: {
        startDate?: string;
        endDate?: string | null;
        reason?: string;
        note?: string;
    }): Promise<any>;
    deleteSuspensionPeriod(id: string): Promise<any>;
    syncEmployees(): Promise<{
        success: boolean;
        total: number;
        created: number;
        updated: number;
        terminated: number;
        errors: string[];
        duration: number;
    }>;
    getEmployees(): Promise<{
        userId: string;
        name: any;
    }[]>;
    getConfig(): Promise<{
        enabled: boolean;
        tokenValid: boolean;
        appType: string;
        operatorId: string;
    }>;
    getAnnualLeaveQuotas(userId?: string, keyword?: string, hideZero?: string, includeAllStatuses?: string): Promise<import("./annual-leave-insight.service").AnnualLeaveQuotaOverview>;
    getAnnualLeaveQuotaDetail(userId?: string, leaveCode?: string): Promise<import("./annual-leave-insight.service").AnnualLeaveQuotaDetail | null>;
    getLeaveRecords(userId: string, leaveCode: string): Promise<{
        records: never[];
        error: string;
        sampleKeys?: undefined;
        sample?: undefined;
    } | {
        records: any[];
        sampleKeys: string[];
        sample: any;
        error?: undefined;
    }>;
    refreshLeaveTypes(): Promise<{
        count: number;
        leaveTypes: Array<{
            leave_code: string;
            leave_name: string;
        }>;
    }>;
    refreshAnnualLeaveQuotas(body: {
        userId?: string;
    }): Promise<import("./annual-leave-insight.service").AnnualLeaveQuotaRefreshResult>;
    refreshAnnualLeaveReleasePlan(body: {
        userId?: string;
        year?: number;
    }): Promise<import("./sync").SyncExecutionResult>;
    triggerAnnualLeaveRelease(body: {
        userId?: string;
        year?: number;
    }): Promise<import("./sync").SyncExecutionResult>;
    updateAnnualLeaveQuota(body: UpdateAnnualLeaveQuotaDto): Promise<{
        success: boolean;
        error: string;
        detail?: undefined;
    } | {
        success: boolean;
        detail: {
            name: any;
            userId: string;
            year: number;
            oldDays: number;
            newDays: number;
        };
        error?: undefined;
    }>;
    getAnnualLeavePlanSettings(query: AnnualLeavePlanSettingsQueryDto): Promise<{
        userId: string;
        year: number;
        adjustmentDays: number;
        notCountDays: number;
        totalDays: number;
        releaseSchedule: any[];
        lastCalculatedAt: string | null;
    }>;
    updateAnnualLeavePlanSettings(body: UpdateAnnualLeavePlanSettingsDto): Promise<{
        userId: string;
        year: number;
        adjustmentDays: number;
        notCountDays: number;
        totalDays: number;
        releaseSchedule: any[];
        lastCalculatedAt: string | null;
    }>;
    getAnnualLeaveReleasePlan(year?: string, userId?: string, keyword?: string, upcomingOnly?: string): Promise<{
        summary: {
            employeeCount: number;
            planCount: number;
            upcomingDays: number;
            todayReleaseEmployeeCount: number;
        };
        items: import("./annual-leave-insight.service").AnnualLeaveReleasePlanItem[];
    }>;
    exportAnnualLeaveReleasePlan(res: Response, year?: string, userId?: string, keyword?: string, upcomingOnly?: string): Promise<void>;
    updateConfig(body: {
        enabled?: boolean;
    }): Promise<{
        success: boolean;
        enabled: boolean;
    }>;
    updateTask(code: string, body: {
        status?: string;
    }): Promise<{
        success: boolean;
        error: string;
        task?: undefined;
    } | {
        success: boolean;
        task: {
            type: import("@prisma/client").$Enums.AutomationTaskType;
            timeout: number;
            code: string;
            id: string;
            createdAt: Date;
            status: import("@prisma/client").$Enums.AutomationTaskStatus;
            name: string;
            updatedAt: Date;
            description: string | null;
            createdById: string | null;
            retryCount: number;
            config: import("@prisma/client/runtime/library").JsonValue;
            scheduleType: string;
            scheduleConfig: import("@prisma/client/runtime/library").JsonValue;
            lastRunAt: Date | null;
            lastStatus: import("@prisma/client").$Enums.AutomationExecutionStatus | null;
            nextRunAt: Date | null;
            totalRuns: number;
            successRuns: number;
            failedRuns: number;
        };
        error?: undefined;
    }>;
    batchCancel(body: {
        records: {
            userId: string;
            approveId: string;
        }[];
        dryRun?: boolean;
    }): Promise<{
        total: number;
        results: any[];
    }>;
    cancelApprovals(body: ApprovalCancellationDto): Promise<import("./sync").SyncExecutionResult>;
    cleanupInvalidFieldApprovals(body: {
        from?: string;
        to?: string;
        userId?: string;
        dryRun?: boolean;
    }): Promise<{
        dryRun: boolean;
        scannedDays: number;
        total: number;
        records: {
            userId: string;
            approveId: string;
            creator: string;
            date: string;
            instanceIds: string[];
        }[];
        success?: undefined;
        failed?: undefined;
        results?: undefined;
    } | {
        dryRun: boolean;
        scannedDays: number;
        total: number;
        success: number;
        failed: number;
        results: any[];
        records?: undefined;
    }>;
    debugApproveFinish(body: any): Promise<any>;
    debugTripOverlap(from?: string, to?: string): Promise<{
        totalApplications: number;
        cancelledByChange: number;
        activeApplications: number;
        totalDayRecords: number;
        overlapCount: number;
        overlaps: {
            userId: string;
            name: string;
            date: string;
            applications: {
                serialNo: string;
                range: string;
            }[];
        }[];
    }>;
    debugBatchCancelTrips(body: {
        since?: string;
        dryRun?: boolean;
    }): Promise<{
        dryRun: boolean;
        since: string;
        totalToCancel: number;
        records: {
            name: string;
            userId: string;
            approveId: string;
            range: string;
        }[];
        total?: undefined;
        success?: undefined;
        failed?: undefined;
        results?: undefined;
    } | {
        since: string;
        total: number;
        success: number;
        failed: number;
        results: any[];
        dryRun?: undefined;
        totalToCancel?: undefined;
        records?: undefined;
    }>;
    private formatDateCST;
    private listCoveredDates;
    private getAttendanceApproveId;
    debugYidaSample(type?: string, serialNo?: string, fromTime?: string, toTime?: string): Promise<{
        message: string;
        approvedCount: number;
        allCount: number;
        serialRange: {
            first: string | undefined;
            last: string | undefined;
        };
        byNameOrNumber: {
            serialNo: string | undefined;
            number: any;
            creator: any;
            userId: any;
        }[];
        source?: undefined;
        serialNo?: undefined;
        creator?: undefined;
        userId?: undefined;
        number?: undefined;
        segments?: undefined;
        totalRecords?: undefined;
        uniqueApplications?: undefined;
        records?: undefined;
    } | {
        source: string;
        serialNo: string | undefined;
        creator: any;
        userId: any;
        number: any;
        segments: any;
        message?: undefined;
        approvedCount?: undefined;
        allCount?: undefined;
        serialRange?: undefined;
        byNameOrNumber?: undefined;
        totalRecords?: undefined;
        uniqueApplications?: undefined;
        records?: undefined;
    } | {
        message: string;
        approvedCount?: undefined;
        allCount?: undefined;
        serialRange?: undefined;
        byNameOrNumber?: undefined;
        source?: undefined;
        serialNo?: undefined;
        creator?: undefined;
        userId?: undefined;
        number?: undefined;
        segments?: undefined;
        totalRecords?: undefined;
        uniqueApplications?: undefined;
        records?: undefined;
    } | {
        totalRecords: number;
        uniqueApplications: number;
        records: any[];
        message?: undefined;
        approvedCount?: undefined;
        allCount?: undefined;
        serialRange?: undefined;
        byNameOrNumber?: undefined;
        source?: undefined;
        serialNo?: undefined;
        creator?: undefined;
        userId?: undefined;
        number?: undefined;
        segments?: undefined;
    }>;
    getSapPurchaseList(sapEnv?: string, keyword?: string, status?: string): Promise<{
        items: {
            formInstanceId: string;
            serialNumber: string;
            applicantName: string;
            applicantDept: string;
            applicantEmployeeId: any;
            budgetNumber: string;
            budgetAmount: number;
            purchaseProjectDescription: string;
            applicationDate: string;
            demandCategory: string;
            demandInitiator: string;
            companyName: any;
            purchasingCompanyName: string;
            purchaser: string;
            expectedCompletionDate: string;
            materialGroup: string;
            costCenterNumber: any;
            fixedAssetsNumber: any;
            generalLedgerAccount: any;
            syncStatus: string;
            sapPrNumber: string | null;
            sapMessages: string | number | true | import("@prisma/client/runtime/library").JsonObject | import("@prisma/client/runtime/library").JsonArray | null;
            sapRawResponse: string | number | true | import("@prisma/client/runtime/library").JsonObject | import("@prisma/client/runtime/library").JsonArray | null;
            approverChain: string | null;
            syncedAt: string | null;
            sapRequestPreview: {
                header: Record<string, string>;
                item: Record<string, string | number>;
            } | null;
        }[];
        total: number;
    }>;
    refreshSapPurchaseCache(body: {
        sapEnv?: 'test' | 'production';
    }): Promise<{
        fetched: number;
        upserted: number;
        fromTime: any;
        toTime: string;
    }>;
    getSapPurchaseRecords(page?: string, limit?: string, status?: string): Promise<{
        items: {
            id: string;
            createdAt: Date;
            updatedAt: Date;
            syncedAt: Date;
            serialNumber: string;
            formInstanceId: string;
            applicantName: string;
            budgetAmount: import("@prisma/client/runtime/library").Decimal;
            sapPrNumber: string | null;
            sapStatus: string;
            sapMessages: import("@prisma/client/runtime/library").JsonValue | null;
            sapRawResponse: import("@prisma/client/runtime/library").JsonValue | null;
            approverChain: string | null;
        }[];
        total: number;
        page: number;
        limit: number;
        totalPages: number;
    }>;
    syncSapPurchases(body: {
        serialNumbers: string[];
        sapEnv: 'test' | 'production';
    }): Promise<{
        success: boolean;
        total: number;
        successCount: number;
        failedCount: number;
        results: ({
            serialNumber: string;
            success: boolean;
            alreadyExists: boolean;
            prNumber: string | null;
            messages: {
                type: string;
                message: string;
            }[];
            approverChain: string;
        } | {
            serialNumber: string;
            success: boolean;
            prNumber: null;
            messages: {
                type: string;
                message: any;
            }[];
            approverChain: string;
        })[];
    }>;
}