import { DbService } from 'src/db/db.service';
import * as admin from 'firebase-admin';
import * as moment from 'moment';
import { StripeService } from './helpers/stripe.service';
import { RazorpayService } from './helpers/razorpay-helper.service';
import mongoose from 'mongoose';
import * as AWS from 'aws-sdk';
import { BookingAggregation } from 'src/booking/booking.aggregation';
import { CashfreeService } from './helpers/cashfree-helper.service';
import { Types } from 'mongoose';
import { BillingDuration } from 'src/company/schema/company.schema';
import { Server } from 'socket.io';
import { RedisService } from 'src/redis/redis.service';
export declare class CommonService {
    private readonly stripeService;
    private readonly razorpayService;
    private readonly cashfreeService;
    private readonly bookingAggregation;
    private readonly redisService;
    private readonly model;
    private readonly firebaseAdmin;
    server: Server;
    private transporter;
    private fcm;
    private client;
    private bucketName;
    private s3;
    constructor(stripeService: StripeService, razorpayService: RazorpayService, cashfreeService: CashfreeService, bookingAggregation: BookingAggregation, redisService: RedisService, model: DbService, firebaseAdmin: admin.app.App);
    initializeTransporter(): Promise<void>;
    generateOtp(): Promise<number>;
    getUserLanguage(req?: any, user?: any): string;
    isServiceArea(lat: string, lng: string, checkWithUnrestricted?: boolean): Promise<any>;
    getPrefferedCurrencySymbol(currency: any): string;
    resetCouponUsage(couponId: string, userId: string): Promise<void>;
    getReciept(id: string, timezone?: string): Promise<{
        message: string;
    }>;
    sendOtpSMS(otp: any, country_code: string, phone: any): Promise<void>;
    getVehicleDetailsIdForSalariedDriver(vehicle_type: string, bookingTime: number, driverId: string): Promise<string>;
    gen_backup_name(): Promise<string>;
    create_backup(backup_name: string, gzip: boolean): Promise<unknown>;
    upload_file_to_spaces(params: any): Promise<unknown>;
    backup_using_cron(): Promise<mongoose.Document<unknown, {}, import("./schema/backup-schema").backup, {}, {}> & import("./schema/backup-schema").backup & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    save_backup_logs: (name: string, location: string) => Promise<mongoose.Document<unknown, {}, import("./schema/backup-schema").backup, {}, {}> & import("./schema/backup-schema").backup & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    deleteOldBackups(): Promise<void>;
    deleteFroms3(key: string, callback?: () => void): Promise<void>;
    transferImmediatePayout(bookingId: string): Promise<{
        status: string;
        pendingSubmitCash: any;
        amount?: undefined;
    } | {
        status: string;
        amount: number;
        pendingSubmitCash?: undefined;
    }>;
    calculateFare(booking: any): Promise<{
        admin_commission_amount: number;
        commission_type: any;
        payout_amount: number;
        commission_gst: number;
        payout_gst: number;
        app_commission: number;
        city_fees: number;
        insurance_fees: number;
        infrastructure_fees: number;
        commissionable_amount: number;
        payoutTo: string;
        payoutOwnerId: Types.ObjectId;
        isPass: boolean;
    }>;
    newCalculatePayout(booking: any, isRideCompleted?: boolean): Promise<{
        admin_commission_amount: number;
        commission_type: any;
        payout_amount: number;
        commission_gst: number;
        payout_gst: number;
        city_fees: number;
        insurance_fees: number;
        infrastructure_fees: number;
        payoutTo: string;
        payoutOwnerId: string | Types.ObjectId;
        isPass: boolean;
        isSalaried: boolean;
        taxAmountForAdmin: number;
        taxAmountForDriver: number;
    }>;
    private getAdminCommissionAmountOnBaseFare;
    newHandleUpdateDistanceTravelled(ongoingBooking: any): Promise<void>;
    calculateTotalBookingAmount(base_fee: any, booking: any): Promise<{
        driver_amount: number;
        app_amount: number;
        basic_trip_amount: number;
        payout_gst_amount: number;
        commission_gst_amount: number;
        app_commission: number;
        total_amount: number;
    }>;
    calculateRentalUsage(booking: any, totalDistance: number): {
        totalHoursTravelled: number;
        extraHoursTravelled: number;
        extraKmsTravelled: number;
        baseFee: number;
    };
    isDriverHaveActiveVehicle(driverId: string): Promise<any>;
    transferMoneyToDriver(amount: any, destination: any): Promise<any>;
    sent_email_driver_for_pay_Commision(driver_detail: any, totalEarningAmount: any, numberOfTrips: any, total_base_fare: any, total_tip: any, toll_charges: any, total_commison_amount: any, total_cash_earning: any, net_payout: any): Promise<void>;
    uploadImage(key: string, file: any, fileBuffer: Buffer): Promise<AWS.S3.ManagedUpload.SendData>;
    checkIsVehicleAlreadyAssignedToDriver(payload: any): Promise<{
        conflict: boolean;
        type: string;
        message: string;
        existing: mongoose.Document<unknown, {}, import("../vehicle/schema/vehicle-assignment.schema").VehicleAssignment, {}, {}> & import("../vehicle/schema/vehicle-assignment.schema").VehicleAssignment & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    } | {
        conflict: boolean;
        type?: undefined;
        message?: undefined;
        existing?: undefined;
    }>;
    changeServiceTypeForSingleDriver(driver_id: string): Promise<{
        message: string;
    }>;
    changeServiceTypeForDrivers(fleet_id: string, serviceType: string[]): Promise<{
        message: string;
    }>;
    driverUpdatesForChangedServiceType(updateConfigurationDto: any): Promise<void>;
    checkCrossTypeConflict(newA: any, existing: any): "Conflict with permanent assignment." | "Time slot conflicts." | "Time slot conflicts with weekday availability." | "Weekday availability conflicts with time slot." | "Time slot conflicts with date range." | "Date range conflicts with time slot." | "Weekday schedule conflicts." | "Weekday availability conflicts with date range." | "Date range overlaps.";
    checkTimeSlotWeekdaysConflict(timeA: any, weekB: any): boolean;
    checkTimeSlotDateRangeConflict(slotA: any, rangeB: any): boolean;
    checkWeekDayDateRangeConflict(weekA: any, rangeB: any): boolean;
    checkWeekDayConflict(newData: any, existing: any): boolean;
    checkTimeSlotConflict(newData: any, existing: any): boolean;
    checkDateRangeConflict(newData: any, existing: any): boolean;
    timeToMinutes(timeStr: string): number;
    isTimeOverlap(start1: string, end1: string, start2: string, end2: string): boolean;
    isDateRangeOverlap(start1: any, end1: any, start2: any, end2: any): boolean;
    normalizeTimeSlots(slots: any): any;
    sent_payout_email(payment_data: any, driver_detail: any, totalEarningAmount: any, numberOfTrips: any, total_base_fare: any, total_tip: any, toll_charges: any, total_commison_amount: any, total_cash_earning: any, pending_submit_cash: any, account_number: any): Promise<void>;
    sent_email_verify_mail(user_data: any, otp: any, body: any, payload: any): Promise<void>;
    sendmail(to: string, subject: string, text: string, html?: any, attachments?: any): Promise<void>;
    findNearestServiceArea(lng: number, lat: number): Promise<{
        isInside: boolean;
        nearestServiceArea: any;
        surcharge: any;
    } | {
        isInside: boolean;
        surcharge: any;
        nearestServiceArea?: undefined;
    }>;
    checkPickupAndDropoff(pickupLng: number, pickupLat: number, dropLng: number, dropLat: number): Promise<{
        success: boolean;
        reason: string;
        serviceArea?: undefined;
    } | {
        success: boolean;
        serviceArea: {
            name: any;
            surcharge: any;
            pointAddress: any;
        };
        reason?: undefined;
    }>;
    emailReferralApplied(email: string, product_name: string, name: string, otp: string, amount?: number, no_of_deliveries?: number, no_of_days?: number): Promise<void>;
    test(): Promise<void>;
    emailVerification(email: string, product_name: string, name: string, otp: number): Promise<void>;
    fetch_fcm_token(customer_id: string): Promise<(mongoose.Document<unknown, {}, import("../customer/schema/session.schema").Sessions, {}, {}> & import("../customer/schema/session.schema").Sessions & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    })[]>;
    getLocationData(lat: any, lng: any): Promise<{
        city: any;
        state: any;
        country: any;
    }>;
    checkHaveActivePassForBooking(customerId: string, body: any): Promise<{
        isAvailable: boolean;
        pass: any;
    }>;
    checkFleetHasAcivePass(fleetId: string, body?: any): Promise<{
        isAvailable: boolean;
        pass: mongoose.FlattenMaps<{
            fleetId: string;
            passId: string;
            startDate: number;
            endDate: number;
            amount: number;
            limit: number;
            limit_exceeded: boolean;
            category: string;
            avail_on_rides: number;
            type: string;
            isActive: boolean;
        }> & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    updatePassUsage(subscription: any): Promise<void>;
    updatePassLimitForCancelCases(subscriptionId: string): Promise<void>;
    updateFleetPassLimitForCancelCases(subscriptionId: string): Promise<void>;
    resolveDriverModeAndServiceType(driverId: string): Promise<void>;
    resolveFleetPayoutMode(fleetId: string): Promise<void>;
    getEligibleDriversByVehicleAndTime({ vehicleTypeId, bookingTime, filter, fleet_id, is_upgrade_vehicle_search, }: {
        vehicleTypeId: Types.ObjectId;
        bookingTime: moment.Moment;
        filter?: string[];
        fleet_id?: string | null;
        is_upgrade_vehicle_search?: boolean;
    }): Promise<string[]>;
    updateFleetPassUsage(subscription: any): Promise<void>;
    checkHaveActiveSubscription(driverId: string): Promise<{
        isAvailable: boolean;
        subscription: any;
    }>;
    calculateDistanceWithStops(pickUpLat: any, pickUpLong: any, dropLat: any, dropLong: any, stops: any[]): Promise<number | null>;
    calculateDistanceWithStopsForLogs(pickUpLat: any, pickUpLong: any, dropLat: any, dropLong: any, stops: any[]): Promise<number>;
    getPlaceNameByCoords(lat: string, lng: string): Promise<any>;
    getDuration(pickUpLat: string, pickUpLong: string, driverLat: string, driverLong: string): Promise<string>;
    calculate_radius_distance(lat1: any, lon1: any, lat2: any, lon2: any): Promise<number>;
    deg2rad(deg: any): Promise<number>;
    updateDriverLocationLogs(driver_id: string): Promise<void>;
    calculateDriverTravelledDistance(driver: any): Promise<number>;
    send_notification: (pushData: any, fcm_tokens: any, data: any, device_type?: string) => Promise<void>;
    calculatePlatformCommission(amount: number, pricing: any): any;
    calculateCityFeeCommission(amount: number, pricing: any): any;
    getRoutePolyline(origin: any, destination: any, waypoints: any): Promise<any>;
    calculateDriverPayoutData(driverId: string): Promise<{
        payments: (mongoose.Document<unknown, {}, import("src/payment/schema/payment.schema").Payments, {}, {}> & import("src/payment/schema/payment.schema").Payments & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        })[];
        cashPayments: (mongoose.Document<unknown, {}, import("src/payment/schema/payment.schema").Payments, {}, {}> & import("src/payment/schema/payment.schema").Payments & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        })[];
        finalReferralAmount: number;
        totalPayoutAmount: number;
        totalEarningAmount: number;
        totalCommissionAmount: number;
        totalBaseFare: number;
        totalTip: number;
        totalToll: number;
        totalCashEarning: number;
        numberOfTrips: number;
        netPayout: number;
        driverOwes: boolean;
        pendingSubmitCash: any;
    }>;
    generateStaticRouteImage(origin: any, destination: any, waypoints: any): Promise<{
        staticMapUrl: string;
    }>;
    payment_with_cash(booking: any, language: any, scheduleBooking: any, schedule_booking: any): Promise<{
        message: any;
    }>;
    localization(language: any, key: any): Promise<mongoose.Document<unknown, {}, import("../admin/schema/language.schema").Languages, {}, {}> & import("../admin/schema/language.schema").Languages & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    set_options(pagination: number, limit: number): Promise<any>;
    sendotp(otp: any, phone: any): Promise<any>;
    reverseGeocode(lat: string, long: string): Promise<string>;
    private createInvoiceId;
    runPayouts(intervalType: BillingDuration): Promise<void>;
    isUpgradeVehicleSearch(algorithm: string, bookings_sec: number): boolean;
}