@webex/plugin-meetings 3.0.0-beta.34 → 3.0.0-beta.340

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

@@ -1,2 +1,215 @@
-declare const MembersUtil: any;
+import { RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape } from './types';
+declare const MembersUtil: {
+    /**
+     * @param {Object} invitee with emailAddress, email or phoneNumber
+     * @param {String} locusUrl
+     * @param {Boolean} alertIfActive
+     * @returns {Object} the format object
+     */
+    generateAddMemberOptions: (invitee: object, locusUrl: string, alertIfActive: boolean) => {
+        invitee: object;
+        locusUrl: string;
+        alertIfActive: boolean;
+    };
+    /**
+     * @param {Array} memberIds
+     * @param {String} locusUrl
+     * @returns {Object} the format object
+     */
+    generateAdmitMemberOptions: (memberIds: Array<any>, locusUrl: string) => {
+        locusUrl: string;
+        memberIds: any[];
+    };
+    /**
+     * @param {Object} options with {invitee: {emailAddress, email, phoneNumber}, alertIfActive}
+     * @returns {Object} with {invitees: [{address}], alertIfActive}
+     */
+    getAddMemberBody: (options: any) => {
+        invitees: {
+            address: any;
+        }[];
+        alertIfActive: any;
+    };
+    /**
+     * @param {Object} options with {memberIds, authorizingLocusUrl}
+     * @returns {Object} admit with {memberIds}
+     */
+    getAdmitMemberRequestBody: (options: any) => any;
+    /**
+     * @param {Object} format with {memberIds, locusUrl, sessionLocusUrls}
+     * @returns {Object} the request parameters (method, uri, body) needed to make a admitMember request
+     * if a host/cohost is in a breakout session, the locus url should be the main session locus url
+     */
+    getAdmitMemberRequestParams: (format: any) => {
+        method: string;
+        uri: string;
+        body: any;
+    };
+    /**
+     * @param {Object} format with {invitee {emailAddress, email, phoneNumber}, locusUrl, alertIfActive}
+     * @returns {Object} the request parameters (method, uri, body) needed to make a addMember request
+     */
+    getAddMemberRequestParams: (format: any) => {
+        method: string;
+        uri: any;
+        body: {
+            invitees: {
+                address: any;
+            }[];
+            alertIfActive: any;
+        };
+    };
+    isInvalidInvitee: (invitee: any) => boolean;
+    getRemoveMemberRequestParams: (options: any) => {
+        method: string;
+        uri: string;
+        body: {
+            reason: any;
+        };
+    };
+    generateTransferHostMemberOptions: (transfer: any, moderator: any, locusUrl: any) => {
+        moderator: any;
+        locusUrl: any;
+        memberId: any;
+    };
+    generateRemoveMemberOptions: (removal: any, locusUrl: any) => {
+        reason: string;
+        memberId: any;
+        locusUrl: any;
+    };
+    generateMuteMemberOptions: (memberId: any, status: any, locusUrl: any, isAudio: any) => {
+        memberId: any;
+        muted: any;
+        locusUrl: any;
+        isAudio: any;
+    };
+    generateRaiseHandMemberOptions: (memberId: any, status: any, locusUrl: any) => {
+        memberId: any;
+        raised: any;
+        locusUrl: any;
+    };
+    /**
+     * @param {String} memberId
+     * @param {[ServerRoleShape]} roles
+     * @param {String} locusUrl
+     * @returns {RoleAssignmentOptions}
+     */
+    generateRoleAssignmentMemberOptions: (memberId: string, roles: Array<ServerRoleShape>, locusUrl: string) => RoleAssignmentOptions;
+    generateLowerAllHandsMemberOptions: (requestingParticipantId: any, locusUrl: any) => {
+        requestingParticipantId: any;
+        locusUrl: any;
+    };
+    /**
+     * @param {String} memberId id of the participant who is receiving request
+     * @param {String} requestingParticipantId id of the participant who is sending request (optional)
+     * @param {String} alias alias name
+     * @param {String} locusUrl url
+     * @returns {Object} consists of {memberID: string, requestingParticipantId: string, alias: string, locusUrl: string}
+     */
+    generateEditDisplayNameMemberOptions: (memberId: any, requestingParticipantId: any, alias: any, locusUrl: any) => {
+        memberId: any;
+        requestingParticipantId: any;
+        alias: any;
+        locusUrl: any;
+    };
+    getMuteMemberRequestParams: (options: any) => {
+        method: string;
+        uri: string;
+        body: {
+            [x: string]: {
+                muted: any;
+            };
+        };
+    };
+    /**
+     * @param {ServerRoleShape} role
+     * @returns {ServerRoleShape} the role shape to be added to the body
+     */
+    getAddedRoleShape: (role: ServerRoleShape) => ServerRoleShape;
+    /**
+     * @param {RoleAssignmentOptions} options
+     * @returns {RoleAssignmentRequest} the request parameters (method, uri, body) needed to make a addMember request
+     */
+    getRoleAssignmentMemberRequestParams: (options: RoleAssignmentOptions) => RoleAssignmentRequest;
+    getRaiseHandMemberRequestParams: (options: any) => {
+        method: string;
+        uri: string;
+        body: {
+            hand: {
+                raised: any;
+            };
+        };
+    };
+    getLowerAllHandsMemberRequestParams: (options: any) => {
+        method: string;
+        uri: string;
+        body: {
+            hand: {
+                raised: boolean;
+            };
+            requestingParticipantId: any;
+        };
+    };
+    /**
+     * @param {Object} options with format of {locusUrl: string, requestingParticipantId: string}
+     * @returns {Object} request parameters (method, uri, body) needed to make a editDisplayName request
+     */
+    editDisplayNameMemberRequestParams: (options: any) => {
+        method: string;
+        uri: string;
+        body: {
+            aliasValue: any;
+            requestingParticipantId: any;
+        };
+    };
+    getTransferHostToMemberRequestParams: (options: any) => {
+        method: string;
+        uri: string;
+        body: {
+            role: {
+                moderator: any;
+            };
+        };
+    };
+    genderateSendDTMFOptions: (url: any, tones: any, memberId: any, locusUrl: any) => {
+        url: any;
+        tones: any;
+        memberId: any;
+        locusUrl: any;
+    };
+    generateSendDTMFRequestParams: ({ url, tones, memberId, locusUrl }: {
+        url: any;
+        tones: any;
+        memberId: any;
+        locusUrl: any;
+    }) => {
+        method: string;
+        uri: string;
+        body: {
+            device: {
+                url: any;
+            };
+            memberId: any;
+            dtmf: {
+                correlationId: any;
+                tones: any;
+                direction: string;
+            };
+        };
+    };
+    cancelPhoneInviteOptions: (invitee: any, locusUrl: any) => {
+        invitee: any;
+        locusUrl: any;
+    };
+    generateCancelInviteRequestParams: (options: any) => {
+        method: string;
+        uri: any;
+        body: {
+            actionType: string;
+            invitees: {
+                address: any;
+            }[];
+        };
+    };
+};
 export default MembersUtil;

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

