@webex/plugin-meetings 3.8.1 → 3.9.0-multiple-llm.1

package/test/unit/spec/multistream/mediaRequestManager.ts

@@ -3,7 +3,7 @@ import {MediaRequestManager} from '@webex/plugin-meetings/src/multistream/mediaR
 import {ReceiveSlot} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
-import {getMaxFs} from '@webex/plugin-meetings/src/multistream/remoteMedia';
+import {getMaxFs, MAX_FS_VALUES} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import FakeTimers from '@sinonjs/fake-timers';
 import * as InternalMediaCoreModule from '@webex/internal-media-core';
 import { expect } from 'chai';
@@ -36,12 +36,15 @@ describe('MediaRequestManager', () => {
   const CROSS_POLICY_DUPLICATION = true;
   const MAX_FPS = 3000;
   const MAX_FS_360p = 920;
+  const MAX_FS_540p = 2040;
   const MAX_FS_720p = 3600;
   const MAX_FS_1080p = 8192;
   const MAX_MBPS_360p = 27600;
+  const MAX_MBPS_540p = 61200;
   const MAX_MBPS_720p = 108000;
   const MAX_MBPS_1080p = 245760;
   const MAX_PAYLOADBITSPS_360p = 640000;
+  const MAX_PAYLOADBITSPS_540p = 880000;
   const MAX_PAYLOADBITSPS_720p = 2500000;
   const MAX_PAYLOADBITSPS_1080p = 4000000;
 
@@ -82,7 +85,14 @@ describe('MediaRequestManager', () => {
   });
 
   // helper function for adding an active speaker request
-  const addActiveSpeakerRequest = (priority, receiveSlots, maxFs, commit = false, preferLiveVideo = true, namedMediaGroups = undefined) =>
+  const addActiveSpeakerRequest = (
+    priority,
+    receiveSlots,
+    maxFs,
+    commit = false,
+    preferLiveVideo = true,
+    namedMediaGroups = undefined
+  ) =>
     mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -216,6 +226,9 @@ describe('MediaRequestManager', () => {
       },
       false
     );
+
+
+
     mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -892,15 +905,15 @@ describe('MediaRequestManager', () => {
     // request 10 "large" 1080p streams
     addActiveSpeakerRequest(255, fakeReceiveSlots.slice(0, 10), getMaxFs('large'), true);
 
-    // check that resulting requests are 10 "small" 360p streams
+    // check that resulting requests are 10 540p streams
     checkMediaRequestsSent([
       {
         policy: 'active-speaker',
         priority: 255,
         receiveSlots: fakeWcmeSlots.slice(0, 10),
-        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_360p,
-        maxFs: getMaxFs('small'),
-        maxMbps: MAX_MBPS_360p,
+        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_540p,
+        maxFs:  MAX_FS_VALUES['540p'],
+        maxMbps: MAX_MBPS_540p,
       },
     ]);
   });

package/test/unit/spec/multistream/remoteMedia.ts

@@ -3,7 +3,7 @@ import 'jsdom-global/register';
 import EventEmitter from 'events';
 
 import {MediaType} from '@webex/internal-media-core';
-import {RemoteMedia, RemoteMediaEvents} from '@webex/plugin-meetings/src/multistream/remoteMedia';
+import {RemoteMedia, RemoteMediaEvents, RemoteVideoResolution} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import {ReceiveSlotEvents} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
@@ -257,7 +257,9 @@ describe('RemoteMedia', () => {
         {height: 198, fs: 920}, // 360p
         {height: 360, fs: 920},
         {height: 395, fs: 920},
-        {height: 396, fs: 3600}, // 720p
+        {height: 396, fs: 2040}, // 540p
+        {height: 540, fs: 2040},
+        {height: 610, fs: 3600}, // 720p
         {height: 720, fs: 3600},
         {height: 721, fs: 8192}, // 1080p
         {height: 1080, fs: 8192},
@@ -271,4 +273,66 @@ describe('RemoteMedia', () => {
       }
     );
   });
+
+  describe('getEffectiveMaxFs()', () => {
+    it('returns maxFrameSize when it is greater than 0', () => {
+      remoteMedia.setSizeHint(960, 540);
+
+      const result = remoteMedia.getEffectiveMaxFs();
+
+      assert.strictEqual(result, 2040);
+    });
+
+    it('returns getMaxFs result when maxFrameSize is 0 and resolution is provided', () => {
+      remoteMedia.setSizeHint(0, 0);
+
+      // remoteMedia was created with {resolution: 'medium'} in beforeEach
+
+      const result = remoteMedia.getEffectiveMaxFs();
+      
+      // 'medium' resolution should map to 720p which is 3600
+      assert.strictEqual(result, 3600);
+    });
+
+    it('returns undefined when maxFrameSize is 0 and no resolution is provided', () => {
+      remoteMedia.setSizeHint(0, 0);
+
+      // Create a new RemoteMedia without resolution option
+      const remoteMediaWithoutResolution = new RemoteMedia(fakeReceiveSlot, fakeMediaRequestManager);
+      
+      const result = remoteMediaWithoutResolution.getEffectiveMaxFs();
+      
+      assert.strictEqual(result, undefined);
+    });
+
+    it('prioritizes maxFrameSize over resolution option', () => {
+      remoteMedia.setSizeHint(640, 360);
+      // remoteMedia was created with {resolution: 'medium'} in beforeEach
+
+      const result = remoteMedia.getEffectiveMaxFs();
+      
+      // Should return maxFrameSize (500) instead of resolution-based value (3600)
+      assert.strictEqual(result, 920);
+    });
+
+    it('works correctly with different resolution options', () => {
+      const testCases: Array<{ resolution: RemoteVideoResolution; expected: number }> = [
+        { resolution: 'thumbnail', expected: 60 },
+        { resolution: 'very small', expected: 240 },
+        { resolution: 'small', expected: 920 },
+        { resolution: 'medium', expected: 3600 },
+        { resolution: 'large', expected: 8192 },
+        { resolution: 'best', expected: 8192 },
+      ];
+
+      testCases.forEach(({ resolution, expected }) => {
+        const testRemoteMedia = new RemoteMedia(fakeReceiveSlot, fakeMediaRequestManager, { resolution });
+        testRemoteMedia.setSizeHint(0, 0); // Ensure maxFrameSize doesn't interfere
+
+        const result = testRemoteMedia.getEffectiveMaxFs();
+        
+        assert.strictEqual(result, expected, `Failed for resolution: ${resolution}`);
+      });
+    });
+  });
 });

