@ale-rainbow/web-sdk 5.1.0

package/lib/models/webinar.model.d.ts

@@ -0,0 +1,738 @@
+/** @module Webinar */
+import type { Subscription } from "rxjs";
+import { Subject } from "rxjs";
+import type { Contact } from "../models/contact.model";
+import { RBEvent } from "../models/event.model";
+import type { Bubble } from "../models/bubble.model";
+import type { JingleSession } from "../libs/strophe/strophe.jingle.session";
+import type { FileDocument } from "./fileDocument.model";
+import type { P2PRecap } from "./p2pRecap.model";
+/**
+ * Playable media of a webinar recording.
+ *
+ * Shaped as an object rather than a bare url so subtitles and transcription can be added later
+ * without changing the signature of {@link Webinar.getRecordMedia}.
+ */
+export interface WebinarRecordMedia {
+    /** Signed, time-limited url. Fetchable with NO auth header. */
+    url: string;
+    /** Absolute expiry of `url`, when the backend provided one. */
+    expiresAt?: Date;
+    /** MIME type reported by the file descriptor, e.g. "video/mp4". */
+    mimeType?: string;
+    /** Size in bytes. The player buffers the whole file in memory, so callers may warn above a threshold. */
+    size?: number;
+    /** Reserved: no webinar transcription exists today. */
+    subtitlesUrl?: string;
+}
+export interface PlaybackController {
+    readonly stream: MediaStream;
+    play: () => Promise<void>;
+    pause: () => void;
+    stop: () => void;
+    seekTo: (timeInSeconds: number) => void;
+    readonly currentTime: number;
+    readonly duration: number;
+}
+/**
+ * Webinar status
+ */
+export declare enum WebinarStatus {
+    UPCOMING = "upcoming",
+    WAITING_ROOM = "waitingRoom",
+    PRACTICE_ROOM = "practiceRoom",
+    PRACTICE_WAITING_ROOM = "practiceWaitingRoom",
+    IN_PROGRESS = "inProgress",
+    TERMINATED = "terminated",
+    OUTDATED = "outDated"
+}
+export declare enum WebinarSessionParticipantMedia {
+    AUDIO = "audio",
+    VIDEO = "video",
+    SHARING = "sharing"
+}
+export declare enum WebinarMediaType {
+    participant = "participant",
+    sharing = "sharing",
+    mix = "mix"
+}
+export interface WebinarCodecs {
+    audio?: string;
+    video?: string;
+    sharing?: string;
+}
+export declare enum WebinarSessionParticipantEvents {
+    UPDATE_PARTICIPANT = "updateParticipant",
+    UPDATE_MEDIA = "updateMedia",
+    UPDATE_ORIGINAL_STREAM = "updateOriginalStream",
+    UPDATE_WEBRTC_READINESS = "updateWebrtcReadiness",
+    MUTE_PARTICIPANT = "muteParticipant",
+    ACTIVE_SPEAKER = "activeSpeaker",
+    UPDATE_VIDEO_DOCUMENT = "UPDATE_VIDEO_DOCUMENT"
+}
+/**
+ * Readiness of the local WebRTC session for a given media (audioVideo or sharing).
+ * Used to prevent staging a media on stage before its WebRTC session is truly
+ * established with the media gateway (Janus), which would otherwise cause
+ * subscribers to fail with a "publisher not found" error.
+ */
+export declare enum WebinarWebrtcReadiness {
+    NOT_STARTED = "notStarted",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    FAILED = "failed"
+}
+export interface WebinarSessionParticipantMedias {
+    audio: boolean;
+    video: boolean;
+    sharing: boolean;
+}
+export interface WebinarSessionParticipantAvailableStreams {
+    audioVideo: boolean;
+    sharing: boolean;
+}
+export declare enum WebinarSessionParticipantType {
+    USER = "USER",
+    MCUBOT = "MCUBOT"
+}
+/** The four corners a speaker can be inlaid into while their screen share plays behind them. */
+export type WebinarSpeakerPipCorner = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export declare class WebinarSessionParticipant {
+    id: string;
+    type: WebinarSessionParticipantType;
+    contact: Contact;
+    activeSpeaker: boolean;
+    putOnStageMuted: boolean;
+    returningBackstage: boolean;
+    mute: boolean;
+    onStage: boolean;
+    sharingOnStage: boolean;
+    trackedBackstage: boolean;
+    searchString: string;
+    role: string;
+    /**
+     * The XMPP resource the participant is currently connected from, as announced by the gateway.
+     *
+     * A switch device replaces the resource while keeping the same user id, and the gateway sends
+     * NO `removed-publishers` for what the previous resource was publishing -- so this is the only
+     * signal that the old device's medias are gone. See `addOrUpdateParticipant` (CRRAINB-54390).
+     */
+    resourceId?: string;
+    raiseHand: boolean;
+    raiseHandDate?: Date;
+    raiseHandPosition?: number;
+    allowedToTalk: boolean;
+    invitedToGoOnStage?: any;
+    audioConfig: string;
+    audible: boolean;
+    audioVideoSessionId?: string;
+    audioVideoSession: JingleSession;
+    originalAudioVideoStream: MediaStream;
+    audioVideoStream?: MediaStream;
+    mcuAudioSessionId?: string;
+    mcuAudioStream?: MediaStream;
+    sharingSessionId?: string;
+    sharingSession: JingleSession;
+    sharingStream?: MediaStream;
+    /**
+     * Set while the local speaker is inlaid into their own screen share (the "speaker PiP"): the
+     * sharing plays as the camera's virtual background instead of being shown as a second media.
+     *
+     * It lives on the participant, not on the cell that renders the control, because the effect is
+     * global to the background pipeline and must survive the cell: moving from backstage to the
+     * stage destroys one cell and builds another, and the inlay has to stay on across that.
+     */
+    speakerPip?: {
+        /** Which corner the speaker is inlaid into. */
+        corner: WebinarSpeakerPipCorner;
+        /** Background to put back when the PiP ends. */
+        previousBackground: {
+            type: string;
+            url?: string;
+        };
+        /**
+         * The sharing capture, kept alive while its WebRTC session is torn down.
+         *
+         * The share is composited into the camera, so publishing it a second time would show every
+         * other speaker the same picture twice. Unpublishing sets `medias.sharing` to false, which
+         * is what makes the duplicate cells disappear everywhere -- but the tracks must keep
+         * running, since the background pipeline reads them. Nothing else holds this stream once
+         * `setMedia(SHARING, false, true)` has cleared `sharingStream`.
+         */
+        suspendedSharingStream?: MediaStream;
+        /** Whether the sharing was on stage before being unpublished, to put it back there. */
+        sharingWasOnStage?: boolean;
+    };
+    videoFileDocument?: FileDocument;
+    videoLocalUrl?: string;
+    playbackController?: PlaybackController;
+    medias: WebinarSessionParticipantMedias;
+    availableStreams: WebinarSessionParticipantAvailableStreams;
+    audioVideoWebrtcReadiness: WebinarWebrtcReadiness;
+    sharingWebrtcReadiness: WebinarWebrtcReadiness;
+    rxSubject: Subject<any>;
+    subStreamLevel: number;
+    temporalLevel: number;
+    nameAndEmail?: string;
+    company?: string;
+    private contactService?;
+    static create(id: string): WebinarSessionParticipant;
+    constructor(id: string);
+    sendEvent(event: WebinarSessionParticipantEvents, data?: any): void;
+    /**
+     * Subscribe to events on the WebinarSessionParticipant (all events are of RBEvent type);
+     * @param handler - The call-back function that will be subscribed to the RxJS subject
+     * @param eventNames - a list of event names that the user wants to receive when subscribing (used a filter)
+     */
+    subscribe(handler: (event: RBEvent<WebinarSessionParticipantEvents>) => any, eventNames?: WebinarSessionParticipantEvents | WebinarSessionParticipantEvents[], debounce?: number): Subscription;
+    getSessionType(sessionId: string): string | null;
+    /**
+     * Drop every media this participant was publishing from a resource that is no longer theirs.
+     *
+     * On a switch device the gateway keeps the same user id, swaps the resource, and sends NO
+     * `removed-publishers` for the previous resource's medias -- so `availableStreams.sharing`
+     * stays armed and the backstage keeps offering a share that died with the old device. Putting
+     * it on stage then yields a grey cell, and subscribing fails with "Publisher stream not
+     * found". This is the only client-side signal of the swap (CRRAINB-54390).
+     *
+     * `onSessionTerminated` already covers the case where we HAD subscribed before the swap: the
+     * gateway then tears that session down. It cannot cover the case where we never subscribed --
+     * there is no session to terminate -- which is exactly what this handles.
+     *
+     * Both ids must be known: a missing one means the stanza did not carry the information, not
+     * that the device changed, and clearing on that would drop a live share.
+     */
+    resetMediasOnResourceChange(resourceId?: string): boolean;
+    onHold(media: "video" | "sharing"): boolean;
+    isLocalParticipant(): boolean;
+    setMedia(media: WebinarSessionParticipantMedia, value: boolean, clean?: boolean): void;
+    /**
+     * Update the local WebRTC readiness for a given media and notify subscribers.
+     * See {@link WebinarWebrtcReadiness}.
+     */
+    setWebrtcReadiness(media: "audioVideo" | "sharing", readiness: WebinarWebrtcReadiness): void;
+    isAudioVideoWebrtcConnected(): boolean;
+    isSharingWebrtcConnected(): boolean;
+    toString(): string;
+}
+export declare class WebinarSessionService {
+    id: string;
+    type: string;
+    sid?: string;
+    audioVideoSession?: JingleSession;
+    audioVideoStream?: MediaStream;
+    static create(id: string, name: string): WebinarSessionService;
+    constructor(id: string, type: string);
+}
+export declare class WebinarSession {
+    jingleJid: string;
+    activeSpeakerId: string;
+    localParticipant: WebinarSessionParticipant;
+    speakerParticipants: WebinarSessionParticipant[];
+    attendeeParticipants: WebinarSessionParticipant[];
+    mcuAudioSession?: any;
+    raiseHandAttendeeParticipants: WebinarSessionParticipant[];
+    raiseHandSpeakers: WebinarSessionParticipant[];
+    service?: WebinarSessionService;
+    connected: boolean;
+    masterMedia: string;
+    showMySharing: boolean;
+    static create(): WebinarSession;
+    getParticipantById(participantId: string): WebinarSessionParticipant;
+    getParticipantBySession(session: JingleSession): WebinarSessionParticipant | undefined;
+    getSpeakerBySessionId(sessionId: string): WebinarSessionParticipant;
+    addOrUpdateParticipant(participant: WebinarSessionParticipant, action?: string): void;
+    removeParticipant(participantId: string): void;
+    addService(serviceId: string, serviceName: string): WebinarSessionService;
+}
+export declare class WebinarParticipant {
+    email: string;
+    lastName: string;
+    firstName: string;
+    company: string;
+    jobTitle: string;
+    state: string;
+    userId: string;
+    lastAvatarUpdateDate: string;
+    country: string;
+    static create(): WebinarParticipant;
+    static createFromData(data: any): WebinarParticipant;
+    getData(): string;
+}
+export declare class WebinarCSVStatus {
+    errorDetails: string;
+    okCount: number;
+    errorCount: number;
+    errorReport: any;
+    static create(): WebinarCSVStatus;
+}
+export declare class WebinarCloneParams {
+    /**
+     * Cloned webinar name
+     * If not specified, the former name will be used
+     */
+    name?: string;
+    /**
+     * Cloned webinar subject
+     * If not specified, the former subject will be used
+     */
+    subject?: string;
+    /** clone webinar start date */
+    startDate?: Date;
+    /** clone webinar end date */
+    endDate?: Date;
+    /** clone webinar timeZone */
+    timeZone?: string;
+    /** clone or not the speakers even if some of them declined the previous invitation */
+    cloneSpeakers: boolean;
+    /** param cloneAttendees - clone or not the attendees */
+    cloneAttendees: boolean;
+    /** clone webinar waiting room start date */
+    waitingRoomStartDate?: string;
+    /** licence profile identifier */
+    profileId: string;
+}
+/**
+ * @eventProperty
+ * `Webinar` specific events
+ */
+export declare enum WebinarEvents {
+    /**
+     * @eventProperty
+     * This RBEvent is send when the webinar status change
+     */
+    ON_STATUS_CHANGE = "ON_STATUS_CHANGE",
+    /**
+     * @eventProperty
+     * This RBEvent is send when
+     */
+    ON_DATA_UPDATE = "ON_DATA_UPDATED",
+    /**
+     * @eventProperty
+     * This RBEvent is send when
+     */
+    ON_AVATAR_UPDATE = "ON_AVATAR_UPDATE",
+    /**
+     * @eventProperty
+     * This RBEvent is send when
+     */
+    ON_LOGO_UPDATE = "ON_LOGO_UPDATE",
+    /**
+     * @eventProperty
+     * This RBEvent is send when
+     */
+    ON_CHAT_OPTIONS_UPDATE = "ON_CHAT_OPTIONS_UPDATE",
+    /**
+     * @eventProperty
+     * This RBEvent is send when the number of raiseHand change
+     */
+    ON_RAISEHAND_CHANGE = "ON_RAISEHAND_CHANGE",
+    /**
+     * @eventProperty
+     * Sent at each intermediate session-end threshold (e.g. 15 and 5 minutes before the
+     * planned end). Generic — no freemium semantics. Payload: {@link WebinarSessionEndEventData}.
+     */
+    ON_SESSION_END_WARNING = "ON_SESSION_END_WARNING",
+    /**
+     * @eventProperty
+     * Sent when the planned end of the session is reached (T-0). Generic — no freemium
+     * semantics; consumers decide what to do. Payload: {@link WebinarSessionEndEventData}.
+     */
+    ON_SESSION_END_REACHED = "ON_SESSION_END_REACHED"
+}
+/**
+ * Payload of {@link WebinarEvents.ON_SESSION_END_WARNING} and
+ * {@link WebinarEvents.ON_SESSION_END_REACHED}.
+ */
+export interface WebinarSessionEndEventData {
+    /** Minutes before the planned end this event fires for (15, 5 or 0). */
+    minutesBeforeEnd: number;
+    /** Planned end of the session (ISO string, server `webinarEndDate`). */
+    endDate: string;
+    /** Milliseconds remaining until the planned end, recomputed when the event fires. */
+    msRemaining: number;
+}
+export interface StreamingService {
+    id: string;
+    rtmpUrl: string;
+    rtmpKey: string;
+    secureDataStream: boolean;
+    rtmpUrlBackup?: string;
+}
+/**
+ * Represents a webinar with various properties and methods for managing its lifecycle,
+ * participants, media, and other related functionalities.
+ */
+export interface Webinar {
+    id: string;
+    name: string;
+    subject: string;
+    webinarStartDate: string;
+    webinarEndDate: string;
+    webinarDuration: string;
+    webinarLastDateCheck: string;
+    waitingRoomStartDate: string;
+    timeZone: string;
+    roomId: string;
+    roomModeratorsChatId: string;
+    room: Bubble;
+    practiceRoom: Bubble;
+    organizers: any[];
+    speakers: any[];
+    participants: WebinarParticipant[];
+    profileId: string;
+    pendingParticipantNumber: number;
+    acceptedParticipantNumber: number;
+    rejectedParticipantNumber: number;
+    color: string;
+    creatorId: string;
+    creatorCompanyId: string;
+    isCreator: boolean;
+    isOrganizer: boolean;
+    isSpeaker: boolean;
+    isAttendee: boolean;
+    isGuestAttendee: boolean;
+    isGuest: boolean;
+    isMCUBOT: boolean;
+    password: string;
+    approvalRegistrationMethod: string;
+    registrationUuid: string;
+    published: boolean;
+    moderatorsNotified: boolean;
+    status: WebinarStatus;
+    webinarUrl: string;
+    rxSubject: Subject<any>;
+    rxParticipantsSubject: Subject<any>;
+    rxServiceSubject: Subject<any>;
+    rxInfoSubject: Subject<any>;
+    isWebinarSync: boolean;
+    session: WebinarSession | null;
+    waitingRoomMultimediaURLs: string[];
+    stageBackground: string;
+    reminderDates: string[];
+    subtitlesEnable: boolean;
+    blur: boolean;
+    bgReplaceUrl: string;
+    chatOption: string;
+    chatOptionExpired: boolean;
+    chatOptionTimer: any;
+    streaming: boolean;
+    streamingService?: StreamingService;
+    recorded?: string;
+    hideRecordInfo: boolean;
+    recordFileId: string;
+    recordStatus: string;
+    action: string;
+    lastAvatarUpdate?: string;
+    lastActorsInfo?: any;
+    incomingStreamsDisabled: any;
+    pendingStageReplay: boolean;
+    sendEvent: (name: WebinarEvents, data?: any) => void;
+    subscribe: (handler: any) => Subscription;
+    subscribe2: (handler: (event: RBEvent<WebinarEvents>) => any, eventNames?: WebinarEvents | WebinarEvents[]) => Subscription;
+    armSessionEndTimer: () => void;
+    clearSessionEndTimer: () => void;
+    updateAttendeeCounters: () => void;
+    getData: () => string;
+    updateRaiseHandParticipants: () => void;
+    isTerminated: () => boolean;
+    isOutdated: () => boolean;
+    isFinished: () => boolean;
+    isWaitingRoomStarted: () => boolean;
+    isInvitation: () => boolean;
+    /**
+     * Asynchronous method to clone a webinar
+     * @param params - The webinar parameters to clone
+     */
+    clone: (params: WebinarCloneParams) => Promise<Webinar>;
+    /**
+     * Asynchronous method to update webinar avatar on server
+     * @param avatarImg - base64 encoded webinar avatar
+     */
+    updateAvatar: (avatarImg?: string) => Promise<Webinar>;
+    /**
+    * Asynchronous method to update webinar logo on server
+    * @param logoSrc - base64 encoded webinar logo
+    */
+    updateLogo: (logoSrc?: string) => Promise<Webinar>;
+    /**
+     * Allow a rainbow attendee to join the webinar room
+     */
+    joinAsRainbowAttendee: () => Promise<void>;
+    /**
+     * Allow a rainbow user to join the webinar
+     */
+    join: () => Promise<void>;
+    /**
+     * Allow to leave a webinar
+     *  - remove the user from the stage (if it was on the stage)
+     *  - remove the user from the conference (stop the session if last user)
+     * @param forced - when set to true this method stop the session (even if not the last user connect in conf)
+     * @param nowait - when set to true this method call async child methods without waiting the end of execution (used in last chance deconnection event mechanism (onunload event))
+     * @returns A promise that is resolved when the user has join the conference
+     */
+    leave: (forced?: boolean, nowait?: boolean, reason?: string) => Promise<void>;
+    /**
+     * Update existing webinar with server data
+     * @param webinarData - server webinar data structure
+     */
+    updateFromData: (webinarData: any) => void;
+    /**
+     * Accept webinar invitation (as a speaker)
+     */
+    acceptInvitation: () => Promise<void>;
+    /**
+     * Add audio/video media
+     * @param media - the media to add
+     */
+    addAudioVideoMedia: (media: string, stream?: MediaStream, replaceBg?: boolean) => Promise<void>;
+    /**
+     * Add a sharing media
+     * @param stream - the mediaStream to add as sharing media
+     */
+    addSharingMedia: (stream: MediaStream) => Promise<void>;
+    /** Publish again a sharing capture that was unpublished with `removeLocalMedia(..., true)`. */
+    resumeSharingPublication: (stream: MediaStream, putOnStage: boolean) => Promise<void>;
+    /**
+     * Put local participant audio/video media on stage
+     * @param master - when set to true the participant media is presented on master
+     */
+    putLocalParticipantAudioVideoMediaOnStage: (master?: boolean) => Promise<Webinar>;
+    /** @internal */
+    putLocalParticipantMixMediaOnStage: () => Promise<Webinar>;
+    /**
+     * Put a participant sharing media on stage
+     * @param master - when set to true the participant sharing is presented on master
+     */
+    putParticipantSharingMediaOnStage: (participant: WebinarSessionParticipant, master?: boolean) => Promise<Webinar>;
+    /**
+     * Remove a participant audio/video media from the stage
+     * @param participant - the participant to remove from the stage
+     */
+    removeParticipantAudioVideoMediaFromStage: (participant: WebinarSessionParticipant) => Promise<Webinar>;
+    /**
+     * Remove a participant sharing media from the stage
+     * @param participant - the participant to remove from the stage
+     */
+    removeParticipantSharingMediaFromStage: (participant: WebinarSessionParticipant) => Promise<Webinar>;
+    /**
+     * Share the local participant audioConfig
+     * @param audioConfig - the audioConfig "stage"|"backstage"|"stageAndBackstage"|a userId
+     */
+    shareLocalParticipantAudioConfig: (audioConfig: string) => Promise<Webinar>;
+    /**
+     * Subscribe to participant media
+     * @param participant - the publisher participant
+     * @param media - the media
+     */
+    subscribeToPublisher: (participant: WebinarSessionParticipant, media: string) => Promise<Webinar>;
+    /**
+     * Unsubscribe to participant media
+     * @param participant - the publisher participant
+     * @param media - the media
+     */
+    unsubscribeToPublisher: (participant: WebinarSessionParticipant, media: string, disableStream?: boolean) => Promise<Webinar>;
+    /**
+     * Send an event to publisher for asking to go on stage
+     * @param participant - the speaker participant
+     * @param media - the media requested to stage
+     */
+    askForStaging: (participant: WebinarSessionParticipant, media: string) => Promise<Webinar>;
+    /**
+     * Decline an "ask to go on stage" offer
+     * @param participant - the speaker participant
+     * @param media -  the media requested to stage
+     */
+    declineStagingInvitation: (participant: WebinarSessionParticipant, media: string) => Promise<Webinar>;
+    muteParticipant: (participant: WebinarSessionParticipant, mute?: boolean) => Promise<Webinar>;
+    declineUnmuteInvitation: (fromParticipant: WebinarSessionParticipant) => Promise<Webinar>;
+    /**
+     * Permit to known if it is possible to add more media audioVideo or sharing on scene
+     */
+    isStageAvailable: () => boolean;
+    allowAttendeeToTalk: (userId: string) => Promise<Webinar>;
+    disableAttendeeToTalk: (userId: string) => Promise<Webinar>;
+    getConnectedUserRole: () => string;
+    isParticipantAnActor: (participant: WebinarSessionParticipant) => boolean;
+    sendCountdownMessage: () => Promise<void>;
+    lowerHand: (userId: string) => Promise<Webinar>;
+    /**
+     * Downloads the recording of this webinar.
+     * @returns A promise that resolves when the download is complete.
+     */
+    downloadRecord: () => Promise<void>;
+    /**
+     * Tells whether this webinar has a recording ready to be played or downloaded.
+     */
+    isRecordAvailable: () => boolean;
+    /**
+     * Returns this webinar's recording as a recap, playable by the recap player.
+     * @returns The recap, or `null` when no recording is available.
+     */
+    getRecap: () => Promise<P2PRecap | null>;
+    /**
+     * Resolves the playable media of this webinar's recording.
+     *
+     * The returned url is signed and time-limited, and requires no auth header.
+     *
+     * @returns The playable media, or `null` when no recording is available.
+     */
+    getRecordMedia: () => Promise<WebinarRecordMedia | null>;
+}
+export declare class WebinarRB implements Webinar {
+    private webinarService?;
+    private xmppService?;
+    id: string;
+    name: string;
+    subject: string;
+    webinarStartDate: string;
+    webinarEndDate: string;
+    webinarDuration: string;
+    webinarLastDateCheck: string;
+    waitingRoomStartDate: string;
+    timeZone: string;
+    roomId: string;
+    roomModeratorsChatId: string;
+    room: Bubble;
+    practiceRoom: Bubble;
+    organizers: any[];
+    speakers: any[];
+    participants: WebinarParticipant[];
+    profileId: string;
+    pendingParticipantNumber: number;
+    acceptedParticipantNumber: number;
+    rejectedParticipantNumber: number;
+    color: string;
+    creatorId: string;
+    creatorCompanyId: string;
+    isCreator: boolean;
+    isOrganizer: boolean;
+    isSpeaker: boolean;
+    isAttendee: boolean;
+    isGuestAttendee: boolean;
+    isGuest: boolean;
+    isMCUBOT: boolean;
+    password: string;
+    approvalRegistrationMethod: string;
+    registrationUuid: string;
+    published: boolean;
+    moderatorsNotified: boolean;
+    status: WebinarStatus;
+    webinarUrl: string;
+    rxSubject: Subject<any>;
+    rxParticipantsSubject: Subject<any>;
+    rxServiceSubject: Subject<any>;
+    rxInfoSubject: Subject<any>;
+    isWebinarSync: boolean;
+    session: WebinarSession | null;
+    waitingRoomMultimediaURLs: string[];
+    stageBackground: string;
+    reminderDates: string[];
+    subtitlesEnable: boolean;
+    blur: boolean;
+    bgReplaceUrl: string;
+    chatOption: string;
+    chatOptionExpired: boolean;
+    chatOptionTimer: any;
+    streaming: boolean;
+    streamingService?: StreamingService;
+    recorded?: string;
+    hideRecordInfo: boolean;
+    recordFileId: string;
+    recordStatus: string;
+    action: string;
+    lastAvatarUpdate?: string;
+    lastActorsInfo?: any;
+    incomingStreamsDisabled: any;
+    /**
+     * Set when an updateStage was skipped because the local SFU session was not yet connected
+     * (e.g. right after a network reconnection). Consumed in onSessionStateChange once the local
+     * audio+video session is connected again, to replay the skipped stage update for attendees --
+     * without it an on-stage attendee reconnecting after a network loss never re-evaluates the
+     * stage and stops seeing the other speakers (CRRAINB-53442).
+     */
+    pendingStageReplay: boolean;
+    /**
+     * Pending session-end timer handles (T-15 / T-5 / T-0). Cleared on terminate/leave.
+     * Optional like the other private fields so `WebinarRB` stays structurally assignable from `Webinar`.
+     */
+    private sessionEndTimers?;
+    private constructor();
+    static create(): WebinarRB;
+    static createFromData(webinarData: any): WebinarRB;
+    sendEvent(name: WebinarEvents, data?: any): void;
+    subscribe2(handler: (event: RBEvent<WebinarEvents>) => any, eventNames?: WebinarEvents | WebinarEvents[]): Subscription;
+    /**
+     * Arms the session-end timers (T-15 / T-5 / T-0) against the effective end of the live
+     * session (start + scheduled duration, see below), not the raw planned `webinarEndDate`.
+     *
+     * Generic — fires {@link WebinarEvents.ON_SESSION_END_WARNING} / {@link WebinarEvents.ON_SESSION_END_REACHED}
+     * with no freemium semantics; consumers decide what to display or enforce. Called both on the
+     * IN_PROGRESS transition and when a participant joins an already-running session (late join), so
+     * it is idempotent: it clears any pending timers before re-arming. Thresholds already past at arm
+     * time are skipped (no retroactive notification).
+     */
+    armSessionEndTimer(): void;
+    /** Clears any pending session-end timers (on terminate, leave, or before re-arming). */
+    clearSessionEndTimer(): void;
+    /**
+     * Update existing webinar with server data
+     * @param webinarData - server webinar data structure
+     */
+    updateFromData(webinarData: any): void;
+    updateAttendeeCounters(): void;
+    subscribe(handler: any): Subscription;
+    getData(): string;
+    updateRaiseHandParticipants(): void;
+    isTerminated(): boolean;
+    isOutdated(): boolean;
+    isFinished(): boolean;
+    isWaitingRoomStarted(): boolean;
+    isInvitation(): boolean;
+    clone(params: WebinarCloneParams): Promise<Webinar>;
+    /**
+     * Asynchronous method to update webinar avatar on server
+     * @param avatarImg - base64 encoded webinar avatar
+     */
+    updateAvatar(avatarImg?: string): Promise<Webinar>;
+    /**
+     * Asynchronous method to update webinar logo on server
+     * @param logoSrc - base64 encoded webinar logo
+     */
+    updateLogo(logoSrc?: string): Promise<Webinar>;
+    acceptInvitation(): Promise<void>;
+    join(): Promise<void>;
+    addAudioVideoMedia(media: string, stream?: MediaStream, replaceBg?: boolean): Promise<void>;
+    addSharingMedia(stream: MediaStream): Promise<void>;
+    resumeSharingPublication(stream: MediaStream, putOnStage: boolean): Promise<void>;
+    leave(forced?: boolean, nowait?: boolean, reason?: string): Promise<void>;
+    joinAsRainbowAttendee(): Promise<void>;
+    putLocalParticipantMixMediaOnStage(): Promise<Webinar>;
+    putLocalParticipantAudioVideoMediaOnStage(master?: boolean): Promise<Webinar>;
+    putParticipantSharingMediaOnStage(participant: WebinarSessionParticipant, master?: boolean): Promise<Webinar>;
+    removeParticipantAudioVideoMediaFromStage(participant: WebinarSessionParticipant): Promise<Webinar>;
+    removeParticipantSharingMediaFromStage(participant: WebinarSessionParticipant): Promise<Webinar>;
+    shareLocalParticipantAudioConfig(audioConfig: string): Promise<Webinar>;
+    subscribeToPublisher(participant: WebinarSessionParticipant, media: string): Promise<Webinar>;
+    unsubscribeToPublisher(participant: WebinarSessionParticipant, media: string, disableStream?: boolean): Promise<Webinar>;
+    askForStaging(participant: WebinarSessionParticipant, media: string): Promise<Webinar>;
+    declineStagingInvitation(participant: WebinarSessionParticipant, media: string): Promise<Webinar>;
+    muteParticipant(participant: WebinarSessionParticipant, mute?: boolean): Promise<Webinar>;
+    declineUnmuteInvitation(participant: WebinarSessionParticipant): Promise<Webinar>;
+    downloadRecord(): Promise<void>;
+    isRecordAvailable(): boolean;
+    getRecap(): Promise<P2PRecap | null>;
+    getRecordMedia(): Promise<WebinarRecordMedia | null>;
+    isStageAvailable(): boolean;
+    allowAttendeeToTalk(userId: string): Promise<Webinar>;
+    disableAttendeeToTalk(userId: string): Promise<Webinar>;
+    lowerHand(userId: string): Promise<Webinar>;
+    getConnectedUserRole(): string;
+    /**
+     * Whether a participant is currently an actor (on stage in audio/video or sharing),
+     * based on the last actors info snapshot.
+     */
+    isParticipantAnActor(participant: WebinarSessionParticipant): boolean;
+    sendCountdownMessage(): Promise<void>;
+}
+//# sourceMappingURL=webinar.model.d.ts.map