@abrar71/lib-jitsi-meet 2131.0.0 → 2133.0.0

package/types/index.d.ts

@@ -312,6 +312,15 @@ declare module "JitsiConferenceEvents" {
          * sources
          */
         FORWARDED_SOURCES_CHANGED = "conference.forwardedSourcesChanged",
+        /**
+         * Indicates that inbound video stats have been received for remote video streams that are receiving
+         * media bytes but decoding no frames. Fired when at least one such stream exists, and once more with an
+         * empty map when all previously-failing streams have recovered (all-clear signal).
+         *
+         * @param {TraceablePeerConnection} tpc - The peer connection.
+         * @param {Map<number, { bitrateDownload: number, fps: number, participantId: string }>} stats - Stats per SSRC.
+         */
+        INBOUND_VIDEO_STATS_RECEIVED = "conference.inbound_video_stats_received",
         /**
          * You are kicked from the conference.
          * @param {JitsiParticipant} the participant that initiated the kick.
@@ -920,6 +929,18 @@ declare module "service/statistics/AnalyticsEvents" {
          *      mediaType: the media type of the local track ('audio' or 'video').
          */
         NO_BYTES_SENT = "track.no-bytes-sent",
+        /**
+         * Indicates a change in the decoding state of a remote video stream that is receiving media bytes.
+         * Fired after the condition persists for at least 3 consecutive stats polling cycles (~30 seconds),
+         * and again when the condition resolves.
+         *
+         * Properties:
+         *      stopped: true when frame decoding has stopped while bytes are still received,
+         *               false when decoding resumes.
+         *      participantId: the ID of the participant whose video stream is affected.
+         *      ssrc: the SSRC of the affected stream.
+         */
+        REMOTE_VIDEO_DECODING = "remote.video.decoding",
         /**
          * Indicates that a track was unmuted (?).
          *
@@ -2626,7 +2647,19 @@ declare module "service/statistics/Events" {
         /**
          * An event carrying the encode time stats for all the local video sources.
          */
-        ENCODE_TIME_STATS = "statistics.encode_time_stats"
+        ENCODE_TIME_STATS = "statistics.encode_time_stats",
+        /**
+         * An event carrying per-SSRC inbound video stats for remote video streams that are receiving bytes but
+         * decoding no frames. Fired in two situations:
+         *   1. When at least one such stream exists (stats map is non-empty).
+         *   2. Once more with an empty map when the set of failing streams transitions from non-empty to empty,
+         *      giving consumers the opportunity to fire resolution events and clean up state.
+         * No event is emitted while all remote streams are healthy.
+         *
+         * @param {TraceablePeerConnection} tpc - The peer connection.
+         * @param {Map<number, { bitrateDownload: number, fps: number, participantId: string }>} stats - Stats per SSRC.
+         */
+        INBOUND_VIDEO_STATS = "statistics.inbound_video_stats"
     }
 }
 declare module "service/statistics/constants" {
@@ -3096,6 +3129,16 @@ declare module "modules/RTCStats/RTCStatsEvents" {
          * Event that indicates that a remote video source is suspended by the JVB because of BWE issues.
          */
         REMOTE_SOURCE_SUSPENDED_EVENT = "remoteSourceSuspended",
+        /**
+         * Event that indicates a change in the decoding state of a remote video stream that is receiving media bytes.
+         *
+         * @param {object} data - The event data.
+         * @param {boolean} data.stopped - True when frame decoding has stopped while bytes are still received,
+         * false when decoding resumes.
+         * @param {string} data.participantId - The participant whose video stream is affected.
+         * @param {number} data.ssrc - The SSRC of the affected stream.
+         */
+        REMOTE_VIDEO_DECODING_EVENT = "remoteVideoDecoding",
         /**
          * Event emitted when any PeerConnection event is triggered.
          *
@@ -7979,6 +8022,13 @@ declare module "modules/statistics/RTPStatsCollector" {
          * @type {Map<number,SsrcStats}
          */
         ssrc2stats: Map<number, SsrcStats>;
+        /**
+         * Tracks whether the previous stats cycle had any inbound video SSRCs in the bad state
+         * (bytes received, no frames decoded). Used to emit a final all-clear call to QualityController
+         * when the set transitions from non-empty to empty.
+         * @type {boolean}
+         */
+        _hadBadInboundSsrcs: boolean;
         /**
          * Set the list of the remote speakers for which audio levels are to be calculated.
          *
@@ -8291,6 +8341,17 @@ declare module "modules/statistics/statistics" {
          * @param {Function} listener - The listener to remove
          */
         removeEncodeTimeStatsListener(listener: (...args: any[]) => void): void;
+        /**
+         * Adds a listener for inbound video stats events. The event fires when at least one remote video stream is
+         * receiving bytes but decoding no frames, and once more with an empty map when all such streams recover.
+         * @param {Function} listener - The listener to add
+         */
+        addInboundVideoStatsListener(listener: (...args: any[]) => void): void;
+        /**
+         * Removes an inbound video stats listener.
+         * @param {Function} listener - The listener to remove
+         */
+        removeInboundVideoStatsListener(listener: (...args: any[]) => void): void;
         /**
          * Adds a listener for byte sent stats events.
          * @param {Function} listener - The listener to add
@@ -11093,1454 +11154,1472 @@ declare module "modules/RTC/JitsiRemoteTrack" {
         toString(): string;
     }
 }
-declare module "JitsiParticipant" {
+declare module "modules/qualitycontrol/CodecSelection" {
     import JitsiConference from "JitsiConference";
-    import JitsiRemoteTrack from "modules/RTC/JitsiRemoteTrack";
-    import { MediaType } from "service/RTC/MediaType";
-    import { SourceName } from "service/RTC/SignalingLayer";
-    import { VideoType } from "service/RTC/VideoType";
-    export interface ISourceInfo {
-        muted: boolean;
-        videoType: string;
+    import JitsiLocalTrack from "modules/RTC/JitsiLocalTrack";
+    import JingleSessionPC from "modules/xmpp/JingleSessionPC";
+    export interface ICodecSelectionOptions {
+        [connectionType: string]: {
+            disabledCodec?: string;
+            enableAV1ForFF?: boolean;
+            preferenceOrder?: string[];
+            preferredCodec?: string;
+            screenshareCodec?: string;
+        };
     }
+    export type CodecPreferenceOrder = {
+        [connectionType: string]: string[];
+    };
+    export type ScreenshareCodec = {
+        [connectionType: string]: string;
+    };
     /**
-     * Represents a participant in (i.e. a member of) a conference.
+     * This class handles the codec selection mechanism for the conference based on the config.js settings.
+     * The preferred codec is selected based on the settings and the list of codecs supported by the browser.
+     * The preferred codec is published in presence which is then used by the other endpoints in the
+     * conference to pick a supported codec at join time and when the call transitions between p2p and jvb
+     * connections.
      */
-    export default class JitsiParticipant {
-        private _jid;
-        private _id;
-        private _conference;
-        private _role;
-        private _hidden;
-        private _statsID?;
-        private _properties;
-        private _identity?;
-        private _isReplacing?;
-        private _isReplaced?;
-        private _isSilent?;
-        private _features;
-        private _sources;
-        private _botType?;
-        private _connectionJid?;
+    export class CodecSelection {
+        private codecPreferenceOrder;
+        private conference;
+        private encodeTimeStats;
+        private options;
+        private screenshareCodec;
+        private visitorCodecs;
         /**
-         * Initializes a new JitsiParticipant instance.
+         * Creates a new instance for a given conference.
          *
-         * @param jid the conference XMPP jid
-         * @param conference
-         * @param displayName
-         * @param {Boolean} hidden - True if the new JitsiParticipant instance is to
-         * represent a hidden participant; otherwise, false.
-         * @param {string} statsID - optional participant statsID
-         * @param {string} status - the initial status if any.
-         * @param {object} identity - the xmpp identity
-         * @param {boolean?} isReplacing - whether this is a participant replacing another into the meeting.
-         * @param {boolean?} isReplaced - whether this is a participant to be kicked and replaced into the meeting.
-         * @param {boolean?} isSilent - whether participant has joined without audio
+         * @param {JitsiConference} conference the conference instance
+         * @param {*} options
+         * @param {string} options.jvb settings (codec list, preferred and disabled) for the jvb connection.
+         * @param {string} options.p2p settings (codec list, preferred and disabled) for the p2p connection.
          */
-        constructor(jid: string, conference: JitsiConference, displayName: string, hidden: boolean, statsID?: string, status?: string, identity?: object, isReplacing?: boolean, isReplaced?: boolean, isSilent?: boolean);
+        constructor(conference: JitsiConference, options: ICodecSelectionOptions);
         /**
-         * Determines whether all JitsiTracks which are of a specific MediaType and which belong to this
-         * JitsiParticipant are muted.
+         * Returns a list of video codecs that are supported by the browser.
          *
-         * @param {MediaType} mediaType - The MediaType of the JitsiTracks to be checked.
-         * @private
-         * @returns {Boolean} True if all JitsiTracks which are of the specified mediaType and which belong to this
-         * JitsiParticipant are muted; otherwise, false.
+         * @param {string} connectionType - media connection type, p2p or jvb.
+         * @returns {Array}
          */
-        _isMediaTypeMuted(mediaType: MediaType): boolean;
+        _getSupportedVideoCodecs(connectionType: string): string[];
         /**
-         * Sets source info.
-         * @param {MediaType} mediaType The media type, 'audio' or 'video'.
-         * @param {boolean} muted The new muted state.
-         * @param {SourceName} sourceName The name of the source.
-         * @param {string} videoType The video type of the source.
-         * @returns {void}
+         * Returns the current codec preference order for the given connection type.
+         *
+         * @param {String} connectionType The media connection type, 'p2p' or 'jvb'.
+         * @returns {Array<string>}
          */
-        _setSources(mediaType: MediaType, muted: boolean, sourceName: SourceName, videoType: VideoType): void;
+        getCodecPreferenceList(connectionType: string): string[];
         /**
-         * Returns the bot type for the participant.
+         * Returns the preferred screenshare codec for the given connection type.
          *
-         * @returns {Optional<string>} - The bot type of the participant.
+         * @param {Optional} connectionType The media connection type, 'p2p' or 'jvb'.
+         * @returns CodecMimeType
          */
-        getBotType(): Optional<string>;
+        getScreenshareCodec(connectionType: string): Optional<string>;
         /**
-         * @returns {JitsiConference} The conference that this participant belongs
-         * to.
+         * Sets the codec on the media session based on the codec preference order configured in config.js and the supported
+         * codecs published by the remote participants in their presence.
+         *
+         * @param {JingleSessionPC} mediaSession session for which the codec selection has to be made.
          */
-        getConference(): JitsiConference;
+        selectPreferredCodec(mediaSession?: JingleSessionPC): void;
         /**
-         * Returns the connection jid for the participant.
+         * Changes the codec preference order.
          *
-         * @returns {Optional<string>} - The connection jid of the participant.
+         * @param {JitsiLocalTrack} localTrack - The local video track.
+         * @param {CodecMimeType} codec - The codec used for encoding the given local video track.
+         * @returns boolean - Returns true if the codec order has been updated, false otherwise.
          */
-        getConnectionJid(): Optional<string>;
+        changeCodecPreferenceOrder(localTrack: JitsiLocalTrack, codec: string): boolean;
         /**
-         * @returns {String} The human-readable display name of this participant.
+         * Updates the aggregate list of the codecs supported by all the visitors in the call and calculates the
+         * selected codec if needed.
+         * @param {Array} codecList - visitor codecs.
+         * @returns {void}
          */
-        getDisplayName(): string;
+        updateVisitorCodecs(codecList: string[]): void;
+    }
+}
+declare module "modules/qualitycontrol/ReceiveAudioController" {
+    import JitsiConference from "JitsiConference";
+    import { IReceiverAudioSubscriptionMessage, ReceiverAudioSubscription } from "service/RTC/ReceiverAudioSubscription";
+    /**
+     * Controller for managing audio subscriptions in a Jitsi conference. It allows subscribing to remote audio streams
+     * based on different modes such as ALL, EXCLUDE, INCLUDE, and NONE.
+     */
+    export class ReceiverAudioController {
+        private _rtc;
         /**
-         * Returns a set with the features for the participant.
-         * @returns {Promise<Set<String>>}
+         * The list of remote audio sources that the local endpoint is subscribed/unsubscribed to.
+         * This is used when the subscription mode is set to INCLUDE or EXCLUDE.
          */
-        getFeatures(): Promise<Set<string>>;
+        private _sourceList;
         /**
-         * @returns {String} The ID of this participant.
+         * The audio subscription options for remote audio streams.
          */
-        getId(): string;
+        private _subscriptionMode;
         /**
-         * Returns the XMPP identity. This is defined by your application in the
-         * JWT `context` claims section.
-         *
-         * @returns {Optional<object>} - XMPP user identity.
+         * Creates a new instance of the ReceiverAudioController.
          */
-        getIdentity(): Optional<object>;
+        constructor(conference: JitsiConference);
         /**
-         * @returns {String} The JID of this participant.
+         * Gets the current audio subscription option.
+         *
+         * @returns {ReceiverAudioSubscription} The current audio subscription option.
          */
-        getJid(): string;
+        get audioSubscription(): ReceiverAudioSubscription;
         /**
-         * Gets the value of a property of this participant.
+         * Mutes or unmutes the remote audio streams based on the provided parameter.
+         *
+         * @param {boolean} muted - Indicates whether the remote audio should be muted or not.
+         * @returns {void}
          */
-        getProperty(name: string): any;
+        muteRemoteAudio(muted: boolean): void;
         /**
-         * @returns {String} The role of this participant.
+         * Sets the audio subscription options.
+         *
+         * @param message The audio subscription message containing the mode and optional source list.
+         * @returns {void}
          */
-        getRole(): string;
+        setAudioSubscriptionMode(message: IReceiverAudioSubscriptionMessage): void;
+    }
+}
+declare module "modules/qualitycontrol/SendVideoController" {
+    import JitsiConference from "JitsiConference";
+    import JingleSessionPC from "modules/xmpp/JingleSessionPC";
+    export interface IVideoConstraint {
+        maxHeight: number;
+        sourceName: string;
+    }
+    /**
+     * The class manages send video constraints across media sessions({@link JingleSessionPC}) which belong to
+     * {@link JitsiConference}. It finds the lowest common value, between the local user's send preference and
+     * the remote party's receive preference. Also this module will consider only the active session's receive value,
+     * because local tracks are shared and while JVB may have no preference, the remote p2p may have and they may be totally
+     * different.
+     */
+    export default class SendVideoController {
+        private _conference;
+        private _preferredSendMaxFrameHeight;
         /**
-         * Returns the sources associated with this participant.
-         * @returns Map<string, Map<string, Object>>
+         * Source name based sender constraints.
+         * @type {Map<string, number>};
          */
-        getSources(): Map<MediaType, Map<string, ISourceInfo>>;
+        private _sourceSenderConstraints;
         /**
-         * @returns {String} The stats ID of this participant.
+         * Creates new instance for a given conference.
+         *
+         * @param {JitsiConference} conference - the conference instance for which the new instance will be managing
+         * the send video quality constraints.
          */
-        getStatsID(): string;
+        constructor(conference: JitsiConference);
         /**
-         * @returns {String} The status of the participant.
+         * Figures out the send video constraint as specified by {@link _selectSendMaxFrameHeight} and sets it on all media
+         * sessions for the reasons mentioned in this class description.
+         *
+         * @param {string} sourceName - The source for which sender constraints have changed.
+         * @returns {Promise<void>}
+         * @private
          */
-        getStatus(): string;
+        _propagateSendMaxFrameHeight(sourceName: string): Promise<void>;
         /**
-         * @returns {Array.<JitsiRemoteTrack>} The list of media tracks for this
-         * participant.
+         * Selects the lowest common value for the local video send constraint by looking at local user's preference and
+         * the active media session's receive preference set by the remote party.
+         *
+         * @param {string} sourceName - The source for which sender constraints have changed.
+         * @returns {Optional<number>}
+         * @private
          */
-        getTracks(): (JitsiRemoteTrack)[];
+        _selectSendMaxFrameHeight(sourceName: string): Optional<number>;
         /**
-         * @param {MediaType} mediaType
-         * @returns {Array.<JitsiRemoteTrack>} an array of media tracks for this
-         * participant, for given media type.
+         * Configures the video encodings on the local sources when a media connection is established or becomes active.
+         *
+         * @returns {void}
          */
-        getTracksByMediaType(mediaType: MediaType): (JitsiRemoteTrack)[];
+        configureConstraintsForLocalSources(): void;
         /**
-         * Checks current set features.
-         * @param {String} feature - the feature to check.
-         * @return {boolean} <tt>true</tt> if this <tt>participant</tt> contains the
-         * <tt>feature</tt>.
-         */
-        hasFeature(feature: string): boolean;
-        /**
-         * @returns {Boolean} Whether this participant has muted their audio.
-         */
-        isAudioMuted(): boolean;
-        /**
-         * @returns {Boolean} Whether this participant is a hidden participant. Some
-         * special system participants may want to join hidden (like for example the
-         * recorder).
+         * Handles the {@link JitsiConferenceEvents.MEDIA_SESSION_STARTED}, that is when the conference creates new media
+         * session. It doesn't mean it's already active though. For example the JVB connection may be created after
+         * the conference has entered the p2p mode already.
+         *
+         * @param {JingleSessionPC} mediaSession - the started media session.
          */
-        isHidden(): boolean;
+        onMediaSessionStarted(mediaSession: JingleSessionPC): void;
         /**
-         * @returns {Boolean} Whether this participant is a hidden participant. Some
-         * special system participants may want to join hidden (like for example the
-         * recorder).
+         * Propagates the video constraints if they have changed.
+         *
+         * @param {IVideoConstraint} videoConstraints - The sender video constraints received from the bridge.
+         * @returns {Promise<void>}
          */
-        isHiddenFromRecorder(): boolean;
+        onSenderConstraintsReceived(videoConstraints: IVideoConstraint): Promise<void>;
         /**
-         * @returns {Boolean} Whether this participant is a moderator or not.
+         * Sets local preference for max send video frame height.
+         *
+         * @param {number} maxFrameHeight - the new value to set.
+         * @returns {Promise<void>} - resolved when the operation is complete.
          */
-        isModerator(): boolean;
+        setPreferredSendMaxFrameHeight(maxFrameHeight: number): Promise<void>;
+    }
+}
+declare module "modules/qualitycontrol/QualityController" {
+    import JitsiConference from "JitsiConference";
+    import { CodecMimeType } from "service/RTC/CodecMimeType";
+    import JitsiLocalTrack from "modules/RTC/JitsiLocalTrack";
+    import TraceablePeerConnection from "modules/RTC/TraceablePeerConnection";
+    import { CodecSelection } from "modules/qualitycontrol/CodecSelection";
+    import { ReceiverAudioController } from "modules/qualitycontrol/ReceiveAudioController";
+    import ReceiveVideoController from "modules/qualitycontrol/ReceiveVideoController";
+    import SendVideoController from "modules/qualitycontrol/SendVideoController";
+    export const NOT_DECODING_THRESHOLD_CYCLES = 6;
+    enum QualityLimitationReason {
+        BANDWIDTH = "bandwidth",
+        CPU = "cpu",
+        NONE = "none"
+    }
+    interface IResolution {
+        height: number;
+        width: number;
+    }
+    interface IOutboundRtpStats {
+        codec: CodecMimeType;
+        encodeTime: number;
+        qualityLimitationReason: QualityLimitationReason;
+        resolution: IResolution;
+        timestamp: number;
+    }
+    export interface ISourceStats {
+        avgEncodeTime: number;
+        codec: CodecMimeType;
+        encodeResolution: number;
+        localTrack: JitsiLocalTrack;
+        qualityLimitationReason: QualityLimitationReason;
+        timestamp: number;
+        tpc: TraceablePeerConnection;
+    }
+    export interface IInboundVideoStats {
+        bitrateDownload: number;
+        fps: number;
+        participantId: string;
+    }
+    export class FixedSizeArray {
+        private _data;
+        private _maxSize;
+        constructor(size: number);
+        add(item: ISourceStats): void;
+        get(index: number): Optional<ISourceStats>;
+        size(): number;
+    }
+    /**
+     * QualityController class that is responsible for maintaining optimal video quality experience on the local endpoint
+     * by controlling the codec, encode resolution and receive resolution of the remote video streams. It also makes
+     * adjustments based on the outbound and inbound rtp stream stats reported by the underlying peer connection.
+     */
+    export class QualityController {
+        private _audioController;
+        private _codecController;
+        private _conference;
+        private _enableAdaptiveMode;
+        private _encodeTimeStats;
+        private _isLastNRampupBlocked;
+        private _lastNRampupTime;
+        private _lastNRampupTimeout;
+        private _limitedByCpuTimeout;
+        private _notDecodingVideoTracker;
+        private _receiveVideoController;
+        private _sendVideoController;
+        private _timer;
         /**
-         * @returns {Boolean} Wheter this participants will be replaced by another
-         * participant in the meeting.
+         *
+         * @param {JitsiConference} conference - The JitsiConference instance.
+         * @param {Object} options - video quality settings passed through config.js.
          */
-        isReplaced(): boolean;
+        constructor(conference: JitsiConference, options: {
+            enableAdaptiveMode: boolean;
+            jvb: object;
+            lastNRampupTime: number;
+            p2p: object;
+        });
         /**
-         * @returns {Boolean} Whether this participant replaces another participant
-         * from the meeting.
+         * Creates a debounced function that delays the execution of the provided function until after the specified delay
+         * has elapsed. Unlike typical debounce implementations, the timer does not reset when the function is called again
+         * within the delay period.
+         *
+         * @param {Function} func - The function to be debounced.
+         * @param {number} delay - The delay in milliseconds.
+         * @returns {Function} - The debounced function.
          */
-        isReplacing(): boolean;
+        _debounce(func: Function, delay: number): (...args: any) => void;
         /**
-         * @returns {Boolean} Whether this participant has joined without audio.
+         * Adjusts the lastN value so that fewer remote video sources are received from the bridge in an attempt to improve
+         * encode resolution of the outbound video streams based on cpuLimited parameter passed. If cpuLimited is false,
+         * the lastN value will slowly be ramped back up to the channelLastN value set in config.js.
+         *
+         * @param {boolean} cpuLimited - whether the endpoint is cpu limited or not.
+         * @returns boolean - Returns true if an action was taken, false otherwise.
          */
-        isSilent(): boolean;
+        _lowerOrRaiseLastN(cpuLimited: boolean): boolean;
         /**
-         * @returns {Boolean} Whether this participant has muted their video.
+         * Adjusts the requested resolution for remote video sources by updating the receiver constraints in an attempt to
+         * improve the encode resolution of the outbound video streams.
+         * @return {void}
          */
-        isVideoMuted(): boolean;
+        _maybeLowerReceiveResolution(): void;
         /**
-         * Sets the bot type for the participant.
-         * @param {String} newBotType - The new bot type to set.
+         * Updates the codec preference order for the local endpoint on the active media session and switches the video
+         * codec if needed.
+         *
+         * @param {number} trackId - The track ID of the local video track for which stats have been captured.
+         * @returns {boolean} - Returns true if video codec was changed.
          */
-        setBotType(newBotType: string): void;
+        _maybeSwitchVideoCodec(trackId: number): boolean;
         /**
-         * Sets the connection jid for the participant.
-         * @param {String} newJid - The connection jid to set.
+         * Adjusts codec, lastN or receive resolution based on the send resolution (of the outbound streams) and limitation
+         * reported by the browser in the WebRTC stats. Recovery is also attempted if the limitation goes away. No action
+         * is taken if the adaptive mode has been disabled through config.js.
+         *
+         * @param {ISourceStats} sourceStats - The outbound-rtp stats for a local video track.
+         * @returns {void}
          */
-        setConnectionJid(newJid: string): void;
+        _performQualityOptimizations(sourceStats: ISourceStats): void;
         /**
-         * Set new features.
-         * @param {Set<String>|undefined} newFeatures - Sets new features.
+         * Processes inbound video stats for remote streams that are receiving bytes but decoding no frames.
+         * Only SSRCs already filtered to the problematic condition (bitrateDownload > 0, fps === 0) are passed in.
+         * Tracks each affected SSRC across consecutive polling cycles and fires RTCStats + Amplitude analytics events
+         * after NOT_DECODING_THRESHOLD_CYCLES consecutive bad cycles. Fires again with stopped=false when resolved.
+         *
+         * @param {TraceablePeerConnection} tpc - The peer connection where stats were captured.
+         * @param {Map<number, IInboundVideoStats>} stats - Per-SSRC stats for streams currently failing the check.
+         * @returns {void}
          */
-        setFeatures(newFeatures?: Set<string>): void;
+        _processInboundVideoStats(tpc: TraceablePeerConnection, stats: Map<number, IInboundVideoStats>): void;
         /**
-         * Sets whether participant is being replaced by another based on jwt.
-         * @param {boolean} newIsReplaced - whether is being replaced.
+         * Processes the outbound RTP stream stats as reported by the WebRTC peerconnection and makes runtime adjustments
+         * to the client for better quality experience if the adaptive mode is enabled.
+         *
+         * @param {TraceablePeerConnection} tpc - The underlying WebRTC peerconnection where stats have been captured.
+         * @param {Map<number, IOutboundRtpStats>} stats - Outbound-rtp stream stats per SSRC.
+         * @returns void
          */
-        setIsReplaced(newIsReplaced: boolean): void;
+        _processOutboundRtpStats(tpc: TraceablePeerConnection, stats: Map<number, IOutboundRtpStats>): void;
         /**
-         * Sets whether participant is replacing another based on jwt.
-         * @param {boolean} newIsReplacing - whether is replacing.
+         * Gets the audio controller instance.
          */
-        setIsReplacing(newIsReplacing: boolean): void;
+        get audioController(): ReceiverAudioController;
         /**
-         * Sets whether participant has joined without audio.
-         * @param {boolean} newIsSilent - whether is silent.
+         * Gets the codec controller instance.
          */
-        setIsSilent(newIsSilent: boolean): void;
+        get codecController(): CodecSelection;
         /**
-         * Sets the value of a property of this participant, and fires an event if
-         * the value has changed.
-         * @param {string} name the name of the property.
-         * @param {any} value the value to set.
+         * Gets the receive video controller instance.
          */
-        setProperty(name: string, value: any): void;
+        get receiveVideoController(): ReceiveVideoController;
         /**
-         * Sets a new participant role.
-         * @param {String} newRole - the new role.
+         * Gets the send video controller instance.
          */
-        setRole(newRole: string): void;
+        get sendVideoController(): SendVideoController;
         /**
-         *
+         * Cleans up the QualityController by clearing all active timeouts and disposing of controllers.
+         * This prevents memory leaks and ensures proper cleanup when the controller is no longer needed.
          */
-        supportsDTMF(): boolean;
+        dispose(): void;
     }
 }
-declare module "modules/recording/recordingXMLUtils" {
-    /**
-     * A collection of utility functions for taking in XML and parsing it to return
-     * certain values.
-     */
-    export interface IFocusRecordingUpdate {
-        error?: string;
-        initiator?: string;
-        recordingMode?: string;
-        sessionID?: string;
-        status?: string;
-    }
-    export interface IHiddenDomainUpdate {
-        liveStreamViewURL?: string;
-        mode?: string;
-        sessionID?: string;
-    }
-    /**
-     * Parses the presence update of the focus and returns an object with the
-     * statuses related to recording.
-     *
-     * @param {Element} presence - An XMPP presence update.
-     * @returns {Optional<Object>} The current presence values related to recording.
-     */
-    export function getFocusRecordingUpdate(presence: Element): Optional<IFocusRecordingUpdate>;
-    /**
-     * Parses the presence update from a hidden domain participant and returns
-     * an object with the statuses related to recording.
-     *
-     * @param {Element} presence - An XMPP presence update.
-     * @returns {Object} The current presence values related to recording.
-     */
-    export function getHiddenDomainUpdate(presence: Element): IHiddenDomainUpdate;
-    /**
-     * Returns the recording session ID from a successful IQ.
-     *
-     * @param {Element} response - The response from the IQ.
-     * @returns {string} The session ID of the recording session.
-     */
-    export function getSessionIdFromIq(response: Element): Nullable<string>;
-    /**
-     * Returns the recording session ID from a presence, if it exists.
-     *
-     * @param {Element} presence - An XMPP presence update.
-     * @returns {string|null|undefined} The session ID of the recording session.
-     */
-    export function getSessionId(presence: Element): Optional<Nullable<string>>;
-    /**
-     * Returns whether or not a presence is from the focus.
-     *
-     * @param {Element} presence - An XMPP presence update.
-     * @returns {boolean} True if the presence is from the focus.
-     */
-    export function isFromFocus(presence: Element): boolean;
-}
-declare module "modules/recording/JibriSession" {
-    import JitsiParticipant from "JitsiParticipant";
-    import XmppConnection from "modules/xmpp/XmppConnection";
-    export interface IJibriSessionOptions {
-        connection?: XmppConnection;
-        focusMucJid?: string;
-        mode?: string;
-        sessionID?: string;
-        status?: string;
-    }
-    export interface IStartOptions {
-        appData?: string;
-        broadcastId?: string;
-        focusMucJid: string;
-        streamId?: string;
-    }
-    export interface IStopOptions {
-        focusMucJid: string;
-    }
-    export interface IQOptions {
-        action?: 'start' | 'stop';
-        appData?: string;
-        broadcastId?: string;
-        focusMucJid: string;
-        streamId?: string;
+declare module "JitsiParticipant" {
+    import JitsiConference from "JitsiConference";
+    import JitsiRemoteTrack from "modules/RTC/JitsiRemoteTrack";
+    import { MediaType } from "service/RTC/MediaType";
+    import { SourceName } from "service/RTC/SignalingLayer";
+    import { VideoType } from "service/RTC/VideoType";
+    export interface ISourceInfo {
+        muted: boolean;
+        videoType: string;
     }
     /**
-     * Represents a recording session.
+     * Represents a participant in (i.e. a member of) a conference.
      */
-    export default class JibriSession {
-        private _connection?;
-        private _mode?;
-        private _jibriJid;
-        private _statusFromJicofo;
-        private _sessionID?;
-        private _status?;
-        private _error?;
-        private _liveStreamViewURL?;
-        private _initiator?;
-        private _terminator?;
-        private _focusMucJid?;
+    export default class JitsiParticipant {
+        private _jid;
+        private _id;
+        private _conference;
+        private _role;
+        private _hidden;
+        private _statsID?;
+        private _properties;
+        private _identity?;
+        private _isReplacing?;
+        private _isReplaced?;
+        private _isSilent?;
+        private _features;
+        private _sources;
+        private _botType?;
+        private _connectionJid?;
         /**
-         * Initializes a new JibriSession instance.
+         * Initializes a new JitsiParticipant instance.
          *
-         * @constructor
+         * @param jid the conference XMPP jid
+         * @param conference
+         * @param displayName
+         * @param {Boolean} hidden - True if the new JitsiParticipant instance is to
+         * represent a hidden participant; otherwise, false.
+         * @param {string} statsID - optional participant statsID
+         * @param {string} status - the initial status if any.
+         * @param {object} identity - the xmpp identity
+         * @param {boolean?} isReplacing - whether this is a participant replacing another into the meeting.
+         * @param {boolean?} isReplaced - whether this is a participant to be kicked and replaced into the meeting.
+         * @param {boolean?} isSilent - whether participant has joined without audio
+         */
+        constructor(jid: string, conference: JitsiConference, displayName: string, hidden: boolean, statsID?: string, status?: string, identity?: object, isReplacing?: boolean, isReplaced?: boolean, isSilent?: boolean);
+        /**
+         * Determines whether all JitsiTracks which are of a specific MediaType and which belong to this
+         * JitsiParticipant are muted.
+         *
+         * @param {MediaType} mediaType - The MediaType of the JitsiTracks to be checked.
+         * @private
+         * @returns {Boolean} True if all JitsiTracks which are of the specified mediaType and which belong to this
+         * JitsiParticipant are muted; otherwise, false.
+         */
+        _isMediaTypeMuted(mediaType: MediaType): boolean;
+        /**
+         * Sets source info.
+         * @param {MediaType} mediaType The media type, 'audio' or 'video'.
+         * @param {boolean} muted The new muted state.
+         * @param {SourceName} sourceName The name of the source.
+         * @param {string} videoType The video type of the source.
+         * @returns {void}
+         */
+        _setSources(mediaType: MediaType, muted: boolean, sourceName: SourceName, videoType: VideoType): void;
+        /**
+         * Returns the bot type for the participant.
+         *
+         * @returns {Optional<string>} - The bot type of the participant.
+         */
+        getBotType(): Optional<string>;
+        /**
+         * @returns {JitsiConference} The conference that this participant belongs
+         * to.
+         */
+        getConference(): JitsiConference;
+        /**
+         * Returns the connection jid for the participant.
+         *
+         * @returns {Optional<string>} - The connection jid of the participant.
+         */
+        getConnectionJid(): Optional<string>;
+        /**
+         * @returns {String} The human-readable display name of this participant.
+         */
+        getDisplayName(): string;
+        /**
+         * Returns a set with the features for the participant.
+         * @returns {Promise<Set<String>>}
+         */
+        getFeatures(): Promise<Set<string>>;
+        /**
+         * @returns {String} The ID of this participant.
          */
-        constructor(options?: IJibriSessionOptions);
+        getId(): string;
         /**
-         * Returns the error related to the session instance, if any.
+         * Returns the XMPP identity. This is defined by your application in the
+         * JWT `context` claims section.
          *
-         * @returns {Optional<string>}
+         * @returns {Optional<object>} - XMPP user identity.
          */
-        getError(): Optional<string>;
+        getIdentity(): Optional<object>;
         /**
-         * Returns the session ID of the session instance.
-         *
-         * @returns {Optional<string>}
+         * @returns {String} The JID of this participant.
          */
-        getID(): Optional<string>;
+        getJid(): string;
         /**
-         * Returns the initiator of the session instance.
-         *
-         * @returns {JitsiParticipant|string} The participant that started the session.
+         * Gets the value of a property of this participant.
          */
-        getInitiator(): JitsiParticipant | string;
+        getProperty(name: string): any;
         /**
-         * Returns the streaming URL of the session.
-         *
-         * @returns {Optional<string>}
+         * @returns {String} The role of this participant.
          */
-        getLiveStreamViewURL(): Optional<string>;
+        getRole(): string;
         /**
-         * Returns the current status of the session.
-         *
-         * @returns {Optional<string>}
+         * Returns the sources associated with this participant.
+         * @returns Map<string, Map<string, Object>>
          */
-        getStatus(): Optional<string>;
+        getSources(): Map<MediaType, Map<string, ISourceInfo>>;
         /**
-         * @returns {Optional<string>}
+         * @returns {String} The stats ID of this participant.
          */
-        getJibriJid(): Optional<string>;
+        getStatsID(): string;
         /**
-         * Returns the jid of the participant that stopped the session.
-         *
-         * @returns {JitsiParticipant|string} The participant that stopped the session.
+         * @returns {String} The status of the participant.
          */
-        getTerminator(): JitsiParticipant | string;
+        getStatus(): string;
         /**
-         * Returns the current recording mode of the session, such as "file".
-         *
-         * @returns {string}
+         * @returns {Array.<JitsiRemoteTrack>} The list of media tracks for this
+         * participant.
          */
-        getMode(): string;
+        getTracks(): (JitsiRemoteTrack)[];
         /**
-         * Sets the last known error message related to the session.
-         *
-         * @param {string} error - The error string explaining why the session
-         * entered an error state.
-         * @returns {void}
+         * @param {MediaType} mediaType
+         * @returns {Array.<JitsiRemoteTrack>} an array of media tracks for this
+         * participant, for given media type.
          */
-        setError(error: string): void;
+        getTracksByMediaType(mediaType: MediaType): (JitsiRemoteTrack)[];
         /**
-         * Sets the last live stream URL for the session instance. Usually this is
-         * a YouTube URL and usually this is only set for "stream" sessions.
-         *
-         * @param {string} url - The live stream URL associated with the session.
-         * @returns {void}
+         * Checks current set features.
+         * @param {String} feature - the feature to check.
+         * @return {boolean} <tt>true</tt> if this <tt>participant</tt> contains the
+         * <tt>feature</tt>.
          */
-        setLiveStreamViewURL(url: string): void;
+        hasFeature(feature: string): boolean;
         /**
-         * Sets the last known status for this recording session.
-         *
-         * @param {string} status - The new status to set.
-         * @returns {void}
+         * @returns {Boolean} Whether this participant has muted their audio.
          */
-        setStatus(status?: string): void;
+        isAudioMuted(): boolean;
         /**
-         * Set the session status reported by jicofo. If a jibri is present in the room,
-         * the status is always 'on'. Otherwise, we fallback to the status reported by jicofo.
-         *
-         * @param {string} status
+         * @returns {Boolean} Whether this participant is a hidden participant. Some
+         * special system participants may want to join hidden (like for example the
+         * recorder).
          */
-        setStatusFromJicofo(status: string): void;
+        isHidden(): boolean;
         /**
-         * Set the JID of the jibri associated with this session.
-         *
-         * @param {*} jibriJid
+         * @returns {Boolean} Whether this participant is a hidden participant. Some
+         * special system participants may want to join hidden (like for example the
+         * recorder).
          */
-        setJibriJid(jibriJid: Nullable<string>): void;
+        isHiddenFromRecorder(): boolean;
         /**
-         * Sets the participant that started the session.
-         * @param {JitsiParticipant | string} participant - The participant or resource id
-         * if local participant.
+         * @returns {Boolean} Whether this participant is a moderator or not.
          */
-        setInitiator(participant: JitsiParticipant | string): void;
+        isModerator(): boolean;
         /**
-         * Sets the participant that stopped the session.
-         * @param {JitsiParticipant | string} participant - The participant or the resource id
-         * if local participant.
+         * @returns {Boolean} Wheter this participants will be replaced by another
+         * participant in the meeting.
          */
-        setTerminator(participant: JitsiParticipant | string): void;
+        isReplaced(): boolean;
         /**
-         * Sends a message to start the actual recording.
-         *
-         * @param {Object} options - Additional arguments for starting therecording.
-         * @param {string} [options.appData] - Data specific to the app/service that the result file will be uploaded.
-         * @param {string} [options.broadcastId] - The broadcast ID of an associated YouTube stream, used for knowing the
-         * URL from which the stream can be viewed.
-         * @param {string} options.focusMucJid - The JID of the focus participant that controls recording.
-         * @param {streamId} options.streamId - Necessary for live streaming, this is the stream key needed to start a live
-         * streaming session with the streaming service provider.
-         * @returns Promise
+         * @returns {Boolean} Whether this participant replaces another participant
+         * from the meeting.
          */
-        start({ appData, broadcastId, focusMucJid, streamId }: IStartOptions): Promise<void>;
+        isReplacing(): boolean;
         /**
-         * Sends a message to actually stop the recording session.
-         *
-         * @param {Object} options - Additional arguments for stopping the recording.
-         * @param {Object} options.focusMucJid - The JID of the focus participant that controls recording.
-         * @returns Promise
+         * @returns {Boolean} Whether this participant has joined without audio.
          */
-        stop({ focusMucJid }: IStopOptions): Promise<any>;
+        isSilent(): boolean;
         /**
-         * Generates the message to change the status of the recording session.
-         *
-         * @param {string} [options.action] - The action to set the IQ
-         * @param {string} [options.appData] - Data specific to the app/service that
-         * the result file will be uploaded.
-         * @param {string} [options.broadcastId] - The broadcast ID of an
-         * associated YouTube stream, used for knowing the URL from which the stream
-         * can be viewed.
-         * @param {string} options.focusMucJid - The JID of the focus participant
-         * that controls recording.
-         * @param {streamId} options.streamId - Necessary for live streaming, this
-         * is the stream key needed to start a live streaming session with the
-         * streaming service provider.
-         * @returns Object - The XMPP IQ message.
+         * @returns {Boolean} Whether this participant has muted their video.
          */
-        _createIQ({ action, appData, broadcastId, focusMucJid, streamId }: IQOptions): any;
+        isVideoMuted(): boolean;
         /**
-         * Handles the error from an iq and stores the error.
-         *
-         * @param {Node} errorIq - The error response from an Iq.
-         * @private
-         * @returns {void}
+         * Sets the bot type for the participant.
+         * @param {String} newBotType - The new bot type to set.
          */
-        _setErrorFromIq(errorIq: any): void;
+        setBotType(newBotType: string): void;
         /**
-         * Sets the known session ID for this recording session.
-         *
-         * @param {string} sessionID
-         * @private
-         * @returns {void}
+         * Sets the connection jid for the participant.
+         * @param {String} newJid - The connection jid to set.
          */
-        _setSessionID(sessionID?: string): void;
-    }
-}
-declare module "modules/statistics/constants" {
-    /**
-     * The number of remote speakers for which the audio levels will be calculated using
-     * RTCRtpReceiver#getSynchronizationSources. Limit the number of endpoints to save cpu on the client as this API call
-     * is known to take longer to execute when there are many audio receivers.
-     */
-    export const SPEAKERS_AUDIO_LEVELS: number;
-}
-declare module "JitsiConferenceEventManager" {
-    import JitsiConference from "JitsiConference";
-    /**
-     * Setups all event listeners related to conference
-     */
-    export default class JitsiConferenceEventManager {
-        private conference;
-        private xmppListeners;
-        private chatRoomForwarder?;
+        setConnectionJid(newJid: string): void;
         /**
-         * Setups all event listeners related to conference
-         * @param conference {JitsiConference} the conference
+         * Set new features.
+         * @param {Set<String>|undefined} newFeatures - Sets new features.
          */
-        constructor(conference: JitsiConference);
+        setFeatures(newFeatures?: Set<string>): void;
         /**
-         * Add XMPP listener and save its reference for remove on leave conference.
-         * @param {string} eventName - The event name.
-         * @param {Function} listener - The listener function.
-         * @private
+         * Sets whether participant is being replaced by another based on jwt.
+         * @param {boolean} newIsReplaced - whether is being replaced.
          */
-        private _addConferenceXMPPListener;
+        setIsReplaced(newIsReplaced: boolean): void;
         /**
-         * Setups event listeners related to conference.chatRoom
+         * Sets whether participant is replacing another based on jwt.
+         * @param {boolean} newIsReplacing - whether is replacing.
          */
-        setupChatRoomListeners(): void;
+        setIsReplacing(newIsReplacing: boolean): void;
         /**
-         * Setups event listeners related to conference.rtc
+         * Sets whether participant has joined without audio.
+         * @param {boolean} newIsSilent - whether is silent.
          */
-        setupRTCListeners(): void;
+        setIsSilent(newIsSilent: boolean): void;
         /**
-         * Setups event listeners related to conference.statistics
+         * Sets the value of a property of this participant, and fires an event if
+         * the value has changed.
+         * @param {string} name the name of the property.
+         * @param {any} value the value to set.
          */
-        setupStatisticsListeners(): void;
+        setProperty(name: string, value: any): void;
         /**
-         * Setups event listeners related to conference.xmpp
+         * Sets a new participant role.
+         * @param {String} newRole - the new role.
          */
-        setupXMPPListeners(): void;
+        setRole(newRole: string): void;
         /**
-         * Removes event listeners related to conference.xmpp
+         *
          */
-        removeXMPPListeners(): void;
+        supportsDTMF(): boolean;
+    }
+}
+declare module "modules/recording/recordingXMLUtils" {
+    /**
+     * A collection of utility functions for taking in XML and parsing it to return
+     * certain values.
+     */
+    export interface IFocusRecordingUpdate {
+        error?: string;
+        initiator?: string;
+        recordingMode?: string;
+        sessionID?: string;
+        status?: string;
+    }
+    export interface IHiddenDomainUpdate {
+        liveStreamViewURL?: string;
+        mode?: string;
+        sessionID?: string;
     }
+    /**
+     * Parses the presence update of the focus and returns an object with the
+     * statuses related to recording.
+     *
+     * @param {Element} presence - An XMPP presence update.
+     * @returns {Optional<Object>} The current presence values related to recording.
+     */
+    export function getFocusRecordingUpdate(presence: Element): Optional<IFocusRecordingUpdate>;
+    /**
+     * Parses the presence update from a hidden domain participant and returns
+     * an object with the statuses related to recording.
+     *
+     * @param {Element} presence - An XMPP presence update.
+     * @returns {Object} The current presence values related to recording.
+     */
+    export function getHiddenDomainUpdate(presence: Element): IHiddenDomainUpdate;
+    /**
+     * Returns the recording session ID from a successful IQ.
+     *
+     * @param {Element} response - The response from the IQ.
+     * @returns {string} The session ID of the recording session.
+     */
+    export function getSessionIdFromIq(response: Element): Nullable<string>;
+    /**
+     * Returns the recording session ID from a presence, if it exists.
+     *
+     * @param {Element} presence - An XMPP presence update.
+     * @returns {string|null|undefined} The session ID of the recording session.
+     */
+    export function getSessionId(presence: Element): Optional<Nullable<string>>;
+    /**
+     * Returns whether or not a presence is from the focus.
+     *
+     * @param {Element} presence - An XMPP presence update.
+     * @returns {boolean} True if the presence is from the focus.
+     */
+    export function isFromFocus(presence: Element): boolean;
 }
-declare module "service/connectivity/ConnectionQualityEvents" {
-    export enum ConnectionQualityEvents {
-        /**
-         * Indicates that the local connection statistics were updated.
-         */
-        LOCAL_STATS_UPDATED = "cq.local_stats_updated",
-        /**
-         * Indicates that the connection statistics for a particular remote participant
-         * were updated.
-         */
-        REMOTE_STATS_UPDATED = "cq.remote_stats_updated"
+declare module "modules/recording/JibriSession" {
+    import JitsiParticipant from "JitsiParticipant";
+    import XmppConnection from "modules/xmpp/XmppConnection";
+    export interface IJibriSessionOptions {
+        connection?: XmppConnection;
+        focusMucJid?: string;
+        mode?: string;
+        sessionID?: string;
+        status?: string;
     }
-}
-declare module "modules/connectivity/ConnectionQuality" {
-    import JitsiConference, { IConferenceOptions } from "JitsiConference";
-    import EventEmitter from "modules/util/EventEmitter";
-    export interface ILocalStats {
-        bandwidth?: {
-            download?: number;
-            upload?: number;
-        };
-        bitrate?: {
-            upload: number;
-        };
-        bridgeCount?: number;
-        connectionQuality: number;
-        jvbRTT?: number;
-        maxEnabledResolution?: {
-            height: number;
-            width: number;
-        };
-        packetLoss?: {
-            upload?: number;
-        };
-        serverRegion?: string;
+    export interface IStartOptions {
+        appData?: string;
+        broadcastId?: string;
+        focusMucJid: string;
+        streamId?: string;
+    }
+    export interface IStopOptions {
+        focusMucJid: string;
+    }
+    export interface IQOptions {
+        action?: 'start' | 'stop';
+        appData?: string;
+        broadcastId?: string;
+        focusMucJid: string;
+        streamId?: string;
     }
-    export type IRemoteStats = Pick<ILocalStats, 'bitrate' | 'connectionQuality' | 'jvbRTT' | 'maxEnabledResolution' | 'packetLoss' | 'serverRegion'>;
     /**
-     * A class which monitors the local statistics coming from the RTC modules, and
-     * calculates a "connection quality" value, in percent, for the media
-     * connection. A value of 100% indicates a very good network connection, and a
-     * value of 0% indicates a poor connection.
+     * Represents a recording session.
      */
-    export default class ConnectionQuality {
-        private eventEmitter;
-        private _conference;
-        private _localStats;
-        private _lastConnectionQualityUpdate;
-        private _options;
-        private _remoteStats;
-        private _timeIceConnected;
-        private _timeVideoUnmuted;
+    export default class JibriSession {
+        private _connection?;
+        private _mode?;
+        private _jibriJid;
+        private _statusFromJicofo;
+        private _sessionID?;
+        private _status?;
+        private _error?;
+        private _liveStreamViewURL?;
+        private _initiator?;
+        private _terminator?;
+        private _focusMucJid?;
         /**
+         * Initializes a new JibriSession instance.
          *
-         * @param conference
-         * @param eventEmitter
-         * @param options
+         * @constructor
          */
-        constructor(conference: JitsiConference, eventEmitter: EventEmitter, options: IConferenceOptions);
+        constructor(options?: IJibriSessionOptions);
         /**
-         * Broadcasts the local statistics to all other participants in the
-         * conference.
+         * Returns the error related to the session instance, if any.
+         *
+         * @returns {Optional<string>}
          */
-        private _broadcastLocalStats;
+        getError(): Optional<string>;
         /**
-         * Calculates a new "connection quality" value.
-         * @param videoType {VideoType} the type of the video source (camera or a screen capture).
-         * @param isMuted {boolean} whether the local video is muted.
-         * @param resolutionName {Resolution} the input resolution used by the camera.
-         * @returns {*} the newly calculated connection quality.
+         * Returns the session ID of the session instance.
+         *
+         * @returns {Optional<string>}
          */
-        private _calculateConnectionQuality;
+        getID(): Optional<string>;
         /**
-         * Sets _timeVideoUnmuted if it was previously unset. If it was already set,
-         * doesn't change it.
+         * Returns the initiator of the session instance.
+         *
+         * @returns {JitsiParticipant|string} The participant that started the session.
          */
-        private _maybeUpdateUnmuteTime;
+        getInitiator(): JitsiParticipant | string;
         /**
-         * Resets the time video was unmuted and triggers a new ramp-up.
+         * Returns the streaming URL of the session.
          *
-         * @private
-         * @returns {void}
+         * @returns {Optional<string>}
          */
-        private _resetVideoUnmuteTime;
+        getLiveStreamViewURL(): Optional<string>;
         /**
-         * Updates the localConnectionQuality value
-         * @param values {number} the new value. Should be in [0, 100].
+         * Returns the current status of the session.
+         *
+         * @returns {Optional<string>}
          */
-        private _updateLocalConnectionQuality;
+        getStatus(): Optional<string>;
         /**
-         * Updates the local statistics
-         * @param {TraceablePeerConnection} tpc the peerconnection which emitted
-         * the stats
-         * @param data new statistics
+         * @returns {Optional<string>}
          */
-        private _updateLocalStats;
+        getJibriJid(): Optional<string>;
         /**
-         * Updates remote statistics
-         * @param id the id of the remote participant
-         * @param data the statistics received
+         * Returns the jid of the participant that stopped the session.
+         *
+         * @returns {JitsiParticipant|string} The participant that stopped the session.
          */
-        private _updateRemoteStats;
+        getTerminator(): JitsiParticipant | string;
         /**
-         * Returns the local statistics.
-         * Exported only for use in jitsi-meet-torture.
+         * Returns the current recording mode of the session, such as "file".
+         *
+         * @returns {string}
          */
-        getStats(): ILocalStats;
-    }
-}
-declare module "modules/connectivity/IceFailedHandling" {
-    import JitsiConference from "JitsiConference";
-    /**
-     * This class deals with shenanigans around JVB media session's ICE failed status handling.
-     *
-     * If ICE connection is not re-established within 2 secs after the internet comes back online, the client will initiate
-     * a session restart via 'session-terminate'. This results in Jicofo re-inviting the participant into the conference by
-     * recreating the jvb media session so that there is minimla disruption to the user by default.
-     */
-    export default class IceFailedHandling {
-        private _conference;
-        private _canceled;
-        private _iceFailedTimeout?;
+        getMode(): string;
         /**
-         * Creates new {@code DelayedIceFailed} task.
-         * @param {JitsiConference} conference
+         * Sets the last known error message related to the session.
+         *
+         * @param {string} error - The error string explaining why the session
+         * entered an error state.
+         * @returns {void}
          */
-        constructor(conference: JitsiConference);
+        setError(error: string): void;
         /**
-         * After making sure there's no way for the ICE connection to recover this method either sends ICE failed
-         * notification to Jicofo or emits the ice failed conference event.
-         * @private
+         * Sets the last live stream URL for the session instance. Usually this is
+         * a YouTube URL and usually this is only set for "stream" sessions.
+         *
+         * @param {string} url - The live stream URL associated with the session.
          * @returns {void}
          */
-        _actOnIceFailed(): void;
+        setLiveStreamViewURL(url: string): void;
         /**
-         * Starts the task.
+         * Sets the last known status for this recording session.
+         *
+         * @param {string} status - The new status to set.
          * @returns {void}
          */
-        start(): void;
+        setStatus(status?: string): void;
         /**
-         * Cancels the task.
-         * @returns {void}
+         * Set the session status reported by jicofo. If a jibri is present in the room,
+         * the status is always 'on'. Otherwise, we fallback to the status reported by jicofo.
+         *
+         * @param {string} status
          */
-        cancel(): void;
-    }
-}
-declare module "modules/detection/NoAudioSignalDetection" {
-    import type JitsiConference from "JitsiConference";
-    import EventEmitter from "modules/util/EventEmitter";
-    /**
-     * Detect if there is no audio input on the current TraceAblePeerConnection selected track. The no audio
-     * state must be constant for a configured amount of time in order for the event to be triggered.
-     * @fires DetectionEvents.AUDIO_INPUT_STATE_CHANGE
-     * @fires DetectionEvents.NO_AUDIO_INPUT
-     */
-    export default class NoAudioSignalDetection extends EventEmitter {
-        private _conference;
-        private _timeoutTrigger;
-        private _hasAudioInput;
-        private _audioTrack;
-        private _eventFired;
+        setStatusFromJicofo(status: string): void;
         /**
-         * Creates new NoAudioSignalDetection.
+         * Set the JID of the jibri associated with this session.
          *
-         * @param conference the JitsiConference instance that created us.
-         * @constructor
+         * @param {*} jibriJid
+         */
+        setJibriJid(jibriJid: Nullable<string>): void;
+        /**
+         * Sets the participant that started the session.
+         * @param {JitsiParticipant | string} participant - The participant or resource id
+         * if local participant.
+         */
+        setInitiator(participant: JitsiParticipant | string): void;
+        /**
+         * Sets the participant that stopped the session.
+         * @param {JitsiParticipant | string} participant - The participant or the resource id
+         * if local participant.
          */
-        constructor(conference: JitsiConference);
+        setTerminator(participant: JitsiParticipant | string): void;
         /**
-         * Clear the timeout state.
+         * Sends a message to start the actual recording.
+         *
+         * @param {Object} options - Additional arguments for starting therecording.
+         * @param {string} [options.appData] - Data specific to the app/service that the result file will be uploaded.
+         * @param {string} [options.broadcastId] - The broadcast ID of an associated YouTube stream, used for knowing the
+         * URL from which the stream can be viewed.
+         * @param {string} options.focusMucJid - The JID of the focus participant that controls recording.
+         * @param {streamId} options.streamId - Necessary for live streaming, this is the stream key needed to start a live
+         * streaming session with the streaming service provider.
+         * @returns Promise
          */
-        private _clearTriggerTimeout;
+        start({ appData, broadcastId, focusMucJid, streamId }: IStartOptions): Promise<void>;
         /**
-         * Generated event triggered by a change in the current conference audio input state.
+         * Sends a message to actually stop the recording session.
          *
-         * @param {number} audioLevel - The audio level of the ssrc.
-         * @fires DetectionEvents.AUDIO_INPUT_STATE_CHANGE
+         * @param {Object} options - Additional arguments for stopping the recording.
+         * @param {Object} options.focusMucJid - The JID of the focus participant that controls recording.
+         * @returns Promise
          */
-        private _handleAudioInputStateChange;
+        stop({ focusMucJid }: IStopOptions): Promise<any>;
         /**
-         * Generate event triggered by a prolonged period of no audio input.
+         * Generates the message to change the status of the recording session.
          *
-         * @param {number} audioLevel - The audio level of the ssrc.
-         * @fires DetectionEvents.NO_AUDIO_INPUT
+         * @param {string} [options.action] - The action to set the IQ
+         * @param {string} [options.appData] - Data specific to the app/service that
+         * the result file will be uploaded.
+         * @param {string} [options.broadcastId] - The broadcast ID of an
+         * associated YouTube stream, used for knowing the URL from which the stream
+         * can be viewed.
+         * @param {string} options.focusMucJid - The JID of the focus participant
+         * that controls recording.
+         * @param {streamId} options.streamId - Necessary for live streaming, this
+         * is the stream key needed to start a live streaming session with the
+         * streaming service provider.
+         * @returns Object - The XMPP IQ message.
          */
-        private _handleNoAudioInputDetection;
+        _createIQ({ action, appData, broadcastId, focusMucJid, streamId }: IQOptions): any;
         /**
-         * Receives audio level events for all send and receive streams on the current TraceablePeerConnection.
+         * Handles the error from an iq and stores the error.
          *
-         * @param {TraceablePeerConnection} tpc - TraceablePeerConnection of the owning conference.
-         * @param {number} ssrc - The synchronization source identifier (SSRC) of the endpoint/participant/stream
-         * being reported.
-         * @param {number} audioLevel - The audio level of the ssrc.
-         * @param {boolean} isLocal - true for local/send streams or false for remote/receive streams.
+         * @param {Node} errorIq - The error response from an Iq.
+         * @private
+         * @returns {void}
          */
-        private _audioLevel;
+        _setErrorFromIq(errorIq: any): void;
         /**
-         * Notifies NoAudioSignalDetection that a JitsiTrack was added to the associated JitsiConference.
-         * Only take into account local audio tracks.
+         * Sets the known session ID for this recording session.
          *
-         * @param {JitsiTrack} track - The added JitsiTrack.
+         * @param {string} sessionID
+         * @private
+         * @returns {void}
          */
-        private _trackAdded;
+        _setSessionID(sessionID?: string): void;
     }
 }
-declare module "modules/detection/P2PDominantSpeakerDetection" {
-    import JitsiConference from "JitsiConference";
+declare module "modules/statistics/constants" {
     /**
-     * The <tt>P2PDominantSpeakerDetection</tt> is activated only when p2p is
-     * currently used.
-     * Listens for changes in the audio level changes of the local p2p audio track
-     * or remote p2p one and fires dominant speaker events to be able to use
-     * features depending on those events (speaker stats), to make them work without
-     * the video bridge.
+     * The number of remote speakers for which the audio levels will be calculated using
+     * RTCRtpReceiver#getSynchronizationSources. Limit the number of endpoints to save cpu on the client as this API call
+     * is known to take longer to execute when there are many audio receivers.
      */
-    export default class P2PDominantSpeakerDetection {
-        private conference;
-        private myUserID;
-        /**
-         * Creates P2PDominantSpeakerDetection
-         * @param conference the JitsiConference instance that created us.
-         * @constructor
-         */
-        constructor(conference: JitsiConference);
-        /**
-         * Receives audio level events for all streams in the conference.
-         *
-         * @param {String} id - The participant id
-         * @param {number} audioLevel - The audio level.
-         */
-        private _audioLevel;
-    }
+    export const SPEAKERS_AUDIO_LEVELS: number;
 }
-declare module "modules/detection/VADNoiseDetection" {
-    import EventEmitter from "modules/util/EventEmitter";
-    import { IVADScore } from "modules/detection/VADAudioAnalyser";
+declare module "JitsiConferenceEventManager" {
+    import JitsiConference from "JitsiConference";
     /**
-     * Detect if provided VAD score and PCM data is considered noise.
+     * Setups all event listeners related to conference
      */
-    export default class VADNoiseDetection extends EventEmitter {
-        /**
-         * Flag which denotes the current state of the detection service i.e.if there is already a processing operation
-         * ongoing.
-         */
-        private _processing;
-        /**
-         * Buffer that keeps the VAD scores for a period of time.
-         */
-        private _scoreArray;
-        /**
-         * Buffer that keeps audio level samples for a period of time.
-         */
-        private _audioLvlArray;
-        /**
-         * Current state of the service, if it's not active no processing will occur.
-         */
-        private _active;
+    export default class JitsiConferenceEventManager {
+        private conference;
+        private xmppListeners;
+        private chatRoomForwarder?;
         /**
-         * Timeout reference for processing VAD scores.
+         * Setups all event listeners related to conference
+         * @param conference {JitsiConference} the conference
          */
-        private _processTimeout?;
+        constructor(conference: JitsiConference);
         /**
-         * Creates <tt>VADNoiseDetection</tt>
-         *
-         * @constructor
+         * Add XMPP listener and save its reference for remove on leave conference.
+         * @param {string} eventName - The event name.
+         * @param {Function} listener - The listener function.
+         * @private
          */
-        constructor();
+        private _addConferenceXMPPListener;
         /**
-         * Compute cumulative VAD score and PCM audio levels once the PROCESS_TIME_FRAME_SPAN_MS timeout has elapsed.
-         * If the score is above the set threshold fire the event.
-         * @returns {void}
-         * @fires VAD_NOISY_DEVICE
+         * Setups event listeners related to conference.chatRoom
          */
-        private _calculateNoisyScore;
+        setupChatRoomListeners(): void;
         /**
-         * Set the active state of the detection service and notify any listeners.
-         *
-         * @param {boolean} active
-         * @fires DETECTOR_STATE_CHANGE
+         * Setups event listeners related to conference.rtc
          */
-        private _setActiveState;
+        setupRTCListeners(): void;
         /**
-         * Record the vad score and average volume in the appropriate buffers.
-         *
-         * @param {number} vadScore
-         * @param {number} avgAudioLvl - average audio level of the PCM sample associated with the VAD score.s
+         * Setups event listeners related to conference.statistics
          */
-        private _recordValues;
+        setupStatisticsListeners(): void;
         /**
-         * Change the state according to the muted status of the tracked device.
-         *
-         * @param {boolean} isMuted - Is the device muted or not.
+         * Setups event listeners related to conference.xmpp
          */
-        changeMuteState(isMuted: boolean): void;
+        setupXMPPListeners(): void;
         /**
-         * Check whether or not the service is active or not.
-         *
-         * @returns {boolean}
+         * Removes event listeners related to conference.xmpp
          */
-        isActive(): boolean;
+        removeXMPPListeners(): void;
+    }
+}
+declare module "service/connectivity/ConnectionQualityEvents" {
+    export enum ConnectionQualityEvents {
         /**
-         * Listens for {@link TrackVADEmitter} events and processes them.
-         *
-         * @param {Object} vadScore -VAD score emitted by {@link TrackVADEmitter}
-         * @param {number}   vadScore.timestamp - Exact time at which processed PCM sample was generated.
-         * @param {number} vadScore.score - VAD score on a scale from 0 to 1 (i.e. 0.7)
-         * @param {Float32Array} vadScore.pcmData - Raw PCM Data associated with the VAD score.
-         * @param {string} vadScore.deviceId - Device id of the associated track.
-         * @listens VAD_SCORE_PUBLISHED
+         * Indicates that the local connection statistics were updated.
          */
-        processVADScore(vadScore: IVADScore): void;
+        LOCAL_STATS_UPDATED = "cq.local_stats_updated",
         /**
-         * Reset the processing context, clear buffers, cancel the timeout trigger.
-         *
-         * @returns {void}
+         * Indicates that the connection statistics for a particular remote participant
+         * were updated.
          */
-        reset(): void;
+        REMOTE_STATS_UPDATED = "cq.remote_stats_updated"
     }
 }
-declare module "modules/detection/VADTalkMutedDetection" {
+declare module "modules/connectivity/ConnectionQuality" {
+    import JitsiConference, { IConferenceOptions } from "JitsiConference";
     import EventEmitter from "modules/util/EventEmitter";
-    export interface IVADScore {
-        deviceId: string;
-        score: number;
-        timestamp: number;
+    export interface ILocalStats {
+        bandwidth?: {
+            download?: number;
+            upload?: number;
+        };
+        bitrate?: {
+            upload: number;
+        };
+        bridgeCount?: number;
+        connectionQuality: number;
+        jvbRTT?: number;
+        maxEnabledResolution?: {
+            height: number;
+            width: number;
+        };
+        packetLoss?: {
+            upload?: number;
+        };
+        serverRegion?: string;
     }
+    export type IRemoteStats = Pick<ILocalStats, 'bitrate' | 'connectionQuality' | 'jvbRTT' | 'maxEnabledResolution' | 'packetLoss' | 'serverRegion'>;
     /**
-     * Detect if provided VAD score which is generated on a muted device is voice and fires an event.
+     * A class which monitors the local statistics coming from the RTC modules, and
+     * calculates a "connection quality" value, in percent, for the media
+     * connection. A value of 100% indicates a very good network connection, and a
+     * value of 0% indicates a poor connection.
      */
-    export default class VADTalkMutedDetection extends EventEmitter {
-        private _processing;
-        private _scoreArray;
-        private _active;
-        private _processTimeout?;
+    export default class ConnectionQuality {
+        private eventEmitter;
+        private _conference;
+        private _localStats;
+        private _lastConnectionQualityUpdate;
+        private _options;
+        private _remoteStats;
+        private _timeIceConnected;
+        private _timeVideoUnmuted;
         /**
-         * Creates <tt>VADTalkMutedDetection</tt>
-         * @constructor
+         *
+         * @param conference
+         * @param eventEmitter
+         * @param options
          */
-        constructor();
+        constructor(conference: JitsiConference, eventEmitter: EventEmitter, options: IConferenceOptions);
         /**
-         * Compute cumulative VAD score function called once the PROCESS_TIME_FRAME_SPAN_MS timeout has elapsed.
-         * @returns {void}
-         * @fires VAD_TALK_WHILE_MUTED
+         * Broadcasts the local statistics to all other participants in the
+         * conference.
+         */
+        private _broadcastLocalStats;
+        /**
+         * Calculates a new "connection quality" value.
+         * @param videoType {VideoType} the type of the video source (camera or a screen capture).
+         * @param isMuted {boolean} whether the local video is muted.
+         * @param resolutionName {Resolution} the input resolution used by the camera.
+         * @returns {*} the newly calculated connection quality.
          */
-        private _calculateVADScore;
+        private _calculateConnectionQuality;
         /**
-         * Set the active state of the detection service and notify any listeners.
-         *
-         * @param {boolean} active
-         * @fires DETECTOR_STATE_CHANGE
+         * Sets _timeVideoUnmuted if it was previously unset. If it was already set,
+         * doesn't change it.
          */
-        private _setActiveState;
+        private _maybeUpdateUnmuteTime;
         /**
-         * Change the state according to the muted status of the tracked device.
+         * Resets the time video was unmuted and triggers a new ramp-up.
          *
-         * @param {boolean} isMuted - Is the device muted or not.
+         * @private
+         * @returns {void}
          */
-        changeMuteState(isMuted: boolean): void;
+        private _resetVideoUnmuteTime;
         /**
-         * Check whether or not the service is active or not.
-         *
-         * @returns {boolean}
+         * Updates the localConnectionQuality value
+         * @param values {number} the new value. Should be in [0, 100].
          */
-        isActive(): boolean;
+        private _updateLocalConnectionQuality;
         /**
-         * Listens for {@link TrackVADEmitter} events and processes them.
-         *
-         * @param {Object} vadScore -VAD score emitted by {@link TrackVADEmitter}
-         * @param {number}   vadScore.timestamp - Exact time at which processed PCM sample was generated.
-         * @param {number} vadScore.score - VAD score on a scale from 0 to 1 (i.e. 0.7)
-         * @param {string} vadScore.deviceId - Device id of the associated track.
-         * @listens VAD_SCORE_PUBLISHED
+         * Updates the local statistics
+         * @param {TraceablePeerConnection} tpc the peerconnection which emitted
+         * the stats
+         * @param data new statistics
          */
-        processVADScore(vadScore: IVADScore): void;
+        private _updateLocalStats;
         /**
-         * Reset the processing context, clear buffer, cancel the timeout trigger.
-         *
-         * @returns {void}
+         * Updates remote statistics
+         * @param id the id of the remote participant
+         * @param data the statistics received
          */
-        reset(): void;
-    }
-}
-declare module "service/e2eping/E2ePingEvents" {
-    export enum E2ePingEvents {
+        private _updateRemoteStats;
         /**
-         * Indicates that the end-to-end round-trip-time for a participant has changed.
+         * Returns the local statistics.
+         * Exported only for use in jitsi-meet-torture.
          */
-        E2E_RTT_CHANGED = "e2eping.e2e_rtt_changed"
+        getStats(): ILocalStats;
     }
 }
-declare module "modules/e2eping/e2eping" {
+declare module "modules/connectivity/IceFailedHandling" {
     import JitsiConference from "JitsiConference";
-    import JitsiParticipant from "JitsiParticipant";
-    export interface IPingMessage {
-        id: number;
-        type: string;
-    }
-    export interface IE2ePingOptions {
-        e2eping?: {
-            enabled?: boolean;
-            maxConferenceSize?: number;
-            maxMessagesPerSecond?: number;
-            numRequests?: number;
-        };
-    }
-    export interface IRequest {
-        id: number;
-        rtt?: number;
-        timeSent: number;
-    }
     /**
-     * Saves e2e ping related state for a single JitsiParticipant.
+     * This class deals with shenanigans around JVB media session's ICE failed status handling.
+     *
+     * If ICE connection is not re-established within 2 secs after the internet comes back online, the client will initiate
+     * a session restart via 'session-terminate'. This results in Jicofo re-inviting the participant into the conference by
+     * recreating the jvb media session so that there is minimla disruption to the user by default.
      */
-    class ParticipantWrapper {
-        participant: JitsiParticipant;
-        e2eping: E2ePing;
-        id: string;
-        requests: {
-            [key: number]: IRequest;
-        };
-        lastRequestId: number;
-        timeout: Nullable<number>;
-        /**
-         * Creates a ParticipantWrapper
-         * @param {JitsiParticipant} participant - The remote participant that this
-         * object wraps.
-         * @param {E2ePing} e2eping
-         */
-        constructor(participant: JitsiParticipant, e2eping: E2ePing);
-        /**
-         * Schedule the next ping to be sent.
-         */
-        scheduleNext(): number;
-        /**
-         * Stop pinging this participant, canceling a scheduled ping, if any.
-         */
-        stop(): void;
+    export default class IceFailedHandling {
+        private _conference;
+        private _canceled;
+        private _iceFailedTimeout?;
         /**
-         * Get the delay until the next ping in milliseconds.
+         * Creates new {@code DelayedIceFailed} task.
+         * @param {JitsiConference} conference
          */
-        getDelay(): number;
+        constructor(conference: JitsiConference);
         /**
-         * Sends the next ping request.
-         * @type {*}
+         * After making sure there's no way for the ICE connection to recover this method either sends ICE failed
+         * notification to Jicofo or emits the ice failed conference event.
+         * @private
+         * @returns {void}
          */
-        sendRequest(): void;
+        _actOnIceFailed(): void;
         /**
-         * Handles a response from this participant.
-         * @type {*}
+         * Starts the task.
+         * @returns {void}
          */
-        handleResponse(response: any): void;
+        start(): void;
         /**
-         * Check if we've received the pre-configured number of responses, and if
-         * so log the measured RTT and stop sending requests.
-         * @type {*}
+         * Cancels the task.
+         * @returns {void}
          */
-        maybeLogRttAndStop(): void;
+        cancel(): void;
     }
+}
+declare module "modules/detection/NoAudioSignalDetection" {
+    import type JitsiConference from "JitsiConference";
+    import EventEmitter from "modules/util/EventEmitter";
     /**
-     * Implements end-to-end ping (from one conference participant to another) via
-     * the jitsi-videobridge channel (either WebRTC data channel or web socket).
-     *
-     * TODO: use a broadcast message instead of individual pings to each remote
-     * participant.
-     *
-     * This class:
-     * 1. Sends periodic ping requests to all other participants in the
-     * conference.
-     * 2. Responds to ping requests from other participants.
-     * 3. Fires events with the end-to-end RTT to each participant whenever a
-     * response is received.
-     * 4. Fires analytics events with the end-to-end RTT periodically.
+     * Detect if there is no audio input on the current TraceAblePeerConnection selected track. The no audio
+     * state must be constant for a configured amount of time in order for the event to be triggered.
+     * @fires DetectionEvents.AUDIO_INPUT_STATE_CHANGE
+     * @fires DetectionEvents.NO_AUDIO_INPUT
      */
-    export default class E2ePing {
-        conference: JitsiConference;
-        eventEmitter: any;
-        sendMessage: (message: IPingMessage, participantId: string) => void;
-        participants: {
-            [key: string]: ParticipantWrapper;
-        };
-        numRequests: number;
-        maxConferenceSize: number;
-        maxMessagesPerSecond: number;
+    export default class NoAudioSignalDetection extends EventEmitter {
+        private _conference;
+        private _timeoutTrigger;
+        private _hasAudioInput;
+        private _audioTrack;
+        private _eventFired;
         /**
-         * @param {JitsiConference} conference - The conference.
-         * @param {Function} sendMessage - The function to use to send a message.
-         * @param {Object} options
+         * Creates new NoAudioSignalDetection.
+         *
+         * @param conference the JitsiConference instance that created us.
+         * @constructor
          */
-        constructor(conference: JitsiConference, options: IE2ePingOptions, sendMessage: (message: IPingMessage, participantId: string) => void);
+        constructor(conference: JitsiConference);
         /**
-         * Delay processing USER_JOINED events until the MUC is fully joined,
-         * otherwise the apparent conference size will be wrong.
+         * Clear the timeout state.
          */
-        conferenceJoined(): void;
+        private _clearTriggerTimeout;
         /**
-         * Handles a message that was received.
+         * Generated event triggered by a change in the current conference audio input state.
          *
-         * @param participant - The message sender.
-         * @param payload - The payload of the message.
+         * @param {number} audioLevel - The audio level of the ssrc.
+         * @fires DetectionEvents.AUDIO_INPUT_STATE_CHANGE
          */
-        messageReceived(participant: JitsiParticipant, payload: IPingMessage): void;
+        private _handleAudioInputStateChange;
         /**
-         * Handles a participant joining the conference. Starts to send ping
-         * requests to the participant.
+         * Generate event triggered by a prolonged period of no audio input.
          *
-         * @param {String} id - The ID of the participant.
-         * @param {JitsiParticipant} participant - The participant that joined.
-         */
-        participantJoined(id: string, participant: JitsiParticipant): void;
-        /**
-         * Remove a participant without calling "stop".
+         * @param {number} audioLevel - The audio level of the ssrc.
+         * @fires DetectionEvents.NO_AUDIO_INPUT
          */
-        removeParticipant(id: string): void;
+        private _handleNoAudioInputDetection;
         /**
-         * Handles a participant leaving the conference. Stops sending requests.
+         * Receives audio level events for all send and receive streams on the current TraceablePeerConnection.
          *
-         * @param {String} id - The ID of the participant.
+         * @param {TraceablePeerConnection} tpc - TraceablePeerConnection of the owning conference.
+         * @param {number} ssrc - The synchronization source identifier (SSRC) of the endpoint/participant/stream
+         * being reported.
+         * @param {number} audioLevel - The audio level of the ssrc.
+         * @param {boolean} isLocal - true for local/send streams or false for remote/receive streams.
          */
-        participantLeft(id: string): void;
+        private _audioLevel;
         /**
-         * Handles a ping request coming from another participant.
+         * Notifies NoAudioSignalDetection that a JitsiTrack was added to the associated JitsiConference.
+         * Only take into account local audio tracks.
          *
-         * @param {string} participantId - The ID of the participant who sent the
-         * request.
-         * @param {Object} request - The request.
-         */
-        handleRequest(participantId: string, request: {
-            id: number;
-        }): void;
-        /**
-         * Handles a ping response coming from another participant
-         * @param {string} participantId - The ID of the participant who sent the
-         * response.
-         * @param {Object} response - The response.
-         */
-        handleResponse(participantId: string, response: {
-            id: number;
-        }): void;
-        /**
-         * Stops this E2ePing (i.e. stop sending requests).
+         * @param {JitsiTrack} track - The added JitsiTrack.
          */
-        stop(): void;
+        private _trackAdded;
     }
 }
-declare module "modules/litemode/LiteModeContext" {
+declare module "modules/detection/P2PDominantSpeakerDetection" {
     import JitsiConference from "JitsiConference";
     /**
-     * This module implements a discard-all insertable stream.  Use to reduce decoder CPU load for testing.
+     * The <tt>P2PDominantSpeakerDetection</tt> is activated only when p2p is
+     * currently used.
+     * Listens for changes in the audio level changes of the local p2p audio track
+     * or remote p2p one and fires dominant speaker events to be able to use
+     * features depending on those events (speaker stats), to make them work without
+     * the video bridge.
      */
-    export class LiteModeContext {
-        private enabled;
+    export default class P2PDominantSpeakerDetection {
+        private conference;
+        private myUserID;
         /**
-         * A constructor.
-         * @param {JitsiConference} conference - The conference instance for which lite mode is to be enabled.
+         * Creates P2PDominantSpeakerDetection
+         * @param conference the JitsiConference instance that created us.
+         * @constructor
          */
         constructor(conference: JitsiConference);
         /**
-         * Setup Lite Mode for a track.
+         * Receives audio level events for all streams in the conference.
          *
-         * @private
+         * @param {String} id - The participant id
+         * @param {number} audioLevel - The audio level.
          */
-        private _setupLiteModeForTrack;
+        private _audioLevel;
     }
 }
-declare module "modules/qualitycontrol/CodecSelection" {
-    import JitsiConference from "JitsiConference";
-    import JitsiLocalTrack from "modules/RTC/JitsiLocalTrack";
-    import JingleSessionPC from "modules/xmpp/JingleSessionPC";
-    export interface ICodecSelectionOptions {
-        [connectionType: string]: {
-            disabledCodec?: string;
-            enableAV1ForFF?: boolean;
-            preferenceOrder?: string[];
-            preferredCodec?: string;
-            screenshareCodec?: string;
-        };
-    }
-    export type CodecPreferenceOrder = {
-        [connectionType: string]: string[];
-    };
-    export type ScreenshareCodec = {
-        [connectionType: string]: string;
-    };
+declare module "modules/detection/VADNoiseDetection" {
+    import EventEmitter from "modules/util/EventEmitter";
+    import { IVADScore } from "modules/detection/VADAudioAnalyser";
     /**
-     * This class handles the codec selection mechanism for the conference based on the config.js settings.
-     * The preferred codec is selected based on the settings and the list of codecs supported by the browser.
-     * The preferred codec is published in presence which is then used by the other endpoints in the
-     * conference to pick a supported codec at join time and when the call transitions between p2p and jvb
-     * connections.
+     * Detect if provided VAD score and PCM data is considered noise.
      */
-    export class CodecSelection {
-        private codecPreferenceOrder;
-        private conference;
-        private encodeTimeStats;
-        private options;
-        private screenshareCodec;
-        private visitorCodecs;
+    export default class VADNoiseDetection extends EventEmitter {
         /**
-         * Creates a new instance for a given conference.
+         * Flag which denotes the current state of the detection service i.e.if there is already a processing operation
+         * ongoing.
+         */
+        private _processing;
+        /**
+         * Buffer that keeps the VAD scores for a period of time.
+         */
+        private _scoreArray;
+        /**
+         * Buffer that keeps audio level samples for a period of time.
+         */
+        private _audioLvlArray;
+        /**
+         * Current state of the service, if it's not active no processing will occur.
+         */
+        private _active;
+        /**
+         * Timeout reference for processing VAD scores.
+         */
+        private _processTimeout?;
+        /**
+         * Creates <tt>VADNoiseDetection</tt>
          *
-         * @param {JitsiConference} conference the conference instance
-         * @param {*} options
-         * @param {string} options.jvb settings (codec list, preferred and disabled) for the jvb connection.
-         * @param {string} options.p2p settings (codec list, preferred and disabled) for the p2p connection.
+         * @constructor
          */
-        constructor(conference: JitsiConference, options: ICodecSelectionOptions);
+        constructor();
         /**
-         * Returns a list of video codecs that are supported by the browser.
+         * Compute cumulative VAD score and PCM audio levels once the PROCESS_TIME_FRAME_SPAN_MS timeout has elapsed.
+         * If the score is above the set threshold fire the event.
+         * @returns {void}
+         * @fires VAD_NOISY_DEVICE
+         */
+        private _calculateNoisyScore;
+        /**
+         * Set the active state of the detection service and notify any listeners.
          *
-         * @param {string} connectionType - media connection type, p2p or jvb.
-         * @returns {Array}
+         * @param {boolean} active
+         * @fires DETECTOR_STATE_CHANGE
          */
-        _getSupportedVideoCodecs(connectionType: string): string[];
+        private _setActiveState;
         /**
-         * Returns the current codec preference order for the given connection type.
+         * Record the vad score and average volume in the appropriate buffers.
          *
-         * @param {String} connectionType The media connection type, 'p2p' or 'jvb'.
-         * @returns {Array<string>}
+         * @param {number} vadScore
+         * @param {number} avgAudioLvl - average audio level of the PCM sample associated with the VAD score.s
          */
-        getCodecPreferenceList(connectionType: string): string[];
+        private _recordValues;
         /**
-         * Returns the preferred screenshare codec for the given connection type.
+         * Change the state according to the muted status of the tracked device.
          *
-         * @param {Optional} connectionType The media connection type, 'p2p' or 'jvb'.
-         * @returns CodecMimeType
+         * @param {boolean} isMuted - Is the device muted or not.
          */
-        getScreenshareCodec(connectionType: string): Optional<string>;
+        changeMuteState(isMuted: boolean): void;
         /**
-         * Sets the codec on the media session based on the codec preference order configured in config.js and the supported
-         * codecs published by the remote participants in their presence.
+         * Check whether or not the service is active or not.
          *
-         * @param {JingleSessionPC} mediaSession session for which the codec selection has to be made.
+         * @returns {boolean}
          */
-        selectPreferredCodec(mediaSession?: JingleSessionPC): void;
+        isActive(): boolean;
         /**
-         * Changes the codec preference order.
+         * Listens for {@link TrackVADEmitter} events and processes them.
          *
-         * @param {JitsiLocalTrack} localTrack - The local video track.
-         * @param {CodecMimeType} codec - The codec used for encoding the given local video track.
-         * @returns boolean - Returns true if the codec order has been updated, false otherwise.
+         * @param {Object} vadScore -VAD score emitted by {@link TrackVADEmitter}
+         * @param {number}   vadScore.timestamp - Exact time at which processed PCM sample was generated.
+         * @param {number} vadScore.score - VAD score on a scale from 0 to 1 (i.e. 0.7)
+         * @param {Float32Array} vadScore.pcmData - Raw PCM Data associated with the VAD score.
+         * @param {string} vadScore.deviceId - Device id of the associated track.
+         * @listens VAD_SCORE_PUBLISHED
          */
-        changeCodecPreferenceOrder(localTrack: JitsiLocalTrack, codec: string): boolean;
+        processVADScore(vadScore: IVADScore): void;
         /**
-         * Updates the aggregate list of the codecs supported by all the visitors in the call and calculates the
-         * selected codec if needed.
-         * @param {Array} codecList - visitor codecs.
+         * Reset the processing context, clear buffers, cancel the timeout trigger.
+         *
          * @returns {void}
          */
-        updateVisitorCodecs(codecList: string[]): void;
+        reset(): void;
     }
 }
-declare module "modules/qualitycontrol/ReceiveAudioController" {
-    import JitsiConference from "JitsiConference";
-    import { IReceiverAudioSubscriptionMessage, ReceiverAudioSubscription } from "service/RTC/ReceiverAudioSubscription";
+declare module "modules/detection/VADTalkMutedDetection" {
+    import EventEmitter from "modules/util/EventEmitter";
+    export interface IVADScore {
+        deviceId: string;
+        score: number;
+        timestamp: number;
+    }
     /**
-     * Controller for managing audio subscriptions in a Jitsi conference. It allows subscribing to remote audio streams
-     * based on different modes such as ALL, EXCLUDE, INCLUDE, and NONE.
+     * Detect if provided VAD score which is generated on a muted device is voice and fires an event.
      */
-    export class ReceiverAudioController {
-        private _rtc;
+    export default class VADTalkMutedDetection extends EventEmitter {
+        private _processing;
+        private _scoreArray;
+        private _active;
+        private _processTimeout?;
         /**
-         * The list of remote audio sources that the local endpoint is subscribed/unsubscribed to.
-         * This is used when the subscription mode is set to INCLUDE or EXCLUDE.
+         * Creates <tt>VADTalkMutedDetection</tt>
+         * @constructor
          */
-        private _sourceList;
+        constructor();
         /**
-         * The audio subscription options for remote audio streams.
+         * Compute cumulative VAD score function called once the PROCESS_TIME_FRAME_SPAN_MS timeout has elapsed.
+         * @returns {void}
+         * @fires VAD_TALK_WHILE_MUTED
          */
-        private _subscriptionMode;
+        private _calculateVADScore;
         /**
-         * Creates a new instance of the ReceiverAudioController.
+         * Set the active state of the detection service and notify any listeners.
+         *
+         * @param {boolean} active
+         * @fires DETECTOR_STATE_CHANGE
          */
-        constructor(conference: JitsiConference);
+        private _setActiveState;
         /**
-         * Gets the current audio subscription option.
+         * Change the state according to the muted status of the tracked device.
          *
-         * @returns {ReceiverAudioSubscription} The current audio subscription option.
+         * @param {boolean} isMuted - Is the device muted or not.
          */
-        get audioSubscription(): ReceiverAudioSubscription;
+        changeMuteState(isMuted: boolean): void;
         /**
-         * Mutes or unmutes the remote audio streams based on the provided parameter.
+         * Check whether or not the service is active or not.
          *
-         * @param {boolean} muted - Indicates whether the remote audio should be muted or not.
-         * @returns {void}
+         * @returns {boolean}
          */
-        muteRemoteAudio(muted: boolean): void;
+        isActive(): boolean;
         /**
-         * Sets the audio subscription options.
+         * Listens for {@link TrackVADEmitter} events and processes them.
+         *
+         * @param {Object} vadScore -VAD score emitted by {@link TrackVADEmitter}
+         * @param {number}   vadScore.timestamp - Exact time at which processed PCM sample was generated.
+         * @param {number} vadScore.score - VAD score on a scale from 0 to 1 (i.e. 0.7)
+         * @param {string} vadScore.deviceId - Device id of the associated track.
+         * @listens VAD_SCORE_PUBLISHED
+         */
+        processVADScore(vadScore: IVADScore): void;
+        /**
+         * Reset the processing context, clear buffer, cancel the timeout trigger.
          *
-         * @param message The audio subscription message containing the mode and optional source list.
          * @returns {void}
          */
-        setAudioSubscriptionMode(message: IReceiverAudioSubscriptionMessage): void;
+        reset(): void;
     }
 }
-declare module "modules/qualitycontrol/SendVideoController" {
+declare module "service/e2eping/E2ePingEvents" {
+    export enum E2ePingEvents {
+        /**
+         * Indicates that the end-to-end round-trip-time for a participant has changed.
+         */
+        E2E_RTT_CHANGED = "e2eping.e2e_rtt_changed"
+    }
+}
+declare module "modules/e2eping/e2eping" {
     import JitsiConference from "JitsiConference";
-    import JingleSessionPC from "modules/xmpp/JingleSessionPC";
-    export interface IVideoConstraint {
-        maxHeight: number;
-        sourceName: string;
+    import JitsiParticipant from "JitsiParticipant";
+    export interface IPingMessage {
+        id: number;
+        type: string;
+    }
+    export interface IE2ePingOptions {
+        e2eping?: {
+            enabled?: boolean;
+            maxConferenceSize?: number;
+            maxMessagesPerSecond?: number;
+            numRequests?: number;
+        };
+    }
+    export interface IRequest {
+        id: number;
+        rtt?: number;
+        timeSent: number;
     }
     /**
-     * The class manages send video constraints across media sessions({@link JingleSessionPC}) which belong to
-     * {@link JitsiConference}. It finds the lowest common value, between the local user's send preference and
-     * the remote party's receive preference. Also this module will consider only the active session's receive value,
-     * because local tracks are shared and while JVB may have no preference, the remote p2p may have and they may be totally
-     * different.
+     * Saves e2e ping related state for a single JitsiParticipant.
      */
-    export default class SendVideoController {
-        private _conference;
-        private _preferredSendMaxFrameHeight;
-        /**
-         * Source name based sender constraints.
-         * @type {Map<string, number>};
-         */
-        private _sourceSenderConstraints;
+    class ParticipantWrapper {
+        participant: JitsiParticipant;
+        e2eping: E2ePing;
+        id: string;
+        requests: {
+            [key: number]: IRequest;
+        };
+        lastRequestId: number;
+        timeout: Nullable<number>;
         /**
-         * Creates new instance for a given conference.
-         *
-         * @param {JitsiConference} conference - the conference instance for which the new instance will be managing
-         * the send video quality constraints.
+         * Creates a ParticipantWrapper
+         * @param {JitsiParticipant} participant - The remote participant that this
+         * object wraps.
+         * @param {E2ePing} e2eping
          */
-        constructor(conference: JitsiConference);
+        constructor(participant: JitsiParticipant, e2eping: E2ePing);
         /**
-         * Figures out the send video constraint as specified by {@link _selectSendMaxFrameHeight} and sets it on all media
-         * sessions for the reasons mentioned in this class description.
-         *
-         * @param {string} sourceName - The source for which sender constraints have changed.
-         * @returns {Promise<void>}
-         * @private
+         * Schedule the next ping to be sent.
          */
-        _propagateSendMaxFrameHeight(sourceName: string): Promise<void>;
+        scheduleNext(): number;
         /**
-         * Selects the lowest common value for the local video send constraint by looking at local user's preference and
-         * the active media session's receive preference set by the remote party.
-         *
-         * @param {string} sourceName - The source for which sender constraints have changed.
-         * @returns {Optional<number>}
-         * @private
+         * Stop pinging this participant, canceling a scheduled ping, if any.
          */
-        _selectSendMaxFrameHeight(sourceName: string): Optional<number>;
+        stop(): void;
         /**
-         * Configures the video encodings on the local sources when a media connection is established or becomes active.
-         *
-         * @returns {void}
+         * Get the delay until the next ping in milliseconds.
          */
-        configureConstraintsForLocalSources(): void;
+        getDelay(): number;
         /**
-         * Handles the {@link JitsiConferenceEvents.MEDIA_SESSION_STARTED}, that is when the conference creates new media
-         * session. It doesn't mean it's already active though. For example the JVB connection may be created after
-         * the conference has entered the p2p mode already.
-         *
-         * @param {JingleSessionPC} mediaSession - the started media session.
+         * Sends the next ping request.
+         * @type {*}
          */
-        onMediaSessionStarted(mediaSession: JingleSessionPC): void;
+        sendRequest(): void;
         /**
-         * Propagates the video constraints if they have changed.
-         *
-         * @param {IVideoConstraint} videoConstraints - The sender video constraints received from the bridge.
-         * @returns {Promise<void>}
+         * Handles a response from this participant.
+         * @type {*}
          */
-        onSenderConstraintsReceived(videoConstraints: IVideoConstraint): Promise<void>;
+        handleResponse(response: any): void;
         /**
-         * Sets local preference for max send video frame height.
-         *
-         * @param {number} maxFrameHeight - the new value to set.
-         * @returns {Promise<void>} - resolved when the operation is complete.
+         * Check if we've received the pre-configured number of responses, and if
+         * so log the measured RTT and stop sending requests.
+         * @type {*}
          */
-        setPreferredSendMaxFrameHeight(maxFrameHeight: number): Promise<void>;
-    }
-}
-declare module "modules/qualitycontrol/QualityController" {
-    import JitsiConference from "JitsiConference";
-    import { CodecMimeType } from "service/RTC/CodecMimeType";
-    import JitsiLocalTrack from "modules/RTC/JitsiLocalTrack";
-    import TraceablePeerConnection from "modules/RTC/TraceablePeerConnection";
-    import { CodecSelection } from "modules/qualitycontrol/CodecSelection";
-    import { ReceiverAudioController } from "modules/qualitycontrol/ReceiveAudioController";
-    import ReceiveVideoController from "modules/qualitycontrol/ReceiveVideoController";
-    import SendVideoController from "modules/qualitycontrol/SendVideoController";
-    enum QualityLimitationReason {
-        BANDWIDTH = "bandwidth",
-        CPU = "cpu",
-        NONE = "none"
-    }
-    interface IResolution {
-        height: number;
-        width: number;
-    }
-    interface IOutboundRtpStats {
-        codec: CodecMimeType;
-        encodeTime: number;
-        qualityLimitationReason: QualityLimitationReason;
-        resolution: IResolution;
-        timestamp: number;
-    }
-    export interface ISourceStats {
-        avgEncodeTime: number;
-        codec: CodecMimeType;
-        encodeResolution: number;
-        localTrack: JitsiLocalTrack;
-        qualityLimitationReason: QualityLimitationReason;
-        timestamp: number;
-        tpc: TraceablePeerConnection;
-    }
-    export class FixedSizeArray {
-        private _data;
-        private _maxSize;
-        constructor(size: number);
-        add(item: ISourceStats): void;
-        get(index: number): Optional<ISourceStats>;
-        size(): number;
+        maybeLogRttAndStop(): void;
     }
     /**
-     * QualityController class that is responsible for maintaining optimal video quality experience on the local endpoint
-     * by controlling the codec, encode resolution and receive resolution of the remote video streams. It also makes
-     * adjustments based on the outbound and inbound rtp stream stats reported by the underlying peer connection.
+     * Implements end-to-end ping (from one conference participant to another) via
+     * the jitsi-videobridge channel (either WebRTC data channel or web socket).
+     *
+     * TODO: use a broadcast message instead of individual pings to each remote
+     * participant.
+     *
+     * This class:
+     * 1. Sends periodic ping requests to all other participants in the
+     * conference.
+     * 2. Responds to ping requests from other participants.
+     * 3. Fires events with the end-to-end RTT to each participant whenever a
+     * response is received.
+     * 4. Fires analytics events with the end-to-end RTT periodically.
      */
-    export class QualityController {
-        private _audioController;
-        private _codecController;
-        private _conference;
-        private _enableAdaptiveMode;
-        private _encodeTimeStats;
-        private _isLastNRampupBlocked;
-        private _lastNRampupTime;
-        private _lastNRampupTimeout;
-        private _limitedByCpuTimeout;
-        private _receiveVideoController;
-        private _sendVideoController;
-        private _timer;
+    export default class E2ePing {
+        conference: JitsiConference;
+        eventEmitter: any;
+        sendMessage: (message: IPingMessage, participantId: string) => void;
+        participants: {
+            [key: string]: ParticipantWrapper;
+        };
+        numRequests: number;
+        maxConferenceSize: number;
+        maxMessagesPerSecond: number;
         /**
-         *
-         * @param {JitsiConference} conference - The JitsiConference instance.
-         * @param {Object} options - video quality settings passed through config.js.
+         * @param {JitsiConference} conference - The conference.
+         * @param {Function} sendMessage - The function to use to send a message.
+         * @param {Object} options
          */
-        constructor(conference: JitsiConference, options: {
-            enableAdaptiveMode: boolean;
-            jvb: object;
-            lastNRampupTime: number;
-            p2p: object;
-        });
+        constructor(conference: JitsiConference, options: IE2ePingOptions, sendMessage: (message: IPingMessage, participantId: string) => void);
         /**
-         * Creates a debounced function that delays the execution of the provided function until after the specified delay
-         * has elapsed. Unlike typical debounce implementations, the timer does not reset when the function is called again
-         * within the delay period.
-         *
-         * @param {Function} func - The function to be debounced.
-         * @param {number} delay - The delay in milliseconds.
-         * @returns {Function} - The debounced function.
+         * Delay processing USER_JOINED events until the MUC is fully joined,
+         * otherwise the apparent conference size will be wrong.
          */
-        _debounce(func: Function, delay: number): (...args: any) => void;
+        conferenceJoined(): void;
         /**
-         * Adjusts the lastN value so that fewer remote video sources are received from the bridge in an attempt to improve
-         * encode resolution of the outbound video streams based on cpuLimited parameter passed. If cpuLimited is false,
-         * the lastN value will slowly be ramped back up to the channelLastN value set in config.js.
+         * Handles a message that was received.
          *
-         * @param {boolean} cpuLimited - whether the endpoint is cpu limited or not.
-         * @returns boolean - Returns true if an action was taken, false otherwise.
-         */
-        _lowerOrRaiseLastN(cpuLimited: boolean): boolean;
-        /**
-         * Adjusts the requested resolution for remote video sources by updating the receiver constraints in an attempt to
-         * improve the encode resolution of the outbound video streams.
-         * @return {void}
+         * @param participant - The message sender.
+         * @param payload - The payload of the message.
          */
-        _maybeLowerReceiveResolution(): void;
+        messageReceived(participant: JitsiParticipant, payload: IPingMessage): void;
         /**
-         * Updates the codec preference order for the local endpoint on the active media session and switches the video
-         * codec if needed.
+         * Handles a participant joining the conference. Starts to send ping
+         * requests to the participant.
          *
-         * @param {number} trackId - The track ID of the local video track for which stats have been captured.
-         * @returns {boolean} - Returns true if video codec was changed.
+         * @param {String} id - The ID of the participant.
+         * @param {JitsiParticipant} participant - The participant that joined.
          */
-        _maybeSwitchVideoCodec(trackId: number): boolean;
+        participantJoined(id: string, participant: JitsiParticipant): void;
         /**
-         * Adjusts codec, lastN or receive resolution based on the send resolution (of the outbound streams) and limitation
-         * reported by the browser in the WebRTC stats. Recovery is also attempted if the limitation goes away. No action
-         * is taken if the adaptive mode has been disabled through config.js.
-         *
-         * @param {ISourceStats} sourceStats - The outbound-rtp stats for a local video track.
-         * @returns {void}
+         * Remove a participant without calling "stop".
          */
-        _performQualityOptimizations(sourceStats: ISourceStats): void;
+        removeParticipant(id: string): void;
         /**
-         * Processes the outbound RTP stream stats as reported by the WebRTC peerconnection and makes runtime adjustments
-         * to the client for better quality experience if the adaptive mode is enabled.
+         * Handles a participant leaving the conference. Stops sending requests.
          *
-         * @param {TraceablePeerConnection} tpc - The underlying WebRTC peerconnection where stats have been captured.
-         * @param {Map<number, IOutboundRtpStats>} stats - Outbound-rtp stream stats per SSRC.
-         * @returns void
+         * @param {String} id - The ID of the participant.
          */
-        _processOutboundRtpStats(tpc: TraceablePeerConnection, stats: Map<number, IOutboundRtpStats>): void;
+        participantLeft(id: string): void;
         /**
-         * Gets the audio controller instance.
+         * Handles a ping request coming from another participant.
+         *
+         * @param {string} participantId - The ID of the participant who sent the
+         * request.
+         * @param {Object} request - The request.
          */
-        get audioController(): ReceiverAudioController;
+        handleRequest(participantId: string, request: {
+            id: number;
+        }): void;
         /**
-         * Gets the codec controller instance.
+         * Handles a ping response coming from another participant
+         * @param {string} participantId - The ID of the participant who sent the
+         * response.
+         * @param {Object} response - The response.
          */
-        get codecController(): CodecSelection;
+        handleResponse(participantId: string, response: {
+            id: number;
+        }): void;
         /**
-         * Gets the receive video controller instance.
+         * Stops this E2ePing (i.e. stop sending requests).
          */
-        get receiveVideoController(): ReceiveVideoController;
+        stop(): void;
+    }
+}
+declare module "modules/litemode/LiteModeContext" {
+    import JitsiConference from "JitsiConference";
+    /**
+     * This module implements a discard-all insertable stream.  Use to reduce decoder CPU load for testing.
+     */
+    export class LiteModeContext {
+        private enabled;
         /**
-         * Gets the send video controller instance.
+         * A constructor.
+         * @param {JitsiConference} conference - The conference instance for which lite mode is to be enabled.
          */
-        get sendVideoController(): SendVideoController;
+        constructor(conference: JitsiConference);
         /**
-         * Cleans up the QualityController by clearing all active timeouts and disposing of controllers.
-         * This prevents memory leaks and ensures proper cleanup when the controller is no longer needed.
+         * Setup Lite Mode for a track.
+         *
+         * @private
          */
-        dispose(): void;
+        private _setupLiteModeForTrack;
     }
 }
 declare module "modules/recording/RecordingManager" {
@@ -15206,7 +15285,7 @@ declare module "modules/webaudio/AudioMixer" {
     }
 }
 declare module "version" {
-    export const COMMIT_HASH = "6912eed8";
+    export const COMMIT_HASH = "1a3c35c0";
 }
 declare module "JitsiMeetJS" {
     import JitsiConference, { IConferenceOptions } from "JitsiConference";