import { DataSource } from 'typeorm';
import { Lead, LeadStatus, ClientGroup } from '../entities/lead.entity';
import { CreateLeadDto } from '../dto/create-lead.dto';
import { UpdateLeadDto } from '../dto/update-lead.dto';
import { AssignLeadDto } from '../dto/assign-lead.dto';
import { ListLeadsQueryDto, KanbanQueryDto, KanbanLoadMoreQueryDto } from '../dto/list-leads.dto';
import { BulkUpdateLeadDto, BulkDestroyLeadDto } from '../dto/bulk-update-lead.dto';
import { CheckDuplicatesDto, RequestHandoverDto } from '../dto/check-duplicates.dto';
import { DuplicateLeadDetectorService } from './duplicate-lead-detector.service';
import { LeadNotificationsService } from './lead-notifications.service';
export declare class LeadService {
    private readonly dataSource;
    private readonly duplicateDetector;
    private readonly leadNotifications;
    private readonly logger;
    constructor(dataSource: DataSource, duplicateDetector: DuplicateLeadDetectorService, leadNotifications: LeadNotificationsService);
    clientGroupOptions(): {
        options: {
            value: ClientGroup.QRS | ClientGroup.TQS | ClientGroup.QRS_NEW;
            label: string;
        }[];
        legacy_rollup: {
            QRS_B: ClientGroup;
        };
    };
    private userHasPermission;
    private userCanViewAll;
    private userCanAssign;
    private nextCode;
    private logActivity;
    findAll(q: ListLeadsQueryDto, currentUserId: number): Promise<{
        data: Lead[];
        meta: {
            total: number;
            page: number;
            limit: number;
            totalPages: number;
        };
    }>;
    kanban(q: KanbanQueryDto, currentUserId: number): Promise<{
        columns: Record<string, Lead[]>;
        totals: Record<string, number>;
        stats: {
            total: number;
            new_month: number;
            converted: number;
            lost: number;
            by_client_group: Record<string, number>;
        };
    }>;
    kanbanLoadMore(q: KanbanLoadMoreQueryDto, currentUserId: number): Promise<{
        cards: {
            id: number;
            lead_code: string;
            company: string;
            contact: string | null;
            client_group: ClientGroup | null;
            priority: import("../entities/lead.entity").LeadPriority;
            standards: string[];
            assignee: string | null;
            created_at: Date | null;
        }[];
        next_offset: number;
        remaining: number;
    }>;
    getAnalytics(currentUserId?: number): Promise<{
        total: number;
        new_month: number;
        converted: number;
        lost: number;
        by_client_group: Record<string, number>;
    }>;
    distinctTags(): Promise<string[]>;
    findOne(id: number): Promise<Lead>;
    checkDuplicates(dto: CheckDuplicatesDto): Promise<{
        matches: {
            id: number;
            lead_code: string;
            company: string;
            contact: string | null;
            email: string | null;
            phone: string | null;
            status: LeadStatus;
            reasons: import("./duplicate-lead-detector.service").DuplicateReason[];
            severity: "low" | "high";
            hard_signals: number;
            soft_signals: number;
        }[];
        client_matches: import("./duplicate-lead-detector.service").DuplicateClientMatch[];
    }>;
    create(dto: CreateLeadDto, currentUserId: number): Promise<Lead>;
    update(id: number, dto: UpdateLeadDto, currentUserId: number): Promise<Lead>;
    assign(id: number, dto: AssignLeadDto, currentUserId: number): Promise<{
        message: string;
        changed: boolean;
        lead?: undefined;
    } | {
        message: string;
        changed: boolean;
        lead: Lead;
    }>;
    bulkUpdate(dto: BulkUpdateLeadDto, currentUserId: number): Promise<{
        message: string;
        count: number;
    }>;
    bulkDestroy(dto: BulkDestroyLeadDto, currentUserId: number): Promise<{
        message: string;
        count: number;
    }>;
    remove(id: number, currentUserId: number): Promise<{
        message: string;
        id: number;
    }>;
    requestHandover(leadId: number, dto: RequestHandoverDto, requesterId: number, requesterName: string): Promise<{
        message: string;
        skipped: boolean;
    } | {
        message: string;
        skipped?: undefined;
    }>;
    private readonly IMPORT_COLUMNS;
    getImportTemplateCsv(): string;
    importLeads(csvContent: string, options: {
        skipDuplicates: boolean;
        defaultAssignedTo: number;
    }, currentUserId: number): Promise<{
        created: number;
        skipped: number;
        errors: string[];
    }>;
    private formatUserName;
    private parseCsvLine;
}