@webex/plugin-meetings 3.8.1 → 3.9.0

package/dist/multistream/mediaRequestManager.d.ts

@@ -1,119 +0,0 @@
-import { StreamRequest, NamedMediaGroup } from '@webex/internal-media-core';
-import { ReceiveSlot } from './receiveSlot';
-export interface ActiveSpeakerPolicyInfo {
-    policy: 'active-speaker';
-    priority: number;
-    crossPriorityDuplication: boolean;
-    crossPolicyDuplication: boolean;
-    preferLiveVideo: boolean;
-    namedMediaGroups?: NamedMediaGroup[];
-}
-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/multistream/receiveSlot.d.ts

@@ -1,68 +0,0 @@
-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/multistream/receiveSlotManager.d.ts

@@ -1,56 +0,0 @@
-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/multistream/remoteMedia.d.ts

@@ -1,72 +0,0 @@
-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/multistream/remoteMediaGroup.d.ts

@@ -1,49 +0,0 @@
-import { NamedMediaGroup } from '@webex/internal-media-core';
-import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
-import { MediaRequestManager } from './mediaRequestManager';
-import { CSI, ReceiveSlot } from './receiveSlot';
-type Options = {
-    resolution?: RemoteVideoResolution;
-    preferLiveVideo?: boolean;
-    namedMediaGroup?: NamedMediaGroup;
-};
-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 {};

package/dist/multistream/remoteMediaManager.d.ts

