@webex/plugin-meetings 3.12.0-next.8 → 3.12.0-task-refactor.1

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

@@ -1,6 +1,5 @@
-import HashTree from './hashTree';
 import { Enum } from '../constants';
-import { HtMeta, HashTreeObject } from './types';
+import { HtMeta } from './types';
 import { LocusDTO } from '../locus-info/types';
 export interface DataSet {
     url: string;
@@ -14,6 +13,10 @@ export interface DataSet {
         exponent: number;
     };
 }
+export interface HashTreeObject {
+    htMeta: HtMeta;
+    data: Record<string, any>;
+}
 export interface RootHashMessage {
     dataSets: Array<DataSet>;
 }
@@ -23,21 +26,9 @@ 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: {
@@ -49,11 +40,11 @@ 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.
+ * Checks if the given hash tree object is of type "self"
+ * @param {HashTreeObject} object object to check
+ * @returns {boolean} True if the object is of type "self", false otherwise
  */
-export declare class MeetingEndedError extends Error {
-}
+export declare function isSelf(object: HashTreeObject): boolean;
 /**
  * Parses hash tree eventing locus data
  */
@@ -62,11 +53,8 @@ declare class HashTreeParser {
     visibleDataSetsUrl: string;
     webexRequest: WebexRequestMethod;
     locusInfoUpdateCallback: LocusInfoUpdateCallback;
-    visibleDataSets: VisibleDataSetInfo[];
+    visibleDataSets: string[];
     debugId: string;
-    heartbeatIntervalMs?: number;
-    private excludedDataSets;
-    state: 'active' | 'stopped';
     /**
      * Constructor for HashTreeParser
      * @param {Object} options
@@ -77,63 +65,10 @@ 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 {VisibleDataSetInfo} visibleDataSetInfo Information about the new visible data set
-     * @param {DataSet} dataSetInfo The new data set to be added
-     * @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
-     *
-     * @returns {Promise}
-     */
-    private getAllVisibleDataSetsFromLocus;
     /**
      * Initializes the hash tree parser from a message received from Locus.
      *
@@ -151,64 +86,6 @@ declare class HashTreeParser {
      * @returns {Promise}
      */
     initializeFromGetLociResponse(locus: LocusDTO): Promise<void>;
-    /**
-     * Initializes data sets by doing an initialization sync on each visible data set that doesn't have a hash tree yet.
-     *
-     * @param {DataSet[]} visibleDataSets Array of visible DataSet objects to initialize
-     * @param {string} debugText Text to include in logs for debugging purposes
-     * @returns {Promise}
-     */
-    private initializeDataSets;
-    /**
-     * Each dataset exists at a different place in the dto
-     * iterate recursively over the locus and if it has a htMeta key,
-     * create an object with the type, id and version and add it to the appropriate leafData array
-     *
-     * @param {any} locus - The current part of the locus being processed
-     * @param {Object} [options]
-     * @param {boolean} [options.copyData=false] - Whether to copy the data for each leaf into returned result
-     * @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.
-     *
-     * @param {HashTreeMessage} message - The hash tree message to check
-     * @returns {boolean} - Returns true if the message indicates the end of the meeting, false otherwise
-     */
-    private isEndMessage;
-    /**
-     * Handles the root hash heartbeat message
-     *
-     * @param {RootHashMessage} message - The root hash heartbeat message
-     * @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
@@ -219,59 +96,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.
-     *
-     * @param {DataSet} receivedDataSet - The latest data set information received from Locus to update the internal state.
-     * @returns {void}
-     */
-    private updateDataSetInfo;
-    /**
-     * Checks for changes in the visible data sets based on the updated objects.
-     * @param {HashTreeObject[]} updatedObjects - The list of updated hash tree objects.
-     * @returns {Object} An object containing the removed and added visible data sets.
-     */
-    private checkForVisibleDataSetChanges;
-    /**
-     * Deletes the hash tree for the specified data set.
-     *
-     * @param {string} dataSetName name of the data set to delete
-     * @returns {void}
-     */
-    private deleteHashTree;
-    /**
-     * Adds entries to the passed in updateObjects array
-     * for the changes that result from removing visible data sets and creates hash
-     * trees for the new visible data sets, but without populating the hash trees.
-     *
-     * This function is synchronous. If we are missing information about some new
-     * visible data sets and they require async initialization, the names of these data sets
-     * are returned in an array.
-     *
-     * @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 {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 {VisibleDataSetInfo[]} addedDataSets - The list of added data sets.
-     * @returns {Promise<void>}
-     */
-    private initializeNewVisibleDataSets;
-    /**
-     * Parses incoming hash tree messages, updates the hash trees and returns information about the changes
-     *
-     * @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 {HashTreeObject[]} list of hash tree objects that were updated as a result of processing the message
-     */
-    private parseMessage;
     /**
      * Handles incoming hash tree messages, updates the hash trees and calls locusInfoUpdateCallback
      *
@@ -279,80 +104,6 @@ declare class HashTreeParser {
      * @param {string} [debugText] - Optional debug text to include in logs
      * @returns {void}
      */
-    handleMessage(message: HashTreeMessage, debugText?: string): void;
-    /**
-     * Calls the updateInfo callback if there are any updates to report
-     *
-     * @param {Object} updates parsed from a Locus message
-     * @returns {void}
-     */
-    private callLocusInfoUpdateCallback;
-    /**
-     * Calculates a weighted backoff time that should be used for syncs
-     *
-     * @param {Object} backoff - The backoff configuration containing maxMs and exponent
-     * @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.
-     *
-     * @param {DataSet} receivedDataSet - The data set to run the sync algorithm for.
-     * @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;
-    /**
-     * 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.
-     * @returns {Promise<HashTreeMessage|null>}
-     */
-    private sendSyncRequestToLocus;
+    handleMessage(message: HashTreeMessage, debugText?: string): Promise<void>;
 }
 export default HashTreeParser;

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

@@ -4,24 +4,8 @@ export declare const ObjectType: {
     readonly self: "self";
     readonly locus: "locus";
     readonly mediaShare: "mediashare";
-    readonly info: "info";
-    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: {
-    links: string;
-    info: string;
-    fullstate: string;
-    self: string;
-    participant: string;
-    mediashare: string;
-    controlentry: string;
-    embeddedapp: string;
-};
 export interface HtMeta {
     elementId: {
         type: ObjectType;
@@ -30,7 +14,3 @@ export interface HtMeta {
     };
     dataSetNames: string[];
 }
-export interface HashTreeObject {
-    htMeta: HtMeta;
-    data: Record<string, any>;
-}

package/dist/types/index.d.ts

@@ -19,4 +19,3 @@ 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/index.d.ts

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

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

@@ -11,8 +11,6 @@ export default class LocusRouteTokenInterceptor extends Interceptor {
      */
     static create(): LocusRouteTokenInterceptor;
     getLocusIdByRequestUrl(url: string): string;
-    getLocusIdByResponseBody(body: any): any;
-    getHeader(headers: Record<string, string>, name: string): string;
     /**
      * @param {Object} options
      * @param {HttpResponse} response

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

@@ -1,9 +1,7 @@
 import EventsScope from '../common/events/events-scope';
 import { LOCUSEVENT } from '../constants';
-import HashTreeParser, { DataSet, HashTreeMessage, Metadata } from '../hashTree/hashTreeParser';
-import { HashTreeObject } from '../hashTree/types';
-import { Links, LocusDTO } from './types';
-import MeetingCollection from '../meetings/collection';
+import HashTreeParser, { DataSet, HashTreeMessage, HashTreeObject } from '../hashTree/hashTreeParser';
+import { LocusDTO } from './types';
 export type LocusLLMEvent = {
     data: {
         eventType: typeof LOCUSEVENT.HASH_TREE_DATA_UPDATED;
@@ -13,33 +11,6 @@ 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
@@ -58,7 +29,10 @@ export default class LocusInfo extends EventsScope {
     aclUrl: any;
     baseSequence: any;
     created: any;
+    identities: any;
+    membership: any;
     participants: any;
+    participantsUrl: any;
     replaces: any;
     scheduledMeeting: any;
     sequence: any;
@@ -70,11 +44,13 @@ export default class LocusInfo extends EventsScope {
     info: any;
     roles: any;
     mediaShares: any;
+    replace: any;
     url: any;
-    links?: Links;
+    services: any;
+    resources: any;
     mainSessionLocusCache: any;
     self: any;
-    hashTreeParsers: Map<string, HashTreeParserEntry>;
+    hashTreeParser?: HashTreeParser;
     hashTreeObjectId2ParticipantId: Map<number, string>;
     classicVsHashTreeMismatchMetricCounter: number;
     /**
@@ -119,13 +95,9 @@ export default class LocusInfo extends EventsScope {
      */
     init(locus?: any): 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
+     * Creates the HashTreeParser instance.
+     * @param {Object} initial locus data
+     * @returns {void}
      */
     private createHashTreeParser;
     /**
@@ -137,7 +109,6 @@ export default class LocusInfo extends EventsScope {
         trigger: 'join-response';
         locus: LocusDTO;
         dataSets?: DataSet[];
-        metadata?: Metadata;
     } | {
         trigger: 'locus-message';
         locus?: LocusDTO;
@@ -154,6 +125,7 @@ export default class LocusInfo extends EventsScope {
      */
     handleLocusAPIResponse(meeting: any, responseBody: LocusApiResponseBody): void;
     /**
+     *
      * @param {HashTreeObject} object data set object
      * @param {any} locus
      * @returns {void}
@@ -167,13 +139,6 @@ 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.
      *
@@ -187,7 +152,6 @@ 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}
@@ -211,9 +175,7 @@ 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}
@@ -222,7 +184,6 @@ 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}
@@ -230,15 +191,13 @@ 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(debugText: string, locus: any, eventType?: string, dataSets?: Array<DataSet>, metadata?: Metadata): void;
+    onFullLocus(locus: any, eventType?: string, dataSets?: Array<DataSet>): void;
     /**
      * Common part of handling full locus, used by both classic and hash tree based locus handling
      * @param {object} locus locus object
@@ -252,13 +211,6 @@ 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}
@@ -270,7 +222,7 @@ export default class LocusInfo extends EventsScope {
      * @returns {undefined}
      * @memberof LocusInfo
      */
-    updateLocusInfo(locus: any): boolean;
+    updateLocusInfo(locus: any): void;
     /**
      * @param {Array} participants
      * @param {Object} self
@@ -326,12 +278,21 @@ export default class LocusInfo extends EventsScope {
      */
     updateCreated(created: object): void;
     /**
-     * Updates links and emits appropriate events if services or resources have changed
-     * @param {Object} links
+     * @param {Object} services
      * @returns {undefined}
      * @memberof LocusInfo
      */
-    updateLinks(links?: Links): void;
+    updateServices(services: Record<'breakout' | 'record', {
+        url: string;
+    }>): void;
+    /**
+     * @param {Object} resources
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateResources(resources: Record<'webcastInstance', {
+        url: string;
+    }>): void;
     /**
      * @param {Object} fullState
      * @returns {undefined}
@@ -369,11 +330,17 @@ export default class LocusInfo extends EventsScope {
      */
     updateMediaShares(mediaShares: object, forceUpdate?: boolean): void;
     /**
-     * @param {Object} replaces
+     * @param {String} participantsUrl
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateParticipantsUrl(participantsUrl: string): void;
+    /**
+     * @param {Object} replace
      * @returns {undefined}
      * @memberof LocusInfo
      */
-    updateReplaces(replaces: object): void;
+    updateReplace(replace: object): void;
     /**
      * handles when the locus.self is updated
      * @param {Object} self the new locus.self
@@ -408,6 +375,18 @@ export default class LocusInfo extends EventsScope {
      * @memberof LocusInfo
      */
     updateSequence(sequence: number): void;
+    /**
+     * @param {Object} membership
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateMemberShip(membership: object): void;
+    /**
+     * @param {Array} identities
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateIdentifiers(identities: Array<any>): void;
     /**
      * check the locus is main session's one or not, if is main session's, update main session cache
      * @param {Object} locus