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

package/dist/types/config.d.ts

@@ -58,17 +58,17 @@ declare const _default: {
         enableExtmap: boolean;
         enableAutomaticLLM: boolean;
         installedOrgID: any;
+        multipartSitePrefixList: string[];
         experimental: {
             enableMediaNegotiatedEvent: boolean;
             enableUnifiedMeetings: boolean;
             enableAdhocMeetings: boolean;
-            enableTcpReachability: boolean;
-            enableTlsReachability: boolean;
             storeLocusHashTreeEventsForDebugging: boolean;
         };
         degradationPreferences: {
             maxMacroblocksLimit: number;
         };
+        enableAv1SlidesSupport: boolean;
         iceCandidatesGatheringTimeout: any;
         backendIpv6NativeSupport: boolean;
         enableReachabilityChecks: boolean;

package/dist/types/constants.d.ts

@@ -1,3 +1,4 @@
+export { LLM_DEFAULT_SESSION, LLM_PRACTICE_SESSION } from '@webex/internal-plugin-llm';
 export type Enum<T extends Record<string, unknown>> = T[keyof T];
 export declare const AUDIO = "audio";
 export declare const AUDIO_STATUS = "audioStatus";
@@ -31,7 +32,6 @@ export declare const LOCAL = "local";
 export declare const LOCI = "loci";
 export declare const LOCUS_URL = "locusUrl";
 export declare const END = "end";
-export declare const LLM_PRACTICE_SESSION = "llm-practice-session";
 export declare const MAX_RANDOM_DELAY_FOR_MEETING_INFO: number;
 export declare const MEETINGINFO = "meetingInfo";
 export declare const MEET = "meet";
@@ -293,6 +293,7 @@ export declare const EVENT_TRIGGERS: {
     MEETING_CAPTION_RECEIVED: string;
     MEETING_PARTICIPANT_REASON_CHANGED: string;
     MEETING_AI_ENABLE_REQUEST: string;
+    MEETING_SRTP_CIPHER_UPDATED: string;
 };
 export declare const EVENT_TYPES: {
     SELF: string;
@@ -566,6 +567,12 @@ export declare const INTERPRETATION: {
         DECLINED: string;
     };
     RESOURCE_TYPE: string;
+    CAPABILITIES: {
+        HOST_CONTROL_SI_SUPPORTED: string;
+        INTERPRETER_CONTROL_SI_SUPPORTED: string;
+        SI_HANDOVER_SUPPORTED: string;
+        SIGN_INTERPRETER_SUPPORTED: string;
+    };
 };
 export declare const LOCUSINFO: {
     EVENTS: {
@@ -849,6 +856,8 @@ export declare const DISPLAY_HINTS: {
     DISABLE_BREAKOUT_START: string;
     DISABLE_VIEW_THE_PARTICIPANT_LIST: string;
     ENABLE_VIEW_THE_PARTICIPANT_LIST: string;
+    VIEW_THE_PARTICIPANT_LIST: string;
+    CAN_VIEW_THE_PARTICIPANT_LIST: string;
     DISABLE_VIEW_THE_PARTICIPANT_LIST_PANELIST: string;
     ENABLE_VIEW_THE_PARTICIPANT_LIST_PANELIST: string;
     DISABLE_SHOW_ATTENDEE_COUNT: string;
@@ -884,6 +893,7 @@ export declare const DISPLAY_HINTS: {
     DISABLE_ATTENDEE_START_POLLING_QA: string;
     ATTENDEE_REQUEST_AI_ASSISTANT_ENABLED: string;
     ATTENDEE_REQUEST_AI_ASSISTANT_DECLINED_ALL: string;
+    ANONYMOUS_DISPLAY_NAMES_ENABLED: string;
 };
 export declare const INTERSTITIAL_DISPLAY_HINTS: string[];
 export declare const SELF_ROLES: {
@@ -891,6 +901,7 @@ export declare const SELF_ROLES: {
     MODERATOR: string;
     ATTENDEE: string;
     PANELIST: string;
+    PRESENTER: string;
 };
 export declare const MEETING_STATE: {
     STATES: {

package/dist/types/controls-options-manager/constants.d.ts

@@ -1,4 +1,9 @@
 declare const ENABLED = "enabled";
 declare const CAN_SET = "canSet";
 declare const CAN_UNSET = "canUnset";
-export { ENABLED, CAN_SET, CAN_UNSET };
+/**
+ * Body keys that represent audio controls. These do not support cross-locus
+ * authorization and must be sent directly to the current locus URL.
+ */
+declare const AUDIO_CONTROL_BODY_KEYS: ReadonlySet<string>;
+export { ENABLED, CAN_SET, CAN_UNSET, AUDIO_CONTROL_BODY_KEYS };

package/dist/types/controls-options-manager/index.d.ts

@@ -43,6 +43,8 @@ export default class ControlsOptionsManager {
      * @memberof ControlsOptionsManager
      */
     private mainLocusUrl;
+    private getControls;
+    private isWebinar;
     /**
      * @param {MeetingRequest} request
      * @param {Object} options
@@ -52,6 +54,8 @@ export default class ControlsOptionsManager {
     constructor(request: MeetingRequest, options?: {
         locusUrl: string;
         displayHints?: Array<string>;
+        getControls?: () => Record<string, any>;
+        isWebinar?: () => boolean;
     });
     /**
      * @param {MeetingRequest} request
@@ -69,6 +73,8 @@ export default class ControlsOptionsManager {
     set(options?: {
         locusUrl: string;
         displayHints?: Array<string>;
+        getControls?: () => Record<string, any>;
+        isWebinar?: () => boolean;
     }): void;
     /**
      * @param {string} url
@@ -118,6 +124,16 @@ export default class ControlsOptionsManager {
      * @returns {Promise}
      */
     private setControls;
+    /**
+     * Sends a controls request to Locus. When authorizingLocusUrl is present in the body,
+     * we use a plain request() because the response contains the main session Locus DTO
+     * instead of the breakout we're in, so we don't want to parse it as a delta.
+     * Otherwise we use locusDeltaRequest() for normal delta processing.
+     *
+     * @param {Object} requestParams - The request parameters from getControlsRequestParams.
+     * @returns {Promise<any>}
+     */
+    private sendControlsRequest;
     /**
      * @public
      * @param {boolean} enabled

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

@@ -7,3 +7,5 @@ export declare const DataSetNames: {
     SELF: string;
     UNJOINED: string;
 };
+export declare const DATA_SET_INIT_PRIORITY: string[];
+export declare const LLM_DATASET_NAMES: string[];

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

@@ -2,6 +2,11 @@ import HashTree from './hashTree';
 import { Enum } from '../constants';
 import { HtMeta, HashTreeObject } from './types';
 import { LocusDTO } from '../locus-info/types';
+export declare enum SyncAllBackoffType {
+    NONE = "none",
+    ONLY_LLM = "onlyLLM",
+    ALL = "all"
+}
 export interface DataSet {
     url: string;
     root: string;
@@ -13,9 +18,11 @@ export interface DataSet {
         maxMs: number;
         exponent: number;
     };
+    heartbeatIntervalMs?: number;
 }
 export interface RootHashMessage {
     dataSets: Array<DataSet>;
+    heartbeatIntervalMs?: number;
 }
 export interface HashTreeMessage {
     dataSets: Array<DataSet>;
@@ -38,22 +45,41 @@ interface InternalDataSet extends DataSet {
     hashTree?: HashTree;
     timer?: ReturnType<typeof setTimeout>;
     heartbeatWatchdogTimer?: ReturnType<typeof setTimeout>;
+    syncAbortController?: AbortController;
 }
 type WebexRequestMethod = (options: Record<string, any>) => Promise<any>;
 export declare const LocusInfoUpdateType: {
     readonly OBJECTS_UPDATED: "OBJECTS_UPDATED";
     readonly MEETING_ENDED: "MEETING_ENDED";
+    readonly LOCUS_NOT_FOUND: "LOCUS_NOT_FOUND";
 };
 export type LocusInfoUpdateType = Enum<typeof LocusInfoUpdateType>;
-export type LocusInfoUpdateCallback = (updateType: LocusInfoUpdateType, data?: {
-    updatedObjects: HashTreeObject[];
-}) => void;
+interface LocusUpdatePayloads {
+    [LocusInfoUpdateType.OBJECTS_UPDATED]: {
+        updatedObjects: HashTreeObject[];
+    };
+    [LocusInfoUpdateType.MEETING_ENDED]: unknown;
+    [LocusInfoUpdateType.LOCUS_NOT_FOUND]: unknown;
+}
+export type LocusInfoUpdate = {
+    [K in keyof LocusUpdatePayloads]: {
+        updateType: K;
+    } & LocusUpdatePayloads[K];
+}[keyof LocusUpdatePayloads];
+export type LocusInfoUpdateCallback = (update: LocusInfoUpdate) => 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 {
 }
+/**
+ * This error is thrown when a 404 is received from Locus hash tree endpoints, indicating that the locus URL
+ * is no longer valid (e.g. participant moved to a breakout room, or meeting ended).
+ * It's handled internally by HashTreeParser and results in LOCUS_NOT_FOUND being sent up.
+ */
+export declare class LocusNotFoundError extends Error {
+}
 /**
  * Parses hash tree eventing locus data
  */
@@ -64,9 +90,14 @@ declare class HashTreeParser {
     locusInfoUpdateCallback: LocusInfoUpdateCallback;
     visibleDataSets: VisibleDataSetInfo[];
     debugId: string;
-    heartbeatIntervalMs?: number;
     private excludedDataSets;
     state: 'active' | 'stopped';
+    private syncQueue;
+    private isSyncInProgress;
+    private syncAllBackoffType;
+    private dataSetsSyncedDuringBackoff;
+    private syncQueueProcessingPromise;
+    private topLevelHeartbeatIntervalMs?;
     /**
      * Constructor for HashTreeParser
      * @param {Object} options
@@ -120,14 +151,6 @@ declare class HashTreeParser {
      * @returns {Promise}
      */
     private initializeNewVisibleDataSet;
-    /**
-     * Sends a special sync request to Locus with all leaves empty - this is a way to get all the data for a given dataset.
-     *
-     * @param {string} datasetName - name of the dataset for which to send the request
-     * @param {string} debugText - text to include in logs
-     * @returns {Promise}
-     */
-    private sendInitializationSyncRequestToLocus;
     /**
      * Queries Locus for all up-to-date information about all visible data sets
      *
@@ -193,6 +216,13 @@ declare class HashTreeParser {
      * @returns {void}
      */
     private handleRootHashHeartBeatMessage;
+    /**
+     * Handles known errors that can happen during syncs
+     *
+     * @param {any} error - The error to handle
+     * @returns {boolean} true if the error was recognized and handled, false otherwise
+     */
+    private handleSyncErrors;
     /**
      * Asynchronously initializes new visible data sets
      *
@@ -228,6 +258,14 @@ declare class HashTreeParser {
      * @returns {void}
      */
     private updateDataSetInfo;
+    /**
+     * Updates the leaf count for a data set, resizing its hash tree accordingly.
+     *
+     * @param {InternalDataSet} dataSet - The data set to update
+     * @param {number} newLeafCount - The new leaf count
+     * @returns {void}
+     */
+    private updateDataSetLeafCount;
     /**
      * Checks for changes in the visible data sets based on the updated objects.
      * @param {HashTreeObject[]} updatedObjects - The list of updated hash tree objects.
@@ -298,11 +336,88 @@ declare class HashTreeParser {
      * 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)
+     * @param {boolean} [isInitialization] - Whether this is an initialization sync (sends empty leaves data instead of comparing hashes)
      * @returns {Promise<void>}
      */
     private performSync;
+    /**
+     * Cancels any pending or in-flight syncs for the specified data sets.
+     * This removes matching entries from the sync queue and aborts any in-flight sync HTTP requests.
+     *
+     * @param {string[]} dataSetNames - The names of the data sets to cancel syncs for
+     * @returns {void}
+     */
+    private cancelPendingSyncsForDataSets;
+    /**
+     * If a syncAllDatasets backoff sleep is in progress, marks the given data sets to be skipped
+     * after the sleep completes.
+     *
+     * @param {string[]} dataSetNames - The names of the data sets to mark
+     * @returns {void}
+     */
+    private markDataSetsForSyncAllBackoffSkip;
+    /**
+     * Aborts any in-flight sync HTTP requests for the specified data sets.
+     *
+     * @param {string[]} dataSetNames - The names of the data sets whose syncs should be aborted
+     * @returns {void}
+     */
+    private abortInFlightSyncs;
+    /**
+     * Enqueues a sync for the given data set. If the data set is already in the queue, the request is ignored.
+     * This ensures that all syncs are executed sequentially and no more than 1 sync runs at a time.
+     *
+     * @param {string} dataSetName - The name of the data set to sync
+     * @param {string} reason - The reason for the sync (used for logging)
+     * @param {boolean} [isInitialization=false] - Whether this is an initialization sync (uses empty leaves data instead of hash comparison)
+     * @returns {void}
+     */
+    private enqueueSyncForDataset;
+    /**
+     * Processes the sync queue sequentially. Only one instance of this method runs at a time.
+     *
+     * @returns {Promise<void>}
+     */
+    private processSyncQueue;
+    /**
+     * sets the backoff type for syncAllDatasets calls, which determines the scope of datasets that will be synced after the backoff delay.
+     *
+     * @param {boolean} onlyLLM - Whether the backoff is for a syncAllDatasets call that is syncing only LLM datasets
+     * @returns {void}
+     */
+    private setSyncAllBackoffType;
+    /**
+     * Checks if a syncAll backoff is already in progress. If so, upgrades the scope from
+     * onlyLLM to all datasets when the new call has a broader scope.
+     *
+     * @param {boolean} onlyLLM - Whether the current call is for LLM datasets only
+     * @returns {boolean} true if a backoff is already pending (caller should return early)
+     */
+    private tryUpgradePendingBackoff;
+    /**
+     * Syncs all data sets that have hash trees, one by one in sequence, using the priority order
+     * provided by sortByInitPriority().
+     *
+     * If a call is already waiting in the backoff delay phase, a new call with a broader scope
+     * (onlyLLM=false) will upgrade the pending scope, and the dataset list will be computed after
+     * the backoff using the upgraded scope. After the backoff, the sync queue handles deduplication
+     * so no guard is needed.
+     *
+     * @param {Object} [options={}] - Options for syncing
+     * @param {boolean} [options.onlyLLM=false] - Whether to sync only LLM based data sets
+     * @returns {Promise<void>}
+     */
+    syncAllDatasets(options?: {
+        onlyLLM?: boolean;
+    }): Promise<void>;
+    /**
+     * Returns the list of data sets that have hash trees, sorted by the priority order provided by sortByInitPriority().
+     *
+     * @param {boolean} onlyLLM - Whether to include only LLM based data sets
+     * @returns {Array<{name: string, backoff: {maxMs: number, exponent: number}}>} The sorted list of data sets with their backoff configurations
+     */
+    private getSortedDataSetsWithHashTrees;
     /**
      * Runs the sync algorithm for the given data set.
      *
@@ -333,24 +448,38 @@ declare class HashTreeParser {
      */
     stop(): void;
     /**
-     * Resumes the HashTreeParser that was previously stopped.
+     * Cleans up the HashTreeParser, stopping all timers and clearing all internal state.
+     * After calling this, the parser should not be used anymore.
+     * @returns {void}
+     */
+    cleanUp(): void;
+    /**
+     * Resumes the HashTreeParser that was previously stopped, using a hash tree message.
      * @param {HashTreeMessage} message - The message to resume with, it must contain metadata with visible data sets info
      * @returns {void}
      */
-    resume(message: HashTreeMessage): void;
+    resumeFromMessage(message: HashTreeMessage): void;
+    /**
+     * Resumes the HashTreeParser that was previously stopped, using a Locus API response.
+     * Unlike resumeFromMessage(), this does not require metadata/dataSets in the input,
+     * as it fetches all necessary information from Locus via initializeFromGetLociResponse.
+     * @param {LocusDTO} locus - locus object from an API response
+     * @returns {Promise}
+     */
+    resumeFromApiResponse(locus: LocusDTO): Promise<void>;
     private checkForSentinelHttpResponse;
     /**
      * Gets the current hashes from the locus for a specific data set.
      * @param {string} dataSetName
      * @param {string} currentRootHash
-     * @returns {string[]}
+     * @returns {Object|null} An object containing the hashes and leaf count, or null if the hashes match and no sync is needed
      */
     private getHashesFromLocus;
     /**
      * Sends a sync request to Locus for the specified data set.
      *
      * @param {InternalDataSet} dataSet The data set to sync.
-     * @param {Record<number, LeafDataItem[]>} mismatchedLeavesData The mismatched leaves data to include in the sync request.
+     * @param {Object} options Either `{ isInitialization: true }` for init syncs (uses leafCount=1 with empty leaf data) or `{ mismatchedLeavesData }` for normal syncs.
      * @returns {Promise<HashTreeMessage|null>}
      */
     private sendSyncRequestToLocus;

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

@@ -20,3 +20,21 @@ export declare function isMetadata(object: HashTreeObject): boolean;
  * @returns {void}
  */
 export declare const deleteNestedObjectsWithHtMeta: (currentLocusPart: any, parent?: any, currentKey?: string | number) => void;
+/**
+ * Reorders items so that those matching the given priority list come first (in priority order),
+ * followed by everything else in their original order.
+ *
+ * @param {Array<T>} items - The items to reorder
+ * @param {string[]} priority - Ordered list of names that should come first
+ * @returns {Array<T>} A new array with prioritized items first
+ */
+export declare function sortByInitPriority<T extends {
+    name: string;
+}>(items: T[], priority: string[]): T[];
+/**
+ * Sleeps for the specified amount of milliseconds
+ *
+ * @param {number} ms amount of milliseconds to sleep
+ * @returns {Promise<void>} A promise that resolves after the specified delay
+ */
+export declare function sleep(ms: number): Promise<void>;

package/dist/types/index.d.ts

@@ -16,6 +16,9 @@ export * as REACTIONS from './reactions/reactions';
 export * as sdkAnnotationTypes from './annotation/annotation.types';
 export * as MeetingInfoV2 from './meeting-info/meeting-info-v2';
 export { type Reaction } from './reactions/reactions.type';
+export { SitePreferenceSelectOption } from './meetings/meetings.types';
+export type { FetchSitePreferencesMeViaSiteOptions, SitePreferencesResponse, } from './meetings/meetings.types';
+export type { Interpreter, InterpreterUsingResource } from './interpretation/interpretation.types';
 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';

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

@@ -11,11 +11,11 @@ export default class LocusRetryStatusInterceptor extends Interceptor {
      */
     static create(): LocusRetryStatusInterceptor;
     /**
-     * Handle response errors
-     * @param {Object} options
-     * @param {WebexHttpError} reason
-     * @returns {Promise<WebexHttpError>}
+     * Check whether a URI is a Locus /hashtree or /sync endpoint.
+     * @param {string} uri
+     * @returns {boolean}
      */
+    private static isLocusHashtreeOrSync;
     onResponseError(options: any, reason: any): Promise<unknown>;
     /**
      * Handle retries for locus service unavailable errors

package/dist/types/interpretation/interpretation.types.d.ts

@@ -0,0 +1,10 @@
+export type InterpreterUsingResource = {
+    id: string;
+    email?: string;
+};
+export type Interpreter = {
+    order: number;
+    sourceLanguage: string;
+    targetLanguage: string;
+    usingResource: InterpreterUsingResource;
+};

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

@@ -25,10 +25,9 @@ export type HashTreeParserEntry = {
  *
  * @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;
+export declare function findMeetingForHashTreeMessage(message: HashTreeMessage | undefined, meetingCollection: MeetingCollection): 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,
@@ -130,6 +129,7 @@ export default class LocusInfo extends EventsScope {
     private createHashTreeParser;
     /**
      * @param {Object} data - data to initialize locus info with. It may be from a join or GET /loci response or from a Mercury event that triggers a creation of meeting object
+     * @param {Function} [onLocusSynced] - optional callback that will be called at the end of initial setup, when locus info is fully synced. It will be called with the full locus snapshot as an argument (which may be null if we haven't received any full locus DTOs during the initial setup, for example in case we receive only hash tree messages without full locus DTOs)
      * @returns {undefined}
      * @memberof LocusInfo
      */
@@ -145,7 +145,13 @@ export default class LocusInfo extends EventsScope {
     } | {
         trigger: 'get-loci-response';
         locus?: LocusDTO;
-    }): Promise<void>;
+    }, onLocusSynced?: (locus: LocusDTO) => void): Promise<void>;
+    /**
+     * Builds a full locus DTO snapshot from current internal locus state.
+     *
+     * @returns {LocusDTO}
+     */
+    private getCurrentLocusSnapshot;
     /**
      * Handles HTTP response from Locus API call.
      * @param {Meeting} meeting meeting object
@@ -167,6 +173,28 @@ export default class LocusInfo extends EventsScope {
      * @returns {void}
      */
     sendClassicVsHashTreeMismatchMetric(meeting: any, message: string): void;
+    /**
+     * Helper that handles the common logic for reactivating a stopped HashTreeParser when
+     * a newer "replaces" is detected. Used by both the message and API response parser switch methods.
+     *
+     * @param {string} callerName - name of the calling method, used in log messages
+     * @param {string} locusUrl - the locus URL of the stopped parser
+     * @param {HashTreeParserEntry} stoppedEntry - the stopped parser entry
+     * @param {ReplacesInfo} replaces - replacement info extracted from self
+     * @param {Function} resumeCallback - callback to invoke after reactivation to resume the parser
+     * @returns {void}
+     */
+    private resumeStoppedParser;
+    /**
+     * Handles an API response whose locusUrl doesn't match any active HashTreeParser
+     * (either no entry exists, or the existing entry is stopped).
+     * Creates a new parser or reactivates a stopped one using initializeFromGetLociResponse.
+     *
+     * @param {string} locusUrl - the locus URL from the API response
+     * @param {LocusDTO} locus - the locus DTO from the API response
+     * @returns {void}
+     */
+    private handleHashTreeParserSwitchForAPIResponse;
     /**
      * Checks if the hash tree message should trigger a switch to a different HashTreeParser
      *
@@ -183,13 +211,23 @@ export default class LocusInfo extends EventsScope {
      * @returns {void}
      */
     private handleHashTreeMessage;
+    /**
+     * Triggers a sync of all hash tree datasets for all hash tree parsers associated with this meeting.
+     * The syncs are executed sequentially within each parser.
+     *
+     * @param {Object} [options={}] - Options for syncing
+     * @param {boolean} [options.onlyLLM=false] - Whether to sync only LLM based data sets
+     * @returns {Promise<void>}
+     */
+    syncAllHashTreeDatasets(options?: {
+        onlyLLM?: boolean;
+    }): Promise<void>;
     /**
      * 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.
+     * @param {LocusInfoUpdate} update - Details about the update.
      * @returns {void}
      */
     private updateFromHashTree;
@@ -214,8 +252,8 @@ export default class LocusInfo extends EventsScope {
      * @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
+     * @param {string} eventType locus event
      * @returns {void}
      */
     private onFullLocusWithHashTrees;
@@ -444,4 +482,10 @@ export default class LocusInfo extends EventsScope {
      * @memberof LocusInfo
      */
     clearMainSessionLocusCache(): void;
+    /**
+     * Cleans up all hash tree parsers and clears internal maps.
+     * @returns {void}
+     * @memberof LocusInfo
+     */
+    cleanUp(): void;
 }

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

@@ -1,2 +1,10 @@
+export declare enum DisplayHintSection {
+    JOINED = "joined",
+    MODERATOR = "moderator",
+    COHOST = "coHost",
+    PRESENTER = "presenter",
+    PANELIST = "panelist",
+    ATTENDEE = "attendee"
+}
 declare const InfoUtils: any;
 export default InfoUtils;

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

@@ -1,14 +1,30 @@
+import { Enum } from '../constants';
 import { HtMeta } from '../hashTree/types';
+export declare const EndMeetingReason: {
+    readonly maxMeetingDuration: "MAX_MEETING_DURATION";
+    readonly allParticipantsLeft: "ALL_PARTICIPANTS_LEFT";
+    readonly sipHostLeft: "SIP_HOST_LEFT";
+    readonly noHost: "NO_HOST";
+    readonly waitingForMpsEndMeetingTimeout: "WAITING_FOR_MPS_END_MEETING_TIMEOUT";
+    readonly fraudDetection: "FRAUD_DETECTION";
+    readonly meetingEndedByHost: "MEETING_ENDED_BY_HOST";
+    readonly meetingUpdated: "MEETING_UPDATED";
+    readonly meetingCancelled: "MEETING_CANCELLED";
+    readonly autoEndWithSingleParticipant: "AUTO_END_WITH_SINGLE_PARTICIPANT";
+    readonly breakoutEnded: "BREAKOUT_ENDED";
+};
+export type EndMeetingReason = Enum<typeof EndMeetingReason>;
 export type LocusFullState = {
     active: boolean;
     count: number;
     lastActive: string;
     locked: boolean;
     sessionId: string;
-    seessionIds: string[];
+    sessionIds: string[];
     startTime: number;
     state: string;
     type: string;
+    endMeetingReason?: EndMeetingReason;
 };
 export type Links = {
     services: Record<'breakout' | 'record', {
@@ -59,3 +75,7 @@ export type ReplacesInfo = {
     replacedAt: string;
     sessionId: string;
 };
+export declare const LocusErrorCodes: {
+    readonly LOCUS_INACTIVE: 2403004;
+};
+export type LocusErrorCodes = Enum<typeof LocusErrorCodes>;

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

@@ -26,6 +26,7 @@ export default class MediaProperties {
     shareAudioStream?: LocalSystemAudioStream;
     videoDeviceId: any;
     videoStream?: LocalCameraStream;
+    srtpCipher: string | undefined;
     namespace: string;
     mediaIssueCounters: {
         [key: string]: number;

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

@@ -115,6 +115,8 @@ interface IInMeetingActions {
     canDisablePollingQA?: boolean;
     canAttendeeRequestAiAssistantEnabled?: boolean;
     isAttendeeRequestAiAssistantDeclinedAll?: boolean;
+    isAnonymizeDisplayNamesEnabled?: boolean;
+    canViewTheParticipantList?: boolean;
 }
 /**
  * @class InMeetingActions
@@ -230,6 +232,8 @@ export default class InMeetingActions implements IInMeetingActions {
     canDisablePollingQA: any;
     canAttendeeRequestAiAssistantEnabled: any;
     isAttendeeRequestAiAssistantDeclinedAll: any;
+    isAnonymizeDisplayNamesEnabled: any;
+    canViewTheParticipantList: any;
     /**
      * Returns all meeting action options
      * @returns {Object}