@@ -1,300 +0,0 @@
-import { EventMap } from 'typed-emitter';
-import { MediaType, NamedMediaGroup } from '@webex/internal-media-core';
-import EventsScope from '../common/events/events-scope';
-import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
-import { CSI } from './receiveSlot';
-import { ReceiveSlotManager } from './receiveSlotManager';
-import { RemoteMediaGroup } from './remoteMediaGroup';
-import { MediaRequestManager } from './mediaRequestManager';
-export type PaneSize = RemoteVideoResolution;
-export type LayoutId = string;
-export type PaneId = string;
-export type PaneGroupId = string;
-export interface ActiveSpeakerVideoPaneGroup {
-    id: PaneGroupId;
-    numPanes: number;
-    size: PaneSize;
-    priority: number;
-}
-export interface MemberVideoPane {
-    id: PaneId;
-    size: PaneSize;
-    csi?: CSI;
-}
-export interface VideoLayout {
-    screenShareVideo?: {
-        size: PaneSize;
-    };
-    activeSpeakerVideoPaneGroups?: ActiveSpeakerVideoPaneGroup[];
-    memberVideoPanes?: MemberVideoPane[];
-}
-export interface Configuration {
-    audio: {
-        numOfActiveSpeakerStreams: number;
-        numOfScreenShareStreams: number;
-    };
-    video: {
-        preferLiveVideo: boolean;
-        initialLayoutId: LayoutId;
-        layouts: {
-            [key: LayoutId]: VideoLayout;
-        };
-    };
-    namedMediaGroup?: NamedMediaGroup;
-}
-/**
- * Default configuration:
- * - uses 3 audio streams
- * - prefers active speakers with live video (e.g. are not audio only or video muted) over active speakers without live video
- * - has a few layouts defined, including 1 that contains remote screen share (ScreenShareView)
- */
-export declare const DefaultConfiguration: Configuration;
-export declare enum Event {
-    AudioCreated = "AudioCreated",
-    InterpretationAudioCreated = "InterpretationAudioCreated",
-    ScreenShareAudioCreated = "ScreenShareAudioCreated",
-    VideoLayoutChanged = "VideoLayoutChanged"
-}
-export interface VideoLayoutChangedEventData {
-    layoutId: LayoutId;
-    activeSpeakerVideoPanes: {
-        [key: PaneGroupId]: RemoteMediaGroup;
-    };
-    memberVideoPanes: {
-        [key: PaneId]: RemoteMedia;
-    };
-    screenShareVideo?: RemoteMedia;
-}
-export interface Events extends EventMap {
-    [Event.AudioCreated]: (audio: RemoteMediaGroup) => void;
-    [Event.ScreenShareAudioCreated]: (screenShareAudio: RemoteMediaGroup) => void;
-    [Event.VideoLayoutChanged]: (data: VideoLayoutChangedEventData) => void;
-}
-/**
- * A helper class that manages all remote audio/video streams in order to achieve a predefined set of layouts.
- * It also creates a fixed number of audio streams and these don't change during the meeting.
- *
- * Things that RemoteMediaManager does:
- * - owns the receive slots (creates them when needed, and re-uses them when switching layouts)
- * - constructs appropriate RemoteMedia and RemoteMediaGroup objects and sends appropriate mediaRequests
- */
-export declare class RemoteMediaManager extends EventsScope {
-    private config;
-    private started;
-    private receiveSlotManager;
-    private mediaRequestManagers;
-    private currentLayout?;
-    private slots;
-    private media;
-    private receiveSlotAllocations;
-    private currentLayoutId?;
-    /**
-     * Constructor
-     *
-     * @param {ReceiveSlotManager} receiveSlotManager
-     * @param {{audio: MediaRequestManager, video: mediaRequestManagers}} mediaRequestManagers
-     * @param {Configuration} config Configuration describing what video layouts to use during the meeting
-     */
-    constructor(receiveSlotManager: ReceiveSlotManager, mediaRequestManagers: {
-        audio: MediaRequestManager;
-        video: MediaRequestManager;
-        screenShareAudio: MediaRequestManager;
-        screenShareVideo: MediaRequestManager;
-    }, config?: Configuration);
-    /**
-     * Checks if configuration is valid, throws an error if it's not
-     */
-    private checkConfigValidity;
-    /**
-     * Starts the RemoteMediaManager.
-     *
-     * @returns {Promise}
-     */
-    start(): Promise<void>;
-    /**
-     * Releases all the used resources (like allocated receive slots). This function needs
-     * to be called when we leave the meeting, etc.
-     */
-    stop(): void;
-    /**
-     * Returns the total number of main video panes required for a given layout
-     *
-     * @param {VideoLayout} layout
-     * @returns {number}
-     */
-    private getRequiredNumVideoSlotsForLayout;
-    /**
-     * Allocates the maximum number of panes that any of the configured layouts will require.
-     * We do this at the beginning, because it's more efficient (much faster) then allocating receive slots
-     * later, after the SDP exchange was done.
-     */
-    private preallocateVideoReceiveSlots;
-    /**
-     * Changes the layout (triggers Event.VideoLayoutChanged)
-     *
-     * @param {LayoutId} layoutId new layout id
-     * @returns {Promise}
-     */
-    setLayout(layoutId: LayoutId): Promise<void>;
-    /**
-     * Returns the currently selected layout id
-     *
-     * @returns {LayoutId}
-     */
-    getLayoutId(): LayoutId | undefined;
-    /**
-     * sets the preferLiveVideo
-     */
-    setPreferLiveVideo(preferLiveVideo: boolean): void;
-    /**
-     * Sets CSIs for multiple RemoteMedia instances belonging to RemoteMediaGroup.
-     * For each entry in the remoteMediaCsis array:
-     * - if csi is specified, the RemoteMedia instance is pinned to that CSI
-     * - if csi is undefined, the RemoteMedia instance is unpinned
-     */
-    setActiveSpeakerCsis(remoteMediaCsis: {
-        remoteMedia: RemoteMedia;
-        csi?: number;
-    }[]): void;
-    /**
-     * Sets which named media group need receiving
-     * @param {MediaType} mediaType of the stream
-     * @param {number} languageCode of the stream. If the languageId is 0, the named media group request will be canceled,
-     * and only receive the main audio stream.
-     * @returns {void}
-     */
-    setReceiveNamedMediaGroup(mediaType: MediaType, languageId: number): Promise<void>;
-    /**
-     * Creates the audio slots
-     */
-    private createAudioMedia;
-    /**
-     * Creates the audio slots for named media
-     */
-    private createInterpretationAudioMedia;
-    /**
-     * Creates receive slots required for receiving screen share audio and video
-     */
-    private createScreenShareReceiveSlots;
-    /**
-     * Creates RemoteMedia objects for screen share
-     */
-    private createScreenShareAudioMedia;
-    /**
-     * Goes over all receiver-selected slots and keeps only the ones that are required by a given layout,
-     * the rest are all moved to the "unused" list
-     */
-    private trimReceiverSelectedSlots;
-    /**
-     * Releases all the "unused" video slots.
-     */
-    private releaseUnusedVideoSlots;
-    /**
-     * Allocates receive slots to all active speaker video panes
-     * in the current selected layout.
-     *
-     * Allocation tries to keep the same order of the slots between the previous
-     * layout and the new one. Sorting helps making sure that highest priority slots
-     * go in the same order in the new layout.
-     */
-    private allocateSlotsToActiveSpeakerPaneGroups;
-    /**
-     * Allocates receive slots to all receiver selected video panes
-     * in the current selected layout
-     */
-    private allocateSlotsToReceiverSelectedVideoPaneGroups;
-    /**
-     * Ensures that we have enough slots for the current layout.
-     */
-    private refillRequiredSlotsIfNeeded;
-    /**
-     * Move all active speaker slots to "unused"
-     */
-    private trimActiveSpeakerSlots;
-    /**
-     * Logs the state of the receive slots
-     */
-    private logMainVideoReceiveSlots;
-    /** logs main audio slots */
-    private logMainAudioReceiveSlots;
-    /** logs slides video slots */
-    private logSlidesVideoReceiveSlots;
-    /** logs slides audio slots */
-    private logSlidesAudioReceiveSlots;
-    /** Logs all current receive slots */
-    logAllReceiveSlots(): void;
-    /**
-     * Makes sure we have the right number of receive slots created for the current layout
-     * and allocates them to the right video panes / pane groups
-     *
-     * @returns {Promise}
-     */
-    private updateVideoReceiveSlots;
-    /**
-     * Creates new RemoteMedia and RemoteMediaGroup objects for the current layout
-     * and sends the media requests for all of them.
-     */
-    private updateVideoRemoteMediaObjects;
-    /**
-     * Checks if current layout requires a screen share.
-     * If it does, it creates new RemoteMediaGroup object for screen share
-     * and sends the media requests for it.
-     * If it doesn't, it makes sure we clean up any RemoteMediaGroup objects
-     * created earlier for screen share (for previous layout).
-     */
-    private updateScreenShareVideoRemoteMediaObject;
-    /**
-     * Invalidates all remote media objects belonging to currently selected layout
-     */
-    private invalidateCurrentRemoteMedia;
-    /** emits Event.VideoLayoutChanged */
-    private emitVideoLayoutChangedEvent;
-    /**
-     * Sets a new CSI on a given remote media object
-     *
-     * @param {RemoteMedia} remoteMedia remote Media object to modify
-     * @param {CSI} csi new CSI value, can be null if we want to stop receiving media
-     */
-    setRemoteVideoCsi(remoteMedia: RemoteMedia, csi: CSI | null): void;
-    /**
-     * Adds a new member video pane to the currently selected layout.
-     *
-     * Changes to the layout are lost after a layout change.
-     *
-     * @param {MemberVideoPane} newPane
-     * @returns {Promise<RemoteMedia>}
-     */
-    addMemberVideoPane(newPane: MemberVideoPane): Promise<RemoteMedia>;
-    /**
-     * Removes a member video pane from the currently selected layout.
-     *
-     * Changes to the layout are lost after a layout change.
-     *
-     * @param {PaneId} paneId pane id of the pane to remove
-     * @returns {Promise<void>}
-     */
-    removeMemberVideoPane(paneId: PaneId): Promise<void>;
-    /**
-     * Pins an active speaker remote media object to the given CSI value. From that moment
-     * onwards the remote media will only play audio/video from that specific CSI until
-     * unpinActiveSpeakerVideoPane() is called or current layout is changed.
-     *
-     * @param {RemoteMedia} remoteMedia remote media object reference
-     * @param {CSI} csi CSI value to pin to, if undefined, then current CSI value is used
-     */
-    pinActiveSpeakerVideoPane(remoteMedia: RemoteMedia, csi?: CSI): void;
-    /**
-     * Unpins a remote media object from the fixed CSI value it was pinned to.
-     *
-     * @param {RemoteMedia} remoteMedia remote media object reference
-     */
-    unpinActiveSpeakerVideoPane(remoteMedia: RemoteMedia): void;
-    /**
-     * Returns true if a given remote media object belongs to an active speaker group and has been pinned.
-     * Throws an error if the remote media object doesn't belong to any active speaker remote media group.
-     *
-     * @param {RemoteMedia} remoteMedia remote media object
-     * @returns {boolean}
-     */
-    isPinned(remoteMedia: RemoteMedia): boolean;
-}