/**
 * @module BubbleConferences
 */
import { Subscription } from "rxjs";
import { Bubble } from '../../models/bubble.model';
import { BubbleConference, BubbleConferenceJoinParameters, BubbleConferenceMedia, BubbleConferenceVideoQuality, 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 { Service } from "../../services/service";
import type { SpeechEnhancementService } from '../../services/speechEnhancement/speech-enhancement.service';
import { BubbleConferenceRecapParams } from "./bubbleConferenceRecap.service";
import { BubbleConferenceRecap } from "../../models";
/**
 * @internal
 */
export declare const BUBBLE_CONFERENCE_SVC = "BubbleConferenceService";
/**
 * 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 {
    /**
     * Subscribe to updates from the service (all events are of RBEvent type {name: string, data:any});
     * @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;
    /** @internal */
    sendCustomEvent(name: string, data?: any): void;
    /** @internal */
    sendEvent(name: string, data?: any): void;
}
/**
 * @eventProperty
 */
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_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 when ????
     */
    ON_WEBCONFERENCE_STOP_HIGHLIGHTING = "stopHighlighting",
    /**
     * @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"
}
/**
 * @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"
}
/**
 * @internal
 */
export declare class BubbleConferenceServiceRB extends Service 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?;
    speechEnhancementService?: SpeechEnhancementService;
    private rxSubject;
    private innerRxSubject;
    private conferenceRef;
    private xmppJingleListener;
    private makingCall;
    private addingMedia;
    private connected;
    private xmppServiceSubscription;
    private xmppConnectionSubscription;
    private subscriptions;
    private eventServiceSubscriptions;
    private statsIntervals;
    private reconnectionsInProgress;
    private audioProfileChanging;
    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;
    eventSubscribe(handler: any, eventNames?: string | string[]): Subscription;
    sendCustomEvent(name: string, data?: any): void;
    sendEvent(name: string, data?: any): 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>;
    /**
     * 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>;
    sendWebConferenceEvent(name: BubbleConferenceServiceEvents, 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;
    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;
    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;
    private createSessionParticipantFromElem;
    private onXmppJingleMessage;
    private onConferenceMessage;
    attachRemoteAudioStream(webConferenceSession: WebConferenceSession): void;
    private getWebConferenceByJingleSessionId;
    private onJingleUpdateStream;
    private webrtcConfigAndUtilsEvent;
    private onJingleMessage;
    private onJingleSessionInvite;
    private onSessionTerminated;
    private onJingleSessionStats;
    private onJingleVideoQualityChangeEvent;
    private onJingleResubscriptionNeededEvent;
    private onJingleErrorEvent;
    private onConfSessionConnectionStateUpdate;
    /**
     * 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): 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>;
}
//# sourceMappingURL=bubbleConference.service.d.ts.map