/**
 * @module BubbleConferences
 */
import { JingleSession } from '../libs/strophe/strophe.jingle.session';
import { Bubble, BubbleRB } from '../models/bubble.model';
import { BubbleConferenceParticipant } from '../models/webConferenceParticipant.model';
import { Subscription } from 'rxjs';
import { RBEvent } from './event.model';
import { BubbleConferenceRecapParams } from '../services/conference/bubbleConferenceRecap.service';
import { DataChannel } from './dataChannel.model';
/**
 * BubbleConference public events
 * @eventProperty
 */
export declare enum BubbleConferenceEvents {
    /**
    * @eventProperty
    * This RBEvent is fired when the bubbleConference status is updated
    */
    ON_STATUS_CHANGE = "ON_STATUS_CHANGE",
    /**
    * @eventProperty
    * This RBEvent is triggered when the mute status of a conference participant (including the connectedUser) changes.
    */
    ON_PARTICIPANT_MUTE_CHANGE = "ON_PARTICIPANT_MUTE_CHANGE",
    /**
     * @eventProperty
     * This RB event is fired when there's a modification in the list of the participants (participants are added or removed)
     */
    ON_PARTICIPANT_LIST_CHANGE = "ON_PARTICIPANT_LIST_CHANGE",
    /**
     * @eventProperty
     * This RB event is fired when there's a modification in the participants raisehand status
     */
    ON_PARTICIPANT_RAISEHAND_CHANGE = "ON_PARTICIPANT_RAISEHAND_CHANGE",
    /**
     * @eventProperty
     * This RB event is fired when there's a modification in the connected user local media
     */
    ON_LOCAL_PARTICIPANT_MEDIA_CHANGE = "ON_LOCAL_PARTICIPANT_MEDIA_CHANGE",
    /**
     * @eventProperty
     * This RB event is fired when there's a modification on remote participant media
     */
    ON_REMOTE_MEDIA_CHANGE = "ON_REMOTE_MEDIAS_CHANGE",
    /**
     * @eventProperty
     * This RBEvent is send when a liveTranscription is ready and activated
     */
    ON_LIVE_TRANSCRIPTION_ACTIVATED = "ON_LIVE_TRANSCRIPTION_ACTIVATED",
    /**
     * @eventProperty
     * This RBEvent is send when a liveTranscription is updated
     * - the list of active languages has changed
     * - the liveTranscriptionUsedBySomeone has changed
     */
    ON_LIVE_TRANSCRIPTION_UPDATE = "ON_LIVE_TRANSCRIPTION_UPDATE",
    /**
     * @eventProperty
     * This RBEvent is send when a liveTranscription is being started
     */
    ON_LIVE_TRANSCRIPTION_ACTIVATING = "ON_LIVE_TRANSCRIPTION_ACTIVATING",
    /**
     * @eventProperty
     * This RBEvent is send when a liveTranscription is stopped
     */
    ON_LIVE_TRANSCRIPTION_STOPPED = "ON_LIVE_TRANSCRIPTION_STOPPED",
    /**
     * @eventProperty
     * **Event Data**
     * - **message**: The new message received
     * This RBEvent is send when a we receive a liveTranscription message
     */
    ON_LIVE_TRANSCRIPTION_MESSAGE_RECEIVED = "ON_LIVE_TRANSCRIPTION_MESSAGE_RECEIVED",
    /**
     * @eventProperty
     * **Event Data**
     * This RBEvent is send when there's a change on the recording state for this conference
     */
    ON_RECORDING_UPDATE = "ON_RECORDING_UPDATE",
    /**
    * @eventProperty
    * * **Event Data**
    * - **participant**: the current participant talking. It could be null / undefined if noone is talking currently;
    * This RBEvent is triggered when the current talker changes.
    */
    ON_TALKER_EVENT = "ON_TALKER_EVENT"
}
export declare enum BubbleConferenceVideoQuality {
    HIGH = 2,
    MEDIUM = 1,
    LOW = 0
}
/**
 * This enum represents the BubbleConference statuses
 */
export declare enum BubbleConferenceStatus {
    UNJOINED = "unjoined",
    CONNECTING = "connecting",
    CONNECTED = "connected",
    ON_HOLD = "onhold",
    RECONNECTING = "reconnecting",
    ENDED = "ended"
}
/**
 * This enum lists the BubbleConference media
 */
export declare enum BubbleConferenceMedia {
    VIDEO = "video",
    SHARING = "sharing",
    MOZAIC = "mozaic",
    DYNAMIC_FEED = "dynamicFeed"
}
/**
 * This enum lists the BubbleConference media action
 */
