@webex/plugin-meetings 2.60.0-next.5 → 2.60.0-next.7

package/dist/meeting/locusMediaRequest.d.ts

@@ -0,0 +1,74 @@
+import { WebexPlugin } from '@webex/webex-core';
+import { IP_VERSION } from '../constants';
+export type MediaRequestType = 'RoapMessage' | 'LocalMute';
+export type RequestResult = any;
+export type RoapRequest = {
+    type: 'RoapMessage';
+    selfUrl: string;
+    mediaId: string;
+    roapMessage: any;
+    reachability: any;
+    sequence?: any;
+    joinCookie: any;
+    ipVersion?: IP_VERSION;
+};
+export type LocalMuteRequest = {
+    type: 'LocalMute';
+    selfUrl: string;
+    mediaId: string;
+    sequence?: any;
+    muteOptions: {
+        audioMuted?: boolean;
+        videoMuted?: boolean;
+    };
+};
+export type Request = RoapRequest | LocalMuteRequest;
+export type Config = {
+    device: {
+        url: string;
+        deviceType: string;
+        countryCode?: string;
+        regionCode?: string;
+    };
+    correlationId: string;
+    preferTranscoding: boolean;
+};
+/**
+ * This class manages all /media API requests to Locus. Every call to that
+ * Locus API has to go through this class.
+ */
+export declare class LocusMediaRequest extends WebexPlugin {
+    private config;
+    private latestAudioMuted?;
+    private latestVideoMuted?;
+    private isRequestInProgress;
+    private queuedRequests;
+    private confluenceState;
+    /**
+     * Constructor
+     */
+    constructor(config: Config, options: any);
+    /**
+     * Add a request to the internal queue.
+     */
+    private addToQueue;
+    /**
+     * Takes the next request from the queue and executes it. Once that
+     * request is completed, the next one will be taken from the queue
+     * and executed and this is repeated until the queue is empty.
+     */
+    private executeNextQueuedRequest;
+    /**
+     * Returns latest requested audio and video mute values. If they have never been
+     * requested, we assume audio/video to be muted.
+     */
+    private getLatestMuteState;
+    /**
+     * Prepares the uri and body for the media request to be sent to Locus
+     */
+    private sendHttpRequest;
+    /**
+     * Sends a media request to Locus
+     */
+    send(request: Request): Promise<RequestResult>;
+}

package/dist/meeting/muteState.d.ts

