/**
 * @module Bubbles
 */
import { BehaviorSubject, Subject, Subscription } from "rxjs";
import { DialInPhoneNumber } from '../models/dial-in-phone-numbers.model';
import { RBEvent } from '../models/event.model';
import { Contact } from "./contact.model";
import { User } from "./user.model";
/**
 * Bubble user role
 * Each role gives access to different functionalities in Bubbles.
 */
export declare enum BubbleUserRole {
    /**
     * Users are basic members who have accepted an invitation to join a Bubble.
     * They can then send messages in the bubble, join a Web Conference and leave the Bubble.
     * Users have no right to manage the bubble and the members in this one.
     */
    USER = "user",
    /**
     * Organizers are bubble members who have been promoted to manage the bubble and the members in this one.
     * Organizers can be promoted by the owner or by another organizer.
     * They can also subsequently be demoted to basic member by another owner or organizer.
     * Organizers have the ability to invite or remove members/guests in the bubble, to share the bubble through a public direct link.
     * They can send messages in the bubble, start/join a Web Conference and leave the Bubble.
     */
    ORGANIZER = "moderator",
    /**
     * @internal
     */
    GUEST = "guest"
}
/**
 * Status of a user in the bubble
 */
export declare enum BubbleUserStatus {
    /**
     * The user has been invited to join the bubble.
     */
    INVITED = "invited",
    /**
     * The user has accepted the invitation to join the bubble and is an active member.
     */
    ACCEPTED = "accepted",
    /**
     * The user has declined the invitation to join the bubble.
     */
    REJECTED = "rejected",
    /**
     * This status applies to 3 situations:
     * - The user has been removed from the bubble by the owner or one of the organizers.
     * - The user left the bubble on his own and has not requested the creation of an archive for this bubble.
     * - The user has deleted the archive of a bubble he previously left
     */
    DELETED = "deleted",
    /**
     * The user left the bubble of his own.
     * During this operation, the user has requested the creation of an archive for this bubble.
     */
    UNSUBSCRIBED = "unsubscribed"
}
/**
 * Type of message history to be returned to a new bubble user.
 */
export declare enum BubbleHistoryType {
    /**
     * All the previous messages history are provided to a new bubble user
     */
    ALL = "all",
    /**
     * No message history is provided to a new bubble user
     */
    NONE = "none"
}
/**
 * Visibility of the bubble
 */
export declare enum BubbleVisibility {
    /**
     * A private bubble can be joined only by invitation or via a public link if the bubble has been shared (bubble configuration parameter).
     */
    PRIVATE = 0,
    /**
     * A public bubble can be found via a search operation (using 'searchBubbles()' method) or get by its identifier
     * even if a user is not a member of this bubble. Information on such bubbles are provided for guidance only.
     */
    PUBLIC = 1
}
/**
 * @eventProperty
 * `Bubble` specific events
 * Can listen to it via `bubble.subscribe()` API
 */
