@webex/plugin-meetings 3.11.0-next.3 → 3.11.0-next.30

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: {
@@ -45,8 +56,10 @@ declare class HashTreeParser {
     visibleDataSetsUrl: string;
     webexRequest: WebexRequestMethod;
     locusInfoUpdateCallback: LocusInfoUpdateCallback;
-    visibleDataSets: string[];
+    visibleDataSets: VisibleDataSetInfo[];
     debugId: string;
+    heartbeatIntervalMs?: number;
+    private excludedDataSets;
     /**
      * Constructor for HashTreeParser
      * @param {Object} options
@@ -57,16 +70,37 @@ declare class HashTreeParser {
             dataSets: Array<DataSet>;
             locus: any;
         };
+        metadata: Metadata | null;
         webexRequest: WebexRequestMethod;
         locusInfoUpdateCallback: LocusInfoUpdateCallback;
         debugId: string;
+        excludedDataSets?: string[];
     });
+    /**
+     * 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 +113,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 +138,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 +154,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 +177,15 @@ declare class HashTreeParser {
      * @returns {void}
      */
     private handleRootHashHeartBeatMessage;
+    /**
+     * 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 +196,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 +227,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;
@@ -220,6 +271,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,6 +287,16 @@ 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}
@@ -235,6 +305,7 @@ declare class HashTreeParser {
     /**
      * 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/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,35 @@
+/*!
+ * 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;
+    /**
+     * 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/locus-info/index.d.ts

@@ -1,6 +1,6 @@
 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';
 export type LocusLLMEvent = {
@@ -12,6 +12,7 @@ export type LocusLLMEvent = {
 export type LocusApiResponseBody = {
     dataSets?: DataSet[];
     locus: LocusDTO;
+    metadata?: Metadata;
 };
 /**
  * @description LocusInfo extends ChildEmitter to convert locusInfo info a private emitter to parent object
@@ -105,6 +106,7 @@ export default class LocusInfo extends EventsScope {
         trigger: 'join-response';
         locus: LocusDTO;
         dataSets?: DataSet[];
+        metadata?: Metadata;
     } | {
         trigger: 'locus-message';
         locus?: LocusDTO;
@@ -171,7 +173,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 +184,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 +192,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

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;

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/index.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 import { StatelessWebexPlugin } from '@webex/webex-core';
 import { ClientEvent, ClientEventLeaveReason } from '@webex/internal-plugin-metrics';
-import { ClientEvent as RawClientEvent } from '@webex/event-dictionary-ts';
+import type { ClientEvent as RawClientEvent } from '@webex/event-dictionary-ts';
 import { MediaType, StatsAnalyzer, NetworkQualityMonitor, StatsMonitor } from '@webex/internal-media-core';
+import { DataChannelTokenType } from '@webex/internal-plugin-llm';
 import { LocalStream, LocalCameraStream, LocalDisplayStream, LocalSystemAudioStream, LocalMicrophoneStream } from '@webex/media-helpers';
 import Roap, { type TurnDiscoverySkipReason } from '../roap/index';
 import { type TurnServerInfo } from '../roap/types';
@@ -23,7 +24,7 @@ import { LocusMediaRequest } from './locusMediaRequest';
 import { BrbState } from './brbState';
 import { SetStageOptions } from './request.type';
 import { Invitee } from './type';
-import { DataSet } from '../hashTree/hashTreeParser';
+import { DataSet, Metadata } from '../hashTree/hashTreeParser';
 import { LocusDTO } from '../locus-info/types';
 export type CaptionData = {
     id: string;
@@ -70,6 +71,7 @@ export type AddMediaOptions = {
     remoteMediaManagerConfig?: RemoteMediaManagerConfiguration;
     bundlePolicy?: BundlePolicy;
     allowMediaInLobby?: boolean;
+    allowPublishMediaInLobby?: boolean;
     additionalMediaOptions?: AdditionalMediaOptions;
 };
 export type AdditionalMediaOptions = {
@@ -405,6 +407,10 @@ export default class Meeting extends StatelessWebexPlugin {
     keepAliveTimerId: NodeJS.Timeout;
     lastVideoLayoutInfo: any;
     locusInfo: any;
+    isUserUnadmitted?: boolean;
+    joinedWith?: any;
+    selfId?: string;
+    roles: any[];
     locusMediaRequest?: LocusMediaRequest;
     mediaProperties: MediaProperties;
     mediaRequestManagers: {
@@ -438,7 +444,6 @@ export default class Meeting extends StatelessWebexPlugin {
     endCallInitJoinReq: any;
     endJoinReqResp: any;
     endLocalSDPGenRemoteSDPRecvDelay: any;
-    joinedWith: any;
     locusId: any;
     startCallInitJoinReq: any;
     startJoinReqResp: any;
@@ -453,12 +458,10 @@ export default class Meeting extends StatelessWebexPlugin {
     permissionTokenReceivedLocalTime: number;
     resourceId: any;
     resourceUrl: string;
-    selfId: string;
     state: any;
     localAudioStreamMuteStateHandler: () => void;
     localVideoStreamMuteStateHandler: () => void;
     localOutputTrackChangeHandler: () => void;
-    roles: any[];
     environment: string;
     namespace: string;
     allowMediaInLobby: boolean;
@@ -1060,6 +1063,7 @@ export default class Meeting extends StatelessWebexPlugin {
         host: object;
         selfId: string;
         dataSets: DataSet[];
+        metadata: Metadata;
     }): void;
     /**
      * Upload logs for the current meeting
@@ -2087,5 +2091,23 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meetings
      */
     cancelSipCallOut(participantId: string): Promise<any>;
+    /**
+     * Method to get new data
+     * @returns {Promise}
+     */
+    refreshDataChannelToken(): Promise<{
+        body: {
+            datachannelToken: any;
+            dataChannelTokenType: DataChannelTokenType;
+        };
+    }>;
+    /**
+     * Determines the current data channel token type based on the meeting state.
+     *
+     * variant should be used when connecting to the LLM data channel.
+     *
+     * @returns {DataChannelTokenType} The token type representing the current session mode.
+     */
+    getDataChannelTokenType(): DataChannelTokenType;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { StatelessWebexPlugin } from '@webex/webex-core';
-import { SendReactionOptions, BrbOptions, ToggleReactionsOptions, PostMeetingDataConsentOptions, SynchronizeVideoLayout } from './request.type';
+import { SendReactionOptions, BrbOptions, ToggleReactionsOptions, PostMeetingDataConsentOptions, SynchronizeVideoLayout, fetchDataChannelTokenOptions } from './request.type';
 import { AnnotationInfo } from '../annotation/annotation.types';
 import { ClientMediaPreferences } from '../reachability/reachability.types';
 /**
@@ -364,4 +364,19 @@ export default class MeetingRequest extends StatelessWebexPlugin {
      * @returns {Promise} The API response
      */
     cancelSipCallOut(participantId: any): Promise<any>;
+    /**
+     * Sends a request to retrieve the datachannel authorization token for a participant.
+     *
+     * For regular meeting data channel:
+     *   GET /locus/api/v1/loci/{uuid:lid}/participant/{uuid:pid}/datachannel/token
+     *
+     * For practice session data channel:
+     *   GET /locus/api/v1/loci/{uuid:lid}/participant/{uuid:pid}/practiceSession/datachannel/token
+     *
+     * @param {string} locusUrl - The locus url.
+     * @param {string} requestingParticipantId - The participant UUID.
+     * @param {boolean} [isPracticeSession=false] - Whether to get the practice session token.
+     * @returns {Promise<{datachannelToken: string}>}
+     */
+    fetchDatachannelToken({ locusUrl, requestingParticipantId, isPracticeSession, }: fetchDataChannelTokenOptions): Promise<any>;
 }

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

@@ -94,4 +94,9 @@ export type SetStageVideoLayout = {
 export type UnsetStageVideoLayout = {
     overrideDefault: false;
 };
+export type fetchDataChannelTokenOptions = {
+    locusUrl: string;
+    requestingParticipantId: string;
+    isPracticeSession: boolean;
+};
 export type SynchronizeVideoLayout = SetStageVideoLayout | UnsetStageVideoLayout;

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

@@ -2,6 +2,34 @@ import { LocalCameraStream, LocalMicrophoneStream } from '@webex/media-helpers';
 import { SELF_POLICY, IP_VERSION } from '../constants';
 declare const MeetingUtil: {
     parseLocusJoin: (response: any) => any;
+    /**
+     * Sanitizes a WebSocket URL by extracting only protocol, host, and pathname
+     * Returns concatenated protocol + host + pathname for safe logging
+     * Note: This is used for logging only; URL matching uses partial matching via _urlsPartiallyMatch
+     * @param {string} urlString - The URL to sanitize
+     * @returns {string} Sanitized URL or empty string if parsing fails
+     */
+    sanitizeWebSocketUrl: (urlString: string) => string;
+    /**
+     * Checks if two URLs partially match using an endsWith approach
+     * Combines host and pathname, then checks if one ends with the other
+     * This handles cases where one URL goes through a proxy (e.g., /webproxy/) while the other is direct
+     * @param {string} url1 - First URL to compare
+     * @param {string} url2 - Second URL to compare
+     * @returns {boolean} True if one URL path ends with the other (partial match), false otherwise
+     */
+    _urlsPartiallyMatch: (url1: string, url2: string) => boolean;
+    /**
+     * Gets socket URL information for metrics, including whether the socket URLs match
+     * Uses partial matching to handle proxy URLs (e.g., URLs with /webproxy/ prefix)
+     * @param {Object} webex - The webex instance
+     * @returns {Object} Object with hasMismatchedSocket, mercurySocketUrl, and deviceSocketUrl properties
+     */
+    getSocketUrlInfo: (webex: any) => {
+        hasMismatchedSocket: boolean;
+        mercurySocketUrl: string;
+        deviceSocketUrl: string;
+    };
     remoteUpdateAudioVideo: (meeting: any, audioMuted?: boolean, videoMuted?: boolean) => any;
     hasOwner: (info: any) => any;
     isOwnerSelf: (owner: any, selfId: any) => boolean;

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

@@ -95,6 +95,8 @@ export default class Meetings extends WebexPlugin {
     preferredWebexSite: any;
     reachability: Reachability;
     registered: any;
+    registrationPromise: Promise<void>;
+    unregistrationPromise: Promise<void>;
     request: any;
     geoHintInfo: any;
     meetingInfo: any;
@@ -287,7 +289,7 @@ export default class Meetings extends WebexPlugin {
      * @public
      * @memberof Meetings
      */
-    unregister(): any;
+    unregister(): Promise<void>;
     /**
      * Creates a noise reduction effect
      *

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

@@ -87,5 +87,6 @@ declare const BEHAVIORAL_METRICS: {
     MEDIA_ISSUE_DETECTED: string;
     LOCUS_CLASSIC_VS_HASH_TREE_MISMATCH: string;
     LOCUS_HASH_TREE_UNSUPPORTED_OPERATION: string;
+    MEDIA_STILL_NOT_CONNECTED: string;
 };
 export { BEHAVIORAL_METRICS as default };

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

@@ -32,6 +32,7 @@ export declare enum SkinToneType {
     dark = "dark"
 }
 export type Sender = {
+    displayName: string;
     participantId: string;
 };
 export type ProcessedReaction = {

package/dist/webinar/index.js

@@ -506,7 +506,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee8);
     }))();
   },
-  version: "3.11.0-next.3"
+  version: "3.11.0-next.30"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map