@ale-rainbow/web-sdk 5.1.0

package/lib/services/conference/bubbleConference.service.d.ts

@@ -0,0 +1,1237 @@
+/**
+ * @module BubbleConferences
+ */
+import type { Subscription } from "rxjs";
+import type { Bubble } from "../../models/bubble.model";
+import type { BubbleConference, BubbleConferenceJoinParameters, BubbleConferenceVideoQuality } from "../../models/webConferenceSession.model";
+import { BubbleConferenceMedia, BubbleConferenceMediaAction, BubbleConferenceStatus, WebConferenceSession } from "../../models/webConferenceSession.model";
+import { BubbleConferenceParticipant } from "../../models/webConferenceParticipant.model";
+import { Contact } from "../../models/contact.model";
+import { WebConferenceHelper } from "./webConferenceHelper";
+import { WebrtcConfigAndUtils } from "../../services/webrtc/webrtcConfigAndUtils";
+import type { EventableService } from "../../services/service";
+import { BubbleConferenceRecapParams } from "./bubbleConferenceRecap.service";
+import type { BubbleConferenceRecap } from "../../models/bubbleConferenceRecap.model";
+import type { WebrtcStatisticsData } from "../../libs/strophe/strophe.jingle.session.stats";
+/**
+ * @internal
+ */
+export declare const BUBBLE_CONFERENCE_SVC = "BubbleConferenceService";
+export interface IBubbleConferenceServiceEvents {
+    ON_CONFERENCE_ENDED: {
+        /** The ended conference session */
+        bubbleConference: WebConferenceSession;
+    };
+    /** @eventProperty Fired when a new recap recording is created. */
+    ON_CONFERENCE_RECAP_CREATED: {
+        /** DB ID of the bubble where the recording was created */
+        roomDbId: string;
+        /** The newly created recap */
+        recap: BubbleConferenceRecap;
+    };
+    /** @eventProperty Fired when a recap recording is ready to be displayed. */
+    ON_CONFERENCE_RECAP_READY: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** The ready recap */
+        recap: BubbleConferenceRecap;
+    };
+    /** @eventProperty Fired when a recap is removed. */
+    ON_CONFERENCE_RECAP_REMOVED: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** The removed recap */
+        recap: BubbleConferenceRecap;
+    };
+    /** @eventProperty Fired when a recap is shared. */
+    ON_CONFERENCE_RECAP_SHARED: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** The shared recap */
+        recap: BubbleConferenceRecap;
+    };
+    /** @eventProperty Fired when the status of the current conference changes. */
+    ON_CONFERENCE_STATUS_UPDATE: {
+        /** The conference session */
+        bubbleConference: WebConferenceSession;
+        /** New status — "connecting" | "connected" | "reconnecting" | "onhold" | "ended" */
+        status: BubbleConferenceStatus;
+        /** Recording config, present only when conference started with record */
+        recordConfig?: {
+            params: BubbleConferenceRecapParams;
+            saveConfig: boolean;
+        };
+    };
+    /** @eventProperty @internal Fired when the participant list is modified (participant added or removed). */
+    ON_WEBCONFERENCE_PARTICIPANT_LIST_UPDATE: {
+        /** DB ID of the bubble related to the conference */
+        roomDbId: string;
+    };
+    /** @eventProperty @internal Fired when a new participant is added to the conference. */
+    ON_WEBCONFERENCE_PARTICIPANT_ADD: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** DB ID of the added participant (the phone number for a PSTN participant) */
+        participantId: string;
+        /** SIP Call-ID of the call that brought the participant in, when the server provides it */
+        callId?: string;
+    };
+    /** @eventProperty @internal Fired when a participant is removed from the conference. */
+    ON_WEBCONFERENCE_PARTICIPANT_REMOVE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** DB ID of the removed participant */
+        participantId: string;
+    };
+    /** @eventProperty @internal Fired when a new video or sharing media is available in the conference. */
+    ON_WEBCONFERENCE_PUBLISHER_ADD: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+    };
+    /** @eventProperty @internal Fired when a video or sharing media is removed from the conference. */
+    ON_WEBCONFERENCE_PUBLISHER_REMOVE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+    };
+    /** @eventProperty @internal Fired when the lock state of the conference changes. */
+    ON_WEBCONFERENCE_LOCKSTATE_UPDATE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** Whether the conference is now locked */
+        isLock: boolean;
+        /** DB ID of the user that locked/unlocked the conference */
+        lockedById: string;
+    };
+    /** @eventProperty @internal Fired when the local user is asked to unmute by a remote party. */
+    ON_WEBCONFERENCE_UNMUTE_DEMAND_RECEIVED: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** DB ID of the user that requested unmute */
+        askedBy: string;
+    };
+    /** @eventProperty @internal Fired when a local media (video or sharing) is added or removed. */
+    ON_WEBCONFERENCE_LOCALMEDIA_UPDATE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** Type of media updated — video | sharing */
+        mediaType: BubbleConferenceMedia;
+        /** Whether the media was added or removed */
+        action: BubbleConferenceMediaAction;
+    };
+    /** @eventProperty @internal Fired when the local participant is updated (mute, delegation, etc.). */
+    ON_WEBCONFERENCE_LOCAL_PARTICIPANT_UPDATE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+    };
+    /** @eventProperty @internal Fired when a remote media session is subscribed (video, sharing, mozaic, or dynamic feed). */
+    ON_WEBCONFERENCE_REMOTEMEDIA_UPDATE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** Type of media — video | sharing | mozaic | dynamicFeed */
+        mediaType: BubbleConferenceMedia;
+        /** Whether the media was added, removed, or put on hold */
+        action: BubbleConferenceMediaAction;
+    };
+    /** @eventProperty @internal Fired when a participant is updated (mute, role, raise-hand, delegation…). */
+    ON_WEBCONFERENCE_PARTICIPANT_UPDATE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** DB ID of the specific participant that was updated (when applicable) */
+        participantId?: string;
+        /** Type of update (e.g. "askToUnmute", "raise-hand", "lower-hand") */
+        action?: string;
+        /** The updated participant object (for hand events) */
+        participant?: BubbleConferenceParticipant;
+    };
+    /** @eventProperty @internal Fired when the active talker changes. */
+    ON_WEBCONFERENCE_TALKER_UPDATE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+    };
+    /** @eventProperty @internal Fired when the conference is delegated (ownership transferred). */
+    ON_WEBCONFERENCE_DELEGATE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** DB ID of the new conference owner */
+        userDbId: string;
+        /** True if the previous owner was the local user */
+        gaveOwnership: boolean;
+    };
+    /** @eventProperty @internal Fired when a conference service state changes (Grid49, etc.). */
+    ON_WEBCONFERENCE_SERVICE_UPDATE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+    };
+    /** @eventProperty @internal Fired when a conference starts in a bubble (not started by the local user). */
+    ON_WEBCONFERENCE_STARTED_EVENT_IN_BUBBLE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+    };
+    /** @eventProperty @internal Fired to instruct the UI to stop the current call-area highlight animation. No payload. */
+    ON_WEBCONFERENCE_STOP_HIGHLIGHTING: unknown;
+    /** @eventProperty @internal Fired when echo-test statistics are available. */
+    ON_WEBCONFERENCE_ECHOTEST_STATS_UPDATE: {
+        /** DB ID of the bubble */
+        roomDbId: string;
+        /** WebRTC statistics snapshot */
+        stats: WebrtcStatisticsData;
+    };
+    /** @eventProperty @internal Fired when a Jingle session is fully established and media is flowing. */
+    ON_SESSION_ESTABLISHED: {
+        /** SID of the established JingleSession */
+        sessionId: string;
+    };
+    /** @eventProperty @internal Fired to instruct the UI to start highlighting the sharing participant. No payload. */
+    ON_WEBCONFERENCE_START_HIGHLIGHTING: unknown;
+    /** @eventProperty @internal Fired when getUserMedia fails, prompting the caller to join without audio. No payload. */
+    ON_JOIN_WITHOUT_AUDIO: unknown;
+    /** @eventProperty Fired when a conference has started in a bubble. */
+    ON_CONFERENCE_STARTED: {
+        /** The started conference session */
+        bubbleConference: WebConferenceSession;
+    };
+    /**
+     * @eventProperty @internal This RB event is fired when the local sharing is aborted because another participant
+     * started sharing while the local user was still selecting the screen to share
+     */
+    ON_WEBCONFERENCE_SHARING_CONFLICT: {
+        /** DB ID of the bubble related to the web conference */
+        roomDbId: string;
+    };
+}
+/**
+ * This service manages web conferences in Rainbow (web conferences that take place in bubbles).
+ * Any Rainbow user in the bubble can take part of the conference (the maximum number of participants is based on the licence of the organiser of the conference)
+ * In each conference, there's only one "organizer" (the user that has started the conference), but every administrator in the bubble is allowed to make additional actions on all other participants (like drop, mute, etc)
+ * Only the organizer of the conference can stop the conference, or delegate it to another user.
+ *
+ * By default, the web conference service is going to use a web conference helper service that will manage
+ * an automatic subscription to all available videos, the management of the dynamic feed.
+ * This service configuration can be managed by setHelperServiceConfiguration API
+ *
+ * NB !! The CPU and bandwidth consumption should/can be managed via additionnal APIs that can be used so that the application is adapted;
+ * As all incoming videos are available in 3 sublayers (high HD, medium VGA and low QVGA) the user can change the sublayer he wants to receive from the server (managed by the Method updateParticipant)
+ * In addition, some session can be put on hold / unhold so that the user can "pause" all incoming videos that are not needed at the moment (managed by putRemoteVideoSessionOnHold)
+ */
+export interface BubbleConferenceService extends EventableService<IBubbleConferenceServiceEvents> {
+    /**
+     * Subscribe to updates from the service (all events are of RBEvent type {name: string, data:any});
+     * @deprecated Use `events()` instead, which returns a typed RxJS Observable.
+     * @example
+     * ```typescript
+     * service.events('ON_CONFERENCE_STARTED').subscribe(event => {
+     *   console.log(event.data.bubbleConference);
+     * });
+     * ```
+     *
+     * @param handler - The call-back function that will be subscribed to the RxJS subject
+     * @param eventNames - array of event to listen
+     * @returns Returns RxJS Subscription
+     */
+    subscribe: (handler: any, eventNames?: string | string[]) => Subscription;
+    /**
+     * Create a web conference in the given bubble
+     * @param bubble - The bubble associated with this conference
+     */
+    startConference: (bubble: Bubble) => Promise<BubbleConference>;
+    /**
+     * Get bubble web conference if exists
+     * @param bubble - The bubble associated with this conference
+     */
+    getConference: (bubble: Bubble) => BubbleConference | undefined;
+    /**
+     * API used to update the bubble conferences configuration
+     * @param disableDynamicFeed - If true, this will disable the subscription mecanisme for the dynamic feed
+     * In case the subscription is already done, this will not effect the current session;
+     * NB The default value is FALSE for all conferences (i.e. by default, dynamic feed is activated)
+     * @param disableAutoSubscriptions - If true, this will disable the auto subscription mecanisme for all incoming publishers (except sharing)
+     * In case the subscription is already done, this will not effect the current session;
+     * NB The default value is FALSE for all conferences (i.e. by default, subscription is done for all publsihers)
+     */
+    setBubbleConferencesConfiguration: (disableDynamicFeed: boolean, disableAutoSubscriptions: boolean) => void;
+    /**
+     * Add media (video or sharing) to an existing web conference
+     * @internal
+     * @param webConference - the WebConference object where we want to add the media
+     * @param mediaType - the type of the media to be added. Accepted values are 'video' or 'sharing';
+     * @param existingStream - if we want to use an already existing stream
+     * @param getAudioForSharing - if we want to add audio from system to sharing
+     */
+    addMediaToWebConference: (webConference: BubbleConference, mediaType: BubbleConferenceMedia, existingStream?: MediaStream, getAudioForSharing?: boolean) => Promise<void>;
+    /**
+     * Remove Media from the current web conference. It could be either 'video' or 'sharing'
+     * @internal
+     * @param webConference - The Web conference
+     * @param mediaType - the media to be removed 'video' or 'sharing'
+     */
+    removeMediaFromWebConference: (webConference: BubbleConference, mediaType: BubbleConferenceMedia) => void;
+    /**
+     *  Update a conference participant (ourself, or any other participant if the user is a moderator of the conference)
+     * @internal
+     * @param webConference -The Web Conference
+     * @param participantId -ID of participant to update
+     * @param option -update data ( could be on of: mute, unmute, hold, retrieve, plug, unplug, update);
+     * With 'update' option we can :
+     * - Update media bandwidth as publisher. Two parameters must be present: media and bitRate
+     * - Update substream level as subscriber. One parameter must be present: subStreamLevel. Parameter publisherId is optional.
+     * @param media - type of media to be updated (video/sharing)
+     * @param bitRate - the max bitrate to be set (0 is unlimited)
+     * @param subStreamLevel - set new sub-stream level. Only available for publishers and in simulcast mode (0 - low, 1 - medium, 2 - high)
+     * @param publisherId - the publisher id related to the update
+     * @returns a promise that resolve when particpant state is updated
+     */
+    updateParticipant: (webConference: BubbleConference, participantId: string, option: string, media?: string, bitRate?: string, subStreamLevel?: string, publisherId?: string) => Promise<void>;
+    /**
+     * Method askToAddSharingToWebConferenceSession
+     * Used only on desktop application : choose which screen to share
+     * FIX SIGNATURE
+     * @internal
+     */
+    askToAddSharingToWebConferenceSession: (conversation: any, conferenceSession: any, shouldAskForAudio?: boolean) => void;
+    /**
+     * Returns WebConferenceSession if the user has an active web conference session (that he has joined)
+     * @returns {WebConferenceSession} Returns WebConferenceSession or null instead
+     * @internal
+     * FIX SIGNATURE
+     */
+    getActiveWebConferenceSession: () => WebConferenceSession | null;
+    /**
+     * Returns WebConferenceSession if the user has an unjoined web conference session owned by the user identified by displayname
+     * @returns {WebConferenceSession} Returns WebConferenceSession or null instead
+     * @internal
+     * FIX SIGNATURE
+     */
+    getUnjoinedWebConferenceSessionByOwnerName: (name: string) => Promise<WebConferenceSession | null>;
+    /**
+     * Decline incoming invitation to join a web conference. This API will send update to all other connected devices to the user to notify;
+     * @param bubble - The bubble to decline the web conference invitation
+     * @internal
+     * Returns on API call success
+     */
+    declineInvitationToJoinConference: (bubble: Bubble) => Promise<void>;
+    /**
+     * Removes a user from the web conference in the given bubble; This API can be used by
+     * the moderators of the bubble to remove other participants too
+     * @param webConferenceSession - The current web conference session
+     * @param participantId - The participant ID that should be removed from the conference
+     * @internal
+     * @returns  Return promise
+     */
+    disconnectUserFromWebConference: (webConferenceSession: WebConferenceSession, participantId: string) => Promise<void>;
+    /**
+     * Add audio to an existing web conference session (ONLY IN CASE THE JOIN IS DONE VIA NOAUDIO OPTION)
+     * @param webConferenceSession - the WebConferenceSession object where we want to add the media
+     * @internal
+     */
+    addAudioToWebConferenceSession: (webConferenceSession: WebConferenceSession) => void;
+    /**
+     * API used to update the conference parameters (can be used by the conference moderator)
+     * @param webConferenceSession - The Web Conference session
+     * @param option - could be one of:
+     * - mute  (Mutes all participants, except requester.)
+     * - unmute (Unmutes all participants)
+     * - lock (Disables any future participant from joining conference)
+     * - unlock (Unlocks the conference)
+     * @returns a promise that resolve when conference parameters are updated
+     * @internal
+     */
+    updateConferenceParameters: (webConferenceSession: WebConferenceSession, option: string) => Promise<void>;
+    /**
+     * Method used to stop the echo test
+     * @param roomDbId - the DB Id of the room where we want to get the stats
+     * @internal
+     */
+    getConferenceTalkingTimeStats: (roomDbId: string) => Promise<any>;
+    /**
+     * Raise your hand in the concerned Conference
+     * @param session - The conference session where the user is going to lower their hand
+     * @returns Returns WebConferenceSession object that is related to the web conference session in that bubble
+     * @internal
+     */
+    raiseHand: (session: WebConferenceSession) => Promise<WebConferenceSession>;
+    /** @internal */
+    putActiveConferenceOnHold: (call?: any) => any;
+    /** @internal */
+    retrieveConferenceOnHold: () => any;
+    /**
+     * Method used to remove all incoming video sessions; Also the dynamic feed / active talker video is removed
+     * @param webConferenceSession - The Web conference participant
+     * @returns returns when it's done
+     * @internal
+     */
+    removeAllRemoteVideoSessions: (webConferenceSession: WebConferenceSession) => void;
+    /**
+     * Method used to start the echo test
+     * @internal
+     */
+    startMediaEchoTest: () => Promise<void>;
+    /**
+     * Method used to stop the echo test
+     * @internal
+     */
+    stopMediaEchoTest: () => Promise<void>;
+    /**
+     * Method used to start a pilot test conference.
+     * @returns the identifyer of the bubble used for the test
+     * @internal
+     */
+    startMediaEchoTestV2: () => Promise<string>;
+    /** @internal */
+    hasActiveWebConferenceSession: () => boolean;
+    /** @internal */
+    waitWebConferenceConnection: (session: BubbleConference) => Promise<void>;
+    /**
+     * Lower your hand in the concerned conference (you can also lower the hand of someone else if you are a Bubble Organizer)
+     * @param session - The conference session where the user is going to lower their hand
+     * @param user - The user lowering their hand
+     * @returns Returns WebConferenceSession object that is related to the web conference session in that bubble
+     * @internal
+     */
+    lowerHand: (session: WebConferenceSession, user: BubbleConferenceParticipant) => Promise<WebConferenceSession>;
+    /**
+     * Get all conference recaps that belong to the connected user
+     */
+    getRecaps: (bubble?: Bubble) => Promise<BubbleConferenceRecap[]>;
+    /**
+     * Get conference recaps shared with the connected user
+     */
+    getSharedWithMeRecaps: (bubble?: Bubble) => Promise<BubbleConferenceRecap[]>;
+    /** @internal */
+    sendInnerEvent: (name: string, data?: any) => void;
+    /** @internal */
+    subscribeToInnerEvents: (handler: any) => Subscription;
+}
+/**
+ * @deprecated Use {@link BubbleConferenceServiceRB.events} directly instead, which returns a typed RxJS Observable.
+ */
+export declare enum BubbleConferenceServiceEvents {
+    /**
+     * @eventProperty ON_CONFERENCE_STARTED
+     * This RB event is fired when a conference has started in a bubble
+     *
+     * **Event Data**
+     * - **bubbleConference** : The newly started webConference
+     */
+    ON_CONFERENCE_STARTED = "ON_CONFERENCE_STARTED",
+    /**
+     * @eventProperty ON_CONFERENCE_ENDED
+     * This event is send when the conference in the given bubble is no longer active. This event is received after the owner has
+     * stopped the conference (it could also be us)
+     *
+     * **Event Data**
+     * - **bubbleConference** : The webConference
+     */
+    ON_CONFERENCE_ENDED = "ON_CONFERENCE_ENDED",
+    /**
+     * @eventProperty ON_CONFERENCE_RECAP_CREATED
+     * @internal
+     * This RB event is fired when a new recap recording is created
+     */
+    ON_CONFERENCE_RECAP_CREATED = "ON_CONFERENCE_RECAP_CREATED",
+    /**
+     * @eventProperty ON_CONFERENCE_RECAP_READY
+     * @internal
+     * This RB event is fired when a new recap recording is ready to be displayed
+     */
+    ON_CONFERENCE_RECAP_READY = "ON_CONFERENCE_RECAP_READY",
+    /**
+     * @eventProperty ON_CONFERENCE_RECAP_REMOVED
+     * @internal
+     * This RB event is fired when a new recap is removed
+     */
+    ON_CONFERENCE_RECAP_REMOVED = "ON_CONFERENCE_RECAP_REMOVED",
+    /**
+     * @eventProperty ON_CONFERENCE_RECAP_SHARED
+     * @internal
+     * This RB event is fired when a recap is shared
+     */
+    ON_CONFERENCE_RECAP_SHARED = "ON_CONFERENCE_RECAP_SHARED",
+    /**
+     * @eventProperty ON_CONFERENCE_STATUS_UPDATE
+     * This RB event is send when the status of the current conference has changed.
+     *
+     * **Event Data**
+     * - **bubbleConference** : The DB ID of the bubble related to the bubble conference
+     * - **status** : The new status for the web conference;It could be "connecting", "connected", "reconnecting", "onhold", "ended"s
+     */
+    ON_CONFERENCE_STATUS_UPDATE = "ON_CONFERENCE_STATUS_UPDATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_PARTICIPANT_LIST_UPDATE
+     * @internal
+     * This RB event is when there's a modification in the list of the participants (participants are added or removed)
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     */
+    ON_WEBCONFERENCE_PARTICIPANT_LIST_UPDATE = "ON_WEBCONFERENCE_PARTICIPANT_LIST_UPDATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_PARTICIPANT_ADD
+     * @internal
+     * This RB event is when there's a new participant that has been added in the participant list / conference
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     * - **participantId** : The DB ID of the participant that is added in the conference
+     */
+    ON_WEBCONFERENCE_PARTICIPANT_ADD = "ON_WEBCONFERENCE_PARTICIPANT_ADD",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_PARTICIPANT_REMOVE
+     * @internal
+     * This RB event is when there's a participant that has been removed in the participant list / conference
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     * - **participantId** : The DB ID of the participant that have been removed from the conference
+     */
+    ON_WEBCONFERENCE_PARTICIPANT_REMOVE = "ON_WEBCONFERENCE_PARTICIPANT_REMOVE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_PUBLISHER_ADD
+     * @internal
+     * This RB event is when there's a new video or sharing media available in the conference.
+     * This could be in the list of the participants (participants have now video available)
+     * Or this could be an update on the sharing session (added)
+     * This event is also fired when the current user adds sharing or video
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     */
+    ON_WEBCONFERENCE_PUBLISHER_ADD = "ON_WEBCONFERENCE_PUBLISHER_ADD",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_PUBLISHER_REMOVE
+     * @internal
+     * This RB event is when there's a video or sharing media removed from the conference.
+     * This could be in the list of the participants (participants have no longer video available)
+     * Or this could be an update on the sharing session (removed)
+     * This event is also fired when the current user removes sharing or video
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     */
+    ON_WEBCONFERENCE_PUBLISHER_REMOVE = "ON_WEBCONFERENCE_PUBLISHER_REMOVE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_LOCKSTATE_UPDATE
+     * @internal
+     * This RB event is when there's an update in the lock state of the conference
+     * If a conference is locked, no other user can join it (the JOIN is rejected)
+     * Conference can be locked or unlocked by any moderator of the bubble / room
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     * - **isLock** : Boolean indicating whether the conference is locked
+     * - **lockedById** : The DB ID of the user that locked / unlocked the conference
+     */
+    ON_WEBCONFERENCE_LOCKSTATE_UPDATE = "ON_WEBCONFERENCE_LOCKSTATE_UPDATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_UNMUTE_DEMAND_RECEIVED
+     * @internal
+     * This RB event is received when we're asked to unmute ourselves from a distant party;
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     * - **askedBy** : The DB ID of the user that asked ourselves to be unmuted
+     */
+    ON_WEBCONFERENCE_UNMUTE_DEMAND_RECEIVED = "ON_WEBCONFERENCE_UNMUTE_DEMAND_RECEIVED",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_SHARING_CONFLICT
+     * @internal
+     * This RB event is fired when the local sharing is aborted because another participant
+     * started sharing while the local user was still selecting the screen to share
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     */
+    ON_WEBCONFERENCE_SHARING_CONFLICT = "ON_WEBCONFERENCE_SHARING_CONFLICT",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_LOCALMEDIA_UPDATE
+     * @internal
+     * This RB event is when there's an update in the local medias.
+     * It could be when we add media (video or sharing)
+     * It could be when we remove media (video or sharing)
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     * - **mediaType** : The type of media that is updated : 'video' or 'sharing'
+     * - **action** : Could be 'added' or 'removed'
+     */
+    ON_WEBCONFERENCE_LOCALMEDIA_UPDATE = "ON_WEBCONFERENCE_LOCALMEDIA_UPDATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_LOCAL_PARTICIPANT_UPDATE
+     * @internal
+     * This RB event is send when the local participant is updated (mute, delegation, etc)
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     */
+    ON_WEBCONFERENCE_LOCAL_PARTICIPANT_UPDATE = "ON_WEBCONFERENCE_LOCAL_PARTICIPANT_UPDATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_REMOTEMEDIA_UPDATE
+     * @internal
+     * This RB event is when there's an update in the remote media sessions
+     * It could be when another user adds media (video or sharing)
+     * The media type is 'mozaic' in case the session is related to the Large Grid service (49 videos at once), available via WebConferenceSession.gridServiceSubscription
+     * It could be when another user removes media (video or sharing)
+     * NB Not the same thing as ON_WEBCONFERENCE_PUBLISHER_ADD, as this event indicates
+     * that there's a publisher available, but the ON_WEBCONFERENCE_REMOTEMEDIA_UPDATE is fired
+     * when we actually subscribe to a remote media (either sharing or video) and the media can be played
+     * by using attachVideoSessionToHtmlElement API
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     * - **mediaType** : The type of media that is updated : 'video' or 'sharing' or 'mozaic' (the large grid of 49 videos) or 'dynamicFeed' (The active talker video)
+     * - **action** : Could be 'added' or 'removed' or 'hold'
+     */
+    ON_WEBCONFERENCE_REMOTEMEDIA_UPDATE = "ON_WEBCONFERENCE_REMOTEMEDIA_UPDATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_PARTICIPANT_UPDATE
+     * @internal
+     * This RB event is when there's an update in one of the participants
+     * It could be when a user is muted/unmuted
+     * It could be when the role or the delegation capability has changed
+     * It could be when the user microphone capability has changed
+     * It could be when the distant user is asked to be unmuted. In that case, participant ID and action "askToUnmute" will be sent to the event
+     * It could be when a user raises/lowers their hand. In that case, participant ID and action "raise-hand" or "lower-hand" will be sent to the event
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     */
+    ON_WEBCONFERENCE_PARTICIPANT_UPDATE = "ON_WEBCONFERENCE_PARTICIPANT_UPDATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_TALKER_UPDATE
+     * @internal
+     * This RB event is when there's an update in the talker participant
+     * It could be when a user starts speaking
+     * It could be when the current speaker changes
+     * It could be when the last speaker stops speaking (noone is speaking)
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     */
+    ON_WEBCONFERENCE_TALKER_UPDATE = "ON_WEBCONFERENCE_TALKER_UPDATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_DELEGATE
+     * @internal
+     * This RB event is fired when the conference is delegated, i.e. the owner of the conference has changed
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     * - **userDbId** : The DB ID of the user that is the new owner
+     * - **gaveOwnership** : If true it means that the last owner of the conference was the "myself"
+     */
+    ON_WEBCONFERENCE_DELEGATE = "ON_WEBCONFERENCE_DELEGATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_SERVICE_UPDATE
+     * @internal
+     * This RB event is when there's an update in the "conference services"
+     * It's used for other services like Grid 49, etc
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble related to the web conference
+     */
+    ON_WEBCONFERENCE_SERVICE_UPDATE = "ON_WEBCONFERENCE_SERVICE_UPDATE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_STARTED_EVENT_IN_BUBBLE
+     * @internal
+     * This RB event is fired when a conference has started in a bubble/room (not by user itself)
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble where the web conference has started
+     */
+    ON_WEBCONFERENCE_STARTED_EVENT_IN_BUBBLE = "ON_WEBCONFERENCE_STARTED_EVENT_IN_BUBBLE",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_STOP_HIGHLIGHTING
+     * @internal
+     * This RB event is fired to instruct the UI to stop the current call-area highlight animation.
+     */
+    ON_WEBCONFERENCE_STOP_HIGHLIGHTING = "ON_WEBCONFERENCE_STOP_HIGHLIGHTING",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_START_HIGHLIGHTING
+     * @internal
+     * This RB event is fired to instruct the UI to start highlighting the sharing participant.
+     */
+    ON_WEBCONFERENCE_START_HIGHLIGHTING = "ON_WEBCONFERENCE_START_HIGHLIGHTING",
+    /**
+     * @eventProperty ON_JOIN_WITHOUT_AUDIO
+     * @internal
+     * Fired when getUserMedia fails, prompting the caller to join without audio.
+     */
+    ON_JOIN_WITHOUT_AUDIO = "ON_JOIN_WITHOUT_AUDIO",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_ECHOTEST_STATS_UPDATE
+     * @internal
+     * This RB event is fired when an echo test conference generates stats
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble where the web conference has started
+     * - **stats** : The WebrtcStatisticsData received
+     */
+    ON_WEBCONFERENCE_ECHOTEST_STATS_UPDATE = "ON_WEBCONFERENCE_ECHOTEST_STATS_UPDATE",
+    /**
+    * @eventProperty ON_SESSION_ESTABLISHED
+    * This event SHOULD NOT BE HERE AT ALL !!!!
+    *
+    * * **Event Data**
+    * - **sessionId**: the id of the session that is part of the bubble conference that is now ACTIVE and flow is coming;
+    * This event is mostly used to attach the session on the HTML audio / video tag as we know that now the flow is active.
+    */
+    ON_SESSION_ESTABLISHED = "ON_SESSION_ESTABLISHED"
+}
+/**
+ * @internal
+ */
+export declare enum WebConferenceServiceInnerEvents {
+    /**
+     * @eventProperty ON_WEBCONFERENCE_HIDE_INVITATION
+     * This event is send when we the user has either joined the conference in that bubble, or rejected the incoming call, or joined with other device
+     * It's used so that we need to hide the incoming call for these additional cases; For end of conference, check also ON_CONFERENCE_ENDED
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble
+     */
+    ON_WEBCONFERENCE_HIDE_INVITATION = "ON_WEBCONFERENCE_HIDE_INVITATION",
+    /**
+     * @eventProperty ON_WEBCONFERENCE_SHOW_INVITATION
+     * This event is send when we need to show an invitation to join the bubble conf
+     *
+     * **Event Data**
+     * - **roomDbId** : The DB ID of the bubble
+     */
+    ON_WEBCONFERENCE_SHOW_INVITATION = "ON_WEBCONFERENCE_SHOW_INVITATION",
+    /**
+     * @eventProperty ON_CONFERENCE_UPDATE_SUPERVISION_STATE
+     * This RB event is send when our participation in a conference is updated and we need to send a supervision state change to our ressources
+     */
+    ON_CONFERENCE_UPDATE_SUPERVISION_STATE = "ON_CONFERENCE_UPDATE_SUPERVISION_STATE"
+}
+declare const BubbleConferenceServiceRB_base: object & (abstract new (...args: any[]) => import("../../services/service").EventsMixinTemplate<IBubbleConferenceServiceEvents>);
+/**
+ * @internal
+ */
+export declare class BubbleConferenceServiceRB extends BubbleConferenceServiceRB_base implements BubbleConferenceService {
+    webConferenceSessions: Record<string, WebConferenceSession>;
+    webConferenceHelper: WebConferenceHelper;
+    webrtcConfigAndUtils: WebrtcConfigAndUtils;
+    private logger;
+    private authService;
+    private errorHelperService;
+    private contactService;
+    private xmppService;
+    private profileService;
+    private mainService;
+    private eventService;
+    private settingsService;
+    private deviceManagementService;
+    private virtualBackgroundService?;
+    private bubbleConferenceRecapService?;
+    private innerRxSubject;
+    private conferenceRef;
+    private xmppJingleListener;
+    private makingCall;
+    /**
+     * In-flight conference REST requests (start/join), keyed by bubble dbId. Lets us abort a request whose
+     * outcome nobody wants any more -- the user cancelled, stopped or left the conference -- so that it cannot
+     * settle minutes later and tear down whatever conference is running by then (CRRAINB-54760).
+     */
+    private pendingConferenceRequests;
+    private addingMedia;
+    private connected;
+    private xmppServiceSubscription;
+    private xmppConnectionSubscription;
+    private subscriptions;
+    private eventServiceSubscriptions;
+    private statsIntervals;
+    private reconnectionsInProgress;
+    private audioProfileChanging;
+    private videoProfileChanging;
+    private promiseInProgress;
+    private nameSpaceJingle;
+    private promiseQueue;
+    private raiseHandTemp;
+    adhocConferenceStarting: boolean;
+    static getInstance(): BubbleConferenceServiceRB;
+    static build(): BubbleConferenceServiceRB;
+    private constructor();
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private attachXmppHandlers;
+    subscribe(handler: any, eventNames?: string | string[]): Subscription;
+    /**
+     * Subscribe to all events from the service (internal + public).
+     * @deprecated Use `events()` instead.
+     * @example
+     * ```typescript
+     * service.events('ON_WEBCONFERENCE_LOCALMEDIA_UPDATE').subscribe(event => {
+     *   console.log(event.data.roomDbId, event.data.mediaType, event.data.action);
+     * });
+     * ```
+     */
+    eventSubscribe(handler: any, eventNames?: string | string[]): Subscription;
+    sendEvent<const EventName extends keyof IBubbleConferenceServiceEvents & string>(eventName: EventName, data: IBubbleConferenceServiceEvents[EventName]): void;
+    /**
+     * Subscribe to inner events for the web conference sessions (all events are of RBEvent type {name: string, data:any});
+     * Most of the events are not documentated, and they're usually not to be used by external app;
+     * @param handler - The call-back function that will be subscribed to the RxJS subject
+     * @returns Returns RxJS Subscription
+     */
+    subscribeToInnerEvents(handler: any): Subscription;
+    sendInnerEvent(name: string, data?: any): void;
+    startConference(bubble: Bubble): Promise<BubbleConference>;
+    getConference(bubble: Bubble): BubbleConference | undefined;
+    /**
+     * Start a web conference in the given bubble
+     * @param bubble - The bubble where the user is going to start the conference
+     * @param recordConfig - Allows to start recording immediately when the conference begins with the specified params.
+     * @returns Returns WebConference object that is related to the web conference session in that bubble
+     */
+    startWebConference(bubble: Bubble, recordConfig?: {
+        params: BubbleConferenceRecapParams;
+        saveConfig: boolean;
+    }): Promise<BubbleConference>;
+    /**
+     * Start a web conference in the given bubble with the audio being available on the deskphone
+     * @param bubble - The bubble where the user is going to start the conference
+     * @returns Returns WebConference object that is related to the web conference session in that bubble
+     */
+    startWebConferenceByPhone(bubble: Bubble): Promise<BubbleConference>;
+    /**
+     * Stop a web conference in the given bubble
+     * @param bubble - The bubble where the user wants to end the conference
+     */
+    stopWebConference(bubble: Bubble): Promise<void>;
+    /**
+     * Joins a web conference in the given bubble
+     * @param bubble - The bubble where the user wants to join a conference (there should be an active conference in the bubble)
+     * @param joinParams - The join conference parameters
+     * @returns  Returns WebConferenceSession object that is related to the web conference session in that bubble
+     */
+    joinWebConference(bubble: Bubble, joinParams?: BubbleConferenceJoinParameters): Promise<BubbleConference>;
+    /**
+     * Joins a web conference in the given bubble by his deskphone (only for RB Hub users); The user will also join the bubble in "no audio mode"
+     * @param bubble - The bubble where the user wants to join a conference (there should be an active conference in the bubble)
+     * @returns Returns WebConference object that is related to the web conference session in that bubble.
+     */
+    joinWebConferenceByPhone(bubble: Bubble): Promise<BubbleConference>;
+    /**
+     * Joins a web conference for media echo test
+     * @param bubble - The bubble where the user wants to join a conference (there should be an active conference in the bubble)
+     * @param joinParams - The join conference parameters
+     * @returns  Returns WebConferenceSession object that is related to the web conference session in that bubble
+     */
+    joinEchoTestWebConference(bubble: Bubble, joinParams?: BubbleConferenceJoinParameters): Promise<BubbleConference>;
+    /**
+     * Removes me from the current conference. A "shortcut" for API disconnectUserFromWebConference
+     * @param webConference - The current web conference
+     */
+    leaveWebConference(webConference: BubbleConference): Promise<void>;
+    /**
+     * SDK-level recording-consent gate. Throws when the conference requires explicit
+     * recording consent and the local participant has not given it. This is defense-in-depth on top
+     * of the app's own UI-level consent popup: it also protects CPaaS/SDK integrations that call the
+     * SDK directly without going through Rainbow's own UI (and therefore never show that popup).
+     * Also fires BubbleConferenceEvents.ON_RECORDING_CONSENT_REQUIRED on the session first, so a
+     * subscriber can react without needing to catch the rejection specifically.
+     * Callers must catch/reject on this -- it never resolves silently.
+     */
+    private assertRecordingConsentGiven;
+    /**
+     * Add media (video or sharing) to an existing web conference
+     * @param webConference - the WebConference object where we want to add the media
+     * @param mediaType - the type of the media to be added. Accepted values are 'video' or 'sharing';
+     * @param existingStream - if we want to use an already existing stream
+     * @param getAudioForSharing - if we want to add audio from system to sharing
+     */
+    addMediaToWebConference(webConference: BubbleConference, mediaType: BubbleConferenceMedia, existingStream?: MediaStream, getAudioForSharing?: boolean): Promise<void>;
+    /**
+     * Remove Media from the current web conference. It could be either 'video' or 'sharing'
+     * @param webConference - The Web conference
+     * @param mediaType - the media to be removed 'video' or 'sharing'
+     */
+    removeMediaFromWebConference(webConference: BubbleConference, mediaType: BubbleConferenceMedia): void;
+    /**
+     *  Update a conference participant (ourself, or any other participant if the user is a moderator of the conference)
+     * @param webConference -The Web Conference
+     * @param participantId -ID of particpant to update
+     * @param option -update data ( could be on of: mute, unmute, hold, retrieve, plug, unplug, update);
+     * With 'update' option we can :
+     * - Update media bandwidth as publisher. Two parameters must be present: media and bitRate
+     * - Update substream level as subscriber. One parameter must be present: subStreamLevel. Parameter publisherId is optional.
+     * @param media - type of media to be updated (video/sharing)
+     * @param bitRate - the max bitrate to be set (0 is unlimited)
+     * @param subStreamLevel - set new sub-stream level. Only available for publishers and in simulcast mode (0 - low, 1 - medium, 2 - high)
+     * @param publisherId - the publisher id related to the update
+     * @returns a promise that resolve when particpant state is updated
+     */
+    updateParticipant(webConference: BubbleConference, participantId: string, option: string, media?: string, bitRate?: string, subStreamLevel?: any, publisherId?: any): Promise<void>;
+    /**
+     * Mute or unmute the local participant's own audio locally only (client-side), without notifying the server or other participants.
+     * Used in stage mode so a participant can silence themselves without leaving the stage.
+     * @param webConference - the web conference session
+     * @param option - "mute" or "unmute"
+     */
+    localMuteParticipant(webConference: BubbleConference, option: "mute" | "unmute"): void;
+    sendWebConferenceEvent(name: keyof IBubbleConferenceServiceEvents, bubble: Bubble): void;
+    /**
+     * Attach the video session to a given HTML <video> tag element (by id)
+     * @param videoElementId - the ID of the HTML video tag element
+     * @param videoSession - the videoSession object that is inside the WebConferenceParticipant object
+     */
+    attachVideoSessionToHtmlElement(videoElementId: string, videoSession: any): void;
+    /**
+     * Detach all stream from an HTML <video> tag element (by id)
+     * @param videoElementId - the ID of the HTML video tag element
+     */
+    detachMediaToHtmlElement(videoElementId: string): void;
+    /**
+     * Get the owner contact for the webConference session
+     * @param webConferenceSession - the ID of the HTML video tag element (should be found by document.getElementById)
+     * @returns the Contact that is the "owner" / leader of the web conference
+     */
+    getConferenceLeaderContact(webConferenceSession: WebConferenceSession): Contact;
+    /**
+     * API used to update the bubble conferences configuration
+     * @param disableDynamicFeed - If true, the webConferenceHelper will disable the subscription mecanisme for the dynamic feed
+     * In case the subscription is already done, this will not effect the current session;
+     * NB The default value is FALSE for all conferences (i.e. by default, dynamic feed is activated)
+     * @param disableAutoSubscriptions - If true, the webConferenceHelper will disable the auto subscription mecanisme for all incoming publishers (except sharing)
+     * In case the subscription is already done, this will not effect the current session;
+     * NB The default value is FALSE for all conferences (i.e. by default, subscription is done for all publsihers)
+     */
+    setBubbleConferencesConfiguration(disableDynamicFeed?: boolean, disableAutoSubscriptions?: boolean): void;
+    private attachHandlers;
+    /**
+     * Get the web conference session by it's ID
+     * @param id - The ID of the web conference session (i.e. also equal to the DB ID of the room)
+     * @returns Returns the WebConferenceSession (or null otherwise)
+     */
+    getWebConferenceSessionById(id?: string): WebConferenceSession | undefined;
+    /**
+     * Returns true if the user is currenty participating in any web conference
+     * @returns Returns true if the user is currenty participating in any web conference
+     */
+    hasActiveWebConferenceSession(): boolean;
+    /**
+     * Returns WebConferenceSession if the user has an active web conference session (that he has joined)
+     * @returns Returns WebConferenceSession or null instead
+     */
+    getActiveWebConferenceSession(): WebConferenceSession | null;
+    /**
+     * CRRAINB-54746: names compared here come from two different worlds -- raw server values
+     * (bubble name, contact data) and values rebuilt by the client (Contact.computeDisplayName()
+     * upper-cases the first letter). Normalize both sides before comparing so the match does not
+     * depend on casing or on stray surrounding spaces.
+     */
+    private normalizeNameForComparison;
+    /**
+     * RQRAINB-14771: RED users can opt in (general settings) to the beta conference infrastructure.
+     * The profile is re-checked here so a stale localStorage value never sends the flag.
+     */
+    private isBetaConferenceActivated;
+    getUnjoinedWebConferenceSessionByOwnerName(name: string): Promise<WebConferenceSession | null>;
+    putActiveConferenceOnHold(call?: any): void;
+    retrieveConferenceOnHold(): void;
+    /**
+     * Joins a web conference in no audio mode. Only video & sharing sessions are available
+     * @param bubble - The bubble where the user wants to join a conference (there should be an active conference in the bubble)
+     * @param audioOnDeskphone - If true, the user has already joined with audio on the deskphone, so dont set the noAudio flag
+     * @returns Returns WebConferenceSession object that is related to the web conference session in that bubble
+     */
+    private joinWebConferenceWithoutAudio;
+    private manageCodecs;
+    /**
+     * API that tells if the user can use the addPSTNParticipantToConference with external phone numbers, or only to call rainbow users
+     * @returns Returns TRUE if user can add participantPhoneNumbers to the conference
+     */
+    canAddPSTNParticipantToWebConference(): boolean;
+    /**
+     * Add (call) rainbow users or PSTN participants in the conference
+     * @param webConferenceSession - The web conference where we want to add the participants
+     * @param participantPhoneNumbers - The phone numbers to be added to the conference
+     * @param userIds - the rainbow user Ids to be added to the conference
+     */
+    addPSTNParticipantToWebConference(webConferenceSession: WebConferenceSession, participantPhoneNumbers: string[], userIds: string[]): Promise<void>;
+    /**
+     * Decline incoming invitation to join a web conference. This API will send update to all other connected devices to the user to notify;
+     * @param bubble - The bubble to decline the web conference invitation
+     * @returns Returns on API call success
+     */
+    declineInvitationToJoinConference(bubble: Bubble): Promise<void>;
+    /**
+     * Add audio to an existing web conference session (ONLY IN CASE THE JOIN IS DONE VIA NOAUDIO OPTION)
+     * @param webConferenceSession - the WebConferenceSession object where we want to add the media
+     */
+    addAudioToWebConferenceSession(webConferenceSession: WebConferenceSession): Promise<void>;
+    private applyConstraintsToSharingStream;
+    /**
+     * Removes a PSTN user from the web conference in the given bubble; This API can be used by
+     * the moderators of the bubble to remove other participants too
+     * @param webConferenceSession - The current web conference session
+     * @param participantId - The participant ID that should be removed from the conference
+     */
+    private disconnectPstnParticipantFromWebConference;
+    private innerDisconnectUserFromWebConference;
+    /**
+     * Removes a user from the web conference in the given bubble; This API can be used by
+     * the moderators of the bubble to remove other participants too
+     * @param webConferenceSession - The current web conference session
+     * @param participantId - The participant ID that should be removed from the conference
+     */
+    disconnectUserFromWebConference(webConferenceSession: WebConferenceSession, participantId: string): Promise<void>;
+    /**
+     * API used to subscribe to the dynamic feed (if not done already)
+     * @param webConferenceSession - The Web Conference session
+     */
+    subscribeToDynamicFeed(webConferenceSession: WebConferenceSession): Promise<void>;
+    /**
+     * Subscribe to a conference service (like the grid 49 / mozaic)
+     * @param webConferenceSession - The Web Conference session
+     * @param serviceId - The serviceId to who we want to subscribe
+     */
+    subscribeToService(webConferenceSession: WebConferenceSession, serviceId: string): Promise<void>;
+    /**
+     * Subscribe to an echo test service
+     * @param webConferenceSession - The Web Conference session
+     * @param serviceId - The serviceId to who we want to subscribe
+     */
+    subscribeToEchoTestService(webConferenceSession: WebConferenceSession, serviceId: string): Promise<void>;
+    /**
+     * Subscribe to a video of a participant
+     * @param webConferenceSession - The Web Conference session
+     * @param participant - The WebConferenceParticipant to who we want to subscribe
+     * @param media - The type of media you want to subscribe to: video or sharing
+     */
+    subscribeToParticipantVideo(webConferenceSession: WebConferenceSession, participant: BubbleConferenceParticipant, media?: string): Promise<void>;
+    /**
+     * Method updatePstnParticipant
+     * @param webConferenceSession - The Web Conference session
+     * @param participantId - ID of particpant to update
+     * @param option - update data (could be on of: mute, unmute);
+     */
+    private updatePstnParticipant;
+    /**
+     * API used to update the conference parameters (can be used by the conference moderator)
+     * @param webConferenceSession - The Web Conference session
+     * @param option - could be one of:
+     * - mute  (Mutes all participants, except requester.)
+     * - unmute (Unmutes all participants)
+     * - lock (Disables any future participant from joining conference)
+     * - unlock (Unlocks the conference)
+     */
+    updateConferenceParameters(webConferenceSession: WebConferenceSession, option: string): Promise<void>;
+    /**
+     * Method used to delegate the conference to another participant
+     * @param webConferenceSession - The Web conference session
+     * @param participantId - the ID of the participant to whom we will delegate the conference
+     */
+    delegateConferenceToParticipant(webConferenceSession: WebConferenceSession, participantId: string): Promise<void>;
+    /**
+     * Method used to stop the echo test
+     * @param roomDbId - the DB Id of the room where we want to get the stats
+     */
+    getConferenceTalkingTimeStats(roomDbId: string): Promise<any>;
+    /**
+     * Method used to start the echo test
+     */
+    startMediaEchoTest(): Promise<any>;
+    /**
+     * Method used to stop the echo test
+     */
+    stopMediaEchoTest(): Promise<void>;
+    /**
+     * Method used to initiates a conference for pilot test.
+     * https://git.openrainbow.org/cloud-services/webrtc-documentation/-/blob/main/chapters/pilot_test.md
+     * @returns Identifyer of the bubble used for test
+     */
+    startMediaEchoTestV2(): Promise<string>;
+    /**
+     * Transfer P2P call to Conference
+     * @param oldSession - Jingle session object related to the P2P session
+     * @param jingleJid - The jid of the Janus server where we want to join
+     * @param bubble - The bubble where the adhoc is done
+     * @param myConference - Is this my conference (initiator of the conf adhoc)
+     * @param shouldMute - Whether the user should mute after join in the conference
+     */
+    transferP2pCallToConference(oldSession: any, jingleJid: string, bubble: Bubble, myConference?: boolean, shouldMute?: boolean): Promise<void>;
+    /**
+     * Method used to put all current incoming video sessions on hold
+     * @param webConferenceSession - The Web conference session
+     */
+    putAllRemoteVideoSessionsOnHold(webConferenceSession: WebConferenceSession): void;
+    /**
+     * Method used to put the video session of the participant on hold; Cannot be done on sharing session !
+     * @param participant - The Web conference participant
+     */
+    putRemoteVideoSessionOnHold(participant: BubbleConferenceParticipant): Promise<void>;
+    /**
+     * Method used to unhold the remote video session for participant; Cannot be done on sharing session !
+     * @param participant - The Web conference participant
+     */
+    putRemoteVideoSessionOnUnhold(participant: BubbleConferenceParticipant): Promise<void>;
+    /**
+     * Method used to remove all incoming video sessions; Also the dynamic feed / active talker video is removed
+     * @param webConferenceSession - The Web conference participant
+     */
+    removeAllRemoteVideoSessions(webConferenceSession: WebConferenceSession): void;
+    private onVideoInputDeviceChange;
+    private onAudioInputDeviceChange;
+    private onReplaceBackgroundChangeEvent;
+    /**
+     * Method askToAddSharingToWebConferenceSession
+     * Used only on desktop application : choose which screen to share
+     */
+    askToAddSharingToWebConferenceSession(conversation: any, conferenceSession: any, shouldAskForAudio?: boolean): void;
+    /**
+     * Method getUserMediaForSession
+     * @param dbId - the ID of the web conference session
+     */
+    private getUserMediaForSession;
+    /**
+     * Shown only when the microphone hasn't answered within {@link GET_USER_MEDIA_TIMEOUT_MS} (e.g. a flaky
+     * USB/Bluetooth device stuck reconnecting) -- lets the user decide instead of the join silently hanging.
+     * @returns "noMic" if the user agrees to join without audio, "cancelled" if they decline
+     */
+    private confirmJoinWithoutMicrophone;
+    private disableMediaStream;
+    private getSilentStream;
+    /**
+     * Method initCall
+     * @param jid - the JID of the distant party to make call
+     * @param dbId - the ID of the web conference session
+     * @param callId - unique call ID for this session
+     * @param forceTurn - a flag whether we should go only through TURN servers or not
+     */
+    private initJingleCall;
+    /**
+     * Creates a new entry for metrics on the server related to this session
+     * @param webConfId - the id of the conference
+     * @param sessionId - the session id related to the conference
+     */
+    private createStatisticsForSession;
+    /**
+     * Updates the metrics for the given session which is part of the conference
+     * @param webConferenceSession - the WebConferenceSession
+     * @param sessionId - the session id related to the conference
+     */
+    private updateStatisticsForSession;
+    /**
+     * Called when the conference is delegated to another user
+     * @param webConfId - the webConfId
+     * @param userId - the userId that is now the owner of the conference
+     */
+    onConferenceDelegated(webConfId: string, userId: string): void;
+    /**
+     * Make snapshot to room and get the conference session info related to that room
+     * Data received from Server
+     * data	Object
+                active	Boolean  -- Is there an active conference?
+                participants	Object[]
+                    userId  optional	String
+                    phoneNumber optional	String
+                    participantRole optional	String (moderator, member, guest)
+                total optional	Number
+                limit   optional	Number	(Default value: 100)
+                offset  optional	Number
+     * @param roomDbId - The Web conference session
+     */
+    private makeSnapshotByRoomDbId;
+    private createSessionParticipantFromSnapshotData;
+    private updateWebConferenceFromSnapshotData;
+    private disableAllLocalStreamsForSession;
+    private removeActiveConferenceSession;
+    private resetBusyStateIfNeeded;
+    /**
+     * Registers a new in-flight conference request (start/join) for the given room and returns its abort
+     * controller. Any request still pending for that room is abandoned first: only the latest attempt is
+     * allowed to act on its own outcome.
+     */
+    private beginConferenceRequest;
+    /**
+     * Abandons the conference request still in flight for the given room, if any. Called from every path that
+     * gives up on joining or ends the conference, so that a start/join request left hanging by the network
+     * cannot outlive the intent that triggered it.
+     */
+    private abortPendingConferenceRequest;
+    /**
+     * True when the rejection is our own abort (see abortPendingConferenceRequest) rather than an actual
+     * failure. Such a rejection must stay silent: no error popup and no teardown, since whoever aborted the
+     * request has already cleaned up.
+     */
+    private isAbortedConferenceRequest;
+    /**
+     * True when the session this call was working on is no longer the one registered for the room -- the user
+     * gave up and started/joined again in the meantime. A late failure must then be reported to its own caller
+     * but must not touch the session that took its place (CRRAINB-54760).
+     */
+    private isStaleConferenceSession;
+    private createSessionParticipantFromElem;
+    private onXmppJingleMessage;
+    private onConferenceMessage;
+    attachRemoteAudioStream(webConferenceSession: WebConferenceSession): void;
+    private getWebConferenceByJingleSessionId;
+    private onJingleUpdateStream;
+    private webrtcConfigAndUtilsEvent;
+    private onJingleMessage;
+    private answerPexipSession;
+    private removePexipMedia;
+    private addVideoPexip;
+    private onJingleSessionInvite;
+    private onSessionTerminated;
+    private onJingleSessionStats;
+    private onJingleVideoQualityChangeEvent;
+    private onJingleErrorEvent;
+    private onConfSessionReconnectNeeded;
+    private onConfSessionConnected;
+    /**
+     * Reconnects all the audio / video / sharing jingle sessions related to the active conference session (if any)
+     */
+    private reconnectActiveConferenceSession;
+    /**
+     * This event occurs when the ICE connection for a given webrtc session goes to "FAILED" state
+     * @param webConferenceSession - the conference session impacted
+     * @param session - the jingle session
+     */
+    private onIceConnectionFailedForSession;
+    /**
+     * This event occurs when the ICE connection for a given webrtc session goes to "disconnected" stat
+     * @param webConference - the conference session impacted
+     * @param session - the jingle session
+     */
+    private onIceConnectionDisconnectedForSession;
+    /**
+     * This event occurs when the ICE connection for a given webrtc session goes to "disconnected" state
+     * @param webConferenceSession - the web conference session impacted
+     * @param session - the jingle session to reconnect
+     * @param timeout - the timeout in ms to wait before doing any action. Default value is 1000ms
+     */
+    private sendTransportReplaceForSession;
+    /**
+     * This method is used to check the current state of the conference and update the local conference
+     * @param webConferenceSession - the web conference session impacted
+     */
+    private updateWebConferenceAfterReconnection;
+    dropAudio(): Promise<void>;
+    waitWebConferenceConnection(session: BubbleConference): Promise<void>;
+    /**
+     * Raise your hand in the concerned Conference
+     * @param webConferenceSession - The conference session where the user is going to lower their hand
+     */
+    raiseHand(webConferenceSession: WebConferenceSession): Promise<WebConferenceSession>;
+    /**
+     * Lower your hand in the concerned conference (you can also lower the hand of someone else if you are a Bubble Organizer)
+     * @param webConferenceSession - The conference session where the user is going to lower their hand
+     * @param user - The user lowering their hand
+     */
+    lowerHand(webConferenceSession: WebConferenceSession, user: BubbleConferenceParticipant): Promise<WebConferenceSession>;
+    /**
+     * Get all conference recaps that belong to the connected user
+     */
+    getRecaps(bubble?: Bubble, forceUpdate?: boolean): Promise<BubbleConferenceRecap[]>;
+    /**
+     * Get conference recaps shared with the connected user
+     */
+    getSharedWithMeRecaps(bubble?: Bubble): Promise<BubbleConferenceRecap[]>;
+    disableIncomingSharing(webConferenceSession: WebConferenceSession, disable: boolean): void;
+    updateVideoQualityForPublisher(conferenceId: string, quality: BubbleConferenceVideoQuality, publisher?: BubbleConferenceParticipant): Promise<void>;
+    startLiveTranscription(webConference: WebConferenceSession, translationLanguage?: string): Promise<void>;
+    stopLiveTranscription(webConference: WebConferenceSession): Promise<void>;
+}
+export {};
+//# sourceMappingURL=bubbleConference.service.d.ts.map