package/test/unit/spec/multistream/sendSlotManager.ts

@@ -272,4 +272,63 @@ describe('SendSlotsManager', () => {
             expect(() => sendSlotsManager.getSlot(MediaType.VideoSlides)).to.throw();
         });
     });
+
+    describe('sourceStateOverride', () => {
+      let mediaConnection: MultistreamRoapMediaConnection;
+      beforeEach(() => {
+        mediaConnection = {
+          createSendSlot: sinon.stub().returns({
+            setSourceStateOverride: sinon.stub().resolves(),
+            clearSourceStateOverride: sinon.stub().resolves(),
+          }),
+        } as MultistreamRoapMediaConnection;
+      });
+
+      it(`can set source state override for ${MediaType.VideoMain}`, () => {
+        const slot: any = sendSlotsManager.createSlot(mediaConnection, MediaType.VideoMain);
+
+        const set = () => sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+
+        expect(set).not.to.throw();
+        expect(slot.setSourceStateOverride.calledWith('away')).to.be.true;
+      });
+
+      [MediaType.VideoSlides, MediaType.AudioMain, MediaType.AudioSlides].forEach((mediaType) => {
+        it(`can't set source state override for ${mediaType}`, () => {
+          const slot: any = sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+          const set = () => sendSlotsManager.setSourceStateOverride(mediaType, 'away');
+
+          expect(set).to.throw();
+          expect(slot.setSourceStateOverride.called).to.be.false;
+        });
+      });
+
+      it("can't set source state override for non-existing slot", () => {
+        const set = () => sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+        expect(set).to.throw(`Slot for ${MediaType.VideoMain} does not exist`);
+      });
+
+      it('can clear source state override', () => {
+        const slot: any = sendSlotsManager.createSlot(mediaConnection, MediaType.VideoMain);
+        sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+
+        expect(slot.setSourceStateOverride.calledWith('away')).to.be.true;
+        expect(slot.clearSourceStateOverride.called).to.be.false;
+
+        sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, null);
+        expect(slot.clearSourceStateOverride.called).to.be.true;
+      });
+
+      it("won't set source state override if it didn't change", () => {
+        const slot: any = sendSlotsManager.createSlot(mediaConnection, MediaType.VideoMain);
+        sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+
+        expect(slot.setSourceStateOverride.calledWith('away')).to.be.true;
+        slot.setSourceStateOverride.resetHistory();
+
+        sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+        expect(slot.setSourceStateOverride.called).to.be.false;
+      });
+    });
 });

