import { DiverSocket } from "./driver.socket";
import { LoyalityPointsService } from "src/loyality-points/loyality-points.service";
import { VendorService } from "src/vendor/vendor.service";
import { PaymentService } from "src/payment/payment.service";
import { RazorpayService } from "src/razorpay/razorpay.service";
import { restaurant_request_list_dto } from "src/restaurant/dto/restaurant.dto";
import { goOnlineDto, OrderUpdateStatus, Listing, payoutListDto, UpdatePendingDriverStatusDto, UpdateDriveRequest, location } from "./dto/create-driver.dto";
import { DbService } from 'src/db/db.service';
import mongoose from 'mongoose';
import { MessageKey } from 'src/common/helpers/message-keys.enum';
import { DocumentDetailDto, DriverStatusDto, EditCommission, GetPaginationDto, MergedDriverDto, RefferalsDriverListingDto, ReviewDto, SetDocExpiryDateDto, SetUlternateVehicleOptionsDto, UpdateLicenceDto, vehicleDetailDto } from './dto/driver.dto';
import { CommonService } from 'src/common/common.service';
import { DriverAggregation } from './driver.aggregation';
import { CustomerAggregation } from 'src/customer/customer.aggregation';
import { AuthService } from 'src/auth/auth.service';
import { DocumentResource, DocumentStatus } from 'src/documents-type/schema/document-type.schema';
import { Server } from 'socket.io';
import { BookingService } from 'src/booking/booking.service';
import { ServiceTypeParcelOrRide } from './schema/driver.schema';
import { Types } from 'mongoose';
import { LocationData, 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 customerAggregation;
    private readonly authService;
    private readonly bookingService;
    private readonly redisService;
    private readonly driverSocketService;
    protected diverSocket: DiverSocket;
    private readonly loyaltyService;
    private readonly vendorService;
    private readonly paymentService;
    private readonly razorpayService;
    server: Server;
    constructor(model: DbService, commonService: CommonService, driverAggregation: DriverAggregation, customerAggregation: CustomerAggregation, authService: AuthService, bookingService: BookingService, redisService: RedisService, driverSocketService: DriverSocketService, diverSocket: DiverSocket, loyaltyService: LoyalityPointsService, vendorService: VendorService, paymentService: PaymentService, razorpayService: RazorpayService);
    get customerAggragation(): CustomerAggregation;
    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: MessageKey;
        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;
            };
        }[];
    }>;
    admin_edit_vehicle_details(vehicleDetailDto: any): Promise<{
        message: MessageKey;
    }>;
    set_vehicle_details(body: vehicleDetailDto, payload: any, req: any): Promise<{
        message: MessageKey;
    }>;
    getUpdateDriverServicePrefrences(driver: any, serviceType: ServiceTypeParcelOrRide): any;
    getAllRefferalAvailDriversListing(dto: RefferalsDriverListingDto): Promise<{
        data: {
            _id: any;
            date: any;
            referred_by: {
                name: any;
                phone: any;
                country_code: any;
            };
            referred_to: {
                name: any;
                phone: any;
                country_code: any;
                email: any;
            };
            bookings_to_complete: any;
            bookings_completed: number;
            days_left: number;
            bonus: any;
            payout_status: string;
            status: string;
        }[];
        count: number;
        message: MessageKey;
    }>;
    set_document_details(body: DocumentDetailDto, payload: any, req: any): Promise<{
        message: MessageKey;
    }>;
    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: "increase" | "decrease" | "stable";
        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: MessageKey;
    }>;
    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;
        pending_drivers: number;
        rejected_drivers: number;
        pendingDrivers: number;
        rejectedDrivers: number;
    }>;
    private getStatusCount;
    FindAllwithStatusAndExport(body: any, req: any): Promise<{
        data: any;
    }>;
    changeDriverServicePrefrence(driver_id: string, body: any): Promise<{
        message: MessageKey;
    }>;
    setUlternateVehicleOptions(driver_id: string, body: SetUlternateVehicleOptionsDto): Promise<{
        message: MessageKey;
    }>;
    getDriverVehicleServiceTypes(driverId: string, service_type: string): Promise<{
        data: ({
            value: string;
            label: string;
            type: PrefrencesType;
        } | {
            value: Types.ObjectId;
            label: string;
            type: PrefrencesType;
        })[];
    }>;
    getDriverVehicleUlternateTypes(driverId: string): Promise<{
        ulternate_vehicle_types: (mongoose.Document<unknown, {}, import("src/vehicle/schema/vehicle-type.schema").Vehicle_types, {}, {}> & import("src/vehicle/schema/vehicle-type.schema").Vehicle_types & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        })[];
    }>;
    getDriverVehicleType(user_id: string): Promise<{
        vehicle_type: any;
    }>;
    FindAllBackupWithStatus(body: any, req: any): Promise<{
        count: any;
        data: any;
    }>;
    findAllAdminDrivers(): Promise<{
        data: any;
    }>;
    findAllFleetDrivers(fleet_id: string): Promise<{
        data: any;
    }>;
    driver_details(id: any): Promise<{
        data: any;
    }>;
    setDocumentExpiry(driverId: string, body: SetDocExpiryDateDto): Promise<{
        message: MessageKey;
        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: "increase" | "decrease" | "stable";
        difference: number;
    }>;
    FindDriverRequests(body: any, req?: any): Promise<{
        count: any;
        data: any;
        pendingDrivers: number;
        rejectedDrivers: number;
        pending_drivers: number;
        rejected_drivers: number;
    }>;
    UpdatedDocsRequests(body: any): Promise<{
        count: any;
        data: any;
    }>;
    UpdateDriverRequests(body: any, req?: any): Promise<{
        message: MessageKey;
    }>;
    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: MessageKey;
    }>;
    update_driver_block_unblock(body: any): Promise<{
        message: MessageKey;
    }>;
    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: LocationData;
    }>;
    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, timeZone?: string): 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: {
            latitude: number;
            longitude: number;
            heading: number;
            socket_id: string;
        };
        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: number;
    }>;
    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;
                expiry_required: boolean;
                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;
    }>;
    getMergedDrivers(body: MergedDriverDto): Promise<{
        data: (mongoose.FlattenMaps<mongoose.Document<unknown, {}, import("../driver-customer-backup/schema/driverBackup.schema").DriversBackup, {}, {}> & import("../driver-customer-backup/schema/driverBackup.schema").DriversBackup & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        }> & Required<{
            _id: Types.ObjectId;
        }>)[];
        count: number;
        page: number;
        limit: number;
    }>;
    createFleetDriver(fleet_id: string, body: any): Promise<{
        message: string;
        data: mongoose.Document<unknown, {}, import("./schema/driver.schema").Drivers, {}, {}> & import("./schema/driver.schema").Drivers & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    find_driver_with_id(id: string): Promise<mongoose.Document<unknown, {}, import("./schema/driver.schema").Drivers, {}, {}> & import("./schema/driver.schema").Drivers & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    checkAndUpdateDriverWorkingHours(driver_id: any): Promise<{
        is_limit_exceeded: boolean;
        total_seconds: number;
        max_allowed_seconds: any;
        daily_max_working_hours?: undefined;
    } | {
        is_limit_exceeded: boolean;
        total_seconds: number;
        max_allowed_seconds: number;
        daily_max_working_hours: string;
    }>;
    recordOnlineSession(driver_id: any): Promise<void>;
    recordOfflineSession(driver_id: any): Promise<void>;
    goOnline(body: goOnlineDto, driver_detail: any): Promise<{
        message: string;
    }>;
    getDriverDailyLogs(driver_id?: string, date?: string, startDate?: string, endDate?: string): Promise<{
        data: (mongoose.FlattenMaps<{
            driver_id: mongoose.Types.ObjectId;
            date: string;
            sessions: {
                online_at: number;
                offline_at: number;
                duration_seconds: number;
            }[];
            total_online_seconds: number;
            total_online_hours: number;
        }> & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        })[];
    }>;
    getDriverWorkingHoursStatus(driver_id?: string): Promise<{
        message: string;
        data: {
            date: string;
            driver_working_hour_enable: boolean;
            daily_max_working_hours: string;
            max_allowed_seconds: number;
            total_completed_seconds: number;
            total_completed_hours: number;
            remaining_seconds: number;
            remaining_hours: number;
            is_limit_exceeded: boolean;
        };
    }>;
    UpdateOrderStatus(body: OrderUpdateStatus, driver_detail: any): Promise<{
        message: string;
    }>;
    AcceptOrder(body: any, driver_detail: any, order: any): Promise<{
        message: string;
    }>;
    RechedAtRestaurant(body: any, order: any): Promise<{
        message: string;
    }>;
    PickedUp(body: any, order: any): Promise<{
        message: string;
    }>;
    RechedAtDelivery(body: any, order: any): Promise<{
        message: string;
    }>;
    OrderDelivered(body: any, order: any, driver_detail: any): Promise<{
        message: string;
    }>;
    VerifyDeliveryOTP(body: any, order: any, driver_detail: any): Promise<void>;
    driverOrderList(body: any): Promise<{
        count: any;
        data: any;
    }>;
    payoutList(body: payoutListDto): Promise<{
        count: any;
        total_payout: any;
        data: any;
    }>;
    FindDriverRequestsNew(body: any): Promise<{
        count: any;
        data: any;
    }>;
    FindDriverUpdateRequests(body: any): Promise<{
        count: any;
        data: any;
    }>;
    driver_list_all(body: restaurant_request_list_dto): Promise<{
        count: any;
        data: any;
    }>;
    block(body: any): Promise<{
        message: string;
    }>;
    updatePendingDriverStatus(body: UpdatePendingDriverStatusDto): Promise<{
        message: string;
    }>;
    UpdateRequest(_id: string, body: UpdateDriveRequest): Promise<{
        message: string;
    }>;
    sent_email_to_driver_for_approve_request(user: any): Promise<void>;
    sent_email_to_driver_for_reject_request(user: any, body: any): Promise<void>;
    driverEarningsForAdmin(body: any): Promise<void>;
    orderList(body: any): Promise<{
        count: any;
        data: any;
    }>;
    openOrders(driver_detail: any, dto: Listing): Promise<{
        count: number;
        data: any[];
    }>;
    updateLocation(dto: location, user: any): Promise<{
        message: string;
    }>;
    getDriver_docs_list_all(body: restaurant_request_list_dto, user: any): Promise<{
        count: any;
        data: any;
        pending_count: number;
        rejected_count: number;
    }>;
    getAvaliableDrivers(restaurant_id: string, search?: string): Promise<{
        message: string;
        data: any[];
    }>;
    GetRiderPickedUpOrder(driver_id: any): Promise<{
        customer_socket_id: string;
        driver: mongoose.Document<unknown, {}, import("./schema/driver.schema").Drivers, {}, {}> & import("./schema/driver.schema").Drivers & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    createDriverIncentive(): Promise<void>;
    getTotalOnlineTime(driver_id: any): Promise<{
        total_seconds: number;
        total_hours: number;
        total_minutes: number;
    }>;
    getTotalDistance(driver_id: any): Promise<{
        total_distance: number;
        total_orders: number;
    }>;
    getDriverWallet(driver_id: string): Promise<{
        wallet_balance: number;
        cod_due_amount: number;
        cod_max_limit: number;
        cod_blocked: boolean;
    }>;
    addWalletFunds(driver: any, amount: number): Promise<{
        razorpay: {
            amount: any;
            currency: any;
            id: any;
            order_id: any;
            slot_id: any;
            plate_id: any;
        };
        amount: number;
        client_secret?: undefined;
        payment_intent_id?: undefined;
    } | {
        client_secret: string;
        payment_intent_id: string;
        razorpay?: undefined;
        amount?: undefined;
    }>;
    getDriverWalletTransactions(driver_id: string, page?: number, limit?: number): Promise<any>;
    settleCodAmount(driver_id: string, amount: number, note?: string, admin_id?: string): Promise<{
        message: string;
        cod_due_before: number;
        cod_due_after: number;
        settled_amount: number;
    }>;
    getVendorsList(search?: string): Promise<{
        message: string;
        data: (mongoose.FlattenMaps<{
            flag: string;
            restaurant_id: string;
            name: string;
            email: string;
            country_code: string;
            phone: string;
            image: string;
            temp_email: string;
            temp_phone: string;
            temp_country_code: string;
            temp_email_otp: number;
            temp_phone_otp: number;
            temp_email_otp_at: number;
            temp_phone_otp_at: number;
            is_active: boolean;
            is_block: boolean;
            block_reason: string;
            is_email_verify: boolean;
            is_phone_verify: boolean;
            is_address_added: boolean;
            is_detail_added: boolean;
            is_timing_added: boolean;
            is_bank_added: boolean;
            is_menu_added: boolean;
            is_catering_menu_added: boolean;
            is_verfication_submitted: boolean;
            device_type: string;
            is_deleted: boolean;
            customer_id: string;
            razor_contact_id: string;
            razor_fund_account_id: string;
            country: string;
            socket_id: string;
            connection_id: string;
            preferred_currency: string;
            preferred_language: string;
            currency_symbol: string;
            delete_reason: string;
            report_reason_id: string;
            delete_description: string;
            created_at: number;
            updated_at: number;
            admin_payout_action: boolean;
            cashfree_beneficiary_account_id: string;
            pending_status: string;
            pending_status_reason: string;
        }> & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        })[];
    }>;
    getDriverAnalytics(id: string): Promise<{
        data: {
            total_orders: number;
            total_active_order: number;
            total_orders_delivered: number;
            total_cancelled_order: number;
            cancellation_order_percentage: number;
            total_revane_amount: number;
            total_receve_commsion_amount: number;
        };
    }>;
}