import { Types } from 'mongoose';
export declare class ChatAggregations {
    match(query: any): Promise<{
        $match: any;
    }>;
    matchData: (user_id: string, groupConnectionIds: Types.ObjectId[], type: string, connection_type: string) => Promise<{
        $match: {
            $and: any[];
        };
    }>;
    lookup_messages: (user_id: any) => Promise<{
        $lookup: {
            from: string;
            let: {
                connection_id: string;
            };
            pipeline: {
                $match: {
                    $expr: {
                        $and: ({
                            $eq: string[];
                            $not?: undefined;
                        } | {
                            $not: {
                                $in: (string | Types.ObjectId)[];
                            };
                            $eq?: undefined;
                        })[];
                    };
                };
            }[];
            as: string;
        };
    }>;
    count_total_messages: () => Promise<{
        $set: {
            total_messages: {
                $size: string;
            };
        };
    }>;
    setData: (user_id: string) => Promise<{
        $set: {
            other_user_id: {
                $cond: {
                    if: {
                        $eq: (string | Types.ObjectId)[];
                    };
                    then: string;
                    else: string;
                };
            };
        };
    }>;
    lookupUser: () => Promise<{
        $lookup: {
            from: string;
            let: {
                other_user_id: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $eq: string[];
                    };
                };
                $project?: undefined;
            } | {
                $project: {
                    profile_pic: number;
                    name: number;
                    username: number;
                    country_code: number;
                    phone_no: number;
                    is_online: number;
                };
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    unwindData: (value: any) => Promise<{
        $unwind: {
            path: any;
            preserveNullAndEmptyArrays: boolean;
        };
    }>;
    filterUsersByName: (search: string) => Promise<{
        $redact: {
            $cond: {
                if: {
                    $or: ({
                        $eq: (string | undefined)[];
                        $regexMatch?: undefined;
                    } | {
                        $regexMatch: {
                            input: string;
                            regex: string;
                            options: string;
                        };
                        $eq?: undefined;
                    })[];
                };
                then: string;
                else: string;
            };
        };
    }>;
    lookupUnreadChat: (sent_to: string) => Promise<{
        $lookup: {
            from: string;
            let: {
                connection_id: string;
            };
            pipeline: {
                $match: {
                    $expr: {
                        $and: ({
                            $ne: (string | Types.ObjectId)[];
                            $eq?: undefined;
                            $not?: undefined;
                        } | {
                            $eq: string[];
                            $ne?: undefined;
                            $not?: undefined;
                        } | {
                            $not: {
                                $in: (string | Types.ObjectId)[];
                            };
                            $ne?: undefined;
                            $eq?: undefined;
                        })[];
                    };
                };
            }[];
            as: string;
        };
    }>;
    countMessageData: () => Promise<{
        $set: {
            count_message: {
                $size: string;
            };
        };
    }>;
    findOtherUserId: (_id: string) => Promise<{
        $set: {
            other_user_id: {
                $cond: {
                    if: {
                        $eq: (string | Types.ObjectId)[];
                    };
                    then: string;
                    else: string;
                };
            };
        };
    }>;
    fetchMessages: (user_id: string) => Promise<{
        $lookup: {
            from: string;
            let: {
                connection_id: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $and: ({
                            $eq: string[];
                            $ne?: undefined;
                            $not?: undefined;
                        } | {
                            $ne: string[];
                            $eq?: undefined;
                            $not?: undefined;
                        } | {
                            $not: {
                                $in: (string | Types.ObjectId)[];
                            };
                            $eq?: undefined;
                            $ne?: undefined;
                        })[];
                    };
                };
                $lookup?: undefined;
                $unwind?: undefined;
                $sort?: undefined;
                $limit?: undefined;
            } | {
                $lookup: {
                    from: string;
                    let: {
                        sender_id: string;
                    };
                    pipeline: {
                        $match: {
                            $expr: {
                                $eq: string[];
                            };
                        };
                    }[];
                    as: string;
                };
                $match?: undefined;
                $unwind?: undefined;
                $sort?: undefined;
                $limit?: undefined;
            } | {
                $unwind: {
                    path: string;
                    preserveNullAndEmptyArrays: boolean;
                };
                $match?: undefined;
                $lookup?: undefined;
                $sort?: undefined;
                $limit?: undefined;
            } | {
                $sort: {
                    _id: number;
                };
                $match?: undefined;
                $lookup?: undefined;
                $unwind?: undefined;
                $limit?: undefined;
            } | {
                $limit: number;
                $match?: undefined;
                $lookup?: undefined;
                $unwind?: undefined;
                $sort?: undefined;
            })[];
            as: string;
        };
    }>;
    setLastMsg: (_id: string) => Promise<{
        $set: {
            get_last_message: {
                $cond: ({
                    $eq: (string | null)[];
                    $switch?: undefined;
                } | {
                    $switch: {
                        branches: ({
                            case: {
                                $eq: string[];
                            };
                            then: string;
                        } | {
                            case: {
                                $eq: string[];
                            };
                            then: {
                                $cond: {
                                    if: {
                                        $eq: string[];
                                    };
                                    then: string;
                                    else: string;
                                };
                                $let?: undefined;
                            };
                        } | {
                            case: {
                                $eq: string[];
                            };
                            then: {
                                $let: {
                                    vars: {
                                        mediaTypes: {
                                            $setUnion: {
                                                $map: {
                                                    input: string;
                                                    as: string;
                                                    in: string;
                                                };
                                            }[];
                                        };
                                    };
                                    in: {
                                        $switch: {
                                            branches: {
                                                case: {
                                                    $eq: (string | string[])[];
                                                };
                                                then: string;
                                            }[];
                                            default: string;
                                        };
                                    };
                                };
                                $cond?: undefined;
                            };
                        })[];
                        default: string;
                    };
                    $eq?: undefined;
                } | null)[];
            };
        };
    }>;
    firstMessage: (user_id: string) => Promise<{
        $lookup: {
            from: string;
            let: {
                connection_id: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $and: {
                            $eq: string[];
                        }[];
                    };
                };
                $limit?: undefined;
            } | {
                $limit: number;
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    setFirstMessage: (_id: string) => Promise<{
        $set: {
            chat_initiated: {
                $cond: (boolean | {
                    $gt: (number | {
                        $size: {
                            $ifNull: (string | never[])[];
                        };
                    })[];
                })[];
            };
        };
    }>;
    groupData: () => Promise<{
        $group: {
            _id: string;
            connection_id: {
                $first: string;
            };
            other_user_id: {
                $first: string;
            };
            group_name: {
                $first: string;
            };
            group_image_url: {
                $first: string;
            };
            user: {
                $first: string;
            };
            message_type: {
                $first: string;
            };
            connection_type: {
                $first: string;
            };
            last_message: {
                $first: string;
            };
            chat_initiated: {
                $first: string;
            };
            last_message_sent_by: {
                $first: string;
            };
            unread_msgs: {
                $first: string;
            };
            total_messages: {
                $first: string;
            };
            updated_at: {
                $first: string;
            };
            is_blocked: {
                $first: string;
            };
            is_locked: {
                $first: string;
            };
            created_at: {
                $first: string;
            };
            type: {
                $first: string;
            };
            connection_pinned_by: {
                $first: string;
            };
            isMuted: {
                $first: {
                    $cond: {
                        if: {
                            $gt: (number | {
                                $size: string;
                            })[];
                        };
                        then: boolean;
                        else: boolean;
                    };
                };
            };
        };
    }>;
    filterWithoutMessage: (user_id: string) => Promise<{
        $match: {
            $expr: {
                $or: {
                    $eq: (string | boolean)[];
                }[];
            };
        };
    }>;
    lookupBlockedUsers: (user_id: string) => Promise<{
        $lookup: {
            from: string;
            let: {
                other_user_id: string;
                connection_type: string;
            };
            pipeline: {
                $match: {
                    $expr: {
                        $and: {
                            $eq: (string | Types.ObjectId)[];
                        }[];
                    };
                };
            }[];
            as: string;
        };
    }>;
    addBlockedStatus: () => Promise<{
        $addFields: {
            is_blocked: {
                $cond: {
                    if: {
                        $gt: (number | {
                            $size: string;
                        })[];
                    };
                    then: boolean;
                    else: boolean;
                };
            };
        };
    }>;
    addLockedStatus: (user_id: string) => Promise<{
        $addFields: {
            is_locked: {
                $cond: {
                    if: {
                        $and: ({
                            $isArray: string;
                            $in?: undefined;
                        } | {
                            $in: (string | Types.ObjectId)[];
                            $isArray?: undefined;
                        })[];
                    };
                    then: boolean;
                    else: boolean;
                };
            };
        };
    }>;
    addPinnedStatus: (user_id: string) => Promise<{
        $addFields: {
            is_pinned: {
                $cond: {
                    if: {
                        $and: ({
                            $isArray: string;
                            $in?: undefined;
                        } | {
                            $in: (string | Types.ObjectId)[];
                            $isArray?: undefined;
                        })[];
                    };
                    then: boolean;
                    else: boolean;
                };
            };
        };
    }>;
    addFieldsIsStared: (user_id: string) => Promise<{
        $addFields: {
            is_starred: {
                $cond: {
                    if: {
                        $and: ({
                            $isArray: string;
                            $in?: undefined;
                        } | {
                            $in: (string | Types.ObjectId)[];
                            $isArray?: undefined;
                        })[];
                    };
                    then: boolean;
                    else: boolean;
                };
            };
        };
    }>;
    lookupForCheckMutedConnection(user_id: any): Promise<{
        $lookup: {
            from: string;
            let: {
                user_id: Types.ObjectId;
                conn_id: string;
            };
            pipeline: {
                $match: {
                    $expr: {
                        $and: ({
                            $eq: string[];
                            $in?: undefined;
                        } | {
                            $in: (string | {
                                $ifNull: (never[] | {
                                    $map: {
                                        input: string;
                                        as: string;
                                        in: string;
                                    };
                                })[];
                            })[];
                            $eq?: undefined;
                        })[];
                    };
                };
            }[];
            as: string;
        };
    }>;
    removeEmptyDoc: () => Promise<{
        $redact: {
            $cond: {
                if: {
                    $or: {
                        $eq: (string | number)[];
                    }[];
                };
                then: string;
                else: string;
            };
        };
    }>;
    facetData(page: any, limit: any): Promise<{
        $facet: {
            count: {
                $count: string;
            }[];
            data: ({
                $sort: {
                    is_pinned: number;
                    updated_at: number;
                };
                $skip?: undefined;
                $limit?: undefined;
            } | {
                $skip: any;
                $sort?: undefined;
                $limit?: undefined;
            } | {
                $limit: any;
                $sort?: undefined;
                $skip?: undefined;
            })[];
        };
    }>;
    lookupSentBy(): Promise<{
        $lookup: {
            from: string;
            let: {
                sent_by: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $eq: string[];
                    };
                };
                $project?: undefined;
            } | {
                $project: {
                    _id: number;
                    name: number;
                    image: number;
                    profile_pic: number;
                };
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    unwindSentBy(): Promise<{
        $unwind: {
            path: string;
            preserveNullAndEmptyArrays: boolean;
        };
    }>;
    unwindSentTo(): Promise<{
        $unwind: {
            path: string;
            preserveNullAndEmptyArrays: boolean;
        };
    }>;
    lookupChatEmoji(): Promise<{
        $lookup: {
            from: string;
            let: {
                message_id: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $eq: string[];
                    };
                };
                $lookup?: undefined;
                $addFields?: undefined;
                $project?: undefined;
            } | {
                $lookup: {
                    from: string;
                    let: {
                        sent_by: string;
                    };
                    pipeline: ({
                        $match: {
                            $expr: {
                                $in: string[];
                            };
                        };
                        $project?: undefined;
                    } | {
                        $project: {
                            _id: number;
                            name: number;
                            image: number;
                            profile_pic: number;
                        };
                        $match?: undefined;
                    })[];
                    as: string;
                };
                $match?: undefined;
                $addFields?: undefined;
                $project?: undefined;
            } | {
                $addFields: {
                    total_users: {
                        $size: string;
                    };
                };
                $match?: undefined;
                $lookup?: undefined;
                $project?: undefined;
            } | {
                $project: {
                    emoji: number;
                    users: string;
                    total_users: number;
                };
                $match?: undefined;
                $lookup?: undefined;
                $addFields?: undefined;
            })[];
            as: string;
        };
    }>;
    unwindReplyTo(): Promise<{
        $unwind: {
            path: string;
            preserveNullAndEmptyArrays: boolean;
        };
    }>;
    lookupSentTo(): Promise<{
        $lookup: {
            from: string;
            let: {
                sent_to: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $eq: string[];
                    };
                };
                $project?: undefined;
            } | {
                $project: {
                    _id: number;
                    name: number;
                    image: number;
                    profile_pic: number;
                    is_online: number;
                };
                $match?: undefined;
            })[];
            as: string;
        };
    }>;
    lookupReplyTo(): Promise<{
        $lookup: {
            from: string;
            let: {
                reply_to: string;
            };
            pipeline: ({
                $match: {
                    $expr: {
                        $eq: string[];
                    };
                };
                $lookup?: undefined;
                $unwind?: undefined;
            } | {
                $lookup: {
                    from: string;
                    let: {
                        sent_by: string;
                    };
                    pipeline: ({
                        $match: {
                            $expr: {
                                $eq: string[];
                            };
                        };
                        $project?: undefined;
                    } | {
                        $project: {
                            _id: number;
                            name: number;
                            image: number;
                            profile_pic: number;
                        };
                        $match?: undefined;
                    })[];
                    as: string;
                };
                $match?: undefined;
                $unwind?: undefined;
            } | {
                $unwind: {
                    path: string;
                    preserveNullAndEmptyArrays: boolean;
                };
                $match?: undefined;
                $lookup?: undefined;
            })[];
            as: string;
        };
    }>;
    groupDataForMessages(userId: Types.ObjectId): Promise<{
        $group: {
            _id: string;
            connection_id: {
                $first: string;
            };
            sent_by: {
                $first: string;
            };
            sent_to: {
                $first: string;
            };
            type: {
                $first: string;
            };
            message_type: {
                $first: string;
            };
            message: {
                $first: string;
            };
            media_url: {
                $first: string;
            };
            read_by: {
                $first: string;
            };
            deleted_for: {
                $first: string;
            };
            is_deleted: {
                $first: string;
            };
            is_edited: {
                $first: string;
            };
            created_at: {
                $first: string;
            };
            media: {
                $first: string;
            };
            stared_by: {
                $first: string;
            };
            call: {
                $first: string;
            };
            message_status: {
                $first: string;
            };
            delivered_at: {
                $first: string;
            };
            read_at: {
                $first: string;
            };
            reply_to: {
                $first: string;
            };
            isStared: {
                $first: string;
            };
            duration: {
                $first: string;
            };
            message_id: {
                $first: string;
            };
            lat: {
                $first: string;
            };
            product_id: {
                $first: string;
            };
            long: {
                $first: string;
            };
            is_live_location_ended: {
                $first: string;
            };
            live_end_at: {
                $first: string;
            };
            message_emoji: {
                $first: string;
            };
            is_message_pin: {
                $first: {
                    $cond: {
                        if: {
                            $and: ({
                                $ne: (string | null)[];
                                $isArray?: undefined;
                                $gt?: undefined;
                            } | {
                                $isArray: string;
                                $ne?: undefined;
                                $gt?: undefined;
                            } | {
                                $gt: (number | {
                                    $size: string;
                                })[];
                                $ne?: undefined;
                                $isArray?: undefined;
                            } | {
                                $gt: (number | {
                                    $size: {
                                        $filter: {
                                            input: string;
                                            as: string;
                                            cond: {
                                                $eq: (string | Types.ObjectId)[];
                                            };
                                        };
                                    };
                                })[];
                                $ne?: undefined;
                                $isArray?: undefined;
                            })[];
                        };
                        then: boolean;
                        else: boolean;
                    };
                };
            };
        };
    }>;
    facetDataForMessage(skip: number, limit: number): Promise<{
        $facet: {
            count: {
                $count: string;
            }[];
            data: ({
                $sort: {
                    _id: number;
                };
                $skip?: undefined;
                $limit?: undefined;
            } | {
                $skip: number;
                $sort?: undefined;
                $limit?: undefined;
            } | {
                $limit: number;
                $sort?: undefined;
                $skip?: undefined;
            })[];
        };
    }>;
    projectData(): Promise<{
        $project: {
            count: {
                $arrayElemAt: (string | number)[];
            };
            data: number;
        };
    }>;
}