package/test/unit/spec/reachability/index.ts

@@ -3,15 +3,14 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 import EventEmitter from 'events';
 import testUtils from '../../../utils/testUtils';
-import Reachability, {
-  ReachabilityResultsForBackend,
-} from '@webex/plugin-meetings/src/reachability/';
+import Reachability from '@webex/plugin-meetings/src/reachability/';
 import {ClusterNode} from '../../../../src/reachability/request';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import * as ClusterReachabilityModule from '@webex/plugin-meetings/src/reachability/clusterReachability';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
+import { ReachabilityResultsForBackend } from '@webex/plugin-meetings/src/reachability/reachability.types';
 
 describe('isAnyPublicClusterReachable', () => {
   let webex;
@@ -836,6 +835,162 @@ describe('gatherReachability', () => {
       },
     },
     // ========================================================================
+    {
+      title: '2 clusters: one with multiple urls, reachability should resolve after the first result for each protocol is ready',
+      waitShortTimeout: false,
+      waitLongTimeout: false,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1-1', 'udp-url1-2'],
+          tcp: ['tcp-url1-1', 'tcp-url1-2'],
+          xtls: ['xtls-url1-1', 'xtls-url1-2'],
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: ['udp-url2'],
+          tcp: ['tcp-url2'],
+          xtls: ['xtls-url2'],
+          isVideoMesh: false,
+        },
+      },
+      mockResultReadyEvents: [
+        // results are only for the first url for each protocol not the 2nd one
+        {
+          clusterId: 'cluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 10,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 100,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 200,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 20,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 110,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 220,
+          },
+        },
+      ],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 10},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100},
+          xtls: {result: 'reachable', latencyInMilliseconds: 200},
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 20},
+          tcp: {result: 'reachable', latencyInMilliseconds: 110},
+          xtls: {result: 'reachable', latencyInMilliseconds: 220},
+          isVideoMesh: false,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 10,
+        public_udp_max: 20,
+        public_udp_average: 15,
+        public_tcp_min: 100,
+        public_tcp_max: 110,
+        public_tcp_average: 105,
+        public_xtls_min: 200,
+        public_xtls_max: 220,
+        public_xtls_average: 210,
+      },
+    },
+    // ========================================================================
+    {
+      title: '1 cluster with zero urls for TCP, reachability should resolve after the first result for each protocol is ready without waiting for TCP',
+      waitShortTimeout: false,
+      waitLongTimeout: false,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1'],
+          tcp: [],
+          xtls: ['xtls-url1'],
+          isVideoMesh: false,
+        },
+      },
+      mockResultReadyEvents: [
+        {
+          clusterId: 'cluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 10,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 200,
+          },
+        },
+      ],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 10},
+          tcp: {result: 'untested'},
+          xtls: {result: 'reachable', latencyInMilliseconds: 200},
+          isVideoMesh: false,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 10,
+        public_udp_max: 10,
+        public_udp_average: 10,
+        public_tcp_min: -1,
+        public_tcp_max: -1,
+        public_tcp_average: -1,
+        public_xtls_min: 200,
+        public_xtls_max: 200,
+        public_xtls_average: 200,
+      },
+    },
+    // ========================================================================
     {
       title: '2 clusters: both with no results at all',
       waitShortTimeout: 'public',
@@ -2764,14 +2919,10 @@ describe('isSubnetReachable', () => {
   });
 
   it('returns true if the subnet is reachable', () => {
-    assert(reachability.isSubnetReachable('1.2.3.4'));
+    assert(reachability.isSubnetReachable('1'));
   });
 
   it(`returns false if the subnet is unreachable`, () => {
-    assert(!reachability.isSubnetReachable('11.2.3.4'));
-  });
-
-  it('returns null if the subnet is not provided', () => {
-    assert.isNull(reachability.isSubnetReachable(undefined));
+    assert(!reachability.isSubnetReachable('11'));
   });
 });

package/test/unit/spec/roap/turnDiscovery.ts

@@ -321,7 +321,7 @@ describe('TurnDiscovery', () => {
             result,
             undefined,
             undefined,
-            'failure: Unexpected token o in JSON at position 1'
+            `failure: Unexpected token 'o', "not a json" is not valid JSON`
           );
           checkFailureMetricsSent();
         });
