import type { Request } from 'express';
import { KanbanPipelineService } from './kanban-pipeline.service';
import { KanbanLeadSourceService } from './kanban-lead-source.service';
import { KanbanCustomerService } from './kanban-customer.service';
import { KanbanActivityService } from './kanban-activity.service';
import { KanbanWebhookService } from './kanban-webhook.service';
import { CreateCustomerDto, UpdateCustomerDto, MoveStageDto, AssignSaleDto, CustomerListQueryDto, CreateStageDto, UpdateStageDto, ReorderStagesDto, CreateLeadSourceDto, CreateActivityDto, UpdateActivityDto, ActivityListQueryDto, CreateWebhookSourceDto, UpdateWebhookSourceDto, WebhookLogQueryDto } from './dto/kanban.dto';
import { CustomerPriority, CustomerStatus } from './entities/kanban-customer.entity';
export declare class KanbanPipelineController {
    private readonly svc;
    private readonly sourceSvc;
    constructor(svc: KanbanPipelineService, sourceSvc: KanbanLeadSourceService);
    findAllStages(req: Request, page?: number, limit?: number, search?: string, isActive?: string): Promise<import("../../common/interfaces/pagination-result.interface").PaginationResult<import("./entities/kanban-pipeline-stage.entity").KanbanPipelineStage>>;
    createStage(dto: CreateStageDto): Promise<import("./entities/kanban-pipeline-stage.entity").KanbanPipelineStage>;
    reorder(dto: ReorderStagesDto): Promise<import("./entities/kanban-pipeline-stage.entity").KanbanPipelineStage[]>;
    updateStage(id: string, dto: UpdateStageDto): Promise<import("./entities/kanban-pipeline-stage.entity").KanbanPipelineStage>;
    deleteStage(id: string): Promise<void>;
    findAllSources(req: Request, page?: number, limit?: number, search?: string, isActive?: string): Promise<import("../../common/interfaces/pagination-result.interface").PaginationResult<import("./entities/kanban-lead-source.entity").KanbanLeadSource>>;
    createSource(dto: CreateLeadSourceDto): Promise<import("./entities/kanban-lead-source.entity").KanbanLeadSource>;
    updateSource(id: string, dto: Partial<CreateLeadSourceDto>): Promise<import("./entities/kanban-lead-source.entity").KanbanLeadSource>;
    deleteSource(id: string): Promise<void>;
}
export declare class KanbanCustomerController {
    private readonly svc;
    constructor(svc: KanbanCustomerService);
    getBoard(userId: number, isSuperAdmin: boolean, search?: string, sourceId?: string, priority?: string, status?: string, tags?: string, fromDate?: string, toDate?: string, assignedSaleIds?: string, relatedSaleIds?: string): Promise<{
        stage: import("./entities/kanban-pipeline-stage.entity").KanbanPipelineStage;
        customers: import("./entities/kanban-customer.entity").KanbanCustomer[];
        totalCount: number;
        totalValue: number;
    }[]>;
    statsByStage(userId: number, isSuperAdmin: boolean, fromDate?: string, toDate?: string): Promise<any[]>;
    statsBySale(userId: number, isSuperAdmin: boolean, fromDate?: string, toDate?: string): Promise<any[]>;
    findAll(req: Request, query: CustomerListQueryDto, currentUserId: number, isSuperAdmin: boolean): Promise<{
        data: import("./entities/kanban-customer.entity").KanbanCustomer[];
        current_page: number;
        first_page_url: string;
        from: number | null;
        last_page: number;
        last_page_url: string;
        links: {
            url: string;
            label: string;
            active: boolean;
        }[];
        next_page_url: string | null;
        path: string;
        per_page: number;
        prev_page_url: string | null;
        to: number | null;
        total: number;
    }>;
    create(dto: CreateCustomerDto, createdById: number): Promise<import("./entities/kanban-customer.entity").KanbanCustomer>;
    findOne(id: string, query: ActivityListQueryDto, req: Request): Promise<{
        activities: {
            data: import("./entities/kanban-activity.entity").KanbanActivity[];
            current_page: number;
            per_page: number;
            from: number | null;
            to: number | null;
            total: number;
            last_page: number;
            first_page_url: string | null;
            last_page_url: string | null;
            next_page_url: string | null;
            prev_page_url: string | null;
            path: string | null;
            links: {
                url: string;
                label: string;
                active: boolean;
            }[];
        };
        id: string;
        fullName: string;
        email: string;
        phone: string;
        phone2: string;
        gender: import("./entities/kanban-customer.entity").CustomerGender;
        dateOfBirth: Date;
        address: string;
        city: string;
        province: string;
        country: string;
        company: string;
        jobTitle: string;
        industry: string;
        estimatedValue: number;
        currency: string;
        stageId: string;
        stage: import("./entities/kanban-pipeline-stage.entity").KanbanPipelineStage;
        stageOrder: number;
        priority: CustomerPriority;
        status: CustomerStatus;
        assignedSaleId: number | null;
        assignedSale: import("./entities/kanban-customer.entity").UserStub;
        relatedSales: import("./entities/kanban-customer.entity").UserStub[];
        sourceId: string;
        source: import("./entities/kanban-lead-source.entity").KanbanLeadSource;
        sourceRef: string;
        rawData: Record<string, any>;
        tags: string;
        notes: string;
        expectedCloseDate: Date;
        lastContactedAt: Date;
        nextFollowUpAt: Date;
        contactCount: number;
        createdById: number;
        stageChangedAt: Date;
        stageChangedById: number;
        createdAt: Date;
        updatedAt: Date;
    }>;
    update(id: string, dto: UpdateCustomerDto): Promise<import("./entities/kanban-customer.entity").KanbanCustomer>;
    delete(id: string): Promise<void>;
    moveStage(id: string, dto: MoveStageDto, userId?: number): Promise<import("./entities/kanban-customer.entity").KanbanCustomer>;
    assignSale(id: string, dto: AssignSaleDto, userId?: number): Promise<import("./entities/kanban-customer.entity").KanbanCustomer>;
}
export declare class KanbanActivityController {
    private readonly svc;
    constructor(svc: KanbanActivityService);
    findByCustomer(customerId: string, query: ActivityListQueryDto): Promise<{
        data: import("./entities/kanban-activity.entity").KanbanActivity[];
        meta: {
            total: number;
            page: number;
            limit: number;
        };
    }>;
    create(customerId: string, dto: CreateActivityDto, userId?: number): Promise<import("./entities/kanban-activity.entity").KanbanActivity>;
    update(id: string, dto: UpdateActivityDto): Promise<import("./entities/kanban-activity.entity").KanbanActivity>;
    delete(id: string): Promise<void>;
    upcoming(userId?: string, days?: string): Promise<import("./entities/kanban-activity.entity").KanbanActivity[]>;
}
export declare class KanbanWebhookController {
    private readonly svc;
    constructor(svc: KanbanWebhookService);
    receive(sourceKey: string, payload: Record<string, any>, headers: Record<string, string>, req: Request): Promise<{
        received: boolean;
        logId: string;
    }>;
    findAllSources(): Promise<import("./entities/kanban-webhook.entity").KanbanWebhookSource[]>;
    createSource(dto: CreateWebhookSourceDto): Promise<import("./entities/kanban-webhook.entity").KanbanWebhookSource>;
    updateSource(id: string, dto: UpdateWebhookSourceDto): Promise<import("./entities/kanban-webhook.entity").KanbanWebhookSource>;
    deleteSource(id: string): Promise<void>;
    getLogs(query: WebhookLogQueryDto): Promise<{
        data: import("./entities/kanban-webhook.entity").KanbanWebhookLog[];
        meta: {
            total: number;
            page: number;
            limit: number;
        };
    }>;
    getLog(id: string): Promise<import("./entities/kanban-webhook.entity").KanbanWebhookLog>;
    replay(id: string): Promise<{
        replayed: boolean;
    }>;
}