export declare enum BubbleEvents {
    /**
     * @eventProperty
     * This `RBEvent` is sent when a user has accepted the invitation in the bubble.
     *
     * **Event Data**
     * - **bubbleUser**: The bubble user who has accepted the invitation
    */
    ON_USER_INVITATION_ACCEPTED = "ON_USER_INVITATION_ACCEPTED",
    /**
     * @eventProperty
     * This `RBEvent` is sent when a user has declined the invitation to join the bubble.
     *
     * **Event Data**
     * - **bubbleUser**: The bubble user who has declined the invitation
     */
    ON_USER_INVITATION_DECLINED = "ON_USER_INVITATION_DECLINED",
    /**
     * @eventProperty
     * This `RBEvent` is sent when a user has left the bubble of his own
     * **Event Data**
     * - **bubbleUser**: The bubble user who has left the bubble
     */
    ON_USER_BUBBLE_LEFT = "ON_USER_BUBBLE_LEFT",
    /**
     * @eventProperty
     * This `RBEvent` is sent when a user has been removed from the bubble by the owner or one of the organizers
     * **Event Data**
     * - **bubbleUser**: The bubble user who has been removed from the bubble
     */
    ON_USER_BUBBLE_REMOVED = "ON_USER_BUBBLE_REMOVED",
    /**
     * @eventProperty
     * This RBEvent is sent when the bubble avatar is updated
     */
    ON_AVATAR_UPDATE = "ON_AVATAR_UPDATE",
    /**
     * @eventProperty
     * This RBEvent is sent when the dialInCode is updated
     */
    ON_DIAL_IN_CODE_UPDATE = "ON_DIAL_IN_CODE_UPDATE",
    /**
     * @eventProperty
     * This RBEvent is sent when the includeAllPhoneNumber is updated
     */
    ON_INCLUDE_ALL_PHONENUMBER_UPDATE = "ON_INCLUDE_ALL_PHONENUMBER_UPDATE",
    /**
     * @eventProperty
     * This RBEvent is sent when the dialInPhoneNumber is updated
     */
    ON_DIAL_IN_PHONENUMBER_UPDATE = "ON_DIAL_IN_PHONENUMBER_UPDATE",
    /**
     * @eventProperty
     * This RB event is sent when the user's role is updated
     */
    ON_USER_ROLE_UPDATE = "ON_USER_ROLE_UPDATE",
    /**
     * @internal
     * @eventProperty
     * @param lobbyUsers - the updated list of lobby users
     * This RB event is send when the list of users in the waiting lobby is updated
     */
    ON_USERS_IN_LOBBY_UPDATE = "ON_USERS_IN_LOBBY_UPDATE",
    /**
     * @internal
     * @eventProperty
     * @param status - The current status of the request of type AccessRequestStatus
     * This RB event is send when the connected user's request to join bubble is updated (or created)
     */
    ON_MY_USER_IN_LOBBY_UPDATE = "ON_MY_USER_IN_LOBBY_UPDATE",
    /**
     * @eventProperty
     * This RB event is send when the conference attached to this bubble is started
     */
    ON_CONFERENCE_START_EVENT = "ON_CONFERENCE_START_EVENT",
    /**
     * @eventProperty
     * This RB event is sent when the conference attached to this bubble is Stopped
     */
    ON_CONFERENCE_STOP_EVENT = "ON_CONFERENCE_STOP_EVENT",
    /**
     * @eventProperty
     * This RB event is sent when the conference attached to this bubble is Stopped
     */
    ON_TAGS_UPDATED = "ON_TAGS_UPDATED",
    /**
     * @eventProperty
     * This RB event is sent when the bubble password configuration has changed (or password is reset)
     */
    ON_BUBBLE_PASSWORD_UPDATED = "ON_BUBBLE_PASSWORD_UPDATED",
    /**
     * @eventProperty
     * This RB WTF event is sent when something happen !!!
     * Temporary event, please don't use this stuff
     */
    ON_DATA_UPDATED = "ON_DATA_UPDATED"
}
/**
 * Bubble data that can be cleaned
 */
export declare enum BubbleCleanupData {
    /**
     * All rooms IM will be removed for all room members, all pins will also be removed
     */
    IM = "im",
    /**
     * All pools associated to that room will be removed
     */
    POLL = "poll",
    /**
     * That rooms won't be viewer of any document (Document's list will appear empty)
     */
    DOCUMENT = "document",
    /**
     *  All members of this room that is not an organizer will be removed
     */
    MEMBER = "member",
    /**
     * All recordings will be removed
     */
    RECORD = "record"
}
export declare enum BubbleReceivedFilePolicyValue {
    ENABLED = "enabled",
    DISABLED = "disabled",
    INTERNAL_ONLY = "internalOnly"
}
export declare enum BubbleShareFileCustomisationValue {
    ENABLED = "enabled",
    DISABLED = "disabled"
}
/**
 * This interface defines the settings that can be sent to the setSettings bubble API
 */
export interface BubbleSettings {
    /**
     * The bubble name
     */
    name?: string;
    /**
     * The bubble description
     */
    description?: string;
    /**
     * A user can create a bubble and not have to register users. He can share instead a public link also called 'public URL'(users public link).
     * Depending on the autoRegister value, if another person uses the link to join the bubble :
     * autoRegister = 'unlock':
     * If this user is not yet registered inside this bubble, he is automatically included with the status 'accepted' and join the bubble.
     * autoRegister = 'lock':
     * If this user is not yet registered inside this bubble, he can't access to the bubble. So that he can't join the bubble.
     * autoRegister = 'unlock_ack' (value not authorized yet):
     * If this user is not yet registered inside this bubble, he can't access to the bubble waiting for the bubble's owner acknowledgment.
     */
    autoRegister?: string;
    /**
     * Invited users will be auto-added in the bubble
     */
    autoAcceptInvitation?: boolean;
    /**
     * In case of conference in this bubble, all participants will be muted upon join
     */
    muteUponEntry?: boolean;
    /**
     * In the event of a conference in this bubble, specify whether a local tone should be played each time a participant joins the conference.
     */
    playEntryTone?: boolean;
    /**
     * Indicates if user chooses to include all Dial In phone numbers
     */
    includeAllPhoneNumbers?: boolean;
    /**
     * Content to clear automatically at conference end (only room creator can modify it)
     */
    contentToAutoClear?: {
        im: boolean;
        poll: boolean;
        document: boolean;
        member: boolean;
    };
    recordingAndTranscription?: ConferenceRecordingConfig;
}
/**
 * In order to classify and find a bubble quickly and easily, a user can decide to assign tags to it.
 *
 * A tag is defined by a name and a color
 * @module BubbleTags
 */