@@ -0,0 +1,184 @@
+import { ServerMuteReason } from '@webex/media-helpers';
+export declare const createMuteState: (type: any, meeting: any, enabled: boolean) => MuteState;
+/** The purpose of this class is to manage the local and remote mute state and make sure that the server state always matches
+   the last requested state by the client.
+
+   More info about Locus muting API: https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html#
+
+   This class is exported only for unit tests. It should never be instantiated directly with new MuteState(), instead createMuteState() should be called
+*/
+export declare class MuteState {
+    state: {
+        client: {
+            enabled: boolean;
+            localMute: boolean;
+        };
+        server: {
+            localMute: boolean;
+            remoteMute: boolean;
+            unmuteAllowed: boolean;
+        };
+        syncToServerInProgress: boolean;
+    };
+    type: any;
+    ignoreMuteStateChange: boolean;
+    /**
+     * Constructor
+     *
+     * @param {String} type - audio or video
+     * @param {Object} meeting - the meeting object (used for reading current remote mute status)
+     * @param {boolean} enabled - whether the client audio/video is enabled at all
+     */
+    constructor(type: string, meeting: any, enabled: boolean);
+    /**
+     * Starts the mute state machine. Needs to be called after a new MuteState instance is created.
+     *
+     * @param {Object} meeting - the meeting object
+     * @returns {void}
+     */
+    init(meeting: any): void;
+    /**
+     * This method needs to be called whenever the local audio/video stream has changed.
+     * It reapplies the remote mute state onto the new stream and also reads the current
+     * local mute state from the stream and updates the internal state machine and sends
+     * any required requests to the server.
+     *
+     * @param {Object} meeting - the meeting object
+     * @returns {void}
+     */
+    handleLocalStreamChange(meeting: any): void;
+    /**
+     * Enables/disables audio/video
+     *
+     * @param {Object} meeting - the meeting object
+     * @param {boolean} enable
+     * @returns {void}
+     */
+    enable(meeting: any, enable: boolean): void;
+    /**
+     * Mutes/unmutes local stream
+     *
+     * @param {Object} meeting - the meeting object
+     * @param {Boolean} mute - true to mute the stream, false to unmute it
+     * @param {ServerMuteReason} reason - reason for muting/unmuting
+     * @returns {void}
+     */
+    private muteLocalStream;
+    /**
+     * This method should be called when the local stream mute state is changed
+     * @public
+     * @memberof MuteState
+     * @param {Object} [meeting] the meeting object
+     * @param {Boolean} [mute] true for muting, false for unmuting request
+     * @returns {void}
+     */
+    handleLocalStreamMuteStateChange(meeting?: object, mute?: boolean): void;
+    /**
+     * Applies the current mute state to the local stream (by enabling or disabling it accordingly)
+     *
+     * @public
+     * @param {Object} [meeting] the meeting object
+     * @param {ServerMuteReason} reason - reason why we're applying our client state to the local stream
+     * @memberof MuteState
+     * @returns {void}
+     */
+    applyClientStateLocally(meeting?: any, reason?: ServerMuteReason): void;
+    /** Returns true if client is locally muted - it takes into account not just the client local mute state,
+     *  but also whether audio/video is enabled at all
+     *
+     * @returns {boolean}
+     */
+    private getClientLocalMuteState;
+    /**
+     * Updates the server local and remote mute values so that they match the current client desired state.
+     *
+     * @private
+     * @param {Object} [meeting] the meeting object
+     * @memberof MuteState
+     * @returns {void}
+     */
+    private applyClientStateToServer;
+    /**
+     * Sets the local mute value in the server
+     *
+     * @private
+     * @param {Object} [meeting] the meeting object
+     * @memberof MuteState
+     * @returns {Promise}
+     */
+    private sendLocalMuteRequestToServer;
+    /**
+     * Sets the remote mute value in the server
+     *
+     * @private
+     * @param {Object} [meeting] the meeting object
+     * @memberof MuteState
+     * @returns {Promise}
+     */
+    private sendRemoteMuteRequestToServer;
+    /** Sets the mute state of the local stream according to what server thinks is our state
+     * @param {Object} meeting - the meeting object
+     * @param {ServerMuteReason} serverMuteReason - reason why we're applying server mute to the local stream
+     * @returns {void}
+     */
+    private applyServerMuteToLocalStream;
+    /** Applies the current value for unmute allowed to the underlying stream
+     *
+     * @param {Meeting} meeting
+     * @returns {void}
+     */
+    private applyUnmuteAllowedToStream;
+    /**
+     * This method should be called whenever the server remote mute state is changed
+     *
+     * @public
+     * @memberof MuteState
+     * @param {Meeting} meeting
+     * @param {Boolean} [muted] true if user is remotely muted, false otherwise
+     * @param {Boolean} [unmuteAllowed] indicates if user is allowed to unmute self (false when "hard mute" feature is used)
+     * @returns {undefined}
+     */
+    handleServerRemoteMuteUpdate(meeting: any, muted?: boolean, unmuteAllowed?: boolean): void;
+    /**
+     * This method should be called whenever we receive from the server a requirement to locally unmute
+     *
+     * @public
+     * @memberof MuteState
+     * @param {Object} [meeting] the meeting object
+     * @returns {undefined}
+     */
+    handleServerLocalUnmuteRequired(meeting?: object): void;
+    /**
+     * Returns true if the user is locally or remotely muted.
+     * It only checks the mute status, ignoring the fact whether audio/video is enabled.
+     *
+     * @public
+     * @memberof MuteState
+     * @returns {Boolean}
+     */
+    isMuted(): boolean;
+    /**
+     * Returns true if the user is remotely muted
+     *
+     * @public
+     * @memberof MuteState
+     * @returns {Boolean}
+     */
+    isRemotelyMuted(): boolean;
+    /**
+     * Returns true if unmute is allowed
+     *
+     * @public
+     * @memberof MuteState
+     * @returns {Boolean}
+     */
+    isUnmuteAllowed(): boolean;
+    /**
+     * Returns true if the user is locally muted or audio/video is disabled
+     *
+     * @public
+     * @memberof MuteState
+     * @returns {Boolean}
+     */
+    isLocallyMuted(): boolean;
+}

package/dist/meeting/request.d.ts

