import * as mongoose from 'mongoose';
export declare class DriverAggregation {
    match(id: string): Promise<{
        $match: {
            _id: mongoose.Types.ObjectId;
        };
    }>;
    DriverVehicleDetailLookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                driver_id: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
                $project?: undefined;
            } | {
                $project: {
                    vehicle_id: number;
                    name: number;
                    model: number;
                    status: number;
                    number: number;
                    color: number;
                    child_seat_availabilty: number;
                    wheel_chair_availabilty: number;
                };
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    DriverBankLookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                driver_id: string;
            };
            pipeline: {
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
            }[];
            as: string;
        };
    }>;
    DriverDocumentDetailLookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                driver_id: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
                $project?: undefined;
            } | {
                $project: {
                    licence_front_image: number;
                    licence_back_image: number;
                    licence_expiry_date: number;
                };
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    unwind_vehicle_detail(): Promise<{
        $unwind: string;
    }>;
    unwind_document_detail(): Promise<{
        $unwind: string;
    }>;
    _drivermatch(match?: any): Promise<{
        $match: any;
    }>;
    InActiveDriverMatch(match?: any): Promise<{
        $match: any;
    }>;
    Blockdrivermatch(match?: any): Promise<{
        $match: any;
    }>;
    Deleteddrivermatch(match?: any): Promise<{
        $match: any;
    }>;
    booking_count_lookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                driverId: string;
            };
            pipeline: {
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
            }[];
            as: string;
        };
    }>;
    vehicle_details_lookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                driverId: string;
                serviceType: string;
            };
            pipeline: ({
                $lookup: {
                    from: string;
                    let: {
                        vehicleDetailId: string;
                    };
                    pipeline: {
                        $match: {
                            $expr: {
                                $and: {
                                    $eq: (string | boolean)[];
                                }[];
                            };
                        };
                    }[];
                    as: string;
                    localField?: undefined;
                    foreignField?: undefined;
                };
                $match?: undefined;
                $project?: undefined;
            } | {
                $lookup: {
                    from: string;
                    localField: string;
                    foreignField: string;
                    as: string;
                    let?: undefined;
                    pipeline?: undefined;
                };
                $match?: undefined;
                $project?: undefined;
            } | {
                $match: {
                    $expr: {
                        $cond: {
                            if: {
                                $eq: string[];
                            };
                            then: {
                                $gt: (number | {
                                    $size: string;
                                })[];
                            };
                            else: {
                                $and: {
                                    $eq: string[];
                                }[];
                            };
                        };
                    };
                };
                $lookup?: undefined;
                $project?: undefined;
            } | {
                $project: {
                    assignment: number;
                };
                $lookup?: undefined;
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    driver_vehicle_type_lookup(): Promise<{
        $lookup: {
            from: string;
            localField: string;
            foreignField: string;
            as: string;
        };
    }>;
    AddField(): Promise<{
        $addFields: {
            bookingCount: {
                $size: string;
            };
        };
    }>;
    private escapeRegex;
    fillter_data(search: any): Promise<{
        $match: {};
        $redact?: undefined;
    } | {
        $redact: {
            $cond: {
                if: {
                    $or: any[];
                };
                then: string;
                else: string;
            };
        };
        $match?: undefined;
    }>;
    filter_by_vehicle_type(vehicleTypeId: string): Promise<{
        $match: {
            $or: ({
                driver_service_type: string;
                vehicle_type_id: {
                    $in: any[];
                };
                'vehicleDetails.vehicle_id'?: undefined;
            } | {
                driver_service_type: {
                    $ne: string;
                };
                'vehicleDetails.vehicle_id': {
                    $in: any[];
                };
                vehicle_type_id?: undefined;
            })[];
        };
    }>;
    face_set(option: any, sort?: any): Promise<{
        $facet: {
            count: {
                $count: string;
            }[];
            data: ({
                $sort: any;
                $skip?: undefined;
                $limit?: undefined;
            } | {
                $skip: any;
                $sort?: undefined;
                $limit?: undefined;
            } | {
                $limit: any;
                $sort?: undefined;
                $skip?: undefined;
            })[];
        };
    }>;
    face_set_for_update(option: any): Promise<{
        $facet: {
            count: {
                $count: string;
            }[];
            data: ({
                $sort: {
                    updated_at: number;
                };
                $skip?: undefined;
                $limit?: undefined;
            } | {
                $skip: any;
                $sort?: undefined;
                $limit?: undefined;
            } | {
                $limit: any;
                $sort?: undefined;
                $skip?: undefined;
            })[];
        };
    }>;
    projectFields(): Promise<{
        $project: {
            _id: number;
            name: number;
            email: number;
            image: number;
            country_code: number;
            phone: number;
            is_active: number;
            is_block: number;
            is_deleted: number;
            is_approved: number;
            bookingCount: number;
            created_at: number;
            license_number: number;
            vehicleDetails: number;
            freelancer_vehicle_type: number;
            driver_service_type: number;
            vehicle_type_id: number;
            payout_mode: number;
            ratings: number;
            status: number;
        };
    }>;
    driverRequestprojectFields(): Promise<{
        $project: {
            _id: number;
            name: number;
            email: number;
            image: number;
            country_code: number;
            phone: number;
            created_at: number;
            documents: number;
        };
    }>;
    UpdateDocsRequestprojectFields(): Promise<{
        $project: {
            _id: number;
            name: number;
            email: number;
            image: number;
            country_code: number;
            phone: number;
            updated_at: number;
            created_at: number;
        };
    }>;
    driverprojectFields(): Promise<({
        $unwind: {
            path: string;
            preserveNullAndEmptyArrays: boolean;
        };
        $lookup?: undefined;
        $addFields?: undefined;
        $group?: undefined;
    } | {
        $lookup: {
            from: string;
            localField: string;
            foreignField: string;
            as: string;
        };
        $unwind?: undefined;
        $addFields?: undefined;
        $group?: undefined;
    } | {
        $addFields: {
            'documents.name': {
                $arrayElemAt: (string | number)[];
            };
            'documents.expiry_required': {
                $arrayElemAt: (string | number)[];
            };
        };
        $unwind?: undefined;
        $lookup?: undefined;
        $group?: undefined;
    } | {
        $group: {
            _id: string;
            name: {
                $first: string;
            };
            email: {
                $first: string;
            };
            image: {
                $first: string;
            };
            phone: {
                $first: string;
            };
            country_code: {
                $first: string;
            };
            is_active: {
                $first: string;
            };
            is_block: {
                $first: string;
            };
            is_deleted: {
                $first: string;
            };
            is_approved: {
                $first: string;
            };
            approved_on: {
                $first: string;
            };
            created_at: {
                $first: string;
            };
            licence_front_image: {
                $first: string;
            };
            licence_back_image: {
                $first: string;
            };
            licence_expiry_date: {
                $first: string;
            };
            total_payout: {
                $first: string;
            };
            upcoming_payout: {
                $first: string;
            };
            bookingCount: {
                $first: string;
            };
            walletbalance: {
                $first: string;
            };
            vehicleDetails: {
                $first: string;
            };
            bankAccount: {
                $first: string;
            };
            block_reason: {
                $first: string;
            };
            reject_reason: {
                $first: string;
            };
            license_number: {
                $first: string;
            };
            driver_service_type: {
                $first: string;
            };
            fleet: {
                $first: string;
            };
            documents: {
                $push: {
                    $cond: (string | {
                        $ifNull: (string | boolean)[];
                        type_id?: undefined;
                        front_image_id?: undefined;
                        back_image_id?: undefined;
                        expire_date?: undefined;
                        is_expired?: undefined;
                        name?: undefined;
                        expiry_required?: undefined;
                        _id?: undefined;
                    } | {
                        type_id: string;
                        front_image_id: string;
                        back_image_id: string;
                        expire_date: string;
                        is_expired: string;
                        name: string;
                        expiry_required: string;
                        _id: string;
                        $ifNull?: undefined;
                    })[];
                };
            };
            gender: {
                $first: string;
            };
            service_prefrence: {
                $first: string;
            };
            payout_mode: {
                $first: string;
            };
            latitude: {
                $first: string;
            };
            longitude: {
                $first: string;
            };
            status: {
                $first: string;
            };
        };
        $unwind?: undefined;
        $lookup?: undefined;
        $addFields?: undefined;
    })[]>;
    total_payout_lookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                driverId: string;
            };
            pipeline: {
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
            }[];
            as: string;
        };
    }>;
    total_payout_AddField(): Promise<{
        $addFields: {
            total_payout: {
                $sum: string;
            };
        };
    }>;
    upcoming_payout_lookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                driverId: string;
            };
            pipeline: {
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
            }[];
            as: string;
        };
    }>;
    upcoming_payout_AddField(): Promise<{
        $addFields: {
            upcoming_payout: {
                $sum: string;
            };
        };
    }>;
    driver_vehicle_detail_match(id: any): Promise<{
        $match: {
            _id: mongoose.Types.ObjectId;
        };
    }>;
    vehicle_document_lookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                vehicle_detail_id: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
                $project?: undefined;
            } | {
                $project: {
                    vehicle_insurance_image: number;
                    vehicle_registration_image: number;
                    insurance_expiry_date: number;
                    registration_expiry_date: number;
                };
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    getDriverVehicleDetailAggregation(id: any): Promise<({
        $match: {
            _id: mongoose.Types.ObjectId;
        };
        $lookup?: undefined;
    } | {
        $lookup: {
            from: string;
            localField: string;
            foreignField: string;
            as: string;
        };
        $match?: undefined;
    })[]>;
    _driverRequestmatch(extraMatch?: any, isFleet?: boolean): Promise<{
        $match: any;
    }>;
    _driverRequestRejectmatch(extraMatch?: any): Promise<{
        $match: any;
    }>;
    _UpdatedDocsRequestmatch(): Promise<{
        $match: {
            is_approved: any;
            is_doc_update: boolean;
            is_deleted: boolean;
        };
    }>;
    Pendingdrivermatch(pending_status?: string): Promise<{
        $match: any;
    }>;
    Expireddrivermatch(): Promise<{
        $match: {
            is_active: boolean;
            is_approved: boolean;
            is_deleted: boolean;
            is_block: boolean;
        };
    }>;
    order_count_lookup(): Promise<{
        $lookup: {
            from: string;
            localField: string;
            foreignField: string;
            as: string;
        };
    }>;
    DriverVhicalLookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                vehicle_id: string;
            };
            pipeline: {
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
            }[];
            as: string;
        };
    }>;
    UnwindVehicalLookup(): Promise<{
        $unwind: {
            path: string;
            preserveNullAndEmptyArrays: boolean;
        };
    }>;
    _driver_custom_match(match_data: any): Promise<{
        $match: any;
    }>;
    _driverUpdateRequestmatch(): Promise<{
        $match: {
            is_approved: boolean;
            is_docs_update: boolean;
            set_up_profile: boolean;
        };
    }>;
    RestaurantLookup(): Promise<{
        $lookup: {
            from: string;
            let: {
                restaurant_id: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
                $project?: undefined;
            } | {
                $project: {
                    restaurant_name: number;
                    address: number;
                    image: number;
                    food_type: number;
                };
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    UnwindRestaurantLookup(): Promise<{
        $unwind: {
            path: string;
            preserveNullAndEmptyArrays: boolean;
        };
    }>;
    _driverUpdateRequestmatchStatus(query: any): Promise<{
        $match: any;
    }>;
    drivermatch(query: any): Promise<{
        $match: any;
    }>;
    project(): Promise<{
        $project: {
            restaurant: number;
            delivery_address: number;
            cart_items: number;
            cart_amount: number;
            delivery_fee: number;
            free_delivery_fee: number;
            distance: number;
            total_amount: number;
            order_placed_at: number;
            order_id: number;
            rider_status: number;
            order_status: number;
            tip_amount: number;
            created_at: number;
        };
    }>;
}