export interface BubbleTag {
    /**
     * The Name of the tag
     */
    name: string;
    /**
     * The color of the tag in hexadecimal color code (ex #ff9900)
     */
    color?: string;
    /**
     * The tagged bubble identifiers
     * @internal
     */
    bubbleIds?: string[];
}
export interface BubbleUser {
    /**
     * The user object related to the user
     * @readonly
     */
    user: User;
    /**
     * Date when the user has been added in the bubble
     * @readonly
     */
    date: Date;
    /**
     * Role of the user in the bubble
     * @readonly
     */
    role: BubbleUserRole;
    /**
     * The status of the user in the bubble.
     * @readonly
     */
    status: BubbleUserStatus;
    /**
     * The ID of the user that has invited us to the bubble
     * @readonly
     */
    invitingUserId?: string;
}
export interface BubbleInvitation {
    /**
     * The bubble database Identifier
     * @readonly
     */
    dbId: string;
    /**
     * The name of the bubble
     * @readonly
     */
    name: string;
    /**
     * A description of the purpose of the bubble
     * @readonly
     */
    description: string;
    /**
     * The bubble avatar
     * @readonly
     */
    avatar: string;
    /**
     * Date when the user has been added in the bubble
     * @readonly
     */
    invitationDate?: Date;
    /**
     * Role of the invited user in the bubble during the invitation step
     * @readonly
     */
    invitationRole?: BubbleUserRole;
    /**
     * The ID of the user that has invited us to the bubble
     * @readonly
     */
    invitingUserId?: string;
    /**
     * Accept invitation to join a bubble
     */
    acceptInvitation(): Promise<Bubble>;
    /**
     * Decline invitation to join a bubble
     */
    declineInvitation(): Promise<Bubble>;
    /**
     * Specifies whether the invitation is to join a bubble or a webinar
     */
    isWebinarInvitation(): boolean;
    /**
     * Method to return a simplified JSON representation of the Bubble object
     */
    toJSON(): any;
}
export interface ConferenceRecordingConfig {
    /**
     * The name of the record file
     */
    recordingName?: string;
    /**
     * Will recording be automatically deleted after 15 days? Only transcription will remains
     */
    persistent?: boolean;
    /**
     * Is transcription requested?
     */
    transcription?: boolean;
    /**
     * Is transcript requested?
     */
    summary?: boolean;
    /**
     * Form for summary
     */
    summaryForm?: string;
    /**
     * Prompt id for summary
     */
    summaryPrompt?: string;
    /**
     * The input language used for live transcription
     */
    inputLanguageLiveTranscription?: string;
    /**
     * The input language used for transcription
     */
    inputLanguageTranscription?: string;
}
/**
 * The saved informations inside the bubble regarding conferences
 */