@@ -0,0 +1,290 @@
+import { StatelessWebexPlugin } from '@webex/webex-core';
+import { IP_VERSION } from '../constants';
+import { SendReactionOptions, ToggleReactionsOptions } from './request.type';
+import { AnnotationInfo } from '../annotation/annotation.types';
+/**
+ * @class MeetingRequest
+ */
+export default class MeetingRequest extends StatelessWebexPlugin {
+    changeVideoLayoutDebounced: any;
+    meetingRef: WeakRef<any>;
+    locusDeltaRequest: (options: object) => Promise<any>;
+    buildLocusDeltaRequestOptions: (options: object) => Promise<any>;
+    /**
+     * Constructor
+     * @param {Object} attrs
+     * @param {Object} options
+     */
+    constructor(attrs: any, options: any);
+    /**
+     * Returns joinCookie from boundedStorage if present.
+     * @returns {Object} joinCookie
+     */
+    private getJoinCookie;
+    /**
+     * Make a network request to join a meeting
+     * @param {Object} options
+     * @param {String} options.sipUri
+     * @param {String} options.deviceUrl
+     * @param {String} options.locusUrl
+     * @param {String} options.resourceId,
+     * @param {String} options.correlationId
+     * @param {boolean} options.ensureConversation
+     * @param {boolean} options.moderator
+     * @param {boolean} options.pin
+     * @param {boolean} options.moveToResource
+     * @param {Object} options.roapMessage
+     * @param {boolean} options.breakoutsSupported
+     * @param {String} options.locale,
+     * @param {Array} options.deviceCapabilities
+     * @param {boolean} options.liveAnnotationSupported
+     * @returns {Promise}
+     */
+    joinMeeting(options: {
+        sipUri: string;
+        deviceUrl: string;
+        locusUrl: string;
+        locusClusterUrl: string;
+        resourceId: string;
+        correlationId: string;
+        ensureConversation: boolean;
+        moderator: boolean;
+        pin: boolean;
+        moveToResource: boolean;
+        roapMessage: any;
+        asResourceOccupant: any;
+        inviteeAddress: any;
+        meetingNumber: any;
+        permissionToken: any;
+        preferTranscoding: any;
+        breakoutsSupported: boolean;
+        locale?: string;
+        deviceCapabilities?: Array<string>;
+        liveAnnotationSupported: boolean;
+        ipVersion?: IP_VERSION;
+    }): Promise<any>;
+    /**
+     * Send a request to refresh the captcha
+     * @param {Object} options
+     * @param {String} options.captchaRefreshUrl
+     * @param {String} options.captchaId
+     * @returns {Promise}
+     * @private
+     */
+    private refreshCaptcha;
+    /**
+     * Make a network request to add a dial in device
+     * @param {Object} options
+     * @param {String} options.correlationId
+     * @param {String} options.locusUrl url for the meeting
+     * @param {String} options.dialInUrl identifier for the to-be provisioned device
+     * @param {String} options.clientUrl identifier for the web device
+     * @returns {Promise}
+     * @private
+     */
+    private dialIn;
+    /**
+     * Make a network request to add a dial out device
+     * @param {Object} options
+     * @param {String} options.correlationId
+     * @param {String} options.locusUrl url for the meeting
+     * @param {String} options.dialOutUrl identifier for the to-be provisioned device
+     * @param {String} options.phoneNumber phone number to dial out to
+     * @param {String} options.clientUrl identifier for the web device
+     * @returns {Promise}
+     * @private
+     */
+    private dialOut;
+    /**
+     * Sends a requests to get the latest locus DTO, it might be a full Locus or a delta, depending on the url provided
+     * @param {Object} options
+     * @param {String} options.locusUrl sync url to get ht elatest locus delta
+     * @returns {Promise}
+     */
+    getLocusDTO(options: {
+        url: string;
+    }): any;
+    /**
+     * Make a network request to make a provisioned phone leave the meeting
+     * @param {Object} options
+     * @param {String} options.locusUrl
+     * @param {String} options.phoneUrl
+     * @param {String} options.correlationId
+     * @param {String} options.selfId
+     * @returns {Promise}
+     * @private
+     */
+    private disconnectPhoneAudio;
+    /**
+     * Prepares request options to to leave a meeting
+     * @param {Object} options
+     * @param {Url} options.locusUrl
+     * @param {String} options.selfId
+     * @param {Url} options.deviceUrl
+     * @param {String} options.resourceId,
+     * @param {String} options.correlationId
+     * @returns {Object} request options
+     */
+    prepareLeaveMeetingRequestOptions({ locusUrl, selfId, deviceUrl: url, resourceId, correlationId, }: {
+        locusUrl: string;
+        selfId: string;
+        deviceUrl: string;
+        resourceId: string;
+        correlationId: string;
+    }): {
+        method: string;
+        uri: string;
+        body: {
+            device: {
+                deviceType: any;
+                url: string;
+            };
+            usingResource: string;
+            correlationId: string;
+        };
+    };
+    /**
+     * Make a network request to leave a meeting
+     * @param {Object} options
+     * @returns {Promise}
+     */
+    leaveMeeting({ locusUrl, selfId, deviceUrl: url, resourceId, correlationId, }: {
+        locusUrl: string;
+        selfId: string;
+        deviceUrl: string;
+        resourceId: string;
+        correlationId: string;
+    }): Promise<any>;
+    /**
+     * Builds request options to leave a meeting
+     * @param {Object} options
+     * @returns {Object} request options
+     */
+    buildLeaveMeetingRequestOptions(options: any): Promise<any>;
+    /**
+     * Make a network request to acknowledge a meeting
+     * @param {Object} options
+     * @param {String} options.locusUrl
+     * @param {String} options.deviceUrl
+     * @param {String} options.correlationId
+     * @returns {Promise}
+     */
+    acknowledgeMeeting(options: {
+        locusUrl: string;
+        deviceUrl: string;
+        correlationId: string;
+    }): Promise<any>;
+    /**
+     * Makes a network request to lock the meeting
+     * @param {Object} options
+     * @param {Boolean} options.lock Whether it is locked or not
+     * @returns {Promise}
+     */
+    lockMeeting(options: any): Promise<any>;
+    /**
+     * Make a network request to decline a meeting
+     * @param {Object} options
+     * @param {String} options.locusUrl
+     * @param {String} options.deviceUrl
+     * @param {String} options.reason
+     * @returns {Promise}
+     */
+    declineMeeting(options: {
+        locusUrl: string;
+        deviceUrl: string;
+        reason: string;
+    }): Promise<any>;
+    /**
+     * change the content floor grant
+     * @param {Object} options options for floor grant
+     * @param {String} options.disposition floor action (granted/released)
+     * @param {String} options.personUrl personUrl who is requesting floor
+     * @param {String} options.deviceUrl Url of a device
+     * @param {String} options.resourceId Populated if you are paired to a device
+     * @param {String} options.uri floor grant uri
+     * @returns {Promise}
+     */
+    changeMeetingFloor(options: {
+        disposition: string;
+        personUrl: string;
+        deviceUrl: string;
+        resourceId: string;
+        uri: string;
+        annotationInfo: AnnotationInfo;
+    } | any): any;
+    /**
+     * Sends a request to the DTMF endpoint to send tones
+     * @param {Object} options
+     * @param {String} options.locusUrl
+     * @param {String} options.deviceUrl
+     * @param {String} options.tones a string of one or more DTMF tones to send
+     * @returns {Promise}
+     */
+    sendDTMF({ locusUrl, deviceUrl, tones }: {
+        locusUrl: string;
+        deviceUrl: string;
+        tones: string;
+    }): Promise<any>;
+    /**
+     * Sends a request to the controls endpoint to set the video layout
+     * @param {Object} options
+     * @param {String} options.locusUrl
+     * @param {String} options.deviceUrl
+     * @param {String} options.layoutType a layout type that should be available in meeting constants {@link #layout_types}
+     * @param {Object} options.main preferred dimensions for the remote main video stream
+     * @param {Number} options.main.width preferred width of main video stream
+     * @param {Number} options.main.height preferred height of main video stream
+     * @param {Object} options.content preferred dimensions for the remote content share stream
+     * @param {Number} options.content.width preferred width of content share stream
+     * @param {Number} options.content.height preferred height of content share stream
+     * @returns {Promise}
+     */
+    changeVideoLayout({ locusUrl, deviceUrl, layoutType, main, content, }: {
+        locusUrl: string;
+        deviceUrl: string;
+        layoutType: string;
+        main: {
+            width: number;
+            height: number;
+        };
+        content: {
+            width: number;
+            height: number;
+        };
+    }): Promise<any>;
+    /**
+     * Make a network request to end meeting for all
+     * @param {Object} options
+     * @param {Url} options.locusUrl
+     * @returns {Promise}
+     */
+    endMeetingForAll({ locusUrl }: {
+        locusUrl: string;
+    }): Promise<any>;
+    /**
+     * Send a locus keepAlive (used in lobby)
+     * @param {Object} options
+     * @param {Url} options.keepAliveUrl
+     * @returns {Promise}
+     */
+    keepAlive({ keepAliveUrl }: {
+        keepAliveUrl: string;
+    }): any;
+    /**
+     * Make a network request to send a reaction.
+     * @param {Object} options
+     * @param {Url} options.reactionChannelUrl
+     * @param {Reaction} options.reaction
+     * @param {string} options.senderID
+     * @returns {Promise}
+     */
+    sendReaction({ reactionChannelUrl, reaction, participantId }: SendReactionOptions): any;
+    /**
+     * Make a network request to enable or disable reactions.
+     * @param {boolean} options.enable - determines if we need to enable or disable.
+     * @param {locusUrl} options.locusUrl
+     * @returns {Promise}
+     */
+    toggleReactions({ enable, locusUrl, requestingParticipantId }: ToggleReactionsOptions): Promise<any>;
+    getLocusStatusByUrl(locusUrl: string): any;
+}

