import { DbService } from 'src/db/db.service';
import * as admin from 'firebase-admin';
import { BookingDocment } from 'src/booking/schema/booking.schema';
import Stripe from 'stripe';
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 { PaymentType } from 'src/payment/dto/payment.dto';
import { BodyPreference } from 'src/booking/dto/booking.dto';
import { FlutterwaveService } from './helpers/flutterwave-helper.service';
import { RedisService } from 'src/redis/redis.service';
import { JwtService } from '@nestjs/jwt';
import { ShareRideService } from 'src/common/helpers/share-ride.service';
interface BookingCalculation {
    driver_amount: number;
    app_amount: number;
    basic_trip_amount: number;
    payout_gst_amount: number;
    commission_gst_amount: number;
    city_fee: number;
    infrastructure_fee: number;
    insurance_fee: number;
    app_commission: number;
    app_commission_value: number;
    app_commission_unit: string;
    total_amount: number;
    surcharge_amount?: number;
    base_fee_without_discount?: number;
    coupon_amount?: number;
    commission?: number;
}
interface VehiclePricing {
    city_fees_unit: string;
    comfort_options: any;
    surcharge_price(surcharge_price: any): unknown;
    service_type: any;
    insurance_fees: number;
    airport_pickup_charges: number;
    airport_drop_charges: number;
    hourly_rate: number;
    hourly_max_km: number;
    hourly_km_rate: number;
    distance_price: number;
    base_fare: number;
    interncity_distance_price: number;
    intercity_base_fare: number;
    night_charges: number;
    stop_charges: number;
    city_fees: number;
    infrastructure_fees: number;
    app_commission_value: number;
    app_commission_unit: 'percentage' | 'fixed';
    intercity_commision_percentage: number;
    commission_percentage: number;
    vehicle_id?: any;
    cancellation_charges: number;
    base_km: number;
    ac_extra_per_km: number;
    load_unload_charges?: number;
    car_pooling_max_passengers?: number;
    car_pooling_discount_percentage?: number;
}
export declare class CommonService {
    private readonly stripeService;
    private readonly razorpayService;
    private readonly cashfreeService;
    private readonly jwtService;
    private readonly flutterwaveService;
    private readonly bookingAggregation;
    private readonly redisService;
    private readonly shareRideService;
    private readonly model;
    private readonly firebaseAdmin;
    server: Server;
    private transporter;
    private client;
    private bucketName;
    private s3;
    constructor(stripeService: StripeService, razorpayService: RazorpayService, cashfreeService: CashfreeService, jwtService: JwtService, flutterwaveService: FlutterwaveService, bookingAggregation: BookingAggregation, redisService: RedisService, shareRideService: ShareRideService, model: DbService, firebaseAdmin: admin.app.App);
    initializeTransporter(): Promise<void>;
    generateOtp(): number;
    getUserLanguage(req?: any, user?: any): string;
    checkIsIntercityRide(pickUpLat: string, pickUpLng: string, dropLat: string, dropLng: string): Promise<any>;
    onlySuperAdminCanUpdate(role: any): Promise<void>;
    getCity(lat: string, lng: string): Promise<any>;
    getServiceTypesSlugAndName(serviceType: string, rideType: string): {
        slug: string;
        name: string;
    };
    generateUniqueFilename: (filename: string) => string;
    isServiceArea(lat: string, lng: string, checkWithUnrestricted?: boolean): Promise<any>;
    getPrefferedCurrencySymbol(currency: any): string;
    getReciept(id: string, timezone?: string): Promise<{
        message: string;
    }>;
    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>;
    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;
    }>;
    calculatePayoutAmounts(booking: BookingDocment, isRideCompleted?: boolean, calculateForPass?: boolean): Promise<{
        admin_commission_amount: number;
        commission_type: string;
        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;
    handleUpdateDistanceTravelledInBooking(ongoingBooking: any): Promise<void>;
    calculateTotalBookingAmount(base_fee: any, booking: any, totalDistanceTravelled: any, addOnKms: any, calculateInsurance?: boolean): 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;
        insurance_fees: number;
    }>;
    translator(text: string, sourceLang: string, targetLang: string, isHaveSourceLanguage?: boolean): Promise<any>;
    getLanguageCode(language: string): any;
    calculateRentalUsage(booking: any, totalDistance: number): {
        totalHoursTravelled: number;
        extraHoursTravelled: number;
        extraKmsTravelled: number;
        baseFee: number;
        extraHoursAmount: number;
        extraKmsAmount: number;
        addOnKms: number;
    };
    isDriverHaveActiveVehicle(driverId: string, getInactive?: boolean): Promise<any>;
    getAdminProfile(payload: any): Promise<any>;
    createSession(data: any, tokenPayload: any): Promise<mongoose.Document<unknown, {}, import("../customer/schema/session.schema").Sessions, {}, {}> & import("../customer/schema/session.schema").Sessions & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    getFleetProfile(payload: any): Promise<any>;
    transferMoneyToDriver(amount: any, bankdata: any): Promise<any>;
    addProductName(subject: string): Promise<string>;
    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, req?: any): Promise<void>;
    uploadImage(key: string, file: any, fileBuffer: Buffer): Promise<AWS.S3.ManagedUpload.SendData>;
    uploadFile(key: string, buffer: Buffer, contentType: string): 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, req?: any): Promise<void>;
    sendmail(to: string, subject: string, text: string, html?: any, attachments?: any): Promise<void>;
    emailReferralApplied(email: string, product_name: string, name: string, otp: string, amount?: number, no_of_deliveries?: number, no_of_days?: number): 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;
            transactionId: string;
            type: string;
            isActive: boolean;
            purchased_at: number;
        }> & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
        subscription: mongoose.FlattenMaps<{
            fleetId: string;
            passId: string;
            startDate: number;
            endDate: number;
            amount: number;
            limit: number;
            limit_exceeded: boolean;
            category: string;
            avail_on_rides: number;
            transactionId: string;
            type: string;
            isActive: boolean;
            purchased_at: number;
        }> & {
            _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>;
    calculateBookingAmount(base_fee: number, coupon_amount: number, surcharge_amount: number, locationSurchargeMultiplier: number, commission_percentage: number, pricing: VehiclePricing, insurance_fees?: number, is_airport_pickup?: boolean, is_airport_drop?: boolean, tip_amount?: number, applyPlatformCommission?: boolean, need_load_unload?: boolean, incentive?: number, request_type?: string): Promise<BookingCalculation>;
    calculateIncentiveOnIntercityRides(totalDistanceOfTravel?: number, totalHoursOfTravel?: number, incentiveAmount?: number): Promise<number>;
    getEligibleDriversByVehicleAndTime({ vehicleTypeId, bookingTime, filter, fleet_id, is_upgrade_vehicle_search, vehicle_body_preference, activeDriverIds, ride_type, is_ac_ride, }: {
        vehicleTypeId: Types.ObjectId;
        bookingTime: moment.Moment;
        filter?: string[];
        fleet_id?: string | null;
        is_upgrade_vehicle_search?: boolean;
        vehicle_body_preference?: BodyPreference;
        activeDriverIds?: string[];
        ride_type: string;
        is_ac_ride?: boolean;
    }): Promise<string[]>;
    updateFleetPassUsage(subscription: any): Promise<void>;
    deleteDriverCustomerPhotos(): Promise<{
        success: boolean;
        deletedKeysCount: number;
        message: string;
    }>;
    bulkDeleteFromS3(keys: string[]): Promise<void>;
    mergeAndDeactivate(): Promise<void>;
    checkHaveActiveSubscription(driverId: string): Promise<{
        isAvailable: boolean;
        subscription: any;
    }>;
    calculateDistanceWithStops(pickUpLat: any, pickUpLong: any, dropLat: any, dropLong: any, stops: any[], needDuration?: boolean): Promise<number | any>;
    calculateDistanceWithStopsForLogs(pickUpLat: any, pickUpLong: any, dropLat: any, dropLong: any, stops: any[]): Promise<number>;
    isAnyOtherBookingExistForCustomer(booking_id: any): Promise<{
        isExist: boolean;
        ids: string[];
    }>;
    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>;
    isAnyBookingScheduled(driver_id: string, agent_customer_id?: string): Promise<{
        isBookingScheduled: boolean;
        scheduledBooking: mongoose.Document<unknown, {}, import("src/booking/schema/booking.schema").Booking, {}, {}> & import("src/booking/schema/booking.schema").Booking & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    createPaymentOrder(body: any, booking_id: any, customer: any, totalAmountOverride?: number): Promise<{
        amount: number;
        meta: any;
        ref_id: string;
    } | {
        client_secret: string;
        paymentIntent: string;
        status: Stripe.PaymentIntent.Status;
        requires_action: boolean;
        amount: number;
        ephemeralKey: any;
        customer: any;
        order_id?: undefined;
        cf_order_id?: undefined;
        payment_sessions_id?: undefined;
    } | {
        order_id: any;
        amount: number;
        client_secret?: undefined;
        paymentIntent?: undefined;
        status?: undefined;
        requires_action?: undefined;
        ephemeralKey?: undefined;
        customer?: undefined;
        cf_order_id?: undefined;
        payment_sessions_id?: undefined;
    } | {
        order_id: any;
        cf_order_id: any;
        payment_sessions_id: any;
        amount: any;
        client_secret?: undefined;
        paymentIntent?: undefined;
        status?: undefined;
        requires_action?: undefined;
        ephemeralKey?: undefined;
        customer?: undefined;
    }>;
    private getPaymentDescription;
    completePaymentToRequestRide(paymentType: any, booking: any, payer: any, language: any, paymentId?: string): Promise<{
        message: string;
        booking: any;
    }>;
    send_ride_request_to_drivers(data: any, customer: any): Promise<unknown>;
    find_booking_with_id(id: any): Promise<any>;
    find_drivers_for_request(pickup_lat: any, pick_up_long: any, vehicle_id: string, booking_id: any, filter: any, created_at: any, customer: any, gender_prefrence: any, algorithm?: string, request_type?: string, vehicle_body_preference?: BodyPreference): Promise<any[] | (mongoose.Document<unknown, {}, import("src/driver/schema/driver.schema").Drivers, {}, {}> & import("src/driver/schema/driver.schema").Drivers & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }) | {
        latitude: any;
        longitude: any;
        _id: any;
        preferred_language: any;
        preferred_currency: any;
        current_booking: any;
        upcoming_booking: any;
        ride_status: any;
    }>;
    refundAmountToSource(booking_id: string, amount: number, deductCancellationCharges?: boolean): Promise<void>;
    refundAmountToCustomerWallet(booking: any, amount: number): Promise<void>;
    refundAmountToAgentWallet(booking: any, amount: number): Promise<void>;
    refundAmountToCorporate(booking: any, deductCancellationCharges?: boolean): Promise<void>;
    isUpgradeVehicleSearch(algorithm: string, bookings_sec: number): boolean;
    socket_booking_accepted(booking_id: string): Promise<{
        socketIds: string[];
        booking_details: mongoose.Document<unknown, {}, import("src/booking/schema/booking.schema").Booking, {}, {}> & import("src/booking/schema/booking.schema").Booking & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        };
    }>;
    dispatchBookingDrivers(): Promise<any[]>;
    getTodayCompletedRides(driverId: string): Promise<number>;
    getDriverRating(driverId: string): Promise<number>;
    finishPayment(paymentType: PaymentType, booking: any, payer: any, language: string, isBookingScheduled: boolean, scheduledBooking?: any, paymentId?: string): Promise<{
        message: any;
    }>;
    calculateEstimatedTimeInMinutes(lat1: string, lon1: string, lat2: string, lon2: string): Promise<number>;
    cal(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>;
    calculateAgentPayableAmount(booking: BookingDocment, needToApplyCancellationFees?: boolean): number;
    refund(booking: any, refundAmount: number): Promise<any>;
    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;
    }>;
    getDiscountedMultiplierForSharedPoolRide(numberOfSeatsRequested: number, allowedSeats: number, maximum_discount_percentage: number): number;
    localization(key: string, key2?: string): Promise<mongoose.Document<unknown, {}, import("../admin/schema/language.schema").Languages, {}, {}> & import("../admin/schema/language.schema").Languages & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    createEarningOnOrder(createOrder: any): Promise<void>;
    processBookingEarningAndWallet(bookingId: any): Promise<void>;
    replaceNotificationParams(text: string, params: {
        orderId?: string;
        customerName?: string;
        restaurantName?: string;
        otp?: string;
        driverName?: string;
        date?: string;
        time?: string;
        rating?: string | number;
        tableNumber?: string | number;
        bookingId?: string;
        subscriptionId?: string;
        booking_time?: string;
    }): string;
    filterSession(filter: any): Promise<any[]>;
    getOtp(phone?: string, countryCode?: string, type?: string): string;
    handleSendPhoneOtp(otp: string, phone: string, countryCode: string, type?: string): Promise<void>;
    needDynamicOtps(phone?: string, countryCode?: string, type?: string): boolean;
    handleSendOtpSms(otp: any, phone: any, countryCode: any): Promise<void>;
    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>;
    sent_email_to_corporate_staff(user_data: any, name: string, email: string, token: string): Promise<void>;
    creditBillPayment: (companyId: string, amount: any) => Promise<void>;
    creditBillPaymentInvoice: (companyId: string, invoice_id: string, amount: any) => Promise<void>;
    createStripeClient(): Promise<Stripe>;
    createEphemeralKey(customer_id: any): Promise<string>;
    send_bulk_notifications: (pushData: any, fcm_tokens: any, data: any) => Promise<void>;
    SendOtpOnMobile(otp: any, phone: any): Promise<void>;
    find_customer_with_phone(phone: string): Promise<mongoose.Document<unknown, {}, import("src/customer/schema/customer.schema").Customers, {}, {}> & import("src/customer/schema/customer.schema").Customers & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    find_driver_with_phone(phone: string): Promise<mongoose.Document<unknown, {}, import("src/driver/schema/driver.schema").Drivers, {}, {}> & import("src/driver/schema/driver.schema").Drivers & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    find_vendor_with_phone(phone: string): Promise<mongoose.Document<unknown, {}, import("../vendor/schema/vendor.schema").Vendor, {}, {}> & import("../vendor/schema/vendor.schema").Vendor & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    find_restaurent_with_phone(phone: string): Promise<mongoose.Document<unknown, {}, import("src/restaurant/schema/restaurant.schema").Restaurant, {}, {}> & import("src/restaurant/schema/restaurant.schema").Restaurant & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    decode_JwtToken(token: string): Promise<any>;
    SentEmailVerificationMail(name: any, otp: any, email: any, scope?: any): Promise<void>;
    checkToken(token: any): Promise<mongoose.Document<unknown, {}, import("../customer/schema/session.schema").Sessions, {}, {}> & import("../customer/schema/session.schema").Sessions & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }>;
    CalculateDistance(lat1: any, lon1: any, lat2: any, lon2: any): Promise<{
        distance: number;
        duration: any;
    }>;
    SentEmailForBlockAccount(user: any, body: any): Promise<void>;
    SentEmailForUnBlockAccount(user: any, body: any): Promise<void>;
    calculateDistanceUsingFormula(lat1?: any, lon1?: any, lat2?: any, lon2?: any): Promise<number>;
    createOrderId(): string;
    UniqueBarCodeID(): string;
    LoyaltyRedeemed(customerId: any, order_id: any, points: any, note?: string): Promise<void>;
    RecaptchaVerify(token: any): Promise<any>;
    createSalesCommissionDistribution(obj: any): Promise<{
        message: string;
        admin_earing_on_commission?: undefined;
    } | {
        admin_earing_on_commission: number;
        message?: undefined;
    }>;
    setCsvDataOnCache(data: any): Promise<Types.ObjectId>;
    getCsvDataFromCache(token: string): Promise<any>;
    generateBarcode(text: string): Promise<Buffer>;
    migrateLocation(): Promise<void>;
    filterFood(body: any): Promise<any[]>;
    lookupRestaurant(body: any): Promise<{
        $lookup: {
            from: string;
            let: {
                restaurant_id: string;
            };
            pipeline: ({
                $match: any;
                $project?: undefined;
            } | {
                $project: {
                    _id: number;
                    type: number;
                    restaurant_name: number;
                    restaurant_phone: number;
                    average_preparing_time: number;
                    status: number;
                    image: number;
                    address: number;
                    location: number;
                    isDineOut: number;
                    catering_services: number;
                };
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    filterItem(search?: string): Promise<any[]>;
    lookupStore(): Promise<{
        $lookup: {
            from: string;
            let: {
                store_id: string;
            };
            pipeline: ({
                $match: any;
                $project?: undefined;
            } | {
                $project: {
                    _id: number;
                    type: number;
                    restaurant_name: number;
                    restaurant_phone: number;
                    average_preparing_time: number;
                    status: number;
                    image: number;
                    address: number;
                    location: number;
                };
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    filterRestaurants(body?: any): Promise<any[]>;
    getOrdinal(n: number): string;
    getUserOrderCount(restaurantId: any, customerId: any, excludeOrderId?: any): Promise<string>;
}
export {};