@@ -7,6 +7,8 @@ declare const BEHAVIORAL_METRICS: {
     JOIN_FAILURE: string;
     ADD_MEDIA_SUCCESS: string;
     ADD_MEDIA_FAILURE: string;
+    ADD_MEDIA_RETRY: string;
+    ROAP_MERCURY_EVENT_RECEIVED: string;
     CONNECTION_SUCCESS: string;
     CONNECTION_FAILURE: string;
     MEETING_LEAVE_FAILURE: string;
@@ -15,13 +17,17 @@ declare const BEHAVIORAL_METRICS: {
     GET_USER_MEDIA_FAILURE: string;
     GET_DISPLAY_MEDIA_FAILURE: string;
     JOIN_WITH_MEDIA_FAILURE: string;
+    LLM_CONNECTION_AFTER_JOIN_FAILURE: string;
+    RECEIVE_TRANSCRIPTION_AFTER_JOIN_FAILURE: string;
     DISCONNECT_DUE_TO_INACTIVITY: string;
     MEETING_MEDIA_INACTIVE: string;
     MEETING_RECONNECT_FAILURE: string;
     MEETING_MAX_REJOIN_FAILURE: string;
+    MEETING_SHARE_SUCCESS: string;
     MEETING_SHARE_FAILURE: string;
     MEETING_START_WHITEBOARD_SHARE_FAILURE: string;
     MEETING_STOP_WHITEBOARD_SHARE_FAILURE: string;
+    MEETING_SHARE_VIDEO_MUTE_STATE_CHANGE: string;
     MUTE_AUDIO_FAILURE: string;
     MUTE_VIDEO_FAILURE: string;
     SET_MEETING_QUALITY_FAILURE: string;
@@ -36,11 +42,8 @@ declare const BEHAVIORAL_METRICS: {
     PEERCONNECTION_FAILURE: string;
     INVALID_ICE_CANDIDATE: string;
     UPLOAD_LOGS_FAILURE: string;
+    UPLOAD_LOGS_SUCCESS: string;
     RECEIVE_TRANSCRIPTION_FAILURE: string;
-    ENABLE_BNR_SUCCESS: string;
-    ENABLE_BNR_FAILURE: string;
-    DISABLE_BNR_SUCCESS: string;
-    DISABLE_BNR_FAILURE: string;
     FETCH_MEETING_INFO_V1_SUCCESS: string;
     FETCH_MEETING_INFO_V1_FAILURE: string;
     ADHOC_MEETING_SUCCESS: string;
@@ -53,5 +56,13 @@ declare const BEHAVIORAL_METRICS: {
     MOVE_FROM_SUCCESS: string;
     MOVE_FROM_FAILURE: string;
     TURN_DISCOVERY_FAILURE: string;
+    MEETING_INFO_POLICY_ERROR: string;
+    LOCUS_DELTA_SYNC_FAILED: string;
+    LOCUS_DELTA_OUT_OF_ORDER: string;
+    PERMISSION_TOKEN_REFRESH: string;
+    PERMISSION_TOKEN_REFRESH_ERROR: string;
+    TURN_DISCOVERY_LATENCY: string;
+    ROAP_OFFER_TO_ANSWER_LATENCY: string;
+    ROAP_HTTP_RESPONSE_MISSING: string;
 };
 export { BEHAVIORAL_METRICS as default };

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

@@ -1,3 +1,6 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
 /**
  * @description Metrics handles all the call metrics events
  * @export
@@ -5,9 +8,6 @@
  */
 declare class Metrics {
     static instance: Metrics;
-    _events: any;
-    keys: any;
-    meetingCollection: any;
     webex: any;
     /**
      * Create Metrics Object
@@ -19,118 +19,11 @@ declare class Metrics {
     /**
      * Initializes the Metrics singleton with a meeting Collection.
      *
-     * @param {Object} meetingCollection meetings object
      * @param {Object} webex  webex SDK object
      *
      * @returns {void}
      */
-    initialSetup(meetingCollection: object, webex: object): void;
-    /**
-     * poste Meeting event metrics
-     * @param {object} options {meetingId/meeting} as a json object
-     * @param {Meeting} options.meeting Meeting object
-     * @param {String} options.meetingId
-     * @param {object} options.data
-     * @param {object} options.event
-     * @returns {object} null
-     */
-    postEvent(options: {
-        meeting?: any;
-        meetingId?: string;
-        data?: object;
-        event?: any;
-    } | any): void;
-    /**
-     *  Docs for Call analyzer metrics
-     *   https://sqbu-github.cisco.com/WebExSquared/call-analyzer/wiki
-     *   https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/master/diagnostic-events.raml
-     */
-    initPayload(eventType: any, identifiers: any, options: any): any;
-    /**
-     * get the payload specific for a media quality event through call analyzer
-     * @param {String} eventType the event name
-     * @param {Object} identifiers contains the identifiers needed for CA
-     * @param {String} identifiers.correlationId
-     * @param {String} identifiers.locusUrl
-     * @param {String} identifiers.locusId
-     * @param {Object} options
-     * @param {Object} options.intervalData
-     * @param {String} options.clientType
-     * @returns {Object}
-     * @public
-     * @memberof Metrics
-     */
-    initMediaPayload(eventType: string, identifiers: {
-        correlationId: string;
-        locusUrl: string;
-        locusId: string;
-    }, options?: {
-        intervalData: object;
-        clientType: string;
-    } | any): {
-        eventId: any;
-        version: number;
-        origin: {
-            audioSetupDelay: any;
-            videoSetupDelay: any;
-            name: string;
-            networkType: any;
-            userAgent: string;
-            clientInfo: {
-                clientType: any;
-                clientVersion: string;
-                localNetworkPrefix: string;
-                os: any;
-                osVersion: any;
-                subClientType: any;
-                browser: any;
-                browserVersion: any;
-            };
-        };
-        originTime: {
-            triggered: string;
-        };
-        senderCountryCode: any;
-        event: {
-            name: string;
-            canProceed: boolean;
-            identifiers: {
-                correlationId: string;
-                locusUrl: string;
-                locusId: string;
-            };
-            intervals: any[];
-            joinTimes: any;
-            eventData: {
-                webClientDomain: any;
-            };
-            sourceMetadata: {
-                applicationSoftwareType: string;
-                applicationSoftwareVersion: any;
-                mediaEngineSoftwareType: any;
-                mediaEngineSoftwareVersion: any;
-                startTime: string;
-            };
-        };
-    };
-    /**
-     * This function Parses a Locus error and returns a diagnostic event payload.
-     * It should keep updating from:
-     * https://sqbu-github.cisco.com/WebExSquared/spark-client-framework/blob/master/spark-client-framework/Adapters/TelephonyAdapter/TelephonyAdapter.cpp#L920
-     *
-     * @param {Object} err the error Object from Locus response
-     * @param {boolean} showToUser true if a toast is shown to user
-     * @returns {{showToUser: boolean, category: string, errorDescription: string,
-     *  errorCode: number, errorData: *, fatal: boolean, name: string}}
-     */
-    parseLocusError(err: any, showToUser: boolean): any;
-    generateErrorPayload(errorCode: any, shownToUser: any, name: any, err: any): any;
-    /**
-     * Returns a formated string of the user agent.
-     *
-     * @returns {string} formatted user agent information
-     */
-    userAgentToString(): string;
+    initialSetup(webex: object): void;
     /**
      * Uploads given metric to the Metrics service as an Behavioral metric.
      * Metadata about the environment such as browser, OS, SDK and their versions

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

@@ -1,4 +1,4 @@
-import { MediaRequest as WcmeMediaRequest } from '@webex/internal-media-core';
+import { StreamRequest } from '@webex/internal-media-core';
 import { ReceiveSlot } from './receiveSlot';
 export interface ActiveSpeakerPolicyInfo {
     policy: 'active-speaker';
@@ -25,27 +25,94 @@ export interface MediaRequest {
     policyInfo: PolicyInfo;
     receiveSlots: Array<ReceiveSlot>;
     codecInfo?: CodecInfo;
+    preferredMaxFs?: number;
+    handleMaxFs?: ({ maxFs }: {
+        maxFs: number;
+    }) => void;
 }
 export type MediaRequestId = string;
 type DegradationPreferences = {
     maxMacroblocksLimit: number;
 };
-type SendMediaRequestsCallback = (mediaRequests: WcmeMediaRequest[]) => void;
+type SendMediaRequestsCallback = (streamRequests: StreamRequest[]) => void;
+type Kind = 'audio' | 'video';
+type Options = {
+    degradationPreferences: DegradationPreferences;
+    kind: Kind;
+    trimRequestsToNumOfSources: boolean;
+};
 export declare class MediaRequestManager {
     private sendMediaRequestsCallback;
+    private kind;
     private counter;
     private clientRequests;
-    private slotsActiveInLastMediaRequest;
     private degradationPreferences;
     private sourceUpdateListener;
-    constructor(degradationPreferences: DegradationPreferences, sendMediaRequestsCallback: SendMediaRequestsCallback);
-    private resetInactiveReceiveSlots;
+    private debouncedSourceUpdateListener;
+    private previousStreamRequests;
+    private trimRequestsToNumOfSources;
+    private numTotalSources;
+    private numLiveSources;
+    constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, options: Options);
     setDegradationPreferences(degradationPreferences: DegradationPreferences): void;
     private getDegradedClientRequests;
+    /**
+     * Returns true if two stream requests are the same, false otherwise.
+     *
+     * @param {StreamRequest} streamRequestA - Stream request A for comparison.
+     * @param {StreamRequest} streamRequestB - Stream request B for comparison.
+     * @returns {boolean} - Whether they are equal.
+     */
+    isEqual(streamRequestA: StreamRequest, streamRequestB: StreamRequest): boolean;
+    /**
+     * Compares new stream requests to previous ones and determines
+     * if they are the same.
+     *
+     * @param {StreamRequest[]} newRequests - Array with new requests.
+     * @returns {boolean} - True if they are equal, false otherwise.
+     */
+    private checkIsNewRequestsEqualToPrev;
+    /**
+     * Returns the maxPayloadBitsPerSecond per Stream
+     *
+     * If MediaRequestManager kind is "audio", a constant bitrate will be returned.
+     * If MediaRequestManager kind is "video", the bitrate will be calculated based
+     * on maxFs (default h264 maxFs as fallback if maxFs is not defined)
+     *
+     * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+     * @returns {number} maxPayloadBitsPerSecond
+     */
+    private getMaxPayloadBitsPerSecond;
+    /**
+     * Returns the max Macro Blocks per second (maxMbps) per H264 Stream
+     *
+     * The maxMbps will be calculated based on maxFs and maxFps
+     * (default h264 maxFps as fallback if maxFps is not defined)
+     *
+     * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+     * @returns {number} maxMbps
+     */
+    private getH264MaxMbps;
+    /**
+     * Clears the previous stream requests.
+     *
+     * @returns {void}
+     */
+    clearPreviousRequests(): void;
+    /** Modifies the passed in clientRequests and makes sure that in total they don't ask
+     *  for more streams than there are available.
+     *
+     * @param {Object} clientRequests
+     * @returns {void}
+     */
+    private trimRequests;
+    private getPreferLiveVideo;
+    private cloneClientRequests;
     private sendRequests;
     addRequest(mediaRequest: MediaRequest, commit?: boolean): MediaRequestId;
     cancelRequest(requestId: MediaRequestId, commit?: boolean): void;
     commit(): void;
     reset(): void;
+    setNumCurrentSources(numTotalSources: number, numLiveSources: number): void;
 }
 export {};

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

@@ -1,9 +1,10 @@
-import { MediaType, ReceiveSlot as WcmeReceiveSlot, SourceState } from '@webex/internal-media-core';
+import { MediaType, ReceiveSlot as WcmeReceiveSlot, StreamState } from '@webex/internal-media-core';
 import EventsScope from '../common/events/events-scope';
 export declare const ReceiveSlotEvents: {
     SourceUpdate: string;
+    MaxFsUpdate: string;
 };
-export type { SourceState } from '@webex/internal-media-core';
+export type { StreamState } from '@webex/internal-media-core';
 export type CSI = number;
 export type MemberId = string;
 export type ReceiveSlotId = string;
@@ -35,16 +36,25 @@ export declare class ReceiveSlot extends EventsScope {
      * Getter for csi
      */
     get csi(): number;
+    /**
+     * Set the max frame size for this slot
+     * @param newFs frame size
+     */
+    setMaxFs(newFs: any): void;
     /**
      * Getter for sourceState
      */
-    get sourceState(): SourceState;
+    get sourceState(): StreamState;
     /**
      * registers event handlers with the underlying ReceiveSlot
      */
     private setupEventListeners;
     /** Tries to find the member id for this receive slot if it hasn't got one */
     findMemberId(): void;
+    /**
+     * @returns {string} a log message used to identify the receive slot
+     */
+    get logString(): string;
     /**
      * The MediaStream object associated with this slot.
      *
@@ -55,12 +65,4 @@ export declare class ReceiveSlot extends EventsScope {
      * The underlying WCME receive slot
      */
     get wcmeReceiveSlot(): WcmeReceiveSlot;
-    /**
-     * Resets the source state to the default 'no source' value.
-     * This function should be called on receive slots that are
-     * no longer part of a media request. It's needed because WCME
-     * does not send any more events on such slots, so the sourceState
-     * value would not represent the truth anymore.
-     */
-    resetSourceState(): void;
 }

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

@@ -1,5 +1,7 @@
-import { MediaType } from '@webex/internal-media-core';
-import { ReceiveSlot } from './receiveSlot';
+import { MediaType, ReceiveSlot as WcmeReceiveSlot } from '@webex/internal-media-core';
+import { FindMemberIdCallback, ReceiveSlot } from './receiveSlot';
+export type CreateSlotCallback = (mediaType: MediaType) => Promise<WcmeReceiveSlot>;
+export type { CSI, FindMemberIdCallback } from './receiveSlot';
 /**
  * Manages all receive slots used by a meeting. WMCE receive slots cannot be ever deleted,
  * so this manager has a pool in order to re-use the slots that were released earlier.
@@ -7,12 +9,13 @@ import { ReceiveSlot } from './receiveSlot';
 export declare class ReceiveSlotManager {
     private allocatedSlots;
     private freeSlots;
-    private meeting;
+    private createSlotCallback;
+    private findMemberIdByCsiCallback;
     /**
      * Constructor
      * @param {Meeting} meeting
      */
-    constructor(meeting: any);
+    constructor(createSlotCallback: CreateSlotCallback, findMemberIdByCsiCallback: FindMemberIdCallback);
     /**
      * Creates a new receive slot or returns one from the existing pool of free slots
      *
@@ -43,4 +46,11 @@ export declare class ReceiveSlotManager {
      * This function should be called when new members are added to the meeting.
      */
     updateMemberIds(): void;
+    /**
+     * Find a receive slot by a ssrc.
+     *
+     * @param ssrc - The ssrc of the receive slot to find.
+     * @returns - The receive slot with this ssrc, undefined if not found.
+     */
+    findReceiveSlotBySsrc(ssrc: number): ReceiveSlot | undefined;
 }

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

@@ -1,7 +1,7 @@
-import { MediaType, SourceState } from '@webex/internal-media-core';
+import { MediaType, StreamState } from '@webex/internal-media-core';
 import EventsScope from '../common/events/events-scope';
 import { MediaRequestManager } from './mediaRequestManager';
-import { CSI, ReceiveSlot } from './receiveSlot';
+import { ReceiveSlot } from './receiveSlot';
 export declare const RemoteMediaEvents: {
     SourceUpdate: string;
     Stopped: string;
@@ -38,28 +38,12 @@ export declare class RemoteMedia extends EventsScope {
      */
     constructor(receiveSlot: ReceiveSlot, mediaRequestManager: MediaRequestManager, options?: Options);
     /**
-     * Invalidates the remote media by clearing the reference to a receive slot and
-     * cancelling the media request.
-     * After this call the remote media is unusable.
-     *
-     * @param {boolean} commit - whether to commit the cancellation of the media request
-     * @internal
-     */
-    stop(commit?: boolean): void;
-    /**
-     * Sends a new media request. This method can only be used for receiver-selected policy,
-     * because only in that policy we have a 1-1 relationship between RemoteMedia and MediaRequest
-     * and the request id is then stored in this RemoteMedia instance.
-     * For active-speaker policy, the same request is shared among many RemoteMedia instances,
-     * so it's managed through RemoteMediaGroup
-     *
-     * @internal
+     * Supply the width and height of the video element
+     * to restrict the requested resolution to this size
+     * @param width width of the video element
+     * @param height height of the video element
      */
-    sendMediaRequest(csi: CSI, commit: boolean): void;
-    /**
-     * @internal
-     */
-    cancelMediaRequest(commit: boolean): void;
+    setSizeHint(width: any, height: any): void;
     /**
      * registers event listeners on the receive slot and forwards all the events
      */
@@ -79,15 +63,10 @@ export declare class RemoteMedia extends EventsScope {
     /**
      * Getter for source state
      */
-    get sourceState(): SourceState;
+    get sourceState(): StreamState;
     /**
      * Getter for remote media stream
      */
     get stream(): MediaStream;
-    /**
-     * @internal
-     * @returns {ReceiveSlot}
-     */
-    getUnderlyingReceiveSlot(): ReceiveSlot;
 }
 export {};

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

@@ -35,15 +35,6 @@ export declare class RemoteMediaGroup {
     isPinned(remoteMedia: RemoteMedia): boolean;
     private sendActiveSpeakerMediaRequest;
     private cancelActiveSpeakerMediaRequest;
-    /**
-     * Invalidates the remote media group by clearing the references to the receive slots
-     * used by all remote media from that group and cancelling all media requests.
-     * After this call the remote media group is unusable.
-     *
-     * @param{boolean} commit whether to commit the cancellation of media requests
-     * @internal
-     */
-    stop(commit?: boolean): void;
     /**
      * Checks if a given RemoteMedia instance belongs to this group.
      *