@webex/plugin-meetings 3.0.0-beta.2 → 3.0.0-beta.200

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

@@ -0,0 +1,24 @@
+export declare enum ServerRoles {
+    Cohost = "COHOST",
+    Moderator = "MODERATOR",
+    Presenter = "PRESENTER"
+}
+export type ServerRoleShape = {
+    type: ServerRoles;
+    hasRole: boolean;
+};
+export type RoleAssignmentOptions = {
+    roles: Array<ServerRoleShape>;
+    locusUrl: string;
+    memberId: string;
+};
+export type RoleAssignmentBody = {
+    role: {
+        roles: Array<ServerRoleShape>;
+    };
+};
+export type RoleAssignmentRequest = {
+    method: string;
+    uri: string;
+    body: RoleAssignmentBody;
+};

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

@@ -0,0 +1,210 @@
+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 {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

@@ -0,0 +1,55 @@
+declare const BEHAVIORAL_METRICS: {
+    MEETINGS_REGISTRATION_FAILED: string;
+    MEETINGS_REGISTRATION_SUCCESS: string;
+    MERCURY_CONNECTION_FAILURE: string;
+    MERCURY_CONNECTION_RESTORED: string;
+    JOIN_SUCCESS: string;
+    JOIN_FAILURE: string;
+    ADD_MEDIA_SUCCESS: string;
+    ADD_MEDIA_FAILURE: string;
+    ROAP_MERCURY_EVENT_RECEIVED: string;
+    CONNECTION_SUCCESS: string;
+    CONNECTION_FAILURE: string;
+    MEETING_LEAVE_FAILURE: string;
+    MEETING_END_ALL_FAILURE: string;
+    MEETING_END_ALL_INITIATED: string;
+    GET_USER_MEDIA_FAILURE: string;
+    GET_DISPLAY_MEDIA_FAILURE: string;
+    JOIN_WITH_MEDIA_FAILURE: string;
+    DISCONNECT_DUE_TO_INACTIVITY: string;
+    MEETING_MEDIA_INACTIVE: string;
+    MEETING_RECONNECT_FAILURE: string;
+    MEETING_MAX_REJOIN_FAILURE: string;
+    MEETING_SHARE_FAILURE: string;
+    MEETING_START_WHITEBOARD_SHARE_FAILURE: string;
+    MEETING_STOP_WHITEBOARD_SHARE_FAILURE: string;
+    MUTE_AUDIO_FAILURE: string;
+    MUTE_VIDEO_FAILURE: string;
+    SET_MEETING_QUALITY_FAILURE: string;
+    STOP_FLOOR_REQUEST_FAILURE: string;
+    ADD_DIAL_IN_FAILURE: string;
+    ADD_DIAL_OUT_FAILURE: string;
+    UPDATE_MEDIA_FAILURE: string;
+    UNMUTE_AUDIO_FAILURE: string;
+    UNMUTE_VIDEO_FAILURE: string;
+    ROAP_ANSWER_FAILURE: string;
+    ROAP_GLARE_CONDITION: string;
+    PEERCONNECTION_FAILURE: string;
+    INVALID_ICE_CANDIDATE: string;
+    UPLOAD_LOGS_FAILURE: string;
+    RECEIVE_TRANSCRIPTION_FAILURE: string;
+    FETCH_MEETING_INFO_V1_SUCCESS: string;
+    FETCH_MEETING_INFO_V1_FAILURE: string;
+    ADHOC_MEETING_SUCCESS: string;
+    ADHOC_MEETING_FAILURE: string;
+    VERIFY_PASSWORD_SUCCESS: string;
+    VERIFY_PASSWORD_ERROR: string;
+    VERIFY_CAPTCHA_ERROR: string;
+    MOVE_TO_SUCCESS: string;
+    MOVE_TO_FAILURE: string;
+    MOVE_FROM_SUCCESS: string;
+    MOVE_FROM_FAILURE: string;
+    TURN_DISCOVERY_FAILURE: string;
+    MEETING_INFO_POLICY_ERROR: string;
+};
+export { BEHAVIORAL_METRICS as default };

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

@@ -0,0 +1,45 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+/**
+ * @description Metrics handles all the call metrics events
+ * @export
+ * @class Metrics
+ */
+declare class Metrics {
+    static instance: Metrics;
+    webex: any;
+    /**
+     * Create Metrics Object
+     * @constructor
+     * @public
+     * @memberof Meetings
+     */
+    constructor();
+    /**
+     * Initializes the Metrics singleton with a meeting Collection.
+     *
+     * @param {Object} webex  webex SDK object
+     *
+     * @returns {void}
+     */
+    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
+     * are automatically added when the metric is sent.
+     *
+     * The Metrics service will send an Behavioral metric to InfluxDB for
+     * aggregation.
+     * See https://confluence-eng-gpk2.cisco.com/conf/display/WBXT/Getting+started+with+Metrics+Service.
+     *
+     * @param {string} metricName  Name of the metric (measurement) to send
+     * @param {Object} metricFields  Key-valye pairs of data or values about this metric
+     * @param {Object} metricTags  Key-value pairs of metric metadata
+     *
+     * @returns {void}
+     */
+    sendBehavioralMetric(metricName: string, metricFields?: object, metricTags?: object): void;
+}
+declare const instance: Metrics;
+export default instance;

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

@@ -0,0 +1,118 @@
+import { StreamRequest } from '@webex/internal-media-core';
+import { ReceiveSlot } from './receiveSlot';
+export interface ActiveSpeakerPolicyInfo {
+    policy: 'active-speaker';
+    priority: number;
+    crossPriorityDuplication: boolean;
+    crossPolicyDuplication: boolean;
+    preferLiveVideo: boolean;
+}
+export interface ReceiverSelectedPolicyInfo {
+    policy: 'receiver-selected';
+    csi: number;
+}
+export type PolicyInfo = ActiveSpeakerPolicyInfo | ReceiverSelectedPolicyInfo;
+export interface H264CodecInfo {
+    codec: 'h264';
+    maxFs?: number;
+    maxFps?: number;
+    maxMbps?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+}
+export type CodecInfo = H264CodecInfo;
+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 = (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 degradationPreferences;
+    private sourceUpdateListener;
+    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

@@ -0,0 +1,68 @@
+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 { StreamState } from '@webex/internal-media-core';
+export type CSI = number;
+export type MemberId = string;
+export type ReceiveSlotId = string;
+export type FindMemberIdCallback = (csi: CSI) => MemberId | undefined;
+/**
+ * Class representing a receive slot. A single receive slot is able to receive a single track
+ * for example some participant's main video or audio
+ */
+export declare class ReceiveSlot extends EventsScope {
+    #private;
+    private readonly mcReceiveSlot;
+    private readonly findMemberIdCallback;
+    readonly id: ReceiveSlotId;
+    readonly mediaType: MediaType;
+    /**
+     * constructor - don't use it directly, you should always use meeting.receiveSlotManager.allocateSlot()
+     * to create any receive slots
+     *
+     * @param {MediaType} mediaType
+     * @param {ReceiveSlot} mcReceiveSlot
+     * @param {FindMemberIdCallback} findMemberIdCallback callback for finding memberId for given CSI
+     */
+    constructor(mediaType: MediaType, mcReceiveSlot: WcmeReceiveSlot, findMemberIdCallback: FindMemberIdCallback);
+    /**
+     * Getter for memberId
+     */
+    get memberId(): string;
+    /**
+     * 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(): 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.
+     *
+     * @returns {MediaStream} The MediaStreamTrack.
+     */
+    get stream(): MediaStream;
+    /**
+     * The underlying WCME receive slot
+     */
+    get wcmeReceiveSlot(): WcmeReceiveSlot;
+}

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

@@ -0,0 +1,56 @@
+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.
+ */
+export declare class ReceiveSlotManager {
+    private allocatedSlots;
+    private freeSlots;
+    private createSlotCallback;
+    private findMemberIdByCsiCallback;
+    /**
+     * Constructor
+     * @param {Meeting} meeting
+     */
+    constructor(createSlotCallback: CreateSlotCallback, findMemberIdByCsiCallback: FindMemberIdCallback);
+    /**
+     * Creates a new receive slot or returns one from the existing pool of free slots
+     *
+     * @param {MediaType} mediaType
+     * @returns {Promise<ReceiveSlot>}
+     */
+    allocateSlot(mediaType: MediaType): Promise<ReceiveSlot>;
+    /**
+     * Releases the slot back to the pool so it can be re-used by others in the future
+     * @param {ReceiveSlot} slot
+     */
+    releaseSlot(slot: ReceiveSlot): void;
+    /**
+     * Resets the slot manager - this method should be called when the media connection is torn down
+     */
+    reset(): void;
+    /**
+     * Returns statistics about the managed slots
+     *
+     * @returns {Object}
+     */
+    getStats(): {
+        numAllocatedSlots: {};
+        numFreeSlots: {};
+    };
+    /**
+     * Tries to find the member id on all allocated receive slots
+     * 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

@@ -0,0 +1,72 @@
+import { MediaType, StreamState } from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+import { MediaRequestManager } from './mediaRequestManager';
+import { ReceiveSlot } from './receiveSlot';
+export declare const RemoteMediaEvents: {
+    SourceUpdate: string;
+    Stopped: string;
+};
+export type RemoteVideoResolution = 'thumbnail' | 'very small' | 'small' | 'medium' | 'large' | 'best';
+/**
+ * Converts pane size into h264 maxFs
+ * @param {PaneSize} paneSize
+ * @returns {number}
+ */
+export declare function getMaxFs(paneSize: RemoteVideoResolution): number;
+type Options = {
+    resolution?: RemoteVideoResolution;
+};
+export type RemoteMediaId = string;
+/**
+ * Class representing a remote audio/video stream.
+ *
+ * Internally it is associated with a specific receive slot
+ * and a media request for it.
+ */
+export declare class RemoteMedia extends EventsScope {
+    private receiveSlot?;
+    private readonly mediaRequestManager;
+    private readonly options;
+    private mediaRequestId?;
+    readonly id: RemoteMediaId;
+    /**
+     * Constructs RemoteMedia instance
+     *
+     * @param receiveSlot
+     * @param mediaRequestManager
+     * @param options
+     */
+    constructor(receiveSlot: ReceiveSlot, mediaRequestManager: MediaRequestManager, options?: Options);
+    /**
+     * 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
+     */
+    setSizeHint(width: any, height: any): void;
+    /**
+     * registers event listeners on the receive slot and forwards all the events
+     */
+    private setupEventListeners;
+    /**
+     * Getter for mediaType
+     */
+    get mediaType(): MediaType;
+    /**
+     * Getter for memberId
+     */
+    get memberId(): string;
+    /**
+     * Getter for csi
+     */
+    get csi(): number;
+    /**
+     * Getter for source state
+     */
+    get sourceState(): StreamState;
+    /**
+     * Getter for remote media stream
+     */
+    get stream(): MediaStream;
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
+import { MediaRequestManager } from './mediaRequestManager';
+import { CSI, ReceiveSlot } from './receiveSlot';
+type Options = {
+    resolution?: RemoteVideoResolution;
+    preferLiveVideo?: boolean;
+};
+export declare class RemoteMediaGroup {
+    private mediaRequestManager;
+    private priority;
+    private options;
+    private unpinnedRemoteMedia;
+    private mediaRequestId?;
+    private pinnedRemoteMedia;
+    constructor(mediaRequestManager: MediaRequestManager, receiveSlots: ReceiveSlot[], priority: number, commitMediaRequest: boolean, options?: Options);
+    /**
+     * Gets the array of remote media elements from the group
+     *
+     * @param {string} filter - 'all' (default) returns both pinned and unpinned
+     * @returns {Array<RemoteMedia>}
+     */
+    getRemoteMedia(filter?: 'all' | 'pinned' | 'unpinned'): RemoteMedia[];
+    /**
+     * Pins a specific remote media instance to a specfic CSI, so the media will
+     * no longer come from active speaker, but from that CSI.
+     * If no CSI is given, the current CSI value is used.
+     *
+     */
+    pin(remoteMedia: RemoteMedia, csi?: CSI): void;
+    /**
+     * Unpins a remote media instance, so that it will again provide media from active speakers
+     *
+     */
+    unpin(remoteMedia: RemoteMedia): void;
+    isPinned(remoteMedia: RemoteMedia): boolean;
+    private sendActiveSpeakerMediaRequest;
+    private cancelActiveSpeakerMediaRequest;
+    /**
+     * Checks if a given RemoteMedia instance belongs to this group.
+     *
+     * @param remoteMedia RemoteMedia instance to check
+     * @param filter controls which remote media from the group to check
+     * @returns true if remote media is found
+     */
+    includes(remoteMedia: RemoteMedia, filter?: 'all' | 'pinned' | 'unpinned'): boolean;
+}
+export {};