@webex/plugin-meetings 3.8.0 → 3.8.1-next.10

package/dist/meeting/locusMediaRequest.d.ts

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

@@ -1,178 +0,0 @@
-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?: any): 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;
-    /** 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?: any): 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

@@ -1,295 +0,0 @@
-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
-     * @param {String} options.alias
-     * @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;
-        reachability: any;
-        breakoutsSupported: boolean;
-        locale?: string;
-        deviceCapabilities?: Array<string>;
-        liveAnnotationSupported: boolean;
-        ipVersion?: IP_VERSION;
-        alias?: string;
-    }): 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
-     * @param {String} options.shareInstanceId id for current share
-     * @returns {Promise}
-     */
-    changeMeetingFloor(options: {
-        disposition: string;
-        personUrl: string;
-        deviceUrl: string;
-        resourceId: string;
-        uri: string;
-        annotationInfo: AnnotationInfo;
-        shareInstanceId: string;
-    } | 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

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

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

@@ -1,119 +0,0 @@
-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;
-    /**
-     * Returns a CA-recognized error payload for the specified raw error message/reason.
-     *
-     * New errors can be added to this function for handling in the future
-     *
-     * @param {String} reason the raw error message
-     * @returns {Array<object>} an array of payload objects
-     */
-    getChangeMeetingFloorErrorPayload: (reason: string) => {
-        fatal: boolean;
-        category: string;
-        errorCode: number;
-        errorDescription: string;
-        name: string;
-        shownToUser: boolean;
-    }[];
-};
-export default MeetingUtil;