@webex/plugin-meetings 3.12.0-next.9 → 3.12.0-next.91

package/dist/types/meeting/index.d.ts

@@ -16,7 +16,7 @@ import { DESTINATION_TYPE, NETWORK_STATUS } from '../constants';
 import { ReceiveSlotManager } from '../multistream/receiveSlotManager';
 import { MediaRequestManager } from '../multistream/mediaRequestManager';
 import { Configuration as RemoteMediaManagerConfiguration, RemoteMediaManager } from '../multistream/remoteMediaManager';
-import { ReactionServerType, SkinToneType } from '../reactions/reactions.type';
+import { SkinToneType } from '../reactions/reactions.type';
 import InMeetingActions from './in-meeting-actions';
 import RecordingController from '../recording-controller';
 import ControlsOptionsManager from '../controls-options-manager';
@@ -374,7 +374,7 @@ export default class Meeting extends StatelessWebexPlugin {
     webinar: any;
     conversationUrl: string;
     callStateForMetrics: CallStateForMetrics;
-    destination: string;
+    destination: string | LocusDTO;
     destinationType: DESTINATION_TYPE;
     deviceUrl: string;
     hostId: string;
@@ -412,6 +412,8 @@ export default class Meeting extends StatelessWebexPlugin {
     floorGrantPending: boolean;
     hasJoinedOnce: boolean;
     hasWebsocketConnected: boolean;
+    private mercuryOnlineHandler?;
+    private mercuryOfflineHandler?;
     inMeetingActions: InMeetingActions;
     isLocalShareLive: boolean;
     isRoapInProgress: boolean;
@@ -422,6 +424,7 @@ export default class Meeting extends StatelessWebexPlugin {
     joinedWith?: any;
     selfId?: string;
     roles: any[];
+    canNotViewTheParticipantList?: boolean;
     locusMediaRequest?: LocusMediaRequest;
     mediaProperties: MediaProperties;
     mediaRequestManagers: {
@@ -491,13 +494,14 @@ export default class Meeting extends StatelessWebexPlugin {
     isMoveToInProgress: boolean;
     registrationIdStatus: string;
     brbState: BrbState;
+    private promisesWaitingForPropUpdate;
     voiceaListenerCallbacks: object;
     private addMediaData;
     private sendSlotManager;
     private deferSDPAnswer?;
     private sdpResponseTimer?;
     private hasMediaConnectionConnectedAtLeastOnce;
-    private joinWithMediaRetryInfo?;
+    private joinWithMediaRetryInfo;
     private connectionStateHandler?;
     private iceCandidateErrors;
     private iceCandidatesCount;
@@ -514,6 +518,15 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     constructor(attrs: any, options: object, callback: (meeting: Meeting) => void);
+    /**
+     * Get the ingress payload type for a given media type and codec mime type
+     * @param {MediaType} mediaType - The media type
+     * @param {MediaCodecMimeType} codecMimeType - The codec mime type
+     * @returns {number | undefined} - The ingress payload type
+     * @private
+     * @memberof Meeting
+     */
+    private getIngressPayloadTypeCallback;
     /**
      * returns meeting is joined
      * @private
@@ -970,7 +983,12 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     mute(memberId: string, mute?: boolean): any;
     /**
-     * Transfer the moderator role to another eligible member
+     * Transfer the moderator role to another eligible member.
+     *
+     * If the target member is currently joined in the current session, the request is
+     * sent against the current locus. Otherwise, we search the breakout sessions and,
+     * when the member is found in one, we send the request against that breakout
+     * session's locus url instead.
      * @param {String} memberId
      * @param {Boolean} moderator
      * @returns {Promise} see #members.transferHostToMember
@@ -1051,6 +1069,13 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     setSipUri(sipUri: string): void;
+    /**
+     * After initial locus setup, refreshes destination with synced locus data and optionally
+     * performs deferred meeting info fetch when initial locus was incomplete.
+     * @param {LocusDTO} locus
+     * @returns {void}
+     */
+    finalizeMeetingAfterInitialLocusSetup(locus: LocusDTO): Promise<void>;
     /**
      * Set the locus info the class instance. Should be called with the parsed locus
      * we got in the join response.
@@ -1163,6 +1188,22 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     setMercuryListener(): void;
+    /**
+     * Removes this meeting's Mercury ONLINE/OFFLINE event listeners registered
+     * by setMercuryListener(). Must be called before Locus /leave to avoid
+     * unnecessary syncs/metrics triggered by events received while leaving
+     * (per Locus team recommendation).
+     *
+     * Mercury is a process-wide singleton shared with other plugins, so we
+     * pass the bound handler refs to .off() to avoid clearing every listener
+     * for ONLINE/OFFLINE on the shared emitter.
+     *
+     * Idempotent: subsequent calls are no-ops because the handler refs are
+     * cleared after detaching.
+     * @private
+     * @returns {void}
+     */
+    private stopListeningForMercuryEvents;
     /**
      * Close the peer connections and remove them from the class.
      * Cleanup any media connection related things.
@@ -1299,6 +1340,12 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {void}
      */
     private processLocusLLMEvent;
+    /**
+     * Verifies the relay event was delivered for the active LLM session binding.
+     * @param {RelayEvent} event Event object coming from LLM Connection
+     * @returns {boolean}
+     */
+    private isRelayEventRouteValid;
     /**
      * Callback called when a relay event is received from meeting LLM Connection
      * @param {RelayEvent} e Event object coming from LLM Connection
@@ -1356,8 +1403,41 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {void}
      */
     private clearLLMHealthCheckTimer;
+    /**
+     * Removes LLM event listeners and clears the health check timer.
+     * Must be called before Locus /leave to avoid unnecessary syncs triggered
+     * by events received while leaving (per Locus team recommendation).
+     * Idempotent: safe to call multiple times; .off() is a no-op when no
+     * matching listener is registered.
+     * @private
+     * @returns {void}
+     */
+    private stopListeningForLLMEvents;
+    /**
+     * Stops listening on every event bus (LLM, Mercury, voicea/transcription,
+     * annotation) that could otherwise deliver events to this meeting while
+     * Locus is processing /leave or /end. Per the Locus team recommendation,
+     * this must run before the Locus request is dispatched to avoid
+     * unnecessary syncs triggered by in-flight events.
+     *
+     * Voicea (transcription) subscribes to llm 'event:relay.event' internally,
+     * and the annotation plugin subscribes to both mercury and llm, so both
+     * must be torn down alongside the direct LLM/Mercury listeners.
+     *
+     * Idempotent: safe to call multiple times; .off() is a no-op when no
+     * matching listener is registered, and stopTranscription is guarded.
+     * @private
+     * @returns {void}
+     */
+    private stopListeningForMeetingEvents;
     /**
      * Disconnects and cleans up the default LLM session listeners/timers.
+     *
+     * Ownership-aware: only calls `disconnectLLM` when this meeting is the
+     * current owner of the default LLM session (or when no owner is recorded).
+     * Event listeners belonging to this meeting instance are always detached
+     * so they do not receive another meeting's relay events.
+     *
      * @param {Object} options
      * @param {boolean} [options.removeOnlineListener=true] removes the one-time online listener
      * @param {boolean} [options.throwOnError=true] rethrows disconnect errors when true
@@ -1365,8 +1445,8 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     private cleanupLLMConneciton;
     /**
-     * Clears all data channel tokens stored in LLM.
-     * Called during meeting cleanup to ensure stale tokens are not reused.
+     * Clears data channel tokens associated with this meeting ownership.
+     * Ownership checks are enforced in internal-plugin-llm.
      * @returns {void}
      */
     clearDataChannelToken(): void;
@@ -1597,6 +1677,13 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {void}
      */
     private setupLocusMediaRequest;
+    /**
+     * Waits for LocusInfo to update meeting.selfUrl, with a timeout fallback.
+     * @returns {Promise<void>}
+     * @private
+     * @memberof Meeting
+     */
+    private waitForSelfUrlChange;
     /**
      * Creates a media connection to the server. Media connection is required for sending or receiving any audio/video.
      *
@@ -1980,7 +2067,7 @@ export default class Meeting extends StatelessWebexPlugin {
      * @public
      * @memberof Meeting
      */
-    sendReaction(reactionType: ReactionServerType, skinToneType?: SkinToneType): any;
+    sendReaction(reactionType: string, skinToneType?: SkinToneType): any;
     /**
      * Extend the current meeting duration.
      *

package/dist/types/meeting/locusMediaRequest.d.ts

@@ -32,6 +32,8 @@ export type Config = {
     correlationId: string;
     meetingId: string;
     preferTranscoding: boolean;
+    getCurrentSelfUrl: () => string | undefined;
+    waitForSelfUrlChange: () => Promise<void>;
 };
 /**
  * This class manages all /media API requests to Locus. Every call to that
@@ -67,6 +69,16 @@ export declare class LocusMediaRequest extends WebexPlugin {
      * Prepares the uri and body for the media request to be sent to Locus
      */
     private sendHttpRequest;
+    /**
+     * Returns the latest selfUrl for this meeting, falling back to the value
+     * captured when the request was enqueued.
+     */
+    private getCurrentSelfUrl;
+    /**
+     * Decides whether a 409 warrants a retry against the meeting's latest
+     * selfUrl.
+     */
+    private shouldRetryOnSelfUrlChange;
     /**
      * Sends a media request to Locus
      */

package/dist/types/meeting/request.d.ts

@@ -63,6 +63,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         locale?: string;
         deviceCapabilities?: Array<string>;
         liveAnnotationSupported: boolean;
+        enableSimultaneousInterpretation: boolean;
         alias?: string;
         clientMediaPreferences: ClientMediaPreferences;
     }): Promise<any>;

package/dist/types/meeting/util.d.ts

@@ -133,6 +133,13 @@ declare const MeetingUtil: {
      * @returns {void}
      */
     addSequence: (meeting: any, requestBody: any) => void;
+    /**
+     * Checks if Locus API response contains a Locus DTO
+     *
+     * @param {any} response http response from Locus API call
+     * @returns {boolean} true if response contains a Locus DTO
+     */
+    isLocusDtoInAPIResponse(response: any): any;
     /**
      * Updates the locus info for the meeting with the locus
      * information returned from API requests made to Locus
@@ -146,6 +153,8 @@ declare const MeetingUtil: {
     generateLocusDeltaRequest: (originalMeeting: any) => (originalOptions: any) => any;
     canAttendeeRequestAiAssistantEnabled: (displayHints?: any[], roles?: any[]) => boolean;
     attendeeRequestAiAssistantDeclinedAll: (displayHints?: any[]) => boolean;
+    isAnonymizeDisplayNamesEnabled: (displayHints: any) => any;
+    canViewTheParticipantList: (displayHints: any, canNotViewTheParticipantList: boolean) => any;
     selfSupportsFeature: (feature: SELF_POLICY, userPolicies: Record<SELF_POLICY, boolean>) => boolean;
     parseInterpretationInfo: (meeting: any, meetingInfo: any) => void;
     /**

package/dist/types/meetings/index.d.ts

@@ -8,7 +8,7 @@ import 'webrtc-adapter';
 import { LOCUSEVENT, DESTINATION_TYPE } from '../constants';
 import { CallStateForMetrics } from '../meeting';
 import Reachability from '../reachability';
-import { INoiseReductionEffect, IVirtualBackgroundEffect, MeetingRegistrationStatus } from './meetings.types';
+import { FetchSitePreferencesMeViaSiteOptions, INoiseReductionEffect, IVirtualBackgroundEffect, MeetingRegistrationStatus, SitePreferencesResponse } from './meetings.types';
 import { HashTreeMessage } from '../hashTree/hashTreeParser';
 export type LocusEvent = {
     eventType: LOCUSEVENT;
@@ -211,22 +211,6 @@ export default class Meetings extends WebexPlugin {
      * @returns {undefined}
      */
     private _toggleAdhocMeetings;
-    /**
-     * API to toggle TCP reachability, needs to be called before webex.meetings.register()
-     * @param {Boolean} newValue
-     * @private
-     * @memberof Meetings
-     * @returns {undefined}
-     */
-    private _toggleTcpReachability;
-    /**
-     * API to toggle TLS reachability, needs to be called before webex.meetings.register()
-     * @param {Boolean} newValue
-     * @private
-     * @memberof Meetings
-     * @returns {undefined}
-     */
-    private _toggleTlsReachability;
     /**
      * API to toggle backend ipv6 native support config, needs to be called before webex.meetings.register()
      *
@@ -254,6 +238,16 @@ export default class Meetings extends WebexPlugin {
      * @returns {undefined}
      */
     private _toggleEnableAudioTwccForMultistream;
+    /**
+     * API to toggle AV1 codec support for video slides in multistream,
+     * needs to be called before webex.meetings.joinWithMedia()
+     *
+     * @param {Boolean} newValue
+     * @private
+     * @memberof Meetings
+     * @returns {undefined}
+     */
+    private _toggleEnableAv1SlidesSupport;
     /**
      * API to toggle stopping ICE Candidates Gathering after first relay candidate,
      * needs to be called before webex.meetings.joinWithMedia()
@@ -368,6 +362,23 @@ export default class Meetings extends WebexPlugin {
      * @memberof Meetings
      */
     getPersonalMeetingRoom(): any;
+    /**
+     * Fetches site preferences for the provided Webex site, or the preferred Webex site.
+     * This is used to determine capabilities of the site, such as whether scheduling a webinar is supported.
+     *
+     * @param {object} [options]
+     * @param {string} [options.siteUrl] - Webex site URL. Defaults to preferredWebexSite, for example "cisco.webex.com".
+     * @param {string} [options.siteName] - Site name query override. Defaults to the site name derived from siteUrl, for example "cisco" for "cisco.webex.com".
+     * @param {SitePreferenceSelectOption[]} [options.selectOptions] - Preference sections to fetch. Defaults to 'scheduling'.
+     * @returns {Promise<SitePreferencesResponse>} site preferences response body
+     * @throws {ParameterError}
+     * @public
+     * @memberof Meetings
+     * @example
+     * const preferences = await webex.meetings.fetchSitePreferencesMeViaSite();
+     * const supportScheduleWebinar = preferences?.scheduling?.supportScheduleWebinar;
+     */
+    fetchSitePreferencesMeViaSite(options?: FetchSitePreferencesMeViaSiteOptions): Promise<SitePreferencesResponse>;
     /**
      * Returns basic information about a meeting that exists or
      * used to exist in the MeetingCollection
@@ -477,8 +488,9 @@ export default class Meetings extends WebexPlugin {
      * @public
      * @memberof Meetings
      */
-    syncMeetings({ keepOnlyLocusMeetings }?: {
+    syncMeetings({ keepOnlyLocusMeetings, skipHashTreeSync, }?: {
         keepOnlyLocusMeetings?: boolean;
+        skipHashTreeSync?: boolean;
     }): Promise<void>;
     /**
      * sort out locus array for initial creating

package/dist/types/meetings/meetings.types.d.ts

@@ -19,3 +19,18 @@ export type MeetingRegistrationStatus = {
     mercuryConnect: boolean;
     checkH264Support: boolean;
 };
+export declare enum SitePreferenceSelectOption {
+    SCHEDULING = "scheduling"
+}
+export type FetchSitePreferencesMeViaSiteOptions = {
+    siteUrl?: string;
+    siteName?: string;
+    selectOptions?: SitePreferenceSelectOption[];
+};
+export declare const DEFAULT_SITE_PREFERENCE_SELECT_OPTIONS: SitePreferenceSelectOption[];
+export type SitePreferencesResponse = {
+    scheduling?: {
+        supportScheduleWebinar?: boolean;
+        webinarWebLink?: string;
+    };
+};

package/dist/types/meetings/request.d.ts

@@ -1,4 +1,5 @@
 import { StatelessWebexPlugin } from '@webex/webex-core';
+import { type FetchSitePreferencesMeViaSiteOptions, type SitePreferencesResponse } from './meetings.types';
 /**
  * @class MeetingRequest
  */
@@ -18,6 +19,19 @@ export default class MeetingRequest extends StatelessWebexPlugin {
      * @returns {Promise<object>} getMeetingPreferences
      */
     getMeetingPreferences(): any;
+    /**
+     * Fetches site preferences from a given site given a select option and a siteUrl with an optional siteName. If siteName is not provided, it will be derived from the siteUrl. If siteUrl is not provided, it will throw an error. If selectOptions is not provided, it will default to scheduling.
+     *
+     * @param {object} [options]
+     * @param {string} [options.siteUrl] - Webex site URL, for example "cisco.webex.com".
+     * @param {string} [options.siteName] - Site name query override. Defaults to the site name derived from options.siteUrl, e.g., "cisco".
+     * @param {SitePreferenceSelectOption[]} [options.selectOptions] - Preference sections to fetch. Defaults to 'scheduling'.
+     * @returns {Promise<SitePreferencesResponse>} site preferences response body
+     * @throws {ParameterError}
+     * @public
+     * @memberof MeetingRequest
+     */
+    fetchSitePreferencesMeViaSite(options?: FetchSitePreferencesMeViaSiteOptions): Promise<SitePreferencesResponse>;
     /**
      *  Fetches indivdual locus rather then getting all at once
      * @param {object} responseBody determine the locus and fetch them if a remoteUrl is given

package/dist/types/member/index.d.ts

@@ -20,6 +20,7 @@ export default class Member {
     isModerator: any;
     isModeratorAssignmentProhibited: any;
     isPresenterAssignmentProhibited: any;
+    isAttendeeAssignmentProhibited: any;
     isMutable: any;
     isNotAdmitted: any;
     isRecording: any;

package/dist/types/member/types.d.ts

@@ -89,6 +89,7 @@ export interface Participant {
     moderator: boolean;
     moderatorAssignmentNotAllowed: boolean;
     presenterAssignmentNotAllowed: boolean;
+    attendeeAssignmentNotAllowed?: boolean;
     person: ParticipantPerson;
     resourceGuest: boolean;
     state: string;

package/dist/types/member/util.d.ts

@@ -66,6 +66,7 @@ declare const MemberUtil: {
     isDevice: (participant: Participant) => boolean;
     isModeratorAssignmentProhibited: (participant: Participant) => boolean;
     isPresenterAssignmentProhibited: (participant: Participant) => boolean;
+    isAttendeeAssignmentProhibited: (participant: Participant) => boolean;
     /**
      * checks to see if the participant id is the same as the passed id
      * there are multiple ids that can be used
@@ -163,5 +164,13 @@ declare const MemberUtil: {
      * @returns {String}
      */
     extractPairedWithParticipantUrl: (participant: Participant) => ParticipantUrl | undefined;
+    /**
+     * Collects all CSIs reported for a participant across all their devices,
+     * looking at both the top-level `csis` array and any `mediaSessions[].csi` values.
+     *
+     * @param {Object} participant - The locus participant object.
+     * @returns {Array<number>} unique CSIs for this participant
+     */
+    extractCsis: (participant: Participant) => number[];
 };
 export default MemberUtil;

package/dist/types/members/index.d.ts

@@ -23,6 +23,14 @@ export default class Members extends StatelessWebexPlugin {
     recordingId: any;
     selfId: any;
     type: any;
+    /**
+     * Map of CSI -> memberId that previously used the CSI in a Locus update.
+     * Keyed by CSI so findMemberByCsi can resolve it in O(1).
+     * Kept here (rather than on each Member) so it survives members being removed
+     * and re-added (e.g. when entering/leaving a breakout session).
+     * @private
+     */
+    private memberIdByHistoryCsi;
     namespace: string;
     /**
      *
@@ -313,11 +321,13 @@ export default class Members extends StatelessWebexPlugin {
      * Transfers the host to another member
      * @param {String} memberId
      * @param {boolean} [moderator] default true
+     * @param {String} [breakoutLocusUrl] when provided, the request is sent against this locus url
+     * (i.e. the breakout session's locus) instead of the main session's locus url
      * @returns {Promise}
      * @public
      * @memberof Members
      */
-    transferHostToMember(memberId: string, moderator?: boolean): any;
+    transferHostToMember(memberId: string, moderator?: boolean, breakoutLocusUrl?: string): any;
     /**
      * Sends DTMF tones for the PSTN member of a meeting
      * @param {String} tones a string of one or more DTMF tones to send
@@ -327,7 +337,10 @@ export default class Members extends StatelessWebexPlugin {
      * @memberof Members
      */
     sendDialPadKey(tones?: string, memberId?: string): any;
-    /** Finds a member that has any device with a csi matching provided value
+    /** Finds a member that has any device with a csi matching provided value.
+     * Falls back to the `memberIdByHistoryCsi` map so that a CSI a member used in
+     * a previous Locus update can still be resolved even if it is no longer
+     * present in `participant.devices[].csis`.
      *
      * @param {number} csi
      * @returns {Member}

package/dist/types/members/util.d.ts

@@ -188,11 +188,7 @@ declare const MembersUtil: {
     getTransferHostToMemberRequestParams: (options: any) => {
         method: string;
         uri: string;
-        body: {
-            role: {
-                moderator: any;
-            };
-        };
+        body: Record<string, any>;
     };
     genderateSendDTMFOptions: (url: any, tones: any, memberId: any, locusUrl: any) => {
         url: any;

package/dist/types/metrics/constants.d.ts

@@ -9,6 +9,7 @@ declare const BEHAVIORAL_METRICS: {
     ADD_MEDIA_SUCCESS: string;
     ADD_MEDIA_FAILURE: string;
     ADD_MEDIA_RETRY: string;
+    LOCUS_MEDIA_REQUEST_RETRY: string;
     ROAP_MERCURY_EVENT_RECEIVED: string;
     CONNECTION_SUCCESS: string;
     CONNECTION_FAILURE: string;
@@ -92,5 +93,8 @@ declare const BEHAVIORAL_METRICS: {
     DEPRECATED_DELETE_CODEC_PARAMETERS_USED: string;
     SET_CUSTOM_CODEC_PARAMETERS_USED: string;
     MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED: string;
+    HASH_TREE_SYNC_FAILURE: string;
+    HASH_TREE_HEARTBEAT_WATCHDOG_EXPIRED: string;
+    HASH_TREE_EMPTY_LOCUS_STATE_ELEMENTS: string;
 };
 export { BEHAVIORAL_METRICS as default };

package/dist/types/multistream/codec/constants.d.ts

@@ -0,0 +1,7 @@
+import { AV1EncodingParams, SupportedResolution } from '@webex/internal-media-core';
+export declare const AV1_CODEC_PARAMETERS: Record<SupportedResolution, AV1EncodingParams>;
+export declare const H264_CODEC_PARAMETERS: {
+    maxFs: number;
+    maxFps: number;
+    maxMbps: number;
+};

package/dist/types/multistream/mediaRequestManager.d.ts

@@ -1,4 +1,4 @@
-import { StreamRequest, NamedMediaGroup } from '@webex/internal-media-core';
+import { StreamRequest, NamedMediaGroup, MediaType, MediaCodecMimeType } from '@webex/internal-media-core';
 import { ReceiveSlot } from './receiveSlot';
 export interface ActiveSpeakerPolicyInfo {
     policy: 'active-speaker';
@@ -36,14 +36,22 @@ type DegradationPreferences = {
     maxMacroblocksLimit: number;
 };
 type SendMediaRequestsCallback = (streamRequests: StreamRequest[]) => void;
-type Kind = 'audio' | 'video';
-type Options = {
+type GetIngressPayloadTypeCallback = (mediaType: MediaType, codecMimeType: MediaCodecMimeType) => number | undefined;
+type AudioMediaRequestManagerOptions = {
     degradationPreferences: DegradationPreferences;
-    kind: Kind;
+    kind: 'audio';
     trimRequestsToNumOfSources: boolean;
 };
+type VideoMediaRequestManagerOptions = {
+    degradationPreferences: DegradationPreferences;
+    kind: 'video';
+    trimRequestsToNumOfSources: boolean;
+    enableAv1?: boolean;
+};
+type Options = AudioMediaRequestManagerOptions | VideoMediaRequestManagerOptions;
 export declare class MediaRequestManager {
     private sendMediaRequestsCallback;
+    private getIngressPayloadTypeCallback;
     private kind;
     private counter;
     private clientRequests;
@@ -51,9 +59,10 @@ export declare class MediaRequestManager {
     private sourceUpdateListener;
     private debouncedSourceUpdateListener;
     private trimRequestsToNumOfSources;
+    private enableAv1;
     private numTotalSources;
     private numLiveSources;
-    constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, options: Options);
+    constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, getIngressPayloadTypeCallback: GetIngressPayloadTypeCallback, options: Options);
     setDegradationPreferences(degradationPreferences: DegradationPreferences): void;
     private getDegradedClientRequests;
     /**
@@ -77,6 +86,14 @@ export declare class MediaRequestManager {
      * @returns {number} maxMbps
      */
     private getH264MaxMbps;
+    /**
+     * Returns the AV1 encoding parameters for a media request
+     * @param mediaRequest - The media request to get the AV1 encoding parameters for
+     * @returns {AV1EncodingParams} The AV1 encoding parameters
+     */
+    private getAv1EncodingParams;
+    private buildH264CodecInfo;
+    private buildAv1CodecInfo;
     /** Modifies the passed in clientRequests and makes sure that in total they don't ask
      *  for more streams than there are available.
      *

package/dist/types/reachability/index.d.ts

@@ -145,7 +145,7 @@ export default class Reachability extends EventsScope {
      * Returns true only if ALL protocols (UDP, TCP and TLS) have been tested and none
      * of the media clusters where reachable with any of the protocols. This is done
      * irrespective of the config, so for example:
-     * if config.meetings.experimental.enableTlsReachability === false,
+     * if config.meetings.enableReachabilityChecks disables TLS,
      * it will return false, because TLS reachability won't be tested,
      * so we can't say for sure that media backend is unreachable over TLS.
      *

package/dist/types/reachability/reachability.types.d.ts

@@ -1,5 +1,12 @@
 import { IP_VERSION, Enum } from '../constants';
 export type Protocol = 'udp' | 'tcp' | 'xtls';
+export type ResolvedReachabilityProtocols = {
+    udp: boolean;
+    tcp: boolean;
+    tls: boolean;
+};
+export type ReachabilityProtocolConfig = Partial<Omit<ResolvedReachabilityProtocols, 'udp'>>;
+export type EnableReachabilityChecksConfig = boolean | ReachabilityProtocolConfig;
 /**
  * Events emitted by ReachabilityPeerConnection
  */

package/dist/types/reachability/util.d.ts

@@ -1,3 +1,20 @@
+import { EnableReachabilityChecksConfig, ResolvedReachabilityProtocols } from './reachability.types';
+/**
+ * Resolves `enableReachabilityChecks` into explicit per-protocol flags.
+ * Defaults to all protocols enabled when not configured.
+ * UDP is always tested unless reachability is disabled entirely (`false`).
+ *
+ * @param {EnableReachabilityChecksConfig} enabled value of config.meetings.enableReachabilityChecks
+ * @returns {ResolvedReachabilityProtocols} resolved per-protocol flags
+ */
+export declare function resolveReachabilityProtocols(enabled?: EnableReachabilityChecksConfig): ResolvedReachabilityProtocols;
+/**
+ * Whether any reachability protocol is enabled.
+ *
+ * @param {EnableReachabilityChecksConfig} config value of config.meetings.enableReachabilityChecks
+ * @returns {boolean} true if any protocol is enabled
+ */
+export declare function isReachabilityEnabled(config?: EnableReachabilityChecksConfig): boolean;
 /**
  * Converts a stun url to a turn url
  *

package/dist/types/reactions/reactions.type.d.ts

@@ -49,5 +49,8 @@ type RelayEventData = {
 };
 export type RelayEvent = {
     data: RelayEventData;
+    headers?: {
+        route?: string;
+    };
 };
 export {};