@@ -568,7 +568,7 @@ describe('TurnDiscovery', () => {
       // @ts-ignore
       mockRoapRequest.sendRoap.resetHistory();
 
-      // simulate the response with some empty urls, normally there would be just 1, but we put more just for the sake of testing 
+      // simulate the response with some empty urls, normally there would be just 1, but we put more just for the sake of testing
       td.handleTurnDiscoveryResponse(
         {
           messageType: 'TURN_DISCOVERY_RESPONSE',
@@ -960,7 +960,7 @@ describe('TurnDiscovery', () => {
 
       assert.deepEqual(result, {
         turnServerInfo: undefined,
-        turnDiscoverySkippedReason: 'failure: Unexpected token o in JSON at position 1',
+        turnDiscoverySkippedReason: `failure: Unexpected token 'o', "not a json" is not valid JSON`,
       });
     });
 

package/dist/annotation/annotation.types.d.ts

@@ -1,42 +0,0 @@
-import { ANNOTATION_POLICY } from './constants';
-/**
- * Type for an StrokeData Object
- */
-type StrokeData = {
-    deviceId: string;
-    toUserId: string;
-    requesterId: string;
-    content: string;
-    shareInstanceId: string;
-    encryptionKeyUrl: string;
-    version: string;
-};
-type RequestData = {
-    toUserId: string;
-    toDeviceUrl: string;
-    shareInstanceId: string;
-};
-type CommandRequestBody = {
-    actionType: string;
-    resourceType: string;
-    shareInstanceId: string;
-    receivers?: any[];
-};
-/**
- * Type for an annotation Object include annotation version and privilege
- */
-type AnnotationInfo = {
-    version: string;
-    policy: ANNOTATION_POLICY;
-};
-interface IAnnotationChannel {
-    acceptRequest: (approval: any) => undefined | Promise<void>;
-    declineRequest: (approval: any) => undefined | Promise<void>;
-    closeAnnotation: (requestData: RequestData) => undefined | Promise<void>;
-    approveAnnotation: (requestData: RequestData) => undefined | Promise<void>;
-    cancelApproveAnnotation: (requestData: RequestData, approval: any) => undefined | Promise<void>;
-    sendStrokeData: (strokeData: StrokeData) => void;
-    approvalUrlUpdate: (approvalUrl: string) => void;
-    locusUrlUpdate: (locusUrl: string) => void;
-}
-export type { StrokeData, RequestData, CommandRequestBody, IAnnotationChannel, AnnotationInfo };

package/dist/annotation/constants.d.ts

@@ -1,31 +0,0 @@
-export declare const EVENT_TRIGGERS: {
-    ANNOTATION_STROKE_DATA: string;
-    ANNOTATION_COMMAND: string;
-};
-export declare const ANNOTATION_RESOURCE_TYPE = "AnnotationOnShare";
-export declare const ANNOTATION_RELAY_TYPES: {
-    ANNOTATION_CLIENT: string;
-};
-export declare const ANNOTATION_STATUS: {
-    NO_ANNOTATION: string;
-    RUNNING_ANNOTATION: string;
-};
-export declare enum ANNOTATION_POLICY {
-    ANYONE_CAN_ANNOTATE = "AnyoneCanAnnotate",
-    APPROVAL = "Approval",
-    ANNOTATION_NOT_ALLOWED = "AnnotationNotAllowed"
-}
-export declare const ANNOTATION_REQUEST_TYPE: {
-    ANNOTATION_MESSAGE: string;
-};
-export declare const enum ANNOTATION_ACTION_TYPE {
-    REQUESTED = "REQUESTED",
-    ACCEPTED = "ACCEPTED",
-    DECLINED = "DECLINED",
-    OFFERED = "OFFERED",
-    CANCELED = "CANCELED",
-    EXPIRED = "EXPIRED",
-    REVOKED = "REVOKED",
-    CLOSED = "CLOSED"
-}
-export declare const ANNOTATION = "annotation";

package/dist/annotation/index.d.ts

@@ -1,117 +0,0 @@
-import { WebexPlugin } from '@webex/webex-core';
-import { StrokeData, RequestData, IAnnotationChannel } from './annotation.types';
-/**
- * @description Annotation to handle LLM and Mercury message and locus API
- * @class
- */
-declare class AnnotationChannel extends WebexPlugin implements IAnnotationChannel {
-    namespace: string;
-    private seqNum;
-    hasSubscribedToEvents: boolean;
-    approvalUrl: string;
-    locusUrl: string;
-    deviceUrl: string;
-    /**
-     * Initializes annotation module
-     */
-    constructor(...args: any[]);
-    /**
-     * Process Stroke Data
-     * @param {object}  data
-     * @returns {void}
-     */
-    private processStrokeMessage;
-    /** bind all events from mercury
-     * @param {Object} e
-     * @returns {undefined}
-     */
-    private eventCommandProcessor;
-    /** bind all events from llm
-     * @param {Object} e
-     * @returns {undefined}
-     */
-    private eventDataProcessor;
-    /**
-     * Listen to websocket messages
-     * @returns {undefined}
-     */
-    private listenToEvents;
-    /**
-     * set locusUrl
-     * @param {string} locusUrl
-     * @returns {void}
-     */
-    locusUrlUpdate(locusUrl: string): void;
-    /**
-     * set approved url
-     * @param {string} approvalUrl
-     * @returns {void}
-     */
-    approvalUrlUpdate(approvalUrl: string): void;
-    /**
-     * accept request
-     * @param {object} approval
-     * @returns {Promise}
-     */
-    acceptRequest(approval: any): any;
-    /**
-     * presenter declined request annotation
-     * @param {approval} approval
-     * @returns {Promise}
-     */
-    declineRequest(approval: any): any;
-    /**
-     * request approved annotation
-     * @param {RequestData} requestData
-     * @returns {Promise}
-     */
-    approveAnnotation(requestData: RequestData): Promise<void>;
-    /**
-     * cancel approved annotation
-     * @param {object} requestData
-     * @param {object} approval
-     * @returns {Promise}
-     */
-    cancelApproveAnnotation(requestData: RequestData, approval: any): any;
-    /**
-     * close annotation
-     * @param {object} requestData
-     * @returns {Promise}
-     */
-    closeAnnotation(requestData: RequestData): Promise<void>;
-    /**
-     * send annotation command
-     * @param {ANNOTATION_ACTION_TYPE} actionType
-     * @param {RequestData} requestData
-     * @returns {Promise}
-     */
-    private sendAnnotationAction;
-    /**
-     * decrypt data
-     * @param {string} encryptionKeyUrl
-     * @param {string} content encrypted content
-     * @returns {string} decrypted content
-     */
-    private decryptContent;
-    /**
-     * encrypt data
-     * @param {string} encryptionKeyUrl
-     * @param {string} content original content
-     * @returns {string} encrypted content
-     */
-    private encryptContent;
-    /**
-     * Sends stroke data to presenter
-     * @param {StrokeData} strokeData
-     * @returns {void}
-     */
-    sendStrokeData: (strokeData: StrokeData) => void;
-    /**
-     * private encrypted the strokes data
-     * @param {string} encryptedContent
-     * @param {StrokeData} strokeData
-     * @returns {void}
-     */
-    private publishEncrypted;
-}
-export default AnnotationChannel;

package/dist/breakouts/breakout.d.ts

@@ -1,8 +0,0 @@
-/*!
- * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
- */
-/**
- * @class
- */
-declare const Breakout: any;
-export default Breakout;

package/dist/breakouts/collection.d.ts

@@ -1,5 +0,0 @@
-/*!
- * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
- */
-declare const BreakoutCollection: any;
-export default BreakoutCollection;

package/dist/breakouts/edit-lock-error.d.ts

@@ -1,15 +0,0 @@
-/**
- * Extended Error object to signify breakout related errors
- */
-export default class BreakoutEditLockedError extends Error {
-    code: any;
-    error: any;
-    sdkMessage: any;
-    /**
-     *
-     * @constructor
-     * @param {String} [message]
-     * @param {Object} [error]
-     */
-    constructor(message?: string, error?: any);
-}

package/dist/breakouts/events.d.ts

@@ -1,8 +0,0 @@
-import { ClientEvent } from '@webex/internal-plugin-metrics';
-declare const breakoutEvent: {
-    onBreakoutMoveRequest: (eventInfo: any, submitClientEvent: any) => void;
-    onBreakoutMoveResponse: (eventInfo: any, submitClientEvent: any) => void;
-    onBreakoutJoinResponse: (eventInfo: any, submitClientEvent: any) => void;
-    postMoveCallAnalyzer: (event: ClientEvent['name'], eventInfo: any, submitClientEvent: any) => void;
-};
-export default breakoutEvent;

package/dist/breakouts/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * @class Breakouts
- */
-declare const Breakouts: any;
-export default Breakouts;