import { PosSyncService } from './pos-sync.service';
import { PosSyncCursorService } from './pos-sync-cursor.service';
import { PosEmergencyService } from './pos-emergency.service';
import { PosSyncPushDto } from './dto/pos-sync-push.dto';
export declare class PosSyncController {
    private readonly service;
    private readonly cursorService;
    private readonly emergencyService;
    constructor(service: PosSyncService, cursorService: PosSyncCursorService, emergencyService: PosEmergencyService);
    push(body: PosSyncPushDto): Promise<{
        batch_status: string;
        batch_id: number;
        results: any[];
    }>;
    pull(deviceId?: string, storeId?: string, sinceMutationId?: string, entity?: string, limit?: string): Promise<{
        mutations: {
            mutation_id: number;
            client_mutation_id: string;
            entity_name: string;
            entity_local_id: string;
            entity_server_id: number;
            action: string;
            payload_json: Record<string, unknown>;
            status: string;
            server_applied_at: Date;
        }[];
        has_more: boolean;
        last_mutation_id: number;
    }>;
    mutations(status?: string, deviceId?: string, storeId?: string, entity?: string, search?: string): Promise<import("./entities/pos-sync-mutation.entity").PosSyncMutation[]>;
    retryMutation(id: number): Promise<{
        mutation_id: number;
        status: string;
        entity_server_id: number;
        retried_at: string;
        error_message?: undefined;
    } | {
        mutation_id: number;
        status: string;
        error_message: string;
        retried_at: string;
        entity_server_id?: undefined;
    }>;
    conflicts(status?: string, deviceId?: string, storeId?: string, type?: string, search?: string): Promise<import("./entities/pos-sync-conflict.entity").PosSyncConflict[]>;
    resolveConflict(id: number, body: {
        resolution?: string;
        resolution_note?: string;
        use_client_payload?: boolean;
    }, userId: number): Promise<{
        conflict_id: number;
        status: string;
        message: string;
        resolution_status?: undefined;
        resolved_at?: undefined;
        entity_name?: undefined;
        local_id?: undefined;
        server_id?: undefined;
    } | {
        conflict_id: number;
        resolution_status: string;
        resolved_at: Date;
        entity_name: string;
        local_id: string;
        server_id: number;
        status?: undefined;
        message?: undefined;
    }>;
    dashboard(storeId?: string, deviceId?: string): Promise<{
        filters: {
            store_id?: number;
            device_id?: number;
        };
        batches: Record<string, number>;
        mutations: Record<string, number>;
        conflicts: Record<string, number>;
        recent_failures: import("./entities/pos-sync-mutation.entity").PosSyncMutation[];
        stale_devices: import("../devices/entities/pos-device.entity").PosDevice[];
    }>;
    getCursor(deviceId: number, entityType?: string): Promise<import("./entities/pos-sync-cursor.entity").PosSyncCursor> | Promise<import("./entities/pos-sync-cursor.entity").PosSyncCursor[]>;
    updateCursor(deviceId: number, body: {
        entity_type: string;
        mutation_id: number;
        store_id?: number;
    }): Promise<import("./entities/pos-sync-cursor.entity").PosSyncCursor>;
    resetCursor(deviceId: number, entityType?: string): Promise<{
        reset: number;
    }>;
    emergencyExport(storeId: number): Promise<{
        store_id: number;
        exported_at: string;
        version: string;
        data: Record<string, any[]>;
        row_counts: {
            [k: string]: number;
        };
    }>;
    emergencyImport(storeId: number, body: {
        data: Record<string, any[]>;
    }): Promise<{
        store_id: number;
        imported_at: string;
        results: Record<string, number>;
    }>;
}