@ale-rainbow/web-sdk 5.1.0

package/lib/services/conversation/conversation.service.d.ts

@@ -0,0 +1,723 @@
+/**
+ * @module Conversations
+ */
+import type { Subscription } from "rxjs";
+import { BehaviorSubject } from "rxjs";
+import { CallRB } from "../../models/call.model";
+import { Contact } from "../../models/contact.model";
+import { BubbleRB } from "../../models/bubble.model";
+import type { MessageAdditionalContent, MessageID, Urgency } from "../../models/message.model";
+import { Mention, MentionLegacy, Message, Reaction } from "../../models/message.model";
+import { RBEvent } from "../../models/event.model";
+import type { Conversation, ConversationBookmark } from "../../models/conversation.model";
+import { ConversationMissedInfoCounters, ConversationRB, ConversationStatus } from "../../models/conversation.model";
+import type { FileDescriptor } from "../../models/common/fileDescriptor";
+import { SearchTextConvResults, SearchTextResult } from "../../models/searchTextConvResults.model";
+import type { UrlMetaData } from "../../services/ulrMetadata/urlMetadata.service";
+import { Service } from "../../services/service";
+import { ConversationServiceBulkHistoryHandler } from "../../services/conversation/conversationServiceBulkHistoryHandler";
+import type { Bubble, FileDocument, User } from "../../models";
+import type { XMLElements } from "../../utils/xmlParser";
+/** @internal */
+export declare const CONVERSATION_SVC = "ConversationService";
+export interface ConversationService {
+    /**
+     * Subscribe to updates from the service (all events are of RBEvent);
+     * @param handler - The call-back function that will be subscribed to the RxJS subject
+     * @param eventNames - array of event to listen
+     */
+    subscribe: (handler: (event: RBEvent<ConversationServiceEvents>) => any, eventNames?: ConversationServiceEvents | ConversationServiceEvents[]) => Subscription;
+    /**
+     * Get the array of current conversations
+     */
+    getConversations: () => Conversation[];
+    /**
+     * Get the array of all current call conversations, regardless of type (phone or webrtc)
+     */
+    getCallConversations: () => Conversation[];
+    /**
+     * Async method which get conversation for a bubble, a user or via conversation id.
+     * Conversation is first search in service cache then server side.
+     * @param convRef - a bubble, a user or a conversation id
+     * @param type - the conversation type
+     */
+    getConversation: (convRef: string | User | Bubble | undefined, type?: "contact" | "room") => Promise<Conversation | undefined>;
+    /**
+     * This method remove locally and server side a conversation; Should be used on conversations already created on server and not local ones
+     * @param conversation - the conversation to remove
+     */
+    removeConversation: (conversation: Conversation) => Promise<void>;
+    /**
+     * This async method allow to ack all conversation message
+     * @param conversation - the conversation
+     * @param force - when true force the ack
+     */
+    ackAllMessages: (conversation: Conversation, force?: boolean) => Promise<Conversation>;
+    /**
+     * Method used to search for text in all rooms and conversation. The searched text length should be 3+ characters.
+     * This API will return a list of all conversations / rooms with the number of occurances of the searched text in each one.
+     * If you need to get the results for a given conversation/room only, then use this API: searchForTextInConversation
+     * @param searchedText - the text to be searched in all conversations and rooms
+     * @param limit - the maximum number results to take. Default value is 500;
+     */
+    globalSearch: (searchedText: string, limit: number) => Promise<SearchTextConvResults>;
+}
+export interface SendMessageData {
+    /**
+     * Additional contents (like markdown or vcard) to be added to the message
+     */
+    additionalContents?: MessageAdditionalContent[];
+    /**
+     * In case we want to reply to a given message
+     */
+    repliedMessage?: Message;
+    /**
+     * The list of mentions inside the message
+     */
+    mentions?: (Mention | MentionLegacy)[];
+    /**
+     * The urgency of the message; Allowed values are (standard) 'std', (notify) 'low', (warning) 'middle', (emergency) 'high'; Default value is "std"
+     */
+    urgency?: Urgency;
+    /**
+     * In case of urgency ACK message, the type of the ACK to send; Accepted values are "ack" or "ignore"
+     */
+    urgencyAckType?: "ack" | "ignore";
+    /**
+     * URL Meta data in case of sending URL
+     */
+    urlMetaData?: UrlMetaData;
+}
+export interface SendFileMessageData {
+    /**
+     * The file name to be shown in the conversation
+     */
+    fileName?: string;
+    /**
+     * The File we want to send (in case of upload from local device)
+     */
+    file?: File & {
+        preview?: Blob;
+    };
+    /**
+     * The FileDescriptor (in case of already existing file)
+     * @internal
+     */
+    existingFile?: FileDescriptor;
+    /**
+     * The Document to send ( in case of already existing document)
+     */
+    document?: FileDocument;
+    /**
+     * In case of vocal message
+     */
+    voiceMessageData?: {
+        duration: number;
+    };
+    /**
+     * The urgency of the message; Allowed values are (standard) 'std', (notify) 'low', (warning) 'middle', (emergency) 'high'; Default value is "std"
+     */
+    urgency?: Urgency;
+}
+/**
+ * @eventProperty
+ */
+export declare enum ConversationServiceEvents {
+    /**
+     * @eventProperty
+     * This RBEvent is send when the conversation service is started and ready to be used (also fired after loss of network and reconnection)
+     */
+    ON_SERVICE_STARTED = "ON_SERVICE_STARTED",
+    /**
+     * @eventProperty ON_CONVERSATION_CREATED
+     * @param conversation - the new conversation
+     * This RBEvent is send when a conversation has been created from the user (or from another client)
+     */
+    ON_CONVERSATION_CREATED = "ON_CONVERSATION_CREATED",
+    /**
+     * @eventProperty ON_CONVERSATION_REMOVED
+     * @param conversation - the concerned conversation
+     * This RBEvent is send when a conversation has been removed from the user (or from another client)
+     */
+    ON_CONVERSATION_REMOVED = "ON_CONVERSATION_REMOVED",
+    /**
+     * @eventProperty ON_MESSAGE_ADDED_IN_CONVERSATION
+     * @param conversation - The conversation where the message is being added
+     * This RBEvent is send when a new message is added to a conversation
+     */
+    ON_MESSAGE_ADDED_IN_CONVERSATION = "ON_MESSAGE_ADDED_IN_CONVERSATION",
+    /**
+     * @eventProperty ON_MESSAGE_MODIFIED_IN_CONVERSATION
+     * @param conversation - The conversation where the message is being modified
+     * This RBEvent is send when a message is being modified (or deleted) in the conversation
+     */
+    ON_MESSAGE_MODIFIED_IN_CONVERSATION = "ON_MESSAGE_MODIFIED_IN_CONVERSATION",
+    /**
+     * @eventProperty ON_NEW_CALL_IN_CONVERSATION
+     * @param conversation - The conversation to which the call is attached
+     * This RBEvent is send when a new call is added to the conversation; Could be used to manage the list of all conversations with calls
+     */
+    ON_NEW_CALL_IN_CONVERSATION = "ON_NEW_CALL_IN_CONVERSATION",
+    /**
+     * @eventProperty ON_REMOVE_CALL_IN_CONVERSATION
+     * @param  conversation - The conversation to which the call is removed
+     * This RBEvent is send when a new call is removed from the conversation; Could be used to manage the list of all conversations with calls
+     */
+    ON_REMOVE_CALL_IN_CONVERSATION = "ON_REMOVE_CALL_IN_CONVERSATION",
+    /**
+     * @eventProperty ON_CALL_IN_CONVERSATION_UPDATE
+     * @param conversation - The conversation related to the call (sometimes the converation will be null, as it has been deleted)
+     * @param call - The related call
+     * This RBEvent is send when there's updated in the call inside the conversation; For Telephony calls, the conversation could be null;
+     */
+    ON_CALL_IN_CONVERSATION_UPDATE = "ON_CALL_IN_CONVERSATION_UPDATE",
+    /**
+     * @eventProperty ON_ACTIVE_CALL_CHANGE
+     * @param conversation - [optional] The conversation where the call is now ACTIVE  or RINGING_OUTGOING; COULD BE NULL if no call is active
+     * @param call - [optional] The call hat is now ACTIVE or RINGING_OUTGOING; COULD BE NULL if no call is active (the current call is no longer active)
+     * This RBEvent is send when there's update on the current active call; If no call is currently active, the event will be send with NO CONVERSATION AND NO CALL
+     */
+    ON_ACTIVE_CALL_CHANGE = "ON_ACTIVE_CALL_CHANGE",
+    /**
+     * @eventProperty ON_MESSAGE_REACTION_REFUSED
+     * @param conversation - The conversation holding the message
+     * @param message - The message the reaction was aimed at, already reverted to its previous state
+     * This RBEvent is send when the server refuses a reaction the user just made; the local state has been
+     * rolled back, so the UI only has to tell the user the reaction could not be applied
+     */
+    ON_MESSAGE_REACTION_REFUSED = "ON_MESSAGE_REACTION_REFUSED"
+}
+/**
+ * @internal
+ * Conversation service internal events send to other sevices via sendInnerEvent()
+ * Should not be used by SDK user
+ */
+export declare enum ConversationServiceInnerEvents {
+    /**
+     * @eventProperty RAINBOW_ON_WEBCONF_ADD_HOC_COMPLETED
+     * @param bubble - the bubble related to the conference
+     * This RBEvent is send when adhoc conference starts in a new conversation; It's used to update the active conversation in the UI
+     */
+    RAINBOW_ON_WEBCONF_ADD_HOC_COMPLETED = "RAINBOW_ON_WEBCONF_ADD_HOC_COMPLETED",
+    /**
+     * @eventProperty RAINBOW_ON_REPLACE_CONVERSATIONS_IN_EXTERNAL_POPOUT
+     * @param conversation - the conversation related to the update
+     * @param call - the call related to the update
+     * This RBEvent is send in case of switch of conversation call (hybrid cases) and the external popup should update the UI accordingly
+     */
+    RAINBOW_ON_REPLACE_CONVERSATIONS_IN_EXTERNAL_POPOUT = "RAINBOW_ON_REPLACE_CONVERSATIONS_IN_EXTERNAL_POPOUT",
+    /**
+     * @eventProperty RAINBOW_CONVERSATION_AUTO_ACK_CHECK
+     * @param conversation - the conversation related
+     * @param message - the related message
+     * @param type - We only manage "IM" in case of IM message as the management is different;
+     * @param checkIfChatIsHidden - in case of P2P or CONF cases only
+     * This RBEvent is send in case we need if UCAAS should auto ack received message and decrease the missed counter;
+     */
+    RAINBOW_CONVERSATION_AUTO_ACK_CHECK = "RAINBOW_CONVERSATION_AUTO_ACK_CHECK",
+    /**
+     * @eventProperty RAINBOW_CONVERSATION_CAPABILITIES_UPDATE
+     * @param conversation - the conversation related
+     * This RBEvent is send in case the capabilities for the conversation have changed
+     */
+    RAINBOW_CONVERSATION_CAPABILITIES_UPDATE = "RAINBOW_CONVERSATION_CAPABILITIES_UPDATE",
+    /**
+     * @eventProperty RAINBOW_ORDER_CONVERSATIONS
+     * This RBEvent is send in case the an order conversations
+     */
+    RAINBOW_ORDER_CONVERSATIONS = "RAINBOW_ORDER_CONVERSATIONS"
+}
+/**
+ * A reaction of ours applied locally and still revertible, should the server refuse it.
+ * @internal
+ */
+export interface PendingReaction {
+    conversation: ConversationRB;
+    message: Message;
+    /** The user's emoji list for that message *before* this reaction -- what a rollback restores. */
+    previousEmojis: string;
+    expiryTimer: ReturnType<typeof setTimeout>;
+}
+/** @internal */
+export declare class ConversationServiceRB extends Service implements ConversationService {
+    searchTextConvResults: SearchTextConvResults;
+    conversationServiceBulkHistoryHandler: ConversationServiceBulkHistoryHandler | null;
+    readonly missedInfoCounters: BehaviorSubject<ConversationMissedInfoCounters>;
+    pendingMessages: any;
+    /**
+     * Reactions applied locally but not yet confirmed by the server, keyed by the id of the message they
+     * target. The server rejects a reaction it cannot match with a 404 error stanza; `previousEmojis` is
+     * the state to go back to in that case, so the emoji does not stay on screen for a reaction that does
+     * not exist server-side. Entries expire by themselves -- see `registerPendingReaction`.
+     */
+    pendingReactions: Record<MessageID, PendingReaction>;
+    /** How long a reaction stays revertible. Past this, a late error stanza is ignored. */
+    private static readonly pendingReactionTtlMs;
+    private conversations;
+    private conversationCreationPromise;
+    /**
+     * True while a `searchForTextInConversation` call is in flight.
+     *
+     * Deliberately separate from `searchTextConvResults.isSearching`, which means "a *global* search
+     * is running" and is rendered as such by the conversations sidebar. The two operations hit
+     * different endpoints and own different state, so an in-conversation search must not lock out
+     * `globalSearch` (that is what made a reopened search modal come back empty).
+     */
+    private convSearchInFlight;
+    private readonly rxSubject;
+    private readonly innerRxSubject;
+    private isBasicCallAllowed;
+    private isSecondCallAllowed;
+    private isSecondWebrtcCallAllowed;
+    private isSecondWebrtcCallAllowedHybrid;
+    private manageTwoWebrtcCallsAllowed;
+    private activeCall;
+    private subscriptions;
+    private eventServiceSubscriptionHandlers;
+    private xmppSubscriptionHandlers;
+    private conversationServiceEventHandler;
+    private mainService;
+    private eventService;
+    private authService;
+    private xmppService;
+    private i18n;
+    private logger;
+    private profileService;
+    private contactService;
+    private readonly userServicec;
+    private errorHelperService;
+    private settingsService;
+    private botService;
+    private bubbleService?;
+    private fileStorageService?;
+    private fileServerService?;
+    private webConferenceService?;
+    private webrtcP2PService?;
+    private webinarService?;
+    private telephonyService?;
+    private webrtcGatewayService?;
+    private notificationCenterService?;
+    private reinitTimer;
+    private readonly computeMyCapabilitiesSignal$;
+    private reinitInProgress;
+    private ccdAgentService;
+    private horizonService;
+    private citrixService;
+    /** This static methods returns the conversationService singleton */
+    static getInstance(): ConversationServiceRB;
+    /** This static factory creates the conversationService singleton */
+    static build(): ConversationServiceRB;
+    private constructor();
+    subscribeToInnerEvents(handler: (event: RBEvent<ConversationServiceInnerEvents>) => any): Subscription;
+    sendInnerEvent(name: ConversationServiceInnerEvents, data?: any): void;
+    /** This async method has to be call to start the conversation service */
+    start(): Promise<void>;
+    reconnect(): Promise<void>;
+    private removeHandlers;
+    attachHandlers(): void;
+    /**
+     * This async method has to be call to stop the conversation service
+     */
+    stop(): Promise<void>;
+    subscribe(handler: (event: RBEvent<ConversationServiceEvents>) => any, eventNames?: ConversationServiceEvents | ConversationServiceEvents[]): Subscription;
+    /**
+     * Contact service events send to other services via sendEvent()
+     * Can listen to it via conversationService.subscribe() API
+     * @param name - the name of the event
+     * @param data -the data to be send (an object)
+     */
+    sendEvent(name: ConversationServiceEvents, data?: unknown): void;
+    /**
+     * Allows to send an event (of type RBEvent) via the RX subject of the instance, and to be captured by subscribe
+     * @param rbEvent - event
+     */
+    publish(rbEvent: RBEvent<ConversationServiceEvents, unknown>): void;
+    private promiseRacer;
+    /**
+     * This async method get valid conversations from the server and update the current list of conversations accordingly
+     */
+    private getServerConversationsAndUpdate;
+    /**
+     * This async method permits to create a conversation from server data
+     * @param conversationData - the conversation identifier
+     */
+    private updateConversationFromData;
+    private updateOneToOneConversationInternal;
+    private updateRoomConversationInternal;
+    /**
+     * This async method get valid conversations from the server
+     */
+    private getServerConversations;
+    /**
+     * This async method create a conversation server side
+     * @param conversation - the conversation to create server side
+     */
+    private createServerConversation;
+    /**
+     * This async method delete a conversation server side
+     * @param conversationId - the identifier of the conversation to remove server side
+     */
+    private deleteServerConversation;
+    /**
+     * This async method update a conversation server side
+     * @param conversation - the conversation to update server side
+     */
+    updateServerConversation(conversation: ConversationRB): Promise<ConversationRB>;
+    /**
+     * This async method allow to ack all conversation message
+     * @param conversation - the conversation
+     * @param force - when true force the ack
+     */
+    ackAllMessages(conversation: ConversationRB, force?: boolean): Promise<ConversationRB>;
+    /**
+     * Method to set or replace a conversation bookmark; This API will provoque an update on the conversation object (event of type ConversationEvents.ON_MESSAGE_BOOKMARKED)
+     * @param conversation - the conversation
+     * @param message - the message to bookmark
+     * @internal
+     */
+    setConversationBookmark(conversation: ConversationRB, message: Message): Promise<void>;
+    /**
+     * Method to set or delete a conversation bookmark
+     * @param conversation - the conversation
+     * @internal
+     */
+    deleteConversationBookmark(conversation: ConversationRB): Promise<void>;
+    /**
+     * This async method permits to get a conversation by conversationId
+     * @param jid - the conversation identifier
+     * @param type - the conversation type ('contact' or 'room') (optional)
+     */
+    getOrCreateConversation(jid: string, type?: string): Promise<ConversationRB>;
+    private createConversationFromData;
+    /**
+     * This method create a local conversation object from a call
+     * @param call - the call
+     */
+    getOrCreateTelephonyConversation(call: CallRB): ConversationRB;
+    /**
+     * This method return the pre-existing conversation if any or create a new one
+     * @param conversationId - the conversation identifier
+     * @param conversationDbId - the conversation dbId
+     * @param conversationData - the conversation data received from server
+     */
+    getOrCreateOneToOneConversationInternal(conversationId: string, conversationDbId?: string, conversationData?: ConversationServerData): Promise<ConversationRB>;
+    /**
+     * This method return the new bot conversation
+     * @param conversationId - the conversation identifier
+     * @param conversationDbId - the conversation dbId
+     * @param conversationData - the conversation data received from server
+     */
+    getOrCreateBotConversationInternal(conversationId?: string, conversationDbId?: string, conversationData?: ConversationServerData): Promise<ConversationRB>;
+    /**
+     * This method return the pre existing room converstion if any or create a new one
+     * @param bubbleId - the bubble identifier, the id or the jid
+     * @param conversationDbId - the conversation dbId
+     * @param conversationData - the conversation data received from server
+     * @param standard - if we should get all users inside the room, or only the strict minimum. Default value is TRUE
+     */
+    getRoomConversationInternal(bubbleId: string, createOnServer?: boolean, conversationDbId?: string, conversationData?: ConversationServerData, standard?: boolean): Promise<ConversationRB | undefined>;
+    /**
+     * This method remove locally and server side a conversation; Should be used on conversations already created on server and not local ones;
+     * @param conversation - the conversation to remove
+     */
+    removeConversation(conversation: Conversation): Promise<void>;
+    /**
+     * This method remove locally a conversation but not from the server
+     * @param  conversation - the conversation to remove
+     */
+    removeLocalConversation(conversation: ConversationRB): void;
+    sendMessage(conversation: ConversationRB, messageText?: string, messageData?: SendMessageData): Message | undefined;
+    sendFileMessage(conversation: ConversationRB, messageData: SendFileMessageData): Promise<Message>;
+    forwardMessage(conversation: ConversationRB, destConv: ConversationRB, forwardedMessage: Message, anonymous?: boolean): Promise<Message | undefined>;
+    addReactionToMessage(conversation: ConversationRB, message: Message, emojiReaction?: string): Promise<Message>;
+    removeReactionFromMessage(conversation: ConversationRB, message: Message, emojiReaction?: string): Promise<Message>;
+    /**
+     * Send the reaction stanza carrying the user's full emoji list for that message, and apply it locally.
+     *
+     * The local update is optimistic: the server answers only when it refuses the reaction. It matches the
+     * message on the pair (msg_id, msg_ts), msg_ts being the microsecond timestamp it assigned when it
+     * stored the message -- so `serverTimestampMicros` must be used whenever the server has told us its
+     * value. Deriving it from `message.date` only works when the local clock agrees with the server's to
+     * the millisecond; a skewed browser clock otherwise makes every reaction fail with a 404 item-not-found.
+     */
+    private sendReactionStanza;
+    /**
+     * Remember what to revert to if the server refuses this reaction.
+     *
+     * The entry has to expire on its own. The server only answers when it *refuses* a reaction, it does
+     * not echo an accepted one back in a P2P conversation, and a stanza sent over a dead connection is
+     * dropped silently -- so "no answer" is the normal case and the map would otherwise grow for the
+     * whole session. The delay matches the server-ack timeout used for messages.
+     */
+    private registerPendingReaction;
+    /** Forget a pending reaction and stop its expiry timer. Returns the entry, or null if there was none. */
+    private clearPendingReaction;
+    /**
+     * Undo a reaction the server refused, and forget it. Returns the entry that was rolled back, or null
+     * when that message has no reaction of ours awaiting confirmation.
+     */
+    rollbackPendingReaction(messageId: MessageID): PendingReaction | null;
+    /** Forget a reaction of ours the server has echoed back: it is confirmed, there is nothing to undo. */
+    confirmPendingReaction(messageId: MessageID): void;
+    modifyMessage(conversation: ConversationRB, message: Message, newMessageText?: string, messageData?: SendMessageData): Message;
+    deleteMessage(conversation: ConversationRB, message: Message): void;
+    resendFSMessage(conversation: Conversation, message: Message): Promise<void>;
+    /**
+     * This methods shareFileToViewer
+     * @param conversation - the conversation
+     * @param fileDescriptor - the file descriptor
+     */
+    private shareFileToViewer;
+    private sendXmppMessage;
+    private addXmppForwardMessage;
+    sendAckReadOrReceivedMessage(conversation: ConversationRB, id: string, event: string): void;
+    sendAckReceivedMessage(conversation: ConversationRB, message: Message): void;
+    sendAckReadMessage(conversation: ConversationRB, message: Message): void;
+    sendAckReadMessages(conversation: ConversationRB): boolean;
+    sendChatStatus(conversation: ConversationRB, status: ConversationStatus): void;
+    sendIsTypingState(conversation: ConversationRB, isTypingState: boolean): void;
+    sendRecordingMessage(conversation: ConversationRB, data: string): Message;
+    /**
+     * Notify the remote party of a recording state change (pause/resume) without adding an admin message
+     * in the conversation: only the transient state is carried, the chat history keeps the start/stop entries.
+     * @param conversation - the conversation
+     * @param data - the recording state ("pause" or "resume")
+     */
+    sendRecordingStateMessage(conversation: ConversationRB, data: string): void;
+    /**
+     * removeAllMessages
+     * @param conversation - the conversation
+     */
+    removeAllMessages(conversation: ConversationRB): Promise<void>;
+    /**
+     * This Methods allow to send the text content of a converstion to the connectedUser email address
+     * @param conversation - the conversation
+     */
+    sendConversationByEmail(conversation: ConversationRB): Promise<void>;
+    /**
+     * This async method is used to retreive messages around a specified date (for search mechanism)
+     * @param conversation - the conversation
+     * @param msgDate - the centered date
+     */
+    retrieveMsgByDate(conversation: ConversationRB, msgDate: any, messageId: MessageID): Promise<void>;
+    /**
+     * clear Search result
+     */
+    clearSearchTextResults(): void;
+    globalSearch(searchedText?: string, limit?: number): Promise<SearchTextConvResults>;
+    /**
+     * Method used to search for text in a given conversation P2P or room. The searched text length should be 3+ characters.
+     * This API will return a SearchTextResult that contains the list of IDs of messages to be searched after that
+     * @param conversation - the conversation
+     * @param searchedText - the text to be searched in the given P2P or room conversation
+     * @param limit - number of results to get; Default value is 20;
+     */
+    searchForTextInConversation(conversation: Conversation, searchedText?: string, limit?: number): Promise<SearchTextResult>;
+    /**
+     * Method used to load the messages around a given timestamp. Can be used when we search for a message via API searchForTextInConversation
+     * and then we want to load the message (or also the messages around it); This API will load the messages in the conversation list of messages and resolve once it's done;
+     * @param conversation - the conversation where we want to load messages
+     * @param timestamp - the timestamp of the message to be loaded
+     * @param nbMessages - the number of messages to load before and after this one
+     */
+    loadHistoryMessagesAroundGivenMessage(conversation: ConversationRB, timestamp: number, nbMessages?: number): Promise<void>;
+    getConversation(convRef: string | User | Bubble | undefined, type?: "contact" | "room"): Promise<Conversation | undefined>;
+    getConversations(): Conversation[];
+    getCallConversations(): Conversation[];
+    getConversationFromCache(id: string): ConversationRB | undefined;
+    updateMissedCounters(): void;
+    existAnotherCallForContact(call: CallRB): boolean;
+    isTempTelephonyConversation(call: CallRB): boolean;
+    onCallEvent(call: CallRB, fromWebRtcGW?: boolean): Promise<void>;
+    allowDesktopSharing(): boolean;
+    private areWebrtcCallsWithSameContact;
+    updateCallInConversation(call: CallRB): Promise<void>;
+    updateAllCallsCapabilities(): void;
+    updateCallCapabilities(call: CallRB): Promise<void>;
+    private calculateListOfDestinations;
+    private updateWebrtcCallCapabilities;
+    private updatePhoneCallCapabilities;
+    updateConversationCall(conversation: ConversationRB, call: CallRB): void;
+    resetAudioCall(conversation: ConversationRB): void;
+    computeCapabilitiesForContact(user: User, skipUpdateConversation?: boolean): void;
+    computeCapabilitiesForMyContact(): void;
+    shallowEqual(object1: any, object2: any): boolean;
+    onReloadCapabilitiesForMyContactEvent(): void;
+    onContactChangedEvent(contact: Contact): void;
+    onTelephonyStateChangeEvent(): void;
+    onRoomHistoryChangedEvent(room: BubbleRB): void;
+    onRoomAdminMessageEvent(roomJid: string, userJid: string, type: string, msgId: MessageID, extraParameters: any): void;
+    onMyContactChangedEvent(): void;
+    reinit(): Promise<any>;
+    reinitInternal(delay?: number): Promise<void>;
+    private linkAllActiveCallsToConversations;
+    cleanUnwantedConversations(): void;
+    /**
+     * AddChatMessage
+     * @param conversation - the conversation
+     * @param from - the from contact
+     * @param date - ???
+     * @param data - the message content
+     * @param messageID - the message identifier
+     * @param isSender - ???
+     * @param subject - ???
+     * @param answeredMsgId - ???
+     * @param answeredMsgDate - ???
+     * @param additionalContents - ???
+     * @param mentions - ???
+     * @param urgency - ???
+     * @param isForwarded - ???
+     */
+    addChatMessage(conversation: ConversationRB, from: Contact, date: Date, data: string, messageID: MessageID, isSender: boolean, subject: any, answeredMsgId: any, answeredMsgDate: any, additionalContents: MessageAdditionalContent[], mentions: (Mention | MentionLegacy)[], urgency?: any, isForwarded?: any): Message;
+    /**
+     * addAdminBubbleMessage
+     * @param conversation - the conversation
+     * @param from - the message from contact
+     * @param date - the date of the message
+     * @param type - the type of message
+     * @param messageId - the message identifier
+     * @param translatedMessage -the translatedMessage
+     */
+    addAdminBubbleMessage(conversation: ConversationRB, from: Contact, date: any, type: string, messageId: MessageID, translatedMessage?: any): Message;
+    private addFSMessage;
+    private addForwardChatMessage;
+    addRecordingMessage(conversation: ConversationRB, from: Contact, date: Date, data: any, messageId: MessageID): Message;
+    addFileMessage(conversation: ConversationRB, from: Contact, date: any, data: any, messageID: any, urgency?: Urgency): Message;
+    addFileSharingMessage(conversation: ConversationRB, from: any, date: any, data: any, messageID: any, fileId: any, fileName: any, geoloc: any, urgency: Urgency, isForwarded: boolean): Message;
+    addWebRTCMessage(conversation: ConversationRB, from: Contact, date: any, data: any, messageID: any): Message;
+    addPinMessage(conversation: ConversationRB, from: Contact, date: any, data: any, messageID: any): Message;
+    addShareRecapMessage(conversation: ConversationRB, from: Contact, date: any, data: any, messageID: any, additionalContents?: MessageAdditionalContent[]): Message;
+    addPollMessage(conversation: ConversationRB, from: Contact, date: any, data: any, messageID: any, additionalContents?: MessageAdditionalContent[]): Message;
+    private addMessage;
+    setStatusMessage(conversation: ConversationRB, from: Contact, status: ConversationStatus): void;
+    onCallStatusChange(call: CallRB): void;
+    /**
+     * Process stanza object to extract mentions
+     * @param body - message body to process
+     * @param mentionElem - mention XMPP XML element containing the mentions
+     * @returns
+     */
+    processStanzaMentions(body: string, mentionElem: XMLElements): {
+        body: string;
+        mentions: Mention[];
+    };
+    processStanzaReaction(reactionsElem: XMLElements): Map<string, Reaction>;
+    processStanzaReactionsCount(reactionsCountElem: XMLElements): Map<string, number>;
+    /**
+     * Transform mention strings back to normal string text
+     * @param message - the message object
+     * @param body - the message string
+     */
+    transformMessageToText(body: string): string;
+}
+/**
+ * @internal
+ * This interface describes the data received from server when creating / getting conversation
+ */
+export interface ConversationServerData {
+    /**
+     * The JID IM of the distant party
+     */
+    jid_im?: string;
+    /**
+     * The DB ID of the conversation itself
+     */
+    id?: string;
+    /**
+     *The type of the conversation (user, room, bot)
+     */
+    type?: string;
+    /**
+     * The last message date in string
+     */
+    lastMessageDate?: string;
+    /**
+     * The last msg text in the conversation
+     */
+    lastMessageText?: string;
+    /**
+     * if the conversation is muted
+     */
+    mute?: boolean;
+    /**
+     * The number of not ACK READ read IMs
+     */
+    unreadMessageNumber?: string;
+    /**
+     * The creation date of the conversation in string
+     */
+    creationDate?: string;
+    /**
+     * The JID IM of the user that send the last message
+     */
+    lastMessageSender?: string;
+    /**
+     * In case of call event in the conversation (P2P only)
+     */
+    call?: null | object;
+    /**
+     * If the last message was modified
+     */
+    modified?: boolean;
+    /**
+     * The JID IM of the user that forwarded the messages
+     */
+    forwardFrom?: string;
+    /**
+     * The forwarded message
+     */
+    forwardedMessage?: string;
+    /**
+     * If the user in the conversation has the right to use IM (p2p only)
+     */
+    instantMessagesCustomisation?: string;
+    /**
+     * If the user in the conversation has the right to ACK messages (p2p only)
+     */
+    readReceiptsCustomisation?: string;
+    /**
+     * If the user in the conversation has the right to use screen sharing
+     */
+    useScreenSharingCustomisation?: string;
+    /**
+     * If the user in the conversation has the right to use audio
+     */
+    useWebRTCAudioCustomisation?: string;
+    /**
+     * If the user in the conversation has the right to use video sharing
+     */
+    useWebRTCVideoCustomisation?: string;
+    /**
+     * The filename
+     */
+    filename?: string;
+    /**
+     * If the last messages is geoloc
+     */
+    geoloc?: boolean;
+    /**
+     * The last message content type (for markdown things)
+     */
+    contentType?: string;
+    /**
+     * Bookmark infos for the conversatiokn
+     */
+    bookmark?: ConversationBookmark;
+    /**
+     * The topic (description) of the bubble
+     */
+    topic?: string;
+    /**
+     * The type of the last event (in case of conference started)
+     */
+    eventName?: string;
+    /**
+     * The JID IM of the user related to the event
+     */
+    eventJid?: string;
+    /**
+     * If we can make a call shift for this conversation
+     */
+    callShift?: boolean;
+}
+//# sourceMappingURL=conversation.service.d.ts.map