package/dist/meeting/request.type.d.ts

@@ -0,0 +1,11 @@
+import { Reaction } from '../reactions/reactions.type';
+export type SendReactionOptions = {
+    reactionChannelUrl: string;
+    reaction: Reaction;
+    participantId: string;
+};
+export type ToggleReactionsOptions = {
+    enable: boolean;
+    locusUrl: string;
+    requestingParticipantId: string;
+};

package/dist/meeting/state.d.ts

@@ -0,0 +1,9 @@
+declare const MeetingStateMachine: {
+    /**
+     * Initializes the StateMachine for the meeting
+     * @param {Meeting} meetingRef A reference to a meeting instance
+     * @returns {StateMachine}
+     */
+    create(meetingRef: any): any;
+};
+export default MeetingStateMachine;

package/dist/meeting/util.d.ts

@@ -0,0 +1,103 @@
+import { LocalCameraStream, LocalMicrophoneStream } from '@webex/media-helpers';
+import { SELF_POLICY, IP_VERSION } from '../constants';
+declare const MeetingUtil: {
+    parseLocusJoin: (response: any) => any;
+    remoteUpdateAudioVideo: (meeting: any, audioMuted?: boolean, videoMuted?: boolean) => any;
+    hasOwner: (info: any) => any;
+    isOwnerSelf: (owner: any, selfId: any) => boolean;
+    isPinOrGuest: (err: any) => boolean;
+    /**
+     * Returns the current state of knowledge about whether we are on an ipv4-only or ipv6-only or mixed (ipv4 and ipv6) network.
+     * The return value matches the possible values of "ipver" parameter used by the backend APIs.
+     *
+     * @param {Object} webex webex instance
+     * @returns {IP_VERSION|undefined} ipver value to be passed to the backend APIs or undefined if we should not pass any value to the backend
+     */
+    getIpVersion(webex: any): IP_VERSION | undefined;
+    joinMeeting: (meeting: any, options: any) => any;
+    cleanUp: (meeting: any) => any;
+    disconnectPhoneAudio: (meeting: any, phoneUrl: any) => any;
+    /**
+     * Returns options for leaving a meeting.
+     * @param {any} meeting
+     * @param {any} options
+     * @returns {any} leave options
+     */
+    prepareLeaveMeetingOptions: (meeting: any, options?: any) => any;
+    leaveMeeting: (meeting: any, options?: any) => any;
+    declineMeeting: (meeting: any, reason: any) => any;
+    isUserInLeftState: (locusInfo: any) => boolean;
+    isUserInIdleState: (locusInfo: any) => boolean;
+    isUserInJoinedState: (locusInfo: any) => boolean;
+    isMediaEstablished: (currentMediaStatus: any) => any;
+    joinMeetingOptions: (meeting: any, options?: any) => any;
+    /**
+     * Returns request options for leaving a meeting.
+     * @param {any} meeting
+     * @param {any} options
+     * @returns {any} request options
+     */
+    buildLeaveFetchRequestOptions: (meeting: any, options?: any) => any;
+    getTrack: (stream: any) => {
+        audioTrack: any;
+        videoTrack: any;
+    };
+    getModeratorFromLocusInfo: (locusInfo: any) => any;
+    getPolicyFromLocusInfo: (locusInfo: any) => any;
+    getUserDisplayHintsFromLocusInfo: (locusInfo: any) => any;
+    canInviteNewParticipants: (displayHints: any) => any;
+    canAdmitParticipant: (displayHints: any) => any;
+    canUserLock: (displayHints: any) => any;
+    canUserUnlock: (displayHints: any) => any;
+    canUserRaiseHand: (displayHints: any) => any;
+    canUserLowerAllHands: (displayHints: any) => any;
+    canUserLowerSomeoneElsesHand: (displayHints: any) => any;
+    bothLeaveAndEndMeetingAvailable: (displayHints: any) => any;
+    canManageBreakout: (displayHints: any) => any;
+    canBroadcastMessageToBreakout: (displayHints: any, policies?: {}) => boolean;
+    isSuppressBreakoutSupport: (displayHints: any) => any;
+    canAdmitLobbyToBreakout: (displayHints: any) => boolean;
+    isBreakoutPreassignmentsEnabled: (displayHints: any) => boolean;
+    canUserAskForHelp: (displayHints: any) => boolean;
+    lockMeeting: (actions: any, request: any, locusUrl: any) => any;
+    unlockMeeting: (actions: any, request: any, locusUrl: any) => any;
+    handleAudioLogging: (audioStream?: LocalMicrophoneStream) => void;
+    handleVideoLogging: (videoStream?: LocalCameraStream) => void;
+    handleDeviceLogging: (devices?: any[]) => void;
+    endMeetingForAll: (meeting: any) => any;
+    canEnableClosedCaption: (displayHints: any) => any;
+    isSaveTranscriptsEnabled: (displayHints: any) => any;
+    canStartTranscribing: (displayHints: any) => any;
+    canStopTranscribing: (displayHints: any) => any;
+    isClosedCaptionActive: (displayHints: any) => any;
+    isWebexAssistantActive: (displayHints: any) => any;
+    canViewCaptionPanel: (displayHints: any) => any;
+    isRealTimeTranslationEnabled: (displayHints: any) => any;
+    canSelectSpokenLanguages: (displayHints: any) => any;
+    waitingForOthersToJoin: (displayHints: any) => any;
+    canSendReactions: (originalValue: any, displayHints: any) => any;
+    canUserRenameSelfAndObserved: (displayHints: any) => any;
+    canUserRenameOthers: (displayHints: any) => any;
+    canShareWhiteBoard: (displayHints: any) => any;
+    /**
+     * Adds the current locus sequence information to a request body
+     * @param {Object} meeting The meeting object
+     * @param {Object} requestBody The body of a request to locus
+     * @returns {void}
+     */
+    addSequence: (meeting: any, requestBody: any) => void;
+    /**
+     * Updates the locus info for the meeting with the delta locus
+     * returned from requests that include the sequence information
+     * Returns the original response object
+     * @param {Object} meeting The meeting object
+     * @param {Object} response The response of the http request
+     * @returns {Object}
+     */
+    updateLocusWithDelta: (meeting: any, response: any) => any;
+    generateBuildLocusDeltaRequestOptions: (originalMeeting: any) => (originalOptions: any) => any;
+    generateLocusDeltaRequest: (originalMeeting: any) => (originalOptions: any) => any;
+    selfSupportsFeature: (feature: SELF_POLICY, userPolicies: Record<SELF_POLICY, boolean>) => boolean;
+    parseInterpretationInfo: (meeting: any, meetingInfo: any) => void;
+};
+export default MeetingUtil;

package/dist/meeting-info/collection.d.ts

@@ -0,0 +1,20 @@
+import Collection from '../common/collection';
+/**
+ * @class MeetingInfoCollection
+ */
+export default class MeetingInfoCollection extends Collection {
+    namespace: string;
+    /**
+     * @memberof MeetingInfoCollection
+     * @constructor
+     * @public
+     */
+    constructor();
+    /**
+     * @param {String} id ID of the meeting info you wish to retreive
+     * @returns {MeetingInfo} returns a meeting info instance
+     * @public
+     * @memberof MeetingInfoCollection
+     */
+    get(id: string): any;
+}