export declare enum BubbleConferenceMediaAction {
    ADDED = "added",
    REMOVED = "removed",
    HOLD = "hold"
}
export interface LiveTranscriptionLanguage {
    iso: string;
    native: string;
    translated: string;
    inverted: boolean;
}
export declare class LiveTranscriptionMessage {
    date: string;
    text: string;
    from?: string;
    static create(date: Date, text: string, from?: string): LiveTranscriptionMessage;
}
/**
 * This interface is used to specify bubbleConference join parameters
 */
export interface BubbleConferenceJoinParameters {
    /**
     * If true, the user will join with no audio.
     * He'll be able to see all videos / sharing and also share his video, but the audio sessions will be "empty".
     */
    noAudio?: boolean;
    /**
     * If set to true, the user will join the conference as an attendee.
     * In other words, he'll receive the audio and video from the conference
     * but won't transmit anything of his own. No access to his microphone and/or camera will be required.
     */
    attendeeMode?: boolean;
    /**
     * If set to true deskphone (only for RB Hub users).
     * The user will be call on it's deskphone to join the audio conference.
     */
    joinByPhone?: boolean;
    /**
     * If set to true, it permits to join several conferences.
     */
    joinMultiple?: boolean;
}
/**
 * This interface is used to represent a bubble conference containing
 * all the relevant information to the current conference session.
 */
export interface BubbleConference {
    /**
     * Global reference of the conference
     * @readonly
     */
    id: string;
    /**
     * The Bubble object related to the conference
     * @readonly
     */
    bubble: Bubble;
    /**
     * The current status of the conference.
     * @readonly
     */
    status: BubbleConferenceStatus;
    /**
     * The current duration of the conference (in seconds)
     * @readonly
     */
    duration: number;
    /**
     * Whether this is my conference (owner of the conference)
     * @readonly
     */
    isMyConference: boolean;
    /**
     * Whether I have moderator rights
     * @readonly
     */
    isModerator: boolean;
    /**
     * Whether this a specific conference for media echo test
     * @readonly
     */
    isMediaEchoTestConference: boolean;
    /**
     * Yourself in the conference
     * @readonly
     */
    localParticipant: BubbleConferenceParticipant;
    /** List of other participants currently connected in the conference */
    participants: BubbleConferenceParticipant[];
    /**
     * TRUE if the current user is sharing his screen at the moment
     */
    hasLocalSharing: boolean;
    /** True when a recap recording is in progress */
    isRecapRecording: boolean;
    /** True when a recap recording is in progress and paused */
    isRecapRecordingPaused: boolean;
    /**
    * Subscribe to events on the webConference (all events are of RBEvent type);
    * @param handler - The call-back function that will be subscribed to the RxJS subject
    * @param filterEvent - a list of event names that the user wants to receive when subscribing (used a filter)
    */
    subscribe(handler: (event: RBEvent<BubbleConferenceEvents>) => any, filterEvent?: BubbleConferenceEvents | BubbleConferenceEvents[], debounce?: number): Subscription;
    /**
     * Join this conference
     * @param joinParams - the join paramters
     */
    join(joinParams?: BubbleConferenceJoinParameters): Promise<void>;
    /**
     * Removes connected user from this conference.
     */
    leave(): Promise<void>;
    /**
     * Stop this conference
     */
    stop(): Promise<void>;
    /**
     * Mute the microphone of the current participant
     */
    mute(): Promise<void>;
    /**
     * Unmute a conference
     */
    unmute(): Promise<void>;
    /**
     * Add media to a conference
     * @param mediaType - the mediaType to add to the bubbleConference
     */
    addMedia(mediaType: BubbleConferenceMedia): Promise<void>;
    /**
     * Remove media from a conference
     * @param mediaType - the mediaType to add to the bubbleConference
     */
    removeMedia(mediaType: BubbleConferenceMedia): Promise<void>;
    /**
     * Utility method to attach conference media to a video element
     * @param videoElementId - the HTML video element id
     * @param mediaType - the type of media to attach
     * @param participant - the participant
     */
    attachMediaToHtmlElement(videoElementId: string, mediaType: BubbleConferenceMedia, participant?: BubbleConferenceParticipant): void;
    /**
     * Utility method to detach all media from a video element
     * @param videoElementId - the HTML video element id
     */
    detachMediaToHtmlElement(videoElementId: string): void;
    /**
     * Utility method to ask the server to change the incoming video quality for given participant;
     * NOTE: The quality depends also on the uplink of the publisher, so even when the asked quality is High, the quality is still dependant on the network condition
     * of both parties (publisher and subscriber)
     * NOTE: This API will throw error if no video session is available for this participant;
     * @param quality - the wanted quality that we want to receive for this participant
     * @param participant - the related participant that is publishing video; If UNDEFINED, then we'll update the quality of the dynamic feed
     */
    updateVideoQualityForParticipant(quality: BubbleConferenceVideoQuality, participant?: BubbleConferenceParticipant): Promise<void>;
    /**
     * Utility method to put the incoming video session from given user ON HOLD; This means that the session is still active, but no video frames
     * are received inside. It's extremely important to manage low bandwith, or in case of having too many incoming videos;
     * This will allow to hold / unhold quickly videos from given participants in case the user is shown on the screen (or hidden), for instance, in case of grid view;
     * @param participant - the related participant that is publishing video;
     */
    holdRemoteVideo(participant: BubbleConferenceParticipant): Promise<void>;
    /**
     * Utility method to RETRIEVE the incoming video session from given user that is ON HOLD;
     * @param participant - the related participant that is publishing video;
     */
    unholdRemoteVideo(participant: BubbleConferenceParticipant): Promise<void>;
    /**
     * MODERATORS ONLY - API to mute another participant
     * @param participant - participant to be muted
     */
    muteParticipant(participant: BubbleConferenceParticipant): Promise<void>;
    /**
     * Raise your hand in the concerned conference
     */
    raiseHand(): Promise<void>;
    /**
     * Lower your hand in the concerned conference
     */
    lowerHand(): Promise<void>;
    /**
     * Get the current participant that is sharing. It could also be the current user
     * if he's the one that is sharing his screen.
     * NB We can have only 1 person that is sharing his screen at the same time !
     */
    getSharingParticipant(): BubbleConferenceParticipant;
    /**
     * Start recap recording a conference.
     * @param params - Recordings parameters
     */
    startRecap(params?: BubbleConferenceRecapParams): Promise<void>;
    /**
     * Pause recap a conference.
     */
    pauseRecap(): Promise<void>;
    /**
     * Resume recap a conference.
     */
    resumeRecap(): Promise<void>;
    /**
     * Stop recap a conference.
     */
    stopRecap(): Promise<void>;
    /**
     * Json serialisation for debug purpose
     * @internal
     */
    toJSON(): any;
}
/**
 * This class is used to represent the current conference recap recording states
 */
export declare class BubbleConferenceRecordState {
    isRecording: boolean;
    recordingIsPaused: boolean;
    /** @internal */
    hideBanner: boolean;
    recordingConfig: BubbleConferenceRecapParams;
}
/**
 * This class is used to represent a web conference session containing
 * all the relevant information to the current conference session
 * @internal
 */
export declare class WebConferenceSession implements BubbleConference {
    /** Conference Session ID. This is a global reference of the conference session */
    id: string;
    /** The Bubble object related to the conference */
    bubble: BubbleRB;
    private _status;
    get status(): BubbleConferenceStatus;
    set status(newStatus: BubbleConferenceStatus);
    /** The current status of the conference. */
    /** The current duration of the conference (in seconds) */
    duration: number;
    /** Yourself in the conference */
    localParticipant: BubbleConferenceParticipant;
    /** The list of other participants currently connected in the conference */
    participants: BubbleConferenceParticipant[];
    /** Boolean indicating whether the current user is currently sharing his screen */
    hasLocalSharing: boolean;
    /** The local sharing session (as a JINGLE SESSION object) or null */
    localSharingSession: JingleSession;
    /** The Audio session related to the web conference. (represented as a Jingle Session object) */
    audioSession: JingleSession;
    /** Object containing the talking time statistics for the conference */
    talkingTimeStats: any;
    /** The ID of the participant that is currently talking */
    private _talker;
    set talker(value: string);
    get talker(): string;
    /** Whether this is my conference (owner of the conference) */
    isMyConference: boolean;
    /** Whether I have moderator rights */
    get isModerator(): boolean;
    /** Whether this is a media echo test specific conference */
    isMediaEchoTestConference: boolean;
    /**
     * The Dynamic feed session related to the web conference. (represented as a Jingle Session object);
     * Dynamic feed is the single video session where we see the last person that spoke in it (for all video participants in the conference)
     */
    dynamicFeedSession: any;
    /** The ID of the participant that spoke before the current talker */
    lastTalker: string;
    /**
     * object containing information about recording (for the "owner") of the recording
     * - isRecording (boolean) : if there's an active recording (could also be on "pause")
     * - recordingIsPaused (boolean) : if the active recording is on pause
     */
    record: BubbleConferenceRecordState;
    private _liveTranscriptionAvailable;
    set liveTranscriptionAvailable(value: boolean);
    get liveTranscriptionAvailable(): boolean;
    liveTranscriptionActivated: boolean;
    set liveTranscriptionUsedBySomeone(value: boolean);
    get liveTranscriptionUsedBySomeone(): boolean;
    private _liveTranscriptionUsedBySomeone;
    liveTranscriptionLanguage: LiveTranscriptionLanguage;
    set liveTranscriptionActiveLanguages(value: string[]);
    get liveTranscriptionActiveLanguages(): string[];
    private _liveTranscriptionActiveLanguages;
    liveTranscriptionLanguages: LiveTranscriptionLanguage[];
    liveTranscriptionMessages: LiveTranscriptionMessage[];
    private cleanString;
    set liveTranscription(value: DataChannel);
    get liveTranscription(): DataChannel;
    private _dataChannelSubscritpion;
    private _liveTranscriptionDataChannel;
    /** recordingStarted If there's currently an active recording in the bubble */
    recordingStarted: boolean;
    /** ID of the user that records the conference */
    recordingUserId: string;
    /** Current recording state ("on" or "paused") */
    currentRecordingState: string;
    /** TRUE If the user has joined using the "noAudio" option (no outgoing audio stream is send, and the incoming audio is muted) */
    noAudio: boolean;
    /** TRUE If the user has joined the conference with audio on the deskphone */
    audioOnDeskphone: boolean;
    /** TRUE If the user have register to liveTranscription */
    transcriptionActivated: boolean;
    /** TRUE If the user have register to postTranscription */
    postTranscriptionActivated: boolean;
    get isRecapRecording(): boolean;
    get isRecapRecordingPaused(): boolean;
    /**
     * Object that will contain the informations related to the large grid/ mozaic service subscription. The object is either null or in this format:
            { id --> id of the service
            sessionId --> id of the Jingle session
            videoSession --> the jingle video session itself
            }
     *
     */
    gridServiceSubscription: any;
    /**
     * A configuration settings that will disable the auto subscription for new videos for this conference. All already activated videos will not be impacted;
     * This only refers to new incoming video sessions. This wil also impact the auto subscription to the dynamic feed
     */
    disableAutoSubscriptions: boolean;
    /** A configuration settings that will put on hold the incoming sharing session (or any other incoming sharing session until this settings is modified again) */
    disableIncomingSharing: boolean;
    /** The list of participants currently raising their hand in the conference */
    private _raiseHandParticipants;
    get raiseHandParticipants(): BubbleConferenceParticipant[];
    set raiseHandParticipants(participants: BubbleConferenceParticipant[]);
    private sharingParticipant;
    private pinnedParticipant;
    /** @internal */
    type: string;
    /** @internal */
    haveJoined: boolean;
    /** @internal */
    isInExternalWindow: boolean;
    /** @internal */
    conferenceView: string;
    /** @internal */
    externalWindowRef: any;
    /** @internal */
    isOnlySharingWindow: boolean;
    /** @internal */
    autoPopoutSharingWindow: boolean;
    /** @internal */
    autoPopoutWindow: boolean;
    /** @internal */
    control: {
        activeControl: boolean;
        hasRemoteControlling: boolean;
        controller: any;
        controlled: any;
        pauseControl: any;
        giveControlFirst: any;
    };
    /** @internal */
    conferenceLayoutSize: any;
    /** @internal */
    subtitlesEnable: boolean;
    /** @internal */
    dimLocalSharingScreen: boolean;
    /** @internal */
    localStreams: any;
    /** @internal */
    jingleJid: string;
    /** @internal */
    originalVideoStream: any;
    /** @internal */
    metricsId: string;
    /** @internal */
    metricsState: string;
    /** @internal */
    networkQuality: number;
    /** @internal */
    services: any;
    /** @internal */
    subscribedToGridService: boolean;
    /** @internal */
    dynamicFeedSubscriptionInProgress: boolean;
    /** @internal */
    locked: boolean;
    /** @internal */
    onHold: boolean;
    private durationTimer;
    private eventSubject;
    private logger?;
    private webConferenceService;
    private conferenceRecordingService;
    static create(id: string, bubble: BubbleRB): WebConferenceSession;
    /** @internal */
    constructor(id: string, room: BubbleRB);
    subscribe(handler: (event: RBEvent<BubbleConferenceEvents>) => any, eventNames?: BubbleConferenceEvents | BubbleConferenceEvents[], debounce?: number): Subscription;
    sendEvent(name: BubbleConferenceEvents, data?: any): void;
    /**
     * Joins this conference
     * @param params - the join paramters
     */
    join(joinParams?: BubbleConferenceJoinParameters): Promise<void>;
    /**
     * Removes connected user from this conference.
     */
    leave(): Promise<void>;
    /**
     * Stop this conference
     */
    stop(): Promise<void>;
    /**
     * Mute a conference
     */
    mute(): Promise<void>;
    /**
     * Unmute a conference
     */
    unmute(): Promise<void>;
    /**
     * Add media
     */
    addMedia(media: BubbleConferenceMedia): Promise<void>;
    /**
     * Remove media
     */
    removeMedia(media: BubbleConferenceMedia): Promise<void>;
    /**
     * Start Live Transcription
     */
    startLiveTranscription(transcriptionLanguage?: LiveTranscriptionLanguage): Promise<void>;
    private changeLiveTranscriptionLanguage;
    /**
     * Start Live Transcription
     */
    stopLiveTranscription(): Promise<void>;
    attachMediaToHtmlElement(videoElementId: string, media: BubbleConferenceMedia, participant?: BubbleConferenceParticipant): void;
    detachMediaToHtmlElement(videoElementId: string): void;
    updateVideoQualityForParticipant(quality: BubbleConferenceVideoQuality, participant?: BubbleConferenceParticipant): Promise<void>;
    holdRemoteVideo(participant: BubbleConferenceParticipant): Promise<void>;
    unholdRemoteVideo(participant: BubbleConferenceParticipant): Promise<void>;
    /**
     * Mute a conference
     */
    muteParticipant(participant: BubbleConferenceParticipant): Promise<void>;
    raiseHand(): Promise<void>;
    lowerHand(): Promise<void>;
    /**
     * As conference owner, if I leave the conference, it also ends for all the other participants.
     * To avoid this inconvenience, simply delegate the conference to another member,
     * and the conference will continue even without the presence of its creator.
     * The delegated participant will inherit the rights to end the conference.
     * @param participantId - the participantId
     */
    delegateToParticipant(participantId: string): Promise<void>;
    /** Return an array of all WebConferenceParticipants taking part of the web conference */
    getParticipants(): BubbleConferenceParticipant[];
    /** Return the current user as a web conference participant connected to the conference*/
    getLocalParticipant(): BubbleConferenceParticipant;
    /** Get the room related to the web conference session */
    getBubble(): Bubble;
    /** Get the jingle audio session related to the conference session */
    getAudioSession(): JingleSession;
    /** Web conference participant object that is currently sharing (could also be myself) */
    getSharingParticipant(): BubbleConferenceParticipant;
    startRecap(params?: BubbleConferenceRecapParams): Promise<void>;
    pauseRecap(): Promise<void>;
    resumeRecap(): Promise<void>;
    stopRecap(): Promise<void>;
    /**
     * Get the remote web conference participant object that is currently sharing in the conference;
     * IF the local participant is currently the sharing participant, will return null
     */
    getRemoteSharingParticipant(): BubbleConferenceParticipant;
    /** Get the local sharing session (if any) */
    getLocalSharingSession(): JingleSession;
    /** Get the remote sharing session (or null) from the sharing participant object */
    getRemoteSharingSession(): JingleSession | undefined;
    /** Get the Sharing session (mine or remote, if any) */
    getSharingSession(): JingleSession | undefined;
    /** Find and return a participant by his Id */
    getParticipantById(id: string): BubbleConferenceParticipant;
    /** Find and return a participant by his contact dbId */
    findParticipantByContactDbId(id: string): BubbleConferenceParticipant;
    /** Check if the current web conference is locked. In case it's locked, no other user is allowed to join its */
    isLocked(): boolean;
    /** Return an array of WebConferenceParticipant to whom we can delegate the conference */
    getParticipantsListWithDelegateCapability(): BubbleConferenceParticipant[];
    addOrUpdateService(serviceId: string, serviceName: string): void;
    addOrUpdateParticipantFromSnapshot(participant: BubbleConferenceParticipant): void;
    addOrUpdateParticipant(participant: BubbleConferenceParticipant, updateRaiseHand?: boolean): void;
    updateTalkingTimeForParticipant(id: string, talkingTime: number): void;
    startDuration(): void;
    stopDuration(): void;
    getPinnedParticipant(): any;
    updatePinnedParticipant(participant?: BubbleConferenceParticipant, mediaType?: string): void;
    setLocked(lock?: boolean): void;
    setSharingParticipant(participant?: BubbleConferenceParticipant): void;
    updateRaiseHandParticipants(): void;
    private getParticipantByIdAndMediaType;
    toJSON(): any;
}
//# sourceMappingURL=webConferenceSession.model.d.ts.map