export interface BubbleConferenceInfo {
    /**
     * If all numbers are included for the dial-in function
     */
    includeAllPhoneNumbers?: boolean;
    /**
     * Are users muted upon entry in the conference. Managed only by owner
     */
    muteUponEntry?: boolean;
    /**
     * The list of phone numbers avaialbe for dial-in
     */
    phoneNumbers?: string[];
    /**
     * If the client should play an entry tone when someone joins the conference
     */
    playEntryTone?: boolean;
    /**
     * Information about the current active conference session inside this bubble
     */
    sessions?: any[];
    /**
     * Information about the current configuration regarding recording and transcription
     */
    recordingAndTranscription?: ConferenceRecordingConfig;
}
export interface Bubble {
    conference: BubbleConferenceInfo;
    /**
     * The bubble database Identifier
     * @readonly
     */
    dbId: string;
    /**
     * The jid associated to this bubble
     * @readonly
     */
    jid: string;
    /**
     * The name of the bubble
     * @readonly
     */
    name: string;
    /**
     * A description of the purpose of the bubble
     * @readonly
     */
    description: string;
    /**
     * The bubble avatar
     * @readonly
     */
    avatar: string;
    /**
     * The visibility of the bubble
     * A public bubble can be found via a search operation (using 'searchBubbles()' method) or get by its identifier
     * even if the connectedUser is not a member of this bubble.
     * A private bubble can be joined only by invitation or via a public link if the bubble has been shared for this purpose.
     * @readonly
     */
    visibility: BubbleVisibility;
    /**
     * Allow newcomers to access or not messages history. If the value is "all", a newcomer can retrieve the full bubble messages history
     * @readonly
     */
    history: BubbleHistoryType;
    /**
     * When set to true, allows to automatically add participants in the bubble (default behavior is that participants need to accept the bubble invitation first before being a member of this bubble)
     * @readonly
     */
    autoAcceptInvitation: boolean;
    /**
     * A user can create a bubble and not have to register users. He can share instead a public link also called 'public URL'(users public link).
     * Depending on the autoRegister value, if another person uses the link to join the bubble :
     * autoRegister = 'unlock':
     * If this user is not yet registered inside this bubble, he is automatically included with the status 'accepted' and join the bubble.
     * autoRegister = 'lock':
     * If this user is not yet registered inside this bubble, he can't access to the bubble. So that he can't join the bubble.
     * autoRegister = 'unlock_ack' (value not authorized yet):
     * If this user is not yet registered inside this bubble, he can't access to the bubble waiting for the bubble's owner acknowledgment.
     * @readonly
     */
    autoRegister: string;
    /**
     * If the bubble has alert notification feature enabled
     * The notification feature must be enabled
     * @readonly
     */
    isAlertNotificationEnabled: boolean;
    /**
     * The owner of the bubble
     * @readonly
     */
    owner: User;
    /**
     * Information on the connected user in this bubble.
     * @readonly
     */
    bubbleConnectedUser: BubbleUser;
    /**
     * Custom data associated to the bubble
     * @readonly
     */
    customData: any;
    /**
     * The number of users of the bubble with the status 'accepted' (he joined the bubble) or 'invited'.
     * They are considered to be the actual participants in the bubble.
     * @readonly
     */
    nbParticipants: number;
    /**
     * The creation date of the bubble
     * @readonly
     */
    creationDate?: Date;
    /**
     * last activity date of bubble
     * @readonly
     */
    lastActivityDate?: Date;
    /**
     * Indicates whether the bubble is ready for chatting.
     * @readonly
     */
    ready: boolean;
    /**
     * Rainbow HUB specificity for Hunting Group .
     * Specifies whether the bubble is created as managed bubble.
     * In this case, there is no owner of the bubble; each member acts as organizer.
     * In addition, a group member cannot leave the bubble and cannot be removed from the bubble.
     * @readonly
     */
    isHuntingGroup: boolean;
    /**
     * The bubble is managed by a Rainbow user acting as the bubble administrator.
     * This user is not a member of the bubble (It is not known to other members) and does not, by default, have the role of owner.
     * But it can manage the list (settings, members), as if it were the owner. In fact, it can give itself this role.
     * @readonly
     */
    isOwnedByBubbleAdmin: boolean;
    /**
     * Bubble associated tags
     * @readonly
     */
    tags: BubbleTag[];
    /**
     * The bubble is managed by a Rainbow user acting as the bubble administrator.
     * This user is not a member of the bubble (It is not known to other members) and does not, by default, have the role of owner.
     * But it can manage the list (settings, members), as if it were the owner. In fact, it can give itself this role.
     */
    contentToClear: {
        im: boolean;
        document: boolean;
        poll: boolean;
        member: boolean;
        record: boolean;
    };
    /**
     * Define if the room restricts the receiving of files to protect from data coming from a foreign user of the company, for all of its users
     *   - ‘enabled’ Users can receive files without restrictions (default value)
     *   - ‘internalOnly’ Users can receive files only within internal company communications
     *   - ‘disabled’ Users can’t receive files under any circumstances. Best for users or roles where no file exchange is necessary or allowed. This ensures maximum protection against unauthorized or potentially harmful file transfers.
     */
    receivedFilePolicy: BubbleReceivedFilePolicyValue;
    /**
     * Defines the rights to upload file in a the bubble for the connected user
     */
    shareFileCustomisation: BubbleShareFileCustomisationValue;
    /**
     * Defined when receivedFilePolicy is internalOnly so that bubble affiliation to a given company can be checked
     */
    companyId: string;
    /**
     * True if the bubble is protected by password (when joining with external link)
     */
    hasPassword: boolean;
    /**
     * The current bubble password; Visible only for owner of the bubble
     */
    bubblePassword: string;
    /**
     * Permits to emit BubbleEvents events
     * Can be listened via bubble.subscribe() API
     * @param name - the name of the event
     * @param data - the data to be send (an object
     */
    sendEvent(name: BubbleEvents, data?: any): void;
    /**
     * Subscribe to updates on this bubble (all events are of `RBEvent` type)
     * @param handler - The call-back function that will be subscribed to the RxJS subject
     */
    subscribe(handler: (event: RBEvent<BubbleEvents>) => any, eventNames?: BubbleEvents | BubbleEvents[]): Subscription;
    /**
     * Bubbles have a default avatar made up of the avatars of the first 4 participants in the bubble.
     * But this avatar can be overloaded by an image chosen by the user
     * @param base64AvatarImg - The image to be set
     * @param width - The width of the image to be set
     * @param height - The height of the image to be set
     */
    setCustomAvatar(base64AvatarImg: string, width?: number, height?: number): Promise<Bubble>;
    /**
     * Remove this bubble custom avatar (reset to default avatar)
     */
    removeCustomAvatar(): Promise<Bubble>;
    /**
     * Update the bubble settings
     * @param bubbleSettings - The settings to be updated in the bubble
     */
    setSettings(bubbleSettings: BubbleSettings): Promise<Bubble>;
    /**
     * Update the bubble custom data
     * @param customData - the custom data to be set to the bubble
     */
    setCustomData(customData: any): Promise<Bubble>;
    /**
     * Update user's role in the Bubble.
     * This operation is only authorised for the organizers and the owner of the bubble.
     * The user can be updated to ORGANIZER or USER.
     * @param user - The user that should be updated
     * @param role - New user role: ORGANIZER or USER
     */
    setUserRole(user: User, role: BubbleUserRole): Promise<Bubble>;
    /**
     * Change the owner of the bubble
     * @param newOwner - The user that should be the new owner
     */
    changeOwner(newOwner: User): Promise<Bubble>;
    /**
     * Add user to the bubble; Can be used to directly add user without invitation or as a organizer
     * @param user - The user to add in the bubble
     * @param role - The user role in this bubble ('user', 'organizer' or 'guest'), by default is 'user'
     * @param reason - Text that will be join in the invitation
     * @param withoutInvitation - When set to true no invitation is sent
     */
    addUser(user: User, role?: BubbleUserRole, reason?: string, withoutInvitation?: boolean): Promise<Bubble>;
    /**
     * Get all bubble users
     *
     * The 'role' parameter allows to get filtered user arrays (only users or only organizers)
     *
     * **Please note:** this method is asynchronous, as user loading is performed lazily to avoid weighing down the application.
     * @param role - users role (defaut value is 'ALL')
     */
    getUsers(role?: 'ALL' | 'USER' | 'ORGANIZER'): Promise<BubbleUser[]>;
    /**
     * Remove a user from the Bubble.
     * API only available for organizers / owner of the bubble
     * The user will no longer have access to this bubble nor the history
     * @param user - the contact that should be removed
     */
    removeUser(user: User): Promise<Bubble>;
    /**
     * Mass provisionning API, allow to invite users and guests to the bubble;
     * The guests will receive an email to join the bubble.
     * @param users - The users to add bubble
     * @param emails - List of emails to invite to the bubble
     * @param role - role to be applied to all invited users (organizer for instance)
     */
    inviteUsers(users: User[], emails?: string[], role?: BubbleUserRole): Promise<Bubble>;
    /**
     * Promote all users (basic member) of a bubble to organizer role.
     * This operation is only authorised for the owner of the bubble.
     */
    promoteAllUsers(): Promise<Bubble>;
    /**
     * Demote all organizers of a bubble, except the owner, to user (basic member) role.
     * This operation is only authorised for the owner of the bubble.
     */
    demoteAllUsers(): Promise<Bubble>;
    /**
     * User leaves the bubble.
     * If createArchive is TRUE, the bubble will be archived, i.e. the user can only read the
     * content that's already in the bubble, but no further action can be done inside the bubble
     * The participant will go to UNSUBSCRIBED state (read-only)
     * @param createArchive - If TRUE, the bubble will be archived for my user
     */
    leave(createArchive?: boolean): Promise<Bubble | undefined>;
    /**
     * Delete own bubble.
     * If createArchive is TRUE, the bubble will be archived, i.e. all users can only read the
     * content that's already in the bubble, but no further action can be done inside the bubble
     * All participants in the bubble will go to UNSUBSCRIBED state (read-only)
     * @param createArchive - If TRUE, the bubble will be archived for all users (i.e. read only mode for all users still inside);
     */
    delete(createArchive?: boolean): Promise<Bubble | undefined>;
    /**
     * Check if the given user is the owner of the bubble
     * @param user - The user to check
     */
    isUserOwner(user: User): boolean;
    /**
     * Check if the connected user is the owner of the bubble
     */
    isConnecteUserOwner(): boolean;
    /**
     * Check if the given user is an organizer of the bubble
     * @param user - The user to check
     */
    isUserOrganizer(user: User): boolean;
    /**
     * Check if the connected user is an organizer of the bubble
     */
    isConnecteUserOrganizer(): boolean;
    /**
     * Check if the connected user is a member of the bubble
     */
    isConnectedUserMember(): Promise<boolean>;
    /**
     * Indicates whether a conference has already been started in the bubble
     */
    isBubbleConferenceStarted(): boolean;
    /**
    * Method helper to know if bubble is a webinar bubble
    */
    isWebinarBubble(): boolean;
    /**
     * In case of active bubble conference, we might know the owner of the conference inside; This API will return the ID of the owner
     */
    getBubbleConferenceOwnerId(): string;
    /**
     * Method helper retrieve the name of the bubble as displayed in the logs
     */
    getNameForLogs(): string;
    /**
     * Get the bubble settings
     */
    getSettings(): BubbleSettings;
    /**
     * Method to retrieve all users of the bubble that have accepted
     */
    getAllAcceptedUsers(): BubbleUser[];
    /**
     * Method to retrieve conference.dialInCode code
     */
    getDialInCode(): string;
    /**
     * Method to retrieve conference.phoneNumbers array status
     */
    getPhoneNumbers(): DialInPhoneNumber[];
    /**
     * Method to create bubble "guest" access code
     */
    createBubbleLink(): Promise<string>;
    /**
     * Method to delete bubble "guest" access code
     */
    deleteBubbleLink(): Promise<void>;
    /**
     * Method to reset bubble "guest" access code
     */
    resetBubbleLink(): Promise<string>;
    /**
     * Method to get bubble "guest" access code
     */
    getBubbleLink(): Promise<string>;
    /**
     * Method to add already existing tags to bubble
     * @param tagNames - array of tag names to add
     */
    addTags(tagNames: string[]): Promise<void>;
    /**
     * Method to remove tags from bubble
     * @param tagNames - array of tag names to remove
     */
    removeTags(tagNames: string[]): Promise<void>;
    /**
     * Method to clear specified data from bubble
     * @param clearData - array of data to clear. Possibile values are: im, poll, document, pin
     */
    clearBubbleData(clearData: BubbleCleanupData[]): Promise<void>;
    /**
     * Method to return a simplified JSON representation of the Bubble object
     */
    toJSON(): any;
    /**
     * Check if the bubble is internal to the connected user
     */
    isInternalBubble(): boolean;
    /**
     * Check if the bubble is external to the connected user
     */
    isExternalBubble(): boolean;
}
/**
* @internal
*/
export interface LobbyUser {
    /**
     * The Contact Object
     * @readonly
     */
    contact: Contact;
    /**
     * The date (in string format) when the user has enterred in the lobby
     * @readonly
     */
    additionDate: string;
}
/**
* @internal
*/
export declare enum AccessRequestStatus {
    /**
     * The request is pending
     */
    PENDING = "pending",
    /**
     * The request is denied
     */
    DENIED = "denied",
    /**
     * The request is accepted
     */
    ACCEPTED = "accepted"
}
/**
 * @internal
 * This class represents a Bubble
 * It is a group conversation that allows users to send messages to all the members, start a web conference, spread information faster
 */
