import { DbService } from 'src/db/db.service';
import mongoose from 'mongoose';
import { DocumentDetailDto, DriverStatusDto, EditCommission, GetPaginationDto, RefferalsDriverListingDto, ReviewDto, SetDocExpiryDateDto, UpdateLicenceDto, vehicleDetailDto } from './dto/driver.dto';
import { CommonService } from 'src/common/common.service';
import { DriverAggregation } from './driver.aggregation';
import { CustomerAggregation } from 'src/customer/customer.aggreagtion';
import { AuthService } from 'src/auth/auth.service';
import { DocumentResource, DocumentStatus } from 'src/documents-type/schema/document-type.schema';
import { BookingService } from 'src/booking/booking.service';
import { ServiceType } from './schema/driver.schema';
import { Types } from 'mongoose';
import { PayoutType } from 'src/configuration/schema/app-configuration.schema';
import { RedisService } from 'src/redis/redis.service';
import { DriverSocketService } from './driver.socket.service';
export declare enum PrefrencesType {
    Vehicle = "vehicle",
    RideType = "ride_type",
    ServiceType = "service_type"
}
export declare class DriverService {
    private readonly model;
    private readonly commonService;
    private readonly driverAggregation;
    private readonly customerAggragation;
    private readonly authService;
    private readonly bookingService;
    private readonly redisService;
    private readonly driverSocketService;
    constructor(model: DbService, commonService: CommonService, driverAggregation: DriverAggregation, customerAggragation: CustomerAggregation, authService: AuthService, bookingService: BookingService, redisService: RedisService, driverSocketService: DriverSocketService);
    update_driver_location(user_id: string, payload: any): Promise<mongoose.Document<unknown, {}, import("./schema/driver.schema").Drivers, {}, {}> & import("./schema/driver.schema").Drivers & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    getDriverDistanceLogs(driverId: string, adminTimezone?: string): Promise<{
        message: string;
        data: {
            date: number;
            logs: any[];
            totals: {
                on_ride: number;
                idle: number;
                going_to_pickup: number;
                total: number;
                on_ride_time: number;
                idle_time: number;
                going_to_pickup_time: number;
                total_time: number;
            };
        }[];
    }>;
    set_vehicle_details(body: vehicleDetailDto, payload: any, req: any): Promise<{
        message: any;
    }>;
    getAllRefferalAvailDriversListing(dto: RefferalsDriverListingDto): Promise<{
        data: any[];
        message: string;
    }>;
    set_document_details(body: DocumentDetailDto, payload: any, req: any): Promise<{
        message: any;
    }>;
    get_all_vehicle(user_id: string, req: any): Promise<{
        data: any[];
    }>;
    getAcceptanceRateDatas(driverId: string): Promise<{
        acceptance_rate: number;
        total_requests: number;
        accepted: number;
        rejected: number;
    }>;
    getAcceptanceRateData(driverId: string): Promise<{
        total_requests: number;
        accepted: number;
        declined: number;
        acceptance_rate: number;
        last_10_requests: {
            total: number;
            accepted: number;
            acceptance_rate: number;
        };
        previous_10_requests: {
            total: number;
            accepted: number;
            acceptance_rate: number;
        };
        accepted_last_10: number;
        trend: string;
        difference: number;
        rejected?: undefined;
    } | {
        acceptance_rate: number;
        total_requests: number;
        accepted: number;
        rejected: number;
        last_10_requests: {
            total: number;
            accepted: number;
            acceptance_rate: number;
        };
        previous_10_requests: {
            total: number;
            accepted: number;
            acceptance_rate: number;
        };
        accepted_last_10: number;
        trend: "stable" | "increase" | "decrease";
        difference: number;
        declined?: undefined;
    }>;
    get_document_detail(user_id: string, req: any): Promise<{
        data: mongoose.Document<unknown, {}, import("./schema/documents-details.schema").DocumentsDetails, {}, {}> & import("./schema/documents-details.schema").DocumentsDetails & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    get_vehicle_detail(vehicle_id: any, req: any): Promise<{
        data: any[];
    }>;
    sos(id: string): Promise<{
        message: string;
    }>;
    send_sos_alert_email(latitude: string, longitude: string, driverName: string, address: string): Promise<void>;
    go_online(id: string, body: DriverStatusDto, req: any): Promise<{
        message: any;
    }>;
    changeServiceTypeForDrivers(fleet_id: string, serviceType: string[]): Promise<{
        message: string;
    }>;
    FindAllwithStatus(body: any, req: any): Promise<{
        count: any;
        data: any;
        active_drivers: number;
        in_active_drivers: number;
        block_drivers: number;
        deleted_drivers: number;
    }>;
    findAllFleetDriver(fleet_id: string): Promise<{
        data: any;
    }>;
    changeDriverServicePrefrence(driver_id: string, body: any): Promise<{
        message: string;
    }>;
    getDriverVehicleServiceTypes(driverId: string): Promise<{
        data: ({
            value: string;
            label: string;
            type: PrefrencesType;
        } | {
            value: Types.ObjectId;
            label: string;
            type: PrefrencesType;
        })[];
    }>;
    getDriverVehicleType(user_id: string): Promise<{
        vehicle_type: any;
    }>;
    FindAllBackupWithStatus(body: any, req: any): Promise<{
        count: any;
        data: any;
    }>;
    findAllAdminDrivers(): Promise<{
        data: any;
    }>;
    FindAllwithStatusAndExport(body: any, req: any): Promise<{
        data: any;
    }>;
    driver_details(id: any): Promise<{
        data: any;
    }>;
    setDocumentExpiry(driverId: string, body: SetDocExpiryDateDto): Promise<{
        message: string;
        data: mongoose.Document<unknown, {}, import("./schema/driver.schema").Drivers, {}, {}> & import("./schema/driver.schema").Drivers & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    UpdateDriverLocation(body: any, driver_id: any): Promise<{
        message: string;
        data: {
            latitude: any;
            longitude: any;
            heading: any;
        };
    }>;
    flushLocationDataFromCacheToDb(): Promise<void>;
    broadcastLocationToCustomer(driver_id: string): Promise<void>;
    broadcastLocationToDriver(driver_id: string): Promise<void>;
    handleUpdateDistanceTravelled(ongoingBooking: any): Promise<void>;
    notifyAboutTimeLimitExceeded(): Promise<void>;
    getReviews(driverId: string, query: ReviewDto): Promise<{
        data: any;
    }>;
    getCancellationRateDatas(driverId: string): Promise<{
        cancellation_rate: number;
        total_accepted: number;
        completed: number;
        cancelled: number;
    }>;
    getOverallCounts(driverId: string): Promise<{
        cancellation_rate: number;
        rating: number;
        total_rides: number;
        acceptance_rate: number;
    }>;
    getCancellationRateData(driverId: string): Promise<{
        cancellation_rate: number;
        total_accepted: number;
        completed: number;
        cancelled: number;
        last_10_days_cancelled: number;
        previous_average_per_10_days: number;
        trend: "stable" | "increase" | "decrease";
        difference: number;
    }>;
    FindDriverRequests(body: any): Promise<{
        count: any;
        data: any;
        pendingDrivers: number;
        rejectedDrivers: number;
    }>;
    UpdatedDocsRequests(body: any): Promise<{
        count: any;
        data: any;
    }>;
    UpdateDriverRequests(body: any, req?: any): Promise<{
        message: string;
    }>;
    sent_email_for_approve_docs(driver: any): Promise<void>;
    sent_email_for_reject_docs(driver: any, body: any): Promise<void>;
    update_driver_active_deactive(body: any): Promise<{
        message: string;
    }>;
    update_driver_block_unblock(body: any): Promise<{
        message: string;
    }>;
    sent_email_for_unblock(driver: any): Promise<void>;
    sent_email_for_block(driver: any, body: any): Promise<void>;
    driver_booking_list(id: any, page: any, limit: any): Promise<{
        count: any;
        data: any;
    }>;
    driver_vehicle_detail(id: any): Promise<{
        data: mongoose.Document<unknown, {}, import("./schema/vehicle-detail.schema").Vehicle_details, {}, {}> & import("./schema/vehicle-detail.schema").Vehicle_details & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    SetExpiryDate(body: any, id: any): Promise<{
        message: string;
    }>;
    edit_vehicle_details(vehicleDetailDto: any, driver_id: any): Promise<{
        message: string;
    }>;
    near_me_rides(body: any): Promise<{
        data: any[];
    }>;
    driver_location(body: any): Promise<{
        data: (mongoose.Document<unknown, {}, import("./schema/driver.schema").Drivers, {}, {}> & import("./schema/driver.schema").Drivers & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        })[];
    }>;
    get_driver_vehicles(id: any, body: any): Promise<{
        data: (mongoose.Document<unknown, {}, import("./schema/vehicle-detail.schema").Vehicle_details, {}, {}> & import("./schema/vehicle-detail.schema").Vehicle_details & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        })[];
    }>;
    findCustomer(id: any): Promise<mongoose.Document<unknown, {}, import("../customer/schema/customer.schema").Customers, {}, {}> & import("../customer/schema/customer.schema").Customers & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    drivers_earnings(id: any): Promise<{
        data: any[];
    }>;
    DriverActiveVehicle(driver_id: any): Promise<{
        data: mongoose.Document<unknown, {}, import("./schema/vehicle-detail.schema").Vehicle_details, {}, {}> & import("./schema/vehicle-detail.schema").Vehicle_details & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    MakeVehicleActive(vehicle_id: any, driver_id: any): Promise<{
        message: string;
    }>;
    check_Expiry_date(): Promise<void>;
    sent_docs_expire_email(data: any): Promise<void>;
    edit_licence(body: UpdateLicenceDto, driver_id: string): Promise<{
        message: string;
    }>;
    DocUpdateHistory(driver_id: any, page: any, limit: any): Promise<{
        count: number;
        data: (mongoose.Document<unknown, {}, import("./schema/docs-update-history").DocsUpdateHistory, {}, {}> & import("./schema/docs-update-history").DocsUpdateHistory & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        })[];
    }>;
    GetOngoingBookings(driver_id: any): Promise<{
        customer_socket_id: string;
        driver: {
            socket_id: string;
            referral_id: string;
            name: string;
            email: string;
            driver_service_type: ServiceType;
            gender: import("./schema/driver.schema").Gender;
            country_code: string;
            rzr_contact_id: string;
            beneId: string;
            commission: number;
            service_prefrence: import("../vehicle/schema/vehicle.schema").ServiceType[];
            vehicle_type_id: string;
            ulternate_vehicle_types: string[];
            phone: string;
            license_number: string;
            image: string;
            latitude: string;
            longitude: string;
            temp_email: string;
            temp_phone: string;
            temp_country_code: string;
            fleet_id: string;
            temp_email_otp: number;
            temp_phone_otp: number;
            temp_email_otp_at: number;
            temp_phone_otp_at: number;
            is_bank_added: boolean;
            is_active: boolean;
            is_block: boolean;
            is_approved: boolean;
            is_doc_update: boolean;
            approved_on: number;
            reject_on: number;
            referral_code: string;
            referral_amount: number;
            applied_referral_code: string;
            applied_referral_code_consumed: boolean;
            reject_reason: string;
            phase_start_at: number;
            total_online_time: number;
            total_on_pickup_time: number;
            total_on_ride_time: number;
            last_phase_start_at: number;
            is_email_verify: boolean;
            is_phone_verify: boolean;
            status: string;
            ride_status: string;
            device_type: string;
            preferred_language: string;
            preferred_currency: string;
            currency_symbol: string;
            pending_submit_cash: number;
            pending_submit_cash_upated_at: number;
            customer_id: string;
            current_booking: string;
            ratings: number;
            connection_id: string;
            currently_send_ride_request: boolean;
            way_points: mongoose.FlattenMaps<{
                lat: number;
                lng: number;
            }>[];
            currently_send_ride_request_id: string;
            currently_send_ride_request_generate_at: number;
            heading: string;
            set_up_profile: boolean;
            set_up_vehicle: boolean;
            set_up_documents: boolean;
            block_reason: string;
            doc_expiry_type: string[];
            volunteer_ride_count: number;
            level: string;
            documents: mongoose.FlattenMaps<{
                type_id: string;
                front_image_id: string;
                back_image_id: string;
                expire_date: number;
                is_expired: boolean;
            }>[];
            missing_documents: mongoose.Types.ObjectId[];
            is_deleted: boolean;
            is_document_missing: boolean;
            timeZone: string;
            created_at: number;
            updated_at: number;
            payout_mode: PayoutType;
            selected_payout_mode: PayoutType;
            location: mongoose.FlattenMaps<{
                type: string;
                coordinates: number[];
            }>;
            _id: Types.ObjectId;
            __v: number;
        };
        booking: mongoose.Document<unknown, {}, import("src/booking/schema/booking.schema").Booking, {}, {}> & import("src/booking/schema/booking.schema").Booking & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    generateMapImage(body: any): Promise<{
        staticMapUrl: string;
    }>;
    findDriversInSameCity(pick_up_lat: string, pick_up_long: string): Promise<number>;
    driverPayoutList(): Promise<{
        data: any[];
    }>;
    editCommision(body: EditCommission): Promise<{
        message: string;
    }>;
    driverPayoutTransactionExport(body: any): Promise<{
        driver_name: string;
        driver_country_code: string;
        driver_phone: string;
        total_bookings: number;
        total_vat: number;
        payment_due_to_app: number;
        payment_due_to_driver: number;
        payment_settled: string;
        booking_data: any[];
    }>;
    getDriverServiceType(fleet_id: any): Promise<{
        service_type: string[];
    }>;
    driverTrackList(body: any, fleetId: any): Promise<{
        data: any;
        count: any;
    }>;
    getActiveDocuments(req: any, dto: GetPaginationDto): Promise<{
        message: string;
        data: {
            data: (mongoose.FlattenMaps<{
                resource: DocumentResource;
                name: string;
                description: string;
                added_by: import("../auth/role/user.role").UsersType;
                status: DocumentStatus;
                sides_required: import("src/documents-type/schema/document-type.schema").DocumentSidesRequired;
                created_by?: Types.ObjectId;
                is_deleted: boolean;
            }> & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            })[];
            count: number;
        };
    }>;
    getWeeklySummary(driverId: string, weekStart: string): Promise<{
        week_range: {
            start: number;
            end: number;
            start_date: string;
            end_date: string;
        };
        weekly_total: number;
        chart: any;
        stats: {
            online: string;
            rides: number;
            kms_on_ride: number;
        };
        amount_breakdown: {
            cash_collected: number;
            online_collected: number;
            app_commission_paid: number;
        };
        weekly_rides_breakdown: any;
    }>;
    admin_edit_vehicle_details(vehicleDetailDto: any): Promise<{
        message: string;
    }>;
}