import { CommonService } from 'src/common/common.service';
import { ModelsService } from 'src/models/models.service';
import { chatHistory, CreateConnection, CreateGroupDto, GroupOperationsDto, RequestDto, SendMessageFromPushDto } from './dto/chat.dto';
import { Types } from 'mongoose';
import { ChatAggregations } from './chat.aggregation';
import { chatDisappearing } from './schema/connections.schema';
import { EditMessageDto } from './dto/socket.dto';
import { ChatGateway } from './chat.gateway';
export declare class ChatService {
    private readonly common;
    private readonly model;
    private readonly aggregate;
    private readonly gatewayService;
    private projection;
    private lean_options;
    private new_lean_options;
    private new_options;
    constructor(common: CommonService, model: ModelsService, aggregate: ChatAggregations, gatewayService: ChatGateway);
    checkConnection(sent_by: string, sent_to: string): Promise<any>;
    createConnections(user_id: string, payload: CreateConnection): Promise<{
        count: any;
        data: any;
    }>;
    saveConnetions(sent_by: string, sent_to: string): Promise<any>;
    listChatUsers: (_id: string, search: string, type: string, conn_type: string, pagination?: number, limit?: number) => Promise<{
        count: any;
        data: any;
        total_archived_connections: number;
        total_locked_connections: number;
    }>;
    message_history: (user_id: string, req_query: chatHistory) => Promise<{
        data: any;
    }>;
    message_history_query: (query: any, user_id: any) => Promise<({
        $match: any;
    } | {
        $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;
        };
    } | {
        $unwind: {
            path: string;
            preserveNullAndEmptyArrays: boolean;
        };
    } | {
        $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;
        };
    } | {
        $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;
        };
    } | {
        $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;
        };
    } | {
        $addFields: {
            is_starred: {
                $cond: {
                    if: {
                        $and: ({
                            $isArray: string;
                            $in?: undefined;
                        } | {
                            $in: (string | Types.ObjectId)[];
                            $isArray?: undefined;
                        })[];
                    };
                    then: boolean;
                    else: boolean;
                };
            };
        };
    } | {
        $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;
                    };
                };
            };
        };
    } | {
        $facet: {
            count: {
                $count: string;
            }[];
            data: ({
                $sort: {
                    _id: number;
                };
                $skip?: undefined;
                $limit?: undefined;
            } | {
                $skip: number;
                $sort?: undefined;
                $limit?: undefined;
            } | {
                $limit: number;
                $sort?: undefined;
                $skip?: undefined;
            })[];
        };
    } | {
        $project: {
            count: {
                $arrayElemAt: (string | number)[];
            };
            data: number;
        };
    })[]>;
    messageDetails(message_id: string): Promise<(import("mongoose").FlattenMaps<{
        connection_type: string;
        connection_id: Types.ObjectId;
        sent_by: Types.ObjectId;
        sent_to: Types.ObjectId;
        call_id: Types.ObjectId;
        reply_msg_id: Types.ObjectId;
        type: string;
        message_id: string;
        message_type: string;
        message: string;
        media_url: string;
        duration: {
            toString: (radix?: number) => string;
            toFixed: (fractionDigits?: number) => string;
            toExponential: (fractionDigits?: number) => string;
            toPrecision: (precision?: number) => string;
            valueOf: () => number;
            toLocaleString: {
                (locales?: string | string[], options?: Intl.NumberFormatOptions): string;
                (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
            };
        };
        media: {
            type: string;
            url: string | null;
            thumbnail: string | null;
            caption: string | null;
            duration: number | null;
        }[];
        read_by: {
            user_id: string;
            read_at: number | null;
        }[];
        delivered_to: {
            user_id: string;
            delivered_at: number;
        }[];
        starred_by: Types.ObjectId[];
        call_data: any;
        deleted_for: Types.ObjectId[];
        chat_disappear_by: {
            user_id: Types.ObjectId;
            is_already_disappeared: boolean;
            is_disappeared_msg: boolean;
            msg_disappearing_date: number;
        }[];
        msg_disappearing_date: number;
        is_disappeared_msg: boolean;
        is_already_disappeared: boolean;
        is_deleted: boolean;
        is_edited: boolean;
        message_status: string;
        lat: string;
        long: string;
        is_live_location_ended: boolean;
        live_end_at: number;
        read_at: number;
        chat_pinned_by: {
            user_id: Types.ObjectId;
            pinned_for: string;
            pinned_to: number;
            pinned_at: number;
        }[];
        updated_at: number;
        created_at: number;
    }> & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }) | null>;
    getUser(user_id: string, projection: any): Promise<(import("mongoose").FlattenMaps<import("mongoose").Document<unknown, {}, import("../user/schema/users.schema").Users, {}> & import("../user/schema/users.schema").Users & Required<{
        _id: unknown;
    }> & {
        __v: number;
    }> & Required<{
        _id: import("mongoose").FlattenMaps<unknown>;
    }>) | null>;
    saveSingleMessage(sent_by: string, payload: any, user_connection_id?: string, sent_to_user_id?: string): Promise<any>;
    checkMsgDisAppearing(connection: any, sent_by: string, sent_to: string): Promise<{
        chat_deleted_at: number;
        is_disappeared_msg: boolean;
        message_disapear_by_single_user: any[];
    }>;
    saveMediasMessage(sent_by: string, payload: any, media: any, is_another_user_blocket_me: boolean): Promise<any>;
    saveForwardMessage(connection_id: string, sent_by: any, messageData: any, is_another_user_blocket_me: boolean): Promise<any>;
    checkMuteOrUnmute(connection_id: string, sent_to: string): Promise<boolean>;
    makeMsgResponse(_id: string): Promise<(import("mongoose").Document<unknown, {}, import("./schema/messages.schema").Message, {}> & import("./schema/messages.schema").Message & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    })[]>;
    sendMessageNotification: (sent_to: string, notification_data: any, is_muted: boolean, is_arvhived: boolean) => Promise<void>;
    private sendNormalIOSNotification;
    private sendSilentIOSNotification;
    starred_messages_query: (query: any, user_id: any) => Promise<({
        $match: any;
    } | {
        $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;
        };
    } | {
        $unwind: {
            path: string;
            preserveNullAndEmptyArrays: boolean;
        };
    } | {
        $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;
        };
    } | {
        $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;
        };
    } | {
        $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;
        };
    } | {
        $addFields: {
            is_starred: {
                $cond: {
                    if: {
                        $and: ({
                            $isArray: string;
                            $in?: undefined;
                        } | {
                            $in: (string | Types.ObjectId)[];
                            $isArray?: undefined;
                        })[];
                    };
                    then: boolean;
                    else: boolean;
                };
            };
        };
    } | {
        $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;
                    };
                };
            };
        };
    } | {
        $facet: {
            count: {
                $count: string;
            }[];
            data: ({
                $sort: {
                    _id: number;
                };
                $skip?: undefined;
                $limit?: undefined;
            } | {
                $skip: number;
                $sort?: undefined;
                $limit?: undefined;
            } | {
                $limit: number;
                $sort?: undefined;
                $skip?: undefined;
            })[];
        };
    } | {
        $project: {
            count: {
                $arrayElemAt: (string | number)[];
            };
            data: number;
        };
    })[]>;
    getStarredMessages(connection_id: string, user_id: string): Promise<{
        message: string;
        data: any;
        count: any;
    }>;
    getMediaByConnection(connection_id: string, user_id: string, media_type?: string, pagination?: number, limit?: number): Promise<{
        message: string;
        data: (import("mongoose").FlattenMaps<{
            connection_id: Types.ObjectId;
            message_id: Types.ObjectId;
            sender_id: Types.ObjectId;
            colors: string[];
            type: string;
            media_url: string;
            caption: string;
            duration: {
                toString: (radix?: number) => string;
                toFixed: (fractionDigits?: number) => string;
                toExponential: (fractionDigits?: number) => string;
                toPrecision: (precision?: number) => string;
                valueOf: () => number;
                toLocaleString: {
                    (locales?: string | string[], options?: Intl.NumberFormatOptions): string;
                    (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
                };
            };
            thumbnail: string;
            deleted_for: Types.ObjectId[];
            updated_at: number;
            created_at: number;
        }> & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        })[];
        count: number;
        pagination: {
            page: number;
            limit: number;
        };
    }>;
    muteOrUnmuteConnection(user_id: string, dto: any): Promise<{
        message: any;
    }>;
    saveDisappearingMessage(connection: any, userId: string, otherUserId: string, message: string, deleted_for: Array<Types.ObjectId>): Promise<(import("mongoose").Document<unknown, {}, import("./schema/messages.schema").Message, {}> & import("./schema/messages.schema").Message & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    })[]>;
    starUnstarMessage(connection_id: Types.ObjectId, message_ids: Types.ObjectId[], user_id: string, type: string): Promise<{
        message: string;
    }>;
    createGroup: (req: RequestDto, body: CreateGroupDto) => Promise<{
        message: string;
        data: (import("mongoose").Document<unknown, {}, import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        }, {}> & import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
            _id: Types.ObjectId;
        } & {
            __v: number;
        } & Required<{
            _id: Types.ObjectId;
        }>) | null;
    }>;
    groupDetails: (req: RequestDto, connection_id: string) => Promise<{
        data: {
            memers: (import("mongoose").Document<unknown, {}, import("./schema/group.members.schema").GroupMembers, {}> & import("./schema/group.members.schema").GroupMembers & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            })[];
            _id?: Types.ObjectId | undefined;
            $assertPopulated?: (<Paths = {}>(path: string | string[], values?: Partial<Paths> | undefined) => Omit<import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }, keyof Paths> & Paths) | undefined;
            $clearModifiedPaths?: (() => import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }) | undefined;
            $clone?: (() => import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }) | undefined;
            $createModifiedPathsSnapshot?: (() => import("mongoose").ModifiedPathsSnapshot) | undefined;
            $getAllSubdocs?: (() => import("mongoose").Document[]) | undefined;
            $ignore?: ((path: string) => void) | undefined;
            $isDefault?: ((path: string) => boolean) | undefined;
            $isDeleted?: ((val?: boolean) => boolean) | undefined;
            $getPopulatedDocs?: (() => import("mongoose").Document[]) | undefined;
            $inc?: ((path: string | string[], val?: number) => import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }) | undefined;
            $isEmpty?: ((path: string) => boolean) | undefined;
            $isValid?: ((path: string) => boolean) | undefined;
            $locals?: import("mongoose").FlattenMaps<Record<string, unknown>> | undefined;
            $markValid?: ((path: string) => void) | undefined;
            $model?: {
                <ModelType = import("mongoose").Model<unknown, {}, {}, {}, import("mongoose").Document<unknown, {}, unknown, {}> & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }, any>>(name: string): ModelType;
                <ModelType = import("mongoose").Model<import("./schema/connections.schema").Connection, {}, {}, {}, import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }, any>>(): ModelType;
            } | undefined;
            $op?: "save" | "validate" | "remove" | null | undefined;
            $restoreModifiedPathsSnapshot?: ((snapshot: import("mongoose").ModifiedPathsSnapshot) => import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }) | undefined;
            $session?: ((session?: import("mongoose").ClientSession | null) => import("mongoose").ClientSession | null) | undefined;
            $set?: {
                (path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions): import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
                (path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions): import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
                (value: string | Record<string, any>): import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
            } | undefined;
            $where?: import("mongoose").FlattenMaps<Record<string, unknown>> | undefined;
            baseModelName?: string;
            collection?: import("mongoose").Collection<import("bson").Document> | undefined;
            db?: import("mongoose").FlattenMaps<import("mongoose").Connection> | undefined;
            deleteOne?: ((options?: import("mongoose").QueryOptions) => import("mongoose").Query<import("mongodb").DeleteResult, import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }, {}, import("./schema/connections.schema").Connection, "deleteOne", Record<string, never>>) | undefined;
            depopulate?: (<Paths = {}>(path?: string | string[]) => import("mongoose").MergeType<import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }, Paths>) | undefined;
            directModifiedPaths?: (() => Array<string>) | undefined;
            equals?: ((doc: import("mongoose").Document<unknown, any, any, Record<string, any>>) => boolean) | undefined;
            errors?: import("mongoose").Error.ValidationError;
            get?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path: T, type?: any, options?: any): import("./schema/connections.schema").Connection[T];
                (path: string, type?: any, options?: any): any;
            } | undefined;
            getChanges?: (() => import("mongoose").UpdateQuery<import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }>) | undefined;
            id?: any;
            increment?: (() => import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }) | undefined;
            init?: ((obj: import("mongoose").AnyObject, opts?: import("mongoose").AnyObject) => import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }) | undefined;
            invalidate?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path: T, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
                (path: string, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
            } | undefined;
            isDirectModified?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path: T | T[]): boolean;
                (path: string | Array<string>): boolean;
            } | undefined;
            isDirectSelected?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path: T): boolean;
                (path: string): boolean;
            } | undefined;
            isInit?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path: T): boolean;
                (path: string): boolean;
            } | undefined;
            isModified?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path?: T | T[] | undefined, options?: {
                    ignoreAtomics?: boolean;
                } | null): boolean;
                (path?: string | Array<string>, options?: {
                    ignoreAtomics?: boolean;
                } | null): boolean;
            } | undefined;
            isNew?: boolean | undefined;
            isSelected?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path: T): boolean;
                (path: string): boolean;
            } | undefined;
            markModified?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path: T, scope?: any): void;
                (path: string, scope?: any): void;
            } | undefined;
            model?: {
                <ModelType = import("mongoose").Model<unknown, {}, {}, {}, import("mongoose").Document<unknown, {}, unknown, {}> & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }, any>>(name: string): ModelType;
                <ModelType = import("mongoose").Model<import("./schema/connections.schema").Connection, {}, {}, {}, import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }, any>>(): ModelType;
            } | undefined;
            modifiedPaths?: ((options?: {
                includeChildren?: boolean;
            }) => Array<string>) | undefined;
            overwrite?: ((obj: import("mongoose").AnyObject) => import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }) | undefined;
            $parent?: (() => import("mongoose").Document | undefined) | undefined;
            populate?: {
                <Paths = {}>(path: string | import("mongoose").PopulateOptions | (string | import("mongoose").PopulateOptions)[]): Promise<import("mongoose").MergeType<import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }, Paths>>;
                <Paths = {}>(path: string, select?: string | import("mongoose").AnyObject, model?: import("mongoose").Model<any>, match?: import("mongoose").AnyObject, options?: import("mongoose").PopulateOptions): Promise<import("mongoose").MergeType<import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }, Paths>>;
            } | undefined;
            populated?: ((path: string) => any) | undefined;
            replaceOne?: ((replacement?: import("mongoose").AnyObject, options?: import("mongoose").QueryOptions | null) => import("mongoose").Query<any, import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }, {}, unknown, "find", Record<string, never>>) | undefined;
            save?: ((options?: import("mongoose").SaveOptions) => Promise<import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }>) | undefined;
            schema?: import("mongoose").FlattenMaps<import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
                [x: string]: unknown;
            }, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
                [x: string]: unknown;
            }>, {}> & import("mongoose").FlatRecord<{
                [x: string]: unknown;
            }> & Required<{
                _id: unknown;
            }> & {
                __v: number;
            }>> | undefined;
            set?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path: T, val: import("./schema/connections.schema").Connection[T], type: any, options?: import("mongoose").DocumentSetOptions): import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
                (path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions): import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
                (path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions): import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
                (value: string | Record<string, any>): import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
            } | undefined;
            toJSON?: {
                (options: import("mongoose").ToObjectOptions & {
                    virtuals: true;
                }): import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
                (options?: import("mongoose").ToObjectOptions & {
                    flattenMaps?: true;
                    flattenObjectIds?: false;
                }): import("mongoose").FlattenMaps<import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }>;
                (options: import("mongoose").ToObjectOptions & {
                    flattenObjectIds: false;
                }): import("mongoose").FlattenMaps<import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }>;
                (options: import("mongoose").ToObjectOptions & {
                    flattenObjectIds: true;
                }): {
                    sent_by: string;
                    sent_to: string;
                    group_name: string;
                    group_creator_id: string;
                    group_image_url: string;
                    connection_type: string;
                    connection_locked_by: string[];
                    connection_pinned_by: string[];
                    connection_deleted_by: string[];
                    connection_archived_by: string[];
                    chat_disappear_by: {
                        user_id: string;
                        chat_disappearing: chatDisappearing;
                        chat_disapear_for: string;
                    }[];
                    chat_disappearing: string;
                    connection_muted_by: {
                        user_id: string;
                        time: number;
                        type: "HOUR" | "WEEK" | "ALWAYS" | null;
                    }[];
                    updated_at: number;
                    created_at: number;
                    _id: string;
                    __v: number;
                };
                (options: import("mongoose").ToObjectOptions & {
                    flattenMaps: false;
                }): import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
                (options: import("mongoose").ToObjectOptions & {
                    flattenMaps: false;
                    flattenObjectIds: true;
                }): {
                    sent_by: string;
                    sent_to: string;
                    group_name: string;
                    group_creator_id: string;
                    group_image_url: string;
                    connection_type: string;
                    connection_locked_by: string[];
                    connection_pinned_by: string[];
                    connection_deleted_by: string[];
                    connection_archived_by: string[];
                    chat_disappear_by: {
                        user_id: string;
                        chat_disappearing: chatDisappearing;
                        chat_disapear_for: string;
                    }[];
                    chat_disappearing: string;
                    connection_muted_by: {
                        user_id: string;
                        time: number;
                        type: "HOUR" | "WEEK" | "ALWAYS" | null;
                    }[];
                    updated_at: number;
                    created_at: number;
                    _id: string;
                    __v: number;
                };
                <T = import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }>(options?: import("mongoose").ToObjectOptions & {
                    flattenMaps?: true;
                    flattenObjectIds?: false;
                }): import("mongoose").FlattenMaps<T>;
                <T = import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }>(options: import("mongoose").ToObjectOptions & {
                    flattenObjectIds: false;
                }): import("mongoose").FlattenMaps<T>;
                <T = import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }>(options: import("mongoose").ToObjectOptions & {
                    flattenObjectIds: true;
                }): import("mongoose").ObjectIdToString<import("mongoose").FlattenMaps<T>>;
                <T = import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }>(options: import("mongoose").ToObjectOptions & {
                    flattenMaps: false;
                }): T;
                <T = import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                }>(options: import("mongoose").ToObjectOptions & {
                    flattenMaps: false;
                    flattenObjectIds: true;
                }): import("mongoose").ObjectIdToString<T>;
            } | undefined;
            toObject?: {
                (options: import("mongoose").ToObjectOptions & {
                    virtuals: true;
                }): import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
                (options?: import("mongoose").ToObjectOptions): import("./schema/connections.schema").Connection & {
                    _id: Types.ObjectId;
                } & {
                    __v: number;
                };
                <T>(options?: import("mongoose").ToObjectOptions): import("mongoose").Default__v<import("mongoose").Require_id<T>>;
            } | undefined;
            unmarkModified?: {
                <T extends keyof import("./schema/connections.schema").Connection>(path: T): void;
                (path: string): void;
            } | undefined;
            updateOne?: ((update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }> | undefined, options?: import("mongoose").QueryOptions | null) => import("mongoose").Query<any, import("mongoose").Document<unknown, {}, import("./schema/connections.schema").Connection, {}> & import("./schema/connections.schema").Connection & {
                _id: Types.ObjectId;
            } & {
                __v: number;
            }, {}, unknown, "find", Record<string, never>>) | undefined;
            validate?: {
                <T extends keyof import("./schema/connections.schema").Connection>(pathsToValidate?: T | T[] | undefined, options?: import("mongoose").AnyObject): Promise<void>;
                (pathsToValidate?: import("mongoose").pathsToValidate, options?: import("mongoose").AnyObject): Promise<void>;
                (options: {
                    pathsToSkip?: import("mongoose").pathsToSkip;
                }): Promise<void>;
            } | undefined;
            validateSync?: {
                (options: {
                    pathsToSkip?: import("mongoose").pathsToSkip;
                    [k: string]: any;
                }): import("mongoose").Error.ValidationError | null;
                <T extends keyof import("./schema/connections.schema").Connection>(pathsToValidate?: T | T[] | undefined, options?: import("mongoose").AnyObject): import("mongoose").Error.ValidationError | null;
                (pathsToValidate?: import("mongoose").pathsToValidate, options?: import("mongoose").AnyObject): import("mongoose").Error.ValidationError | null;
            } | undefined;
            sent_by?: Types.ObjectId | undefined;
            sent_to?: Types.ObjectId | undefined;
            group_name?: string | undefined;
            group_creator_id?: Types.ObjectId | undefined;
            group_image_url?: string | undefined;
            connection_type?: string | undefined;
            connection_locked_by?: Types.ObjectId[] | undefined;
            connection_pinned_by?: Types.ObjectId[] | undefined;
            connection_deleted_by?: Types.ObjectId[] | undefined;
            connection_archived_by?: Types.ObjectId[] | undefined;
            chat_disappear_by?: import("mongoose").FlattenMaps<{
                user_id: Types.ObjectId;
                chat_disappearing: chatDisappearing;
                chat_disapear_for: string;
            }>[] | undefined;
            chat_disappearing?: string | undefined;
            connection_muted_by?: import("mongoose").FlattenMaps<{
                user_id: Types.ObjectId;
                time: number;
                type: "HOUR" | "WEEK" | "ALWAYS" | null;
            }>[] | undefined;
            updated_at?: number | undefined;
            created_at?: number | undefined;
            __v?: number | undefined;
        };
    }>;
    connectionDetails: (req: RequestDto, connection_id: string) => Promise<{
        message: string;
        data: {};
    } | {
        data: any;
        message?: undefined;
    }>;
    exitFromGroup: (user_id: string, connection_id: string) => Promise<{
        message: string;
    }>;
    exitFromGroupAndDeleteChatForMe: (user_id: string, connection_id: string) => Promise<{
        message: string;
    }>;
    clearChatForParticularConnections: (user_id: string, connection_id: string) => Promise<{
        message: string;
    }>;
    lockMultipleConnections: (user_id: string, connection_ids: string[]) => Promise<{
        message: string;
    }>;
    unLockMultipleConnections: (user_id: string, connection_ids: string[]) => Promise<{
        message: string;
    }>;
    pinMultipleConnections: (user_id: string, connection_ids: string[]) => Promise<{
        message: string;
        pinned_count?: undefined;
        total_pinned?: undefined;
    } | {
        message: string;
        pinned_count: number;
        total_pinned: number;
    }>;
    unPinMultipleConnections: (user_id: string, connection_ids: string[]) => Promise<{
        message: string;
    }>;
    pinMessage: (user_id: string, connection_id: string, message_id: string) => Promise<{
        message: string;
        pinned: boolean;
        total_pinned?: undefined;
        removed_oldest?: undefined;
    } | {
        message: string;
        pinned: boolean;
        total_pinned: number;
        removed_oldest: boolean;
    }>;
    unpinMessage: (user_id: string, connection_id: string, message_id: string) => Promise<{
        message: string;
        unpinned: boolean;
        total_pinned: number;
    }>;
    getPinnedMessages: (user_id: string, connection_id: string) => Promise<{
        pinned_messages: {
            _id: Types.ObjectId;
            message: string;
            message_type: string;
            media_url: string;
            media: {
                type: string;
                url: string | null;
                thumbnail: string | null;
                caption: string | null;
                duration: number | null;
            }[];
            type: string;
            sent_by: Types.ObjectId;
            created_at: number;
            pinned_at: number;
        }[];
        total_pinned: number;
        max_allowed: number;
    }>;
    archiveMultipleConnections: (user_id: string, connection_ids: string[]) => Promise<{
        message: string;
    }>;
    unArchiveMultipleConnections: (user_id: string, connection_ids: string[]) => Promise<{
        message: string;
    }>;
    deleteMultipleConnections: (user_id: string, connection_ids: string[], is_delete_chat: boolean) => Promise<{
        message: string;
    }>;
    deleteMessageForMe: (user_id: string, message_ids: string[]) => Promise<{
        message: string;
    }>;
    deleteMessageForEveryOne: (user_id: string, message_ids: string[]) => Promise<{
        message: string;
        connection_id: Types.ObjectId;
    }>;
    removeMemberFromGroup: (user_id: string, user_ids: string[], connection_id: string) => Promise<{
        message: string;
    }>;
    addMemberInGroup: (user_id: string, user_ids: string[], connection_id: string) => Promise<{
        message: string;
    }>;
    blockUnBlockUser: (loggerUserId: string, connectionId: string) => Promise<{
        message: string;
    }>;
    groupOperations: (req: RequestDto, body: GroupOperationsDto) => Promise<string | {
        message: string;
        pinned: boolean;
        total_pinned?: undefined;
        removed_oldest?: undefined;
    } | {
        message: string;
        pinned: boolean;
        total_pinned: number;
        removed_oldest: boolean;
    } | {
        message: string;
        unpinned: boolean;
        total_pinned: number;
    }>;
    messageNotifications(title: string, payload: any, from_user: any, connection_id: string, user_id: string, sent_to: string, message: any, fetchConnectionType: any, response_data: any): Promise<void>;
    editMessage(payload: EditMessageDto, user_id: string): Promise<(import("mongoose").Document<unknown, {}, import("./schema/messages.schema").Message, {}> & import("./schema/messages.schema").Message & {
        _id: Types.ObjectId;
    } & {
        __v: number;
    }) | null>;
    handleDisconnect: (token: string, server?: any) => Promise<void>;
    sendMessageWithPush(userId: string, payload: SendMessageFromPushDto): Promise<void>;
    messageDisappearing(): Promise<void>;
}