export declare class BubbleRB implements Bubble, BubbleInvitation {
    dbId: string;
    jid: string;
    owner: Contact;
    name: string;
    avatar: string;
    description: string;
    autoAcceptInvitation: boolean;
    history: BubbleHistoryType;
    autoRegister: string;
    contentToAutoClear: {
        im: boolean;
        poll: boolean;
        document: boolean;
        member: boolean;
    };
    visibility: BubbleVisibility;
    /**
     * Indicates whether the bubble is ready for chatting.
     */
    ready: boolean;
    /**
     * The number of users of the bubble with the status 'accepted' (he joined the bubble) or 'invited'.
     * They are considered to be the actual participants in the bubble.
     */
    nbParticipants: number;
    customData: any;
    /**
     * Rainbow HUB specificity for Hunting Group.
     * Specifies whether the bubble is created as managed bubble.
     * In this case, there is no owner of the bubble; each member acts as organizer.
     * In addition, a group member cannot leave the bubble and cannot be removed from the bubble.
     * @readonly
     */
    isHuntingGroup: boolean;
    /**
     * The bubble is managed by a Rainbow user acting as the bubble administrator.
     * This user is not a member of the bubble (It is not known to other members) and does not, by default, have the role of owner.
     * But it can manage the list (settings, members), as if it were the owner. In fact, it can give itself this role.
     * @readonly
     */
    isOwnedByBubbleAdmin: boolean;
    /**
     * If the bubble has alert notification feature enabled
     * The notification feature must be enabled
     * @readonly
     */
    isAlertNotificationEnabled: boolean;
    /**
     * Infos on the connected user in this bubble.
     * Used only as a shortcut to access the information of the user connected to this bubble.
     * This information is actually a ref of the 'users' entry.
     */
    bubbleConnectedUser: BubbleUser;
    /**
     * The bubble is managed by a Rainbow user acting as the bubble administrator.
     * This user is not a member of the bubble (It is not known to other members) and does not, by default, have the role of owner.
     * But it can manage the list (settings, members), as if it were the owner. In fact, it can give itself this role.
     */
    contentToClear: {
        im: boolean;
        document: boolean;
        poll: boolean;
        member: boolean;
        record: boolean;
    };
    /**
     * True if the bubble has waiting lobby activated (for guests)
     */
    hasLobby: boolean;
    /**
     * True if the bubble has password protection activated
     */
    private _hasPassword;
    set hasPassword(value: boolean);
    get hasPassword(): boolean;
    /**
     * True if the bubble has password protection activated
     */
    private _bubblePassword;
    set bubblePassword(value: string);
    get bubblePassword(): string;
    receivedFilePolicy: BubbleReceivedFilePolicyValue;
    shareFileCustomisation: BubbleShareFileCustomisationValue;
    companyId: string;
    private _creationDate?;
    get creationDate(): Date;
    set creationDate(date: Date);
    private _lastActivityDate?;
    get lastActivityDate(): Date;
    set lastActivityDate(date: Date);
    get lobbyUsers(): LobbyUser[];
    get invitationDate(): Date;
    get invitationRole(): BubbleUserRole;
    get invitingUserId(): string;
    initPresPromise: any;
    initPresPromiseResolve: any;
    initPresInterval: any;
    isActive: boolean;
    filterName: string;
    nameForLogs: string;
    tags: BubbleTag[];
    lastAvatarUpdate: string;
    users: BubbleUser[];
    organizers: BubbleUser[];
    members: BubbleUser[];
    guestPhoneNumbers: string[];
    guestEmails: string[];
    avatarContacts: any[];
    endOfConferenceBehavior: any;
    containerName: string;
    containerId: string;
    conference: any;
    webinarId: string;
    groupId: string;
    externalStorageAccessUrl?: string;
    rxSubject: Subject<any>;
    usersReady: BehaviorSubject<boolean>;
    noNotificationPopUp: boolean;
    selected: boolean;
    private bubbleService?;
    private bubbleTagService?;
    private userService?;
    private constructor();
    static create(): BubbleRB;
    sendEvent(name: BubbleEvents, data?: any): void;
    subscribe(handler: (event: RBEvent<BubbleEvents>) => any, eventNames?: BubbleEvents | BubbleEvents[]): Subscription;
    setCustomAvatar(base64AvatarImg: string, width?: number, height?: number): Promise<Bubble>;
    removeCustomAvatar(): Promise<Bubble>;
    setSettings(bubbleSettings: BubbleSettings): Promise<Bubble>;
    getSettings(): BubbleSettings;
    setCustomData(customData: any): Promise<Bubble>;
    setUserRole(user: User, role: BubbleUserRole): Promise<Bubble>;
    changeOwner(newOwner: User): Promise<Bubble>;
    addUser(user: User, role?: BubbleUserRole, reason?: string, withoutInvitation?: boolean): Promise<Bubble>;
    inviteUsers(users: User[], emails?: string[], role?: BubbleUserRole): Promise<Bubble>;
    removeUser(user: User): Promise<Bubble>;
    getUsers(role?: 'ALL' | 'USER' | 'ORGANIZER'): Promise<BubbleUser[]>;
    getAllAcceptedUsers(): BubbleUser[];
    promoteAllUsers(): Promise<Bubble>;
    demoteAllUsers(): Promise<Bubble>;
    acceptInvitation(): Promise<Bubble>;
    declineInvitation(): Promise<Bubble>;
    leave(createArchive?: boolean): Promise<Bubble | undefined>;
    delete(createArchive?: boolean): Promise<Bubble | undefined>;
    isUserOwner(user: User): boolean;
    isConnecteUserOwner(): boolean;
    isUserOrganizer(user: User): boolean;
    isConnecteUserOrganizer(): boolean;
    isConnectedUserMember(): Promise<boolean>;
    isBubbleConferenceStarted(): boolean;
    getBubbleConferenceOwnerId(): string;
    isWebinarBubble(): boolean;
    createBubbleLink(): Promise<string>;
    manageBubblePassword(activate: boolean): Promise<void>;
    resetBubblePassword(): Promise<void>;
    resetBubbleLink(): Promise<string>;
    deleteBubbleLink(): Promise<void>;
    getBubbleLink(): Promise<string>;
    getBubbleOpenInviteIdLinkFromCache(): string | null;
    /**
     * Allow access to one or many lobby users that are in the waiting lobby;
     * If the lobbyUsers is empty; then this will allow ALL users to join the bubble
     */
    allowAccessToBubbleForWaitingLobbyUsers(lobbyUsers?: LobbyUser[]): Promise<any>;
    /**
     * Deny access to the given lobby user waiting in the lobby room
     */
    allowAccessToBubbleForLobbyUser(lobbyUser: LobbyUser): Promise<any>;
    /**
     * Deny access to one or many lobby users that are in the waiting lobby;
     * If the lobbyUsers is empty; then this will DENY ALL users from joining the bubble
     */
    denyAccessToBubbleForWaitingLobbyUsers(lobbyUsers?: LobbyUser[]): Promise<any>;
    /**
     * Clear specified data from bubble
     */
    clearBubbleData(clearData: BubbleCleanupData[]): Promise<any>;
    /**
     * Deny access to the given lobby user waiting in the lobby room
     */
    denyAccessToBubbleForLobbyUser(lobbyUser: LobbyUser): Promise<any>;
    getDialInCode(): string;
    getPhoneNumbers(): DialInPhoneNumber[];
    addTags(tagNames: string[]): Promise<void>;
    removeTags(tagNames: string[]): Promise<void>;
    getNameForLogs(): string;
    isWebinarInvitation(): boolean;
    isInternalBubble(): boolean;
    isExternalBubble(): boolean;
    update(bubbleData: any): this;
    updateAvatarInfo(): void;
    addRainbowTVs(androidTVs: User[]): Promise<Bubble>;
    isUserStatusAcceptedOrInvited(contact: any): boolean;
    isUserStillBelongToBubble(userJid: string): boolean;
    getUserByJid(userJid: string): BubbleUser;
    setWebConferenceOwnerId(ownerId: string): void;
    addConferenceSession(ownerId: string): void;
    getCurrentConferenceSession(): any;
    setAutoRegister(value: string): void;
    setMuteUponEntry(value: boolean): void;
    setPlayEntryTone(value: boolean): void;
    setDialInCode(value: string): void;
    setIncludeAllPhoneNumbers(value: boolean): void;
    setPhoneNumbers(value: DialInPhoneNumber[]): void;
    setContentToAutoclear(contentToAutoclear: {
        im: boolean;
        poll: boolean;
        document: boolean;
        member: boolean;
    }): void;
    setConferencePreConfig(value: ConferenceRecordingConfig): void;
    toString(): string;
    toJSON(): any;
}
//# sourceMappingURL=bubble.model.d.ts.map