@webex/plugin-meetings 3.11.0-webex-services-ready.1 → 3.12.0-mobius-socket.1

package/dist/types/hashTree/hashTree.d.ts

@@ -110,6 +110,13 @@ declare class HashTree {
      * or an empty array if the index is invalid or leaf is empty.
      */
     getLeafData(leafIndex: number): LeafDataItem[];
+    /**
+     * Retrieves the version of a specific item by its id and type.
+     * @param {number} id The ID of the item.
+     * @param {ObjectType} type The type of the item.
+     * @returns {number | undefined} The version of the item if found, undefined otherwise.
+     */
+    getItemVersion(id: number, type: ObjectType): number | undefined;
     /**
      * Resizes the HashTree to have a new number of leaf nodes, redistributing all existing items.
      * @param {number} newNumLeaves The new number of leaf nodes (must be 0 or a power of 2).

package/dist/types/hashTree/hashTreeParser.d.ts

@@ -1,6 +1,6 @@
 import HashTree from './hashTree';
 import { Enum } from '../constants';
-import { HashTreeObject } from './types';
+import { HtMeta, HashTreeObject } from './types';
 import { LocusDTO } from '../locus-info/types';
 export interface DataSet {
     url: string;
@@ -23,10 +23,21 @@ export interface HashTreeMessage {
     locusStateElements?: Array<HashTreeObject>;
     locusSessionId?: string;
     locusUrl: string;
+    heartbeatIntervalMs?: number;
+}
+export interface VisibleDataSetInfo {
+    name: string;
+    url: string;
+    dataChannelUrl?: string;
+}
+export interface Metadata {
+    htMeta: HtMeta;
+    visibleDataSets: VisibleDataSetInfo[];
 }
 interface InternalDataSet extends DataSet {
     hashTree?: HashTree;
     timer?: ReturnType<typeof setTimeout>;
+    heartbeatWatchdogTimer?: ReturnType<typeof setTimeout>;
 }
 type WebexRequestMethod = (options: Record<string, any>) => Promise<any>;
 export declare const LocusInfoUpdateType: {
@@ -37,6 +48,12 @@ export type LocusInfoUpdateType = Enum<typeof LocusInfoUpdateType>;
 export type LocusInfoUpdateCallback = (updateType: LocusInfoUpdateType, data?: {
     updatedObjects: HashTreeObject[];
 }) => void;
+/**
+ * This error is thrown if we receive information that the meeting has ended while we're processing some hash messages.
+ * It's handled internally by HashTreeParser and results in MEETING_ENDED being sent up.
+ */
+export declare class MeetingEndedError extends Error {
+}
 /**
  * Parses hash tree eventing locus data
  */
@@ -45,8 +62,11 @@ declare class HashTreeParser {
     visibleDataSetsUrl: string;
     webexRequest: WebexRequestMethod;
     locusInfoUpdateCallback: LocusInfoUpdateCallback;
-    visibleDataSets: string[];
+    visibleDataSets: VisibleDataSetInfo[];
     debugId: string;
+    heartbeatIntervalMs?: number;
+    private excludedDataSets;
+    state: 'active' | 'stopped';
     /**
      * Constructor for HashTreeParser
      * @param {Object} options
@@ -57,16 +77,46 @@ declare class HashTreeParser {
             dataSets: Array<DataSet>;
             locus: any;
         };
+        metadata: Metadata | null;
         webexRequest: WebexRequestMethod;
         locusInfoUpdateCallback: LocusInfoUpdateCallback;
         debugId: string;
+        excludedDataSets?: string[];
     });
+    /**
+     * Sets the visible data sets list for the HashTreeParser. This method should be called only at the start, to initialize
+     * the visible data sets, before any message processsing, so for example from the constructor or when resuming the parser.
+     *
+     * @param {Array<VisibleDataSetInfo>} visibleDataSets - The visible data sets to set
+     * @param {Array<DataSet>} dataSets - The "dataSets" list from Locus (yes, Locus sends visibleDataSets and dataSets as separate lists and they can differ)
+     * @returns {void}
+     */
+    private setVisibleDataSets;
+    /**
+     * Checks if the given data set name is in the list of visible data sets
+     * @param {string} dataSetName data set name to check
+     * @returns {Boolean} True if the data set is visible, false otherwise
+     */
+    private isVisibleDataSet;
+    /**
+     * Checks if the given data set name is in the excluded list
+     * @param {string} dataSetName data set name to check
+     * @returns {boolean} True if the data set is excluded, false otherwise
+     */
+    private isExcludedDataSet;
+    /**
+     * Adds a data set to the visible data sets list, unless it is in the excluded list.
+     * @param {VisibleDataSetInfo} dataSetInfo data set info to add
+     * @returns {boolean} True if the data set was added, false if it was excluded
+     */
+    private addToVisibleDataSetsList;
     /**
      * Initializes a new visible data set by creating a hash tree for it, adding it to all the internal structures,
      * and sending an initial sync request to Locus with empty leaf data - that will trigger Locus to gives us all the data
      * from that dataset (in the response or via messages).
      *
-     * @param {DataSet} dataSet The new data set to be added
+     * @param {VisibleDataSetInfo} visibleDataSetInfo Information about the new visible data set
+     * @param {DataSet} dataSetInfo The new data set to be added
      * @returns {Promise}
      */
     private initializeNewVisibleDataSet;
@@ -79,12 +129,11 @@ declare class HashTreeParser {
      */
     private sendInitializationSyncRequestToLocus;
     /**
-     * Queries Locus for information about all the data sets
+     * Queries Locus for all up-to-date information about all visible data sets
      *
-     * @param {string} url - url from which we can get info about all data sets
      * @returns {Promise}
      */
-    private getAllDataSetsMetadata;
+    private getAllVisibleDataSetsFromLocus;
     /**
      * Initializes the hash tree parser from a message received from Locus.
      *
@@ -105,7 +154,7 @@ declare class HashTreeParser {
     /**
      * Initializes data sets by doing an initialization sync on each visible data set that doesn't have a hash tree yet.
      *
-     * @param {DataSet[]} dataSets Array of DataSet objects to initialize
+     * @param {DataSet[]} visibleDataSets Array of visible DataSet objects to initialize
      * @param {string} debugText Text to include in logs for debugging purposes
      * @returns {Promise}
      */
@@ -121,6 +170,15 @@ declare class HashTreeParser {
      * @returns {any} - An object mapping dataset names to arrays of leaf data
      */
     private analyzeLocusHtMeta;
+    /**
+     * Analyzes the Metadata object that is sent outside of Locus object, and appends its data to passed in leafInfo
+     * structure.
+     *
+     * @param {Record<string, LeafInfo[]>} leafInfo the structure to which the Metadata info will be appended
+     * @param {Metadata} metadata Metadata object
+     * @returns {void}
+     */
+    private analyzeMetadata;
     /**
      * Checks if the provided hash tree message indicates the end of the meeting and that there won't be any more updates.
      *
@@ -135,6 +193,22 @@ declare class HashTreeParser {
      * @returns {void}
      */
     private handleRootHashHeartBeatMessage;
+    /**
+     * Asynchronously initializes new visible data sets
+     *
+     * @param {VisibleDataSetInfo[]} dataSetsRequiringInitialization list of datasets to initialize
+     * @returns {void}
+     */
+    private queueInitForNewVisibleDataSets;
+    /**
+     * Handles updates to Metadata object that we receive from Locus via other means than messages. Right now
+     * that means only in the API response alongside locus object.
+     *
+     * @param {Metadata} metadata received in Locus update other than a message (for example in an API response)
+     * @param {HashTreeObject[]} updatedObjects a list of updated hash tree objects to which any updates resulting from new Metadata will be added
+     * @returns {void}
+     */
+    handleMetadataUpdate(metadata: Metadata, updatedObjects: HashTreeObject[]): void;
     /**
      * This method should be called when we receive a partial locus DTO that contains dataSets and htMeta information
      * It updates the hash trees with the new leaf data based on the received Locus
@@ -145,6 +219,7 @@ declare class HashTreeParser {
     handleLocusUpdate(update: {
         dataSets?: Array<DataSet>;
         locus: any;
+        metadata?: Metadata;
     }): void;
     /**
      * Updates the internal data set information based on the received data set from Locus.
@@ -175,18 +250,17 @@ declare class HashTreeParser {
      * visible data sets and they require async initialization, the names of these data sets
      * are returned in an array.
      *
-     * @param {string[]} removedDataSets - The list of removed data sets.
-     * @param {string[]} addedDataSets - The list of added data sets.
+     * @param {VisibleDataSetInfo[]} removedDataSets - The list of removed data sets.
+     * @param {VisibleDataSetInfo[]} addedDataSets - The list of added data sets.
      * @param {HashTreeObject[]} updatedObjects - The list of updated hash tree objects to which changes will be added.
-     * @returns {string[]} names of data sets that couldn't be initialized synchronously
+     * @returns {VisibleDataSetInfo[]} list of data sets that couldn't be initialized synchronously
      */
     private processVisibleDataSetChanges;
     /**
      * Adds entries to the passed in updateObjects array
      * for the changes that result from adding and removing visible data sets.
      *
-     * @param {HashTreeMessage} message - The hash tree message that triggered the visible data set changes.
-     * @param {string[]} addedDataSets - The list of added data sets.
+     * @param {VisibleDataSetInfo[]} addedDataSets - The list of added data sets.
      * @returns {Promise<void>}
      */
     private initializeNewVisibleDataSets;
@@ -195,7 +269,7 @@ declare class HashTreeParser {
      *
      * @param {HashTreeMessage} message - The hash tree message containing data sets and objects to be processed
      * @param {string} [debugText] - Optional debug text to include in logs
-     * @returns {Promise}
+     * @returns {HashTreeObject[]} list of hash tree objects that were updated as a result of processing the message
      */
     private parseMessage;
     /**
@@ -205,7 +279,7 @@ declare class HashTreeParser {
      * @param {string} [debugText] - Optional debug text to include in logs
      * @returns {void}
      */
-    handleMessage(message: HashTreeMessage, debugText?: string): Promise<void>;
+    handleMessage(message: HashTreeMessage, debugText?: string): void;
     /**
      * Calls the updateInfo callback if there are any updates to report
      *
@@ -220,6 +294,15 @@ declare class HashTreeParser {
      * @returns {number} - A weighted backoff time based on the provided configuration, using algorithm supplied by Locus team
      */
     private getWeightedBackoffTime;
+    /**
+     * Performs a sync for the given data set.
+     *
+     * @param {InternalDataSet} dataSet - The data set to sync
+     * @param {string} rootHash - Our current root hash for this data set
+     * @param {string} reason - The reason for the sync (used for logging)
+     * @returns {Promise<void>}
+     */
+    private performSync;
     /**
      * Runs the sync algorithm for the given data set.
      *
@@ -227,14 +310,39 @@ declare class HashTreeParser {
      * @returns {void}
      */
     private runSyncAlgorithm;
+    /**
+     * Resets the heartbeat watchdog timers for the specified data sets. Each data set has its own
+     * watchdog timer that monitors whether heartbeats are being received within the expected interval.
+     * If a heartbeat is not received for a specific data set within heartbeatIntervalMs plus
+     * a backoff-calculated time, the sync algorithm is initiated for that data set
+     *
+     * @param {Array<DataSet>} receivedDataSets - The data sets from the received message for which watchdog timers should be reset
+     * @returns {void}
+     */
+    private resetHeartbeatWatchdogs;
     /**
      * Stops all timers for the data sets to prevent any further sync attempts.
      * @returns {void}
      */
     private stopAllTimers;
+    /**
+     * Stops the HashTreeParser, preventing it from processing any further messages and clearing all timers.
+     * It also clears all the hash trees, so if the parser is resumed later, it will need to do a sync
+     * to be up-to-date.
+     * @returns {void}
+     */
+    stop(): void;
+    /**
+     * Resumes the HashTreeParser that was previously stopped.
+     * @param {HashTreeMessage} message - The message to resume with, it must contain metadata with visible data sets info
+     * @returns {void}
+     */
+    resume(message: HashTreeMessage): void;
+    private checkForSentinelHttpResponse;
     /**
      * Gets the current hashes from the locus for a specific data set.
      * @param {string} dataSetName
+     * @param {string} currentRootHash
      * @returns {string[]}
      */
     private getHashesFromLocus;

package/dist/types/hashTree/types.d.ts

@@ -8,6 +8,8 @@ export declare const ObjectType: {
     readonly fullState: "fullstate";
     readonly links: "links";
     readonly control: "controlentry";
+    readonly metadata: "metadata";
+    readonly embeddedApp: "embeddedapp";
 };
 export type ObjectType = Enum<typeof ObjectType>;
 export declare const ObjectTypeToLocusKeyMap: {
@@ -18,6 +20,7 @@ export declare const ObjectTypeToLocusKeyMap: {
     participant: string;
     mediashare: string;
     controlentry: string;
+    embeddedapp: string;
 };
 export interface HtMeta {
     elementId: {

package/dist/types/hashTree/utils.d.ts

@@ -5,6 +5,12 @@ import { HashTreeObject } from './types';
  * @returns {boolean} True if the object is of type "self", false otherwise
  */
 export declare function isSelf(object: HashTreeObject): boolean;
+/**
+ * Checks if the given hash tree object is of type "Metadata"
+ * @param {HashTreeObject} object object to check
+ * @returns {boolean} True if the object is of type "Metadata", false otherwise
+ */
+export declare function isMetadata(object: HashTreeObject): boolean;
 /**
  * Analyzes given part of Locus DTO recursively and delete any nested objects that have their own htMeta
  *

package/dist/types/index.d.ts

@@ -19,3 +19,4 @@ export { type Reaction } from './reactions/reactions.type';
 export { CaptchaError, IntentToJoinError, JoinMeetingError, PasswordError, PermissionError, ReclaimHostIsHostAlreadyError, ReclaimHostNotAllowedError, ReclaimHostNotSupportedError, ReclaimHostEmptyWrongKeyError, Meeting, MeetingInfoUtil, JoinWebinarError, SdpResponseTimeoutError, };
 export { RemoteMedia } from './multistream/remoteMedia';
 export { default as TriggerProxy } from './common/events/trigger-proxy';
+export { getAIEnablementApprover } from './aiEnableRequest/utils';

package/dist/types/interceptors/constant.d.ts

@@ -0,0 +1,5 @@
+declare const DATA_CHANNEL_AUTH_HEADER = "Data-Channel-Auth-Token";
+declare const MAX_RETRY = 1;
+declare const RETRY_INTERVAL = 2000;
+declare const RETRY_KEY = "_dcRetryKey";
+export { DATA_CHANNEL_AUTH_HEADER, MAX_RETRY, RETRY_INTERVAL, RETRY_KEY };

package/dist/types/interceptors/dataChannelAuthToken.d.ts

@@ -0,0 +1,43 @@
+/*!
+ * Copyright (c) 2015-2026 Cisco Systems, Inc. See LICENSE file.
+ */
+import { Interceptor } from '@webex/http-core';
+/**
+ * @class
+ */
+export default class DataChannelAuthTokenInterceptor extends Interceptor {
+    private _refreshDataChannelToken;
+    private _isDataChannelTokenEnabled;
+    constructor(options: any);
+    /**
+     * @returns {DataChannelAuthTokenInterceptor}
+     */
+    static create(): DataChannelAuthTokenInterceptor;
+    private getRetryKey;
+    private getHeader;
+    /**
+     * Intercepts outgoing requests and refreshes the Data-Channel-Auth-Token
+     * if the current JWT token is expired before the request is sent.
+     *
+     * @param {Object} options - The original request options.
+     * @returns {Promise<Object>} Updated request options with refreshed token if needed.
+     */
+    onRequest(options: any): Promise<any>;
+    /**
+     * Intercept responses and, on 401/403 with `Data-Channel-Auth-Token` header,
+     * attempt to refresh the data channel token and retry the original request once.
+     *
+     * @param {Object} options
+     * @param {Object} reason
+     * @returns {Promise<HttpResponse>}
+     */
+    onResponseError(options: any, reason: any): Promise<unknown>;
+    /**
+     * Retry the failed data channel request after a delay.
+     * Refreshes the Data-Channel-Auth-Token and re-sends the original request.
+     *
+     * @param {Object} options - Original request options.
+     * @returns {Promise<HttpResponse>} - Resolves on successful retry.
+     */
+    refreshTokenAndRetryWithDelay(options: any): Promise<unknown>;
+}

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

@@ -1,3 +1,4 @@
 import LocusRetryStatusInterceptor from './locusRetry';
 import LocusRouteTokenInterceptor from './locusRouteToken';
-export { LocusRetryStatusInterceptor, LocusRouteTokenInterceptor };
+import DataChannelAuthTokenInterceptor from './dataChannelAuthToken';
+export { LocusRetryStatusInterceptor, LocusRouteTokenInterceptor, DataChannelAuthTokenInterceptor };

package/dist/types/interceptors/utils.d.ts

@@ -0,0 +1 @@
+export declare const isJwtTokenExpired: (token: string) => boolean;

package/dist/types/locus-info/index.d.ts

@@ -1,8 +1,9 @@
 import EventsScope from '../common/events/events-scope';
 import { LOCUSEVENT } from '../constants';
-import HashTreeParser, { DataSet, HashTreeMessage } from '../hashTree/hashTreeParser';
+import HashTreeParser, { DataSet, HashTreeMessage, Metadata } from '../hashTree/hashTreeParser';
 import { HashTreeObject } from '../hashTree/types';
 import { Links, LocusDTO } from './types';
+import MeetingCollection from '../meetings/collection';
 export type LocusLLMEvent = {
     data: {
         eventType: typeof LOCUSEVENT.HASH_TREE_DATA_UPDATED;
@@ -12,6 +13,33 @@ export type LocusLLMEvent = {
 export type LocusApiResponseBody = {
     dataSets?: DataSet[];
     locus: LocusDTO;
+    metadata?: Metadata;
+} | LocusDTO;
+export type HashTreeParserEntry = {
+    parser: HashTreeParser;
+    replacedAt?: string;
+    initializedFromHashTree: boolean;
+};
+/**
+ * Finds a meeting for a given hash tree message.
+ *
+ * @param {HashTreeMessage} message - The hash tree message to find the meeting for
+ * @param {MeetingCollection} meetingCollection - The collection of meetings to search
+ * @param {string} deviceUrl - The URL of the user's device
+ * @returns {any} The meeting if found, otherwise undefined
+ */
+export declare function findMeetingForHashTreeMessage(message: HashTreeMessage, meetingCollection: MeetingCollection, deviceUrl: string): any;
+/**
+ * Creates a locus object from the objects received in a hash tree message. It usually will be
+ * incomplete, because hash tree messages only contain the parts of locus that have changed,
+ * and some updates come separately over Mercury or LLM in separate messages.
+ *
+ * @param {HashTreeMessage} message hash tree message to created the locus from
+ * @returns {Object} the created locus object and metadata if present
+ */
+export declare function createLocusFromHashTreeMessage(message: HashTreeMessage): {
+    locus: LocusDTO;
+    metadata?: Metadata;
 };
 /**
  * @description LocusInfo extends ChildEmitter to convert locusInfo info a private emitter to parent object
@@ -46,7 +74,7 @@ export default class LocusInfo extends EventsScope {
     links?: Links;
     mainSessionLocusCache: any;
     self: any;
-    hashTreeParser?: HashTreeParser;
+    hashTreeParsers: Map<string, HashTreeParserEntry>;
     hashTreeObjectId2ParticipantId: Map<number, string>;
     classicVsHashTreeMismatchMetricCounter: number;
     /**
@@ -91,9 +119,13 @@ export default class LocusInfo extends EventsScope {
      */
     init(locus?: any): void;
     /**
-     * Creates the HashTreeParser instance.
-     * @param {Object} initial locus data
-     * @returns {void}
+     * Creates a HashTreeParser instance for a given locusUrl and stores it in the map.
+     * @param {Object} params
+     * @param {string} params.locusUrl - the locus URL used as the map key
+     * @param {Object} params.initialLocus - initial locus data
+     * @param {Object} params.metadata - hash tree metadata
+     * @param {string} params.replacedAt - timestamp from Locus indicating when the replacement happened
+     * @returns {HashTreeParser} the newly created parser
      */
     private createHashTreeParser;
     /**
@@ -105,6 +137,7 @@ export default class LocusInfo extends EventsScope {
         trigger: 'join-response';
         locus: LocusDTO;
         dataSets?: DataSet[];
+        metadata?: Metadata;
     } | {
         trigger: 'locus-message';
         locus?: LocusDTO;
@@ -121,7 +154,6 @@ export default class LocusInfo extends EventsScope {
      */
     handleLocusAPIResponse(meeting: any, responseBody: LocusApiResponseBody): void;
     /**
-     *
      * @param {HashTreeObject} object data set object
      * @param {any} locus
      * @returns {void}
@@ -135,6 +167,13 @@ export default class LocusInfo extends EventsScope {
      * @returns {void}
      */
     sendClassicVsHashTreeMismatchMetric(meeting: any, message: string): void;
+    /**
+     * Checks if the hash tree message should trigger a switch to a different HashTreeParser
+     *
+     * @param {HashTreeMessage} message incoming hash tree message
+     * @returns {boolean} true if the message was handled as a parser switch, false otherwise
+     */
+    private handleHashTreeParserSwitch;
     /**
      * Handles a hash tree message received from Locus.
      *
@@ -148,6 +187,7 @@ export default class LocusInfo extends EventsScope {
      * Callback registered with HashTreeParser to receive locus info updates.
      * Updates our locus info based on the data parsed by the hash tree parser.
      *
+     * @param {string} locusUrl - the locus URL for which the update is received
      * @param {LocusInfoUpdateType} updateType - The type of update received.
      * @param {Object} [data] - Additional data for the update, if applicable.
      * @returns {void}
@@ -171,7 +211,9 @@ export default class LocusInfo extends EventsScope {
     /**
      * Function for handling full locus when it's using hash trees (so not the "classic" one).
      *
+     * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
      * @param {object} locus locus object
+     * @param {object} metadata locus hash trees metadata
      * @param {string} eventType locus event
      * @param {DataSet[]} dataSets
      * @returns {void}
@@ -180,6 +222,7 @@ export default class LocusInfo extends EventsScope {
     /**
      * Function for handling full locus when it's the "classic" one (not hash trees)
      *
+     * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
      * @param {object} locus locus object
      * @param {string} eventType locus event
      * @returns {void}
@@ -187,13 +230,15 @@ export default class LocusInfo extends EventsScope {
     private onFullLocusClassic;
     /**
      * updates the locus with full locus object
+     * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
      * @param {object} locus locus object
      * @param {string} eventType locus event
      * @param {DataSet[]} dataSets
+     * @param {object} metadata locus hash trees metadata
      * @returns {object} null
      * @memberof LocusInfo
      */
-    onFullLocus(locus: any, eventType?: string, dataSets?: Array<DataSet>): void;
+    onFullLocus(debugText: string, locus: any, eventType?: string, dataSets?: Array<DataSet>, metadata?: Metadata): void;
     /**
      * Common part of handling full locus, used by both classic and hash tree based locus handling
      * @param {object} locus locus object
@@ -207,6 +252,13 @@ export default class LocusInfo extends EventsScope {
      * @memberof LocusInfo
      */
     handleOneOnOneEvent(eventType: string): void;
+    /**
+     * Makes sure that passed in locus object has a participant object for self.
+     *
+     * @param {LocusDTO} locus The locus object to check and modify if needed
+     * @returns {void}
+     */
+    ensureSelfParticipantExists(locus: any): void;
     /**
      * @param {Object} locus
      * @returns {undefined}
@@ -218,7 +270,7 @@ export default class LocusInfo extends EventsScope {
      * @returns {undefined}
      * @memberof LocusInfo
      */
-    updateLocusInfo(locus: any): void;
+    updateLocusInfo(locus: any): boolean;
     /**
      * @param {Array} participants
      * @param {Object} self

package/dist/types/locus-info/types.d.ts

@@ -20,6 +20,7 @@ export type Links = {
 };
 export type LocusDTO = {
     controls?: any;
+    embeddedApps?: any[];
     fullState?: LocusFullState;
     host?: {
         id: string;
@@ -32,6 +33,7 @@ export type LocusDTO = {
     info?: any;
     jsSdkMeta?: {
         removedParticipantIds: string[];
+        forceReplaceMembers?: boolean;
     };
     links?: Links;
     mediaShares?: any[];
@@ -52,3 +54,8 @@ export type LocusDTO = {
     syncUrl?: string;
     url?: string;
 };
+export type ReplacesInfo = {
+    locusUrl: string;
+    replacedAt: string;
+    sessionId: string;
+};

package/dist/types/media/MediaConnectionAwaiter.d.ts

@@ -1,5 +1,6 @@
 export interface MediaConnectionAwaiterProps {
     webrtcMediaConnection: any;
+    correlationId: string;
 }
 /**
  * @class MediaConnectionAwaiter
@@ -10,6 +11,7 @@ export default class MediaConnectionAwaiter {
     private defer;
     private retried;
     private iceConnected;
+    private correlationId;
     private onTimeoutCallback;
     private peerConnectionStateCallback;
     private iceConnectionStateCallback;
@@ -17,7 +19,7 @@ export default class MediaConnectionAwaiter {
     /**
      * @param {MediaConnectionAwaiterProps} mediaConnectionAwaiterProps
      */
-    constructor({ webrtcMediaConnection }: MediaConnectionAwaiterProps);
+    constructor({ webrtcMediaConnection, correlationId }: MediaConnectionAwaiterProps);
     /**
      * Returns true if the connection is connected, false otherwise.
      *
@@ -66,6 +68,13 @@ export default class MediaConnectionAwaiter {
      * @returns {void}
      */
     iceGatheringStateHandler(): void;
+    /**
+     * sends a metric with some additional info that might help debugging
+     * issues where browser doesn't update the RTCPeerConnection's iceConnectionState or connectionState
+     *
+     * @returns {void}
+     */
+    sendMetric(): Promise<void>;
     /**
      * Function called when the timeout is reached.
      *

package/dist/types/media/properties.d.ts

@@ -93,9 +93,10 @@ export default class MediaProperties {
     /**
      * Waits for the webrtc media connection to be connected.
      *
+     * @param {string} correlationId
      * @returns {Promise<void>}
      */
-    waitForMediaConnectionConnected(): Promise<void>;
+    waitForMediaConnectionConnected(correlationId: string): Promise<void>;
     /**
      * Returns ICE transport information:
      * - selectedCandidatePairChanges - number of times the selected candidate pair was changed, it should be at least 1 for successful connections

package/dist/types/meeting/in-meeting-actions.d.ts

@@ -28,6 +28,7 @@ interface IInMeetingActions {
     canLowerAllHands?: boolean;
     canLowerSomeoneElsesHand?: boolean;
     bothLeaveAndEndMeetingAvailable?: boolean;
+    requireHostEndMeetingBeforeLeave?: boolean;
     canEnableClosedCaption?: boolean;
     canStartTranscribing?: boolean;
     canStopTranscribing?: boolean;
@@ -112,6 +113,8 @@ interface IInMeetingActions {
     canMoveToLobby?: boolean;
     canEnablePollingQA?: boolean;
     canDisablePollingQA?: boolean;
+    canAttendeeRequestAiAssistantEnabled?: boolean;
+    isAttendeeRequestAiAssistantDeclinedAll?: boolean;
 }
 /**
  * @class InMeetingActions
@@ -140,6 +143,7 @@ export default class InMeetingActions implements IInMeetingActions {
     canLowerAllHands: any;
     canLowerSomeoneElsesHand: any;
     bothLeaveAndEndMeetingAvailable: any;
+    requireHostEndMeetingBeforeLeave: any;
     canEnableClosedCaption: any;
     canStartTranscribing: any;
     canStopTranscribing: any;
@@ -224,6 +228,8 @@ export default class InMeetingActions implements IInMeetingActions {
     canMoveToLobby: any;
     canEnablePollingQA: any;
     canDisablePollingQA: any;
+    canAttendeeRequestAiAssistantEnabled: any;
+    isAttendeeRequestAiAssistantDeclinedAll: any;
     /**
      * Returns all meeting action options
      * @returns {Object}