@webex/plugin-meetings 3.0.0-next.2 → 3.0.0-next.21

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

@@ -121,7 +121,7 @@ describe('TurnDiscovery', () => {
         });
 
         // checks that OK roap message was sent or not sent and that the result is as expected
-        const checkResult = async (resultPromise, expectedRoapMessageSent, expectedResult) => {
+        const checkResult = async (resultPromise, expectedRoapMessageSent, expectedResult, expectedSkipReason?: string) => {
           let turnServerInfo, turnDiscoverySkippedReason;
 
           if (expectedRoapMessageSent === 'OK') {
@@ -150,7 +150,7 @@ describe('TurnDiscovery', () => {
           }
 
           assert.deepEqual(turnServerInfo, expectedResult);
-          assert.isUndefined(turnDiscoverySkippedReason);
+          assert.equal(turnDiscoverySkippedReason, expectedSkipReason);
         };
 
         it('sends TURN_DISCOVERY_REQUEST, waits for response and sends OK', async () => {
@@ -302,7 +302,7 @@ describe('TurnDiscovery', () => {
           // @ts-ignore
           mockRoapRequest.sendRoap.resetHistory();
 
-          await checkResult(result, undefined, undefined);
+          await checkResult(result, undefined, undefined, 'failure: Unexpected token o in JSON at position 1');
           checkFailureMetricsSent();
         });
 
@@ -366,7 +366,7 @@ describe('TurnDiscovery', () => {
           // @ts-ignore
           mockRoapRequest.sendRoap.resetHistory();
 
-          await checkResult(result, undefined, undefined);
+          await checkResult(result, undefined, undefined, 'failure: TURN_DISCOVERY_RESPONSE in http response has unexpected messageType: {"seq":"0","messageType":"ERROR"}');
         });
       });
     });
@@ -494,7 +494,7 @@ describe('TurnDiscovery', () => {
       assert.isUndefined(turnDiscoverySkippedReason);
     });
 
-    it('resolves with undefined if sending the request fails', async () => {
+    it('resolves with undefined turnServerInfo if sending the request fails', async () => {
       const td = new TurnDiscovery(mockRoapRequest);
 
       mockRoapRequest.sendRoap = sinon.fake.rejects(new Error('fake error'));
@@ -504,11 +504,11 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = result;
 
       assert.isUndefined(turnServerInfo);
-      assert.isUndefined(turnDiscoverySkippedReason);
+      assert.equal(turnDiscoverySkippedReason, 'failure: fake error');
       checkFailureMetricsSent();
     });
 
-    it('resolves with undefined when cluster is reachable', async () => {
+    it('resolves with undefined turnServerInfo when cluster is reachable', async () => {
       const prev = testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable;
       testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = () =>
         Promise.resolve(true);
@@ -523,7 +523,7 @@ describe('TurnDiscovery', () => {
       testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = prev;
     });
 
-    it("resolves with undefined if we don't get a response within 10s", async () => {
+    it("resolves with undefined turnServerInfo if we don't get a response within 10s", async () => {
       const td = new TurnDiscovery(mockRoapRequest);
 
       const promise = td.doTurnDiscovery(testMeeting, false);
@@ -534,11 +534,11 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await promise;
 
       assert.isUndefined(turnServerInfo);
-      assert.isUndefined(turnDiscoverySkippedReason);
+      assert.equal(turnDiscoverySkippedReason, 'failure: Timed out waiting for TURN_DISCOVERY_RESPONSE');
       checkFailureMetricsSent();
     });
 
-    it('resolves with undefined if the response does not have all the headers we expect', async () => {
+    it('resolves with undefined turnServerInfo if the response does not have all the headers we expect', async () => {
       const td = new TurnDiscovery(mockRoapRequest);
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
@@ -559,11 +559,11 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
       assert.isUndefined(turnServerInfo);
-      assert.isUndefined(turnDiscoverySkippedReason);
+      assert.equal(turnDiscoverySkippedReason, `failure: TURN_DISCOVERY_RESPONSE from test missing some headers: ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}"]`);
       checkFailureMetricsSent();
     });
 
-    it('resolves with undefined if the response does not have any headers', async () => {
+    it('resolves with undefined turnServerInfo if the response does not have any headers', async () => {
       const td = new TurnDiscovery(mockRoapRequest);
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
@@ -576,11 +576,11 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
       assert.isUndefined(turnServerInfo);
-      assert.isUndefined(turnDiscoverySkippedReason);
+      assert.equal(turnDiscoverySkippedReason, 'failure: TURN_DISCOVERY_RESPONSE from test missing some headers: undefined');
       checkFailureMetricsSent();
     });
 
-    it('resolves with undefined if the response has empty headers array', async () => {
+    it('resolves with undefined turnServerInfo if the response has empty headers array', async () => {
       const td = new TurnDiscovery(mockRoapRequest);
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
@@ -596,7 +596,7 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
       assert.isUndefined(turnServerInfo);
-      assert.isUndefined(turnDiscoverySkippedReason);
+      assert.equal(turnDiscoverySkippedReason, 'failure: TURN_DISCOVERY_RESPONSE from test missing some headers: []');
       checkFailureMetricsSent();
     });
 
@@ -636,7 +636,7 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
       assert.isUndefined(turnServerInfo);
-      assert.isUndefined(turnDiscoverySkippedReason);
+      assert.equal(turnDiscoverySkippedReason, 'failure: fake error');
       checkFailureMetricsSent();
     });
   });
@@ -676,4 +676,286 @@ describe('TurnDiscovery', () => {
       assert.notCalled(mockRoapRequest.sendRoap);
     });
   });
+
+  describe('generateTurnDiscoveryRequestMessage', () => {
+    let td;
+
+    beforeEach(() => {
+      td = new TurnDiscovery(mockRoapRequest);
+      sinon.stub(td, 'getSkipReason').resolves(undefined);
+    });
+
+    it('generates TURN_DISCOVERY_REQUEST message irrespective of skip reason when called with isForced=true', async () => {
+      td.getSkipReason.resolves('reachability');
+
+      const result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+
+      assert.deepEqual(result, {
+        roapMessage: {
+          messageType: 'TURN_DISCOVERY_REQUEST',
+          version: '2',
+          seq: 0,
+          headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
+        },
+        turnDiscoverySkippedReason: undefined,
+      });
+    });
+
+    it('takes into account skip reason when called with isForced=false', async () => {
+      td.getSkipReason.resolves('reachability');
+
+      const result = await td.generateTurnDiscoveryRequestMessage(testMeeting, false);
+
+      assert.deepEqual(result, {
+        roapMessage: undefined,
+        turnDiscoverySkippedReason: 'reachability',
+      });
+    });
+
+    it('generates TURN_DISCOVERY_REQUEST message if there is no skip reason when called with isForced=false', async () => {
+      const result = await td.generateTurnDiscoveryRequestMessage(testMeeting, false);
+
+      assert.deepEqual(result, {
+        roapMessage: {
+          messageType: 'TURN_DISCOVERY_REQUEST',
+          version: '2',
+          seq: 0,
+          headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
+        },
+        turnDiscoverySkippedReason: undefined,
+      });
+    });
+
+    it('returns "already in progress" if TURN_DISCOVERY_REQUEST was already generated', async () => {
+      // 1st call
+      await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+
+      // 2nd call
+      const result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+
+      assert.deepEqual(result, {
+        roapMessage: undefined,
+        turnDiscoverySkippedReason: 'already in progress',
+      });
+    });
+
+    it('returns "already in progress" if doTurnDiscovery was called and not completed', async () => {
+      let promiseResolve;
+
+      // set it up so that doTurnDiscovery doesn't complete
+      mockRoapRequest.sendRoap = sinon.fake.returns(new Promise((resolve) => {
+        promiseResolve = resolve;
+      }));
+      td.doTurnDiscovery(testMeeting, false, true);
+
+      // now call generateTurnDiscoveryRequestMessage
+      const result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+
+      assert.deepEqual(result, {
+        roapMessage: undefined,
+        turnDiscoverySkippedReason: 'already in progress',
+      });
+
+      // resolve the promise, just so that we don't leave it hanging
+      promiseResolve();
+    });
+  });
+
+  describe('handleTurnDiscoveryHttpResponse', () => {
+    let td;
+    let roapMessage;
+
+    beforeEach(() => {
+      roapMessage = {
+        seq: 1,
+        messageType: 'TURN_DISCOVERY_RESPONSE',
+        errorType: undefined,
+        errorCause: undefined,
+        headers: [
+          `x-cisco-turn-url=${FAKE_TURN_URL}`,
+          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+          `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+          'noOkInTransaction'
+        ],
+      }
+
+      td = new TurnDiscovery(mockRoapRequest);
+    });
+
+    // checks if another TURN discovery can be started without any problem
+    const checkNextTurnDiscovery = async () => {
+        // after each test check that another TURN discovery can be started without any problems
+        const secondMessage = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+
+        assert.isDefined(secondMessage.roapMessage);
+    };
+
+    it('works as expected when called with undefined httpResponse', async () => {
+      await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+
+      const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, undefined);
+
+      assert.deepEqual(result, {
+        turnServerInfo: undefined,
+        turnDiscoverySkippedReason: 'missing http response',
+      });
+    });
+
+    [
+      {testCase: 'is missing mediaConnections', httpResponse: {}},
+      {testCase: 'is missing mediaConnections[0]', httpResponse: {mediaConnections: []}},
+      {testCase: 'is missing mediaConnections[0].remoteSdp', httpResponse: {mediaConnections: [{}]}},
+      {testCase: 'is missing roapMesssage in mediaConnections[0].remoteSdp', httpResponse: {mediaConnections: [{remoteSdp: JSON.stringify({something: "whatever"})}]}},
+    ].forEach(({testCase, httpResponse}) => {
+      it(`handles httpResponse that ${testCase}`, async () => {
+        await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+
+        const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
+
+        assert.deepEqual(result, {
+          turnServerInfo: undefined,
+          turnDiscoverySkippedReason: 'missing http response',
+        });
+      });
+      });
+
+      it('handles httpResponse with invalid JSON in mediaConnections[0].remoteSdp', async () => {
+        await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+
+        const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, {mediaConnections: [{remoteSdp: 'not a json'}]});
+
+        assert.deepEqual(result, {
+          turnServerInfo: undefined,
+          turnDiscoverySkippedReason: 'failure: Unexpected token o in JSON at position 1',
+        });
+      });
+
+      it('fails when called before generateTurnDiscoveryRequestMessage() was called', async () => {
+        const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
+        await assert.isRejected(td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse),
+          'handleTurnDiscoveryHttpResponse() called before generateTurnDiscoveryRequestMessage()');
+      });
+
+      it('works as expected when called with valid httpResponse', async () => {
+        const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
+
+        // we spy on handleTurnDiscoveryResponse and check that it's called so that we don't have to repeat
+        // all the edge case tests here, they're already covered in other tests that call handleTurnDiscoveryResponse
+        const handleTurnDiscoveryResponseSpy = sinon.spy(td, 'handleTurnDiscoveryResponse');
+
+        await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+        const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
+
+        assert.deepEqual(result, {
+          turnServerInfo: {
+            url: FAKE_TURN_URL,
+            username: FAKE_TURN_USERNAME,
+            password: FAKE_TURN_PASSWORD,
+          },
+          turnDiscoverySkippedReason: undefined,
+        });
+
+        assert.calledOnceWithExactly(handleTurnDiscoveryResponseSpy, roapMessage, 'in http response');
+      });
+
+      it('works as expected when httpResponse is missing some headers', async () => {
+        roapMessage.headers = [
+          `x-cisco-turn-url=${FAKE_TURN_URL}`, // missing headers for username and password
+        ];
+
+        const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
+
+        // we spy on handleTurnDiscoveryResponse and check that it's called so that we don't have to repeat
+        // all the edge case tests here, they're already covered in other tests that call handleTurnDiscoveryResponse
+        // we test just this 1 edge case here to confirm that when handleTurnDiscoveryResponse rejects, we get the correct result
+        const handleTurnDiscoveryResponseSpy = sinon.spy(td, 'handleTurnDiscoveryResponse');
+
+        await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+        const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
+
+        assert.deepEqual(result, {
+          turnServerInfo: undefined,
+          turnDiscoverySkippedReason: 'failure: TURN_DISCOVERY_RESPONSE in http response missing some headers: ["x-cisco-turn-url=turns:fakeTurnServer.com:443?transport=tcp"]',
+        });
+        assert.calledOnceWithExactly(handleTurnDiscoveryResponseSpy, roapMessage, 'in http response');
+
+        checkNextTurnDiscovery();
+      });
+
+      it('sends OK when required', async () => {
+        roapMessage.headers = [
+          `x-cisco-turn-url=${FAKE_TURN_URL}`,
+          `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+          `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+          // noOkInTransaction is missing
+        ];
+        const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
+
+        await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+        const result = await td.handleTurnDiscoveryHttpResponse(testMeeting, httpResponse);
+
+        assert.deepEqual(result, {
+          turnServerInfo: {
+            url: FAKE_TURN_URL,
+            username: FAKE_TURN_USERNAME,
+            password: FAKE_TURN_PASSWORD,
+          },
+          turnDiscoverySkippedReason: undefined,
+        });
+
+        // check that OK was sent along with the metric for it
+        await checkRoapMessageSent('OK', 0);
+
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.TURN_DISCOVERY_REQUIRES_OK,
+          sinon.match({
+            correlation_id: testMeeting.correlationId,
+            locus_id: FAKE_LOCUS_ID,
+          })
+        );
+
+        checkNextTurnDiscovery();
+      });
+
+      describe('abort', () => {
+        it('allows starting a new TURN discovery', async () => {
+          let result;
+
+          // this mock is required for doTurnDiscovery() to work
+          mockRoapRequest.sendRoap = sinon.fake.resolves({
+            mediaConnections: [
+              {
+                mediaId: '464ff97f-4bda-466a-ad06-3a22184a2274',
+                remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}", "noOkInTransaction"]}}`,
+              },
+            ],
+          });
+
+          result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+          assert.isDefined(result.roapMessage);
+
+          td.abort();
+
+          result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+          assert.isDefined(result.roapMessage);
+
+          td.abort();
+
+          // check also that doTurnDiscovery()  works after abort()
+          result = await td.doTurnDiscovery(testMeeting, false);
+        });
+
+        it('does nothing when called outside of a TURN discovery', async () => {
+          let result;
+
+          // call abort() without any other calls before it - it should do nothing
+          // there is not much we can check, so afterwards we just check that we can start a new TURN discovery
+          td.abort();
+
+          result = await td.generateTurnDiscoveryRequestMessage(testMeeting, true);
+          assert.isDefined(result.roapMessage);
+        });
+      });
+  });
 });

package/test/unit/spec/stats-analyzer/index.js

@@ -776,13 +776,11 @@ describe('plugin-meetings', () => {
         await progressTime();
 
         assert.strictEqual(
-          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE)
-            .information,
+          mqeData.intervalMetadata.microphoneInfo.deviceName,
           'fake-microphone'
         );
         assert.strictEqual(
-          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA)
-            .information,
+          mqeData.intervalMetadata.cameraInfo.deviceName,
           'fake-camera'
         );
       });
@@ -796,13 +794,11 @@ describe('plugin-meetings', () => {
         await progressTime();
 
         assert.strictEqual(
-          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE)
-            .information,
+          mqeData.intervalMetadata.microphoneInfo.deviceName,
           _UNKNOWN_
         );
         assert.strictEqual(
-          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA)
-            .information,
+          mqeData.intervalMetadata.cameraInfo.deviceName,
           _UNKNOWN_
         );
       });
@@ -1543,6 +1539,185 @@ describe('plugin-meetings', () => {
           },
         ]);
       });
+
+      it('has three streams for video senders for simulcast', async () => {
+        pc.getTransceiverStats = sinon.stub().resolves({
+          audio: {
+            senders: [fakeStats.audio.senders[0]],
+            receivers: [fakeStats.audio.receivers[0]],
+          },
+          video: {
+            senders: [
+              {
+                localTrackLabel: 'fake-camera',
+                report: [
+                  {
+                    type: 'outbound-rtp',
+                    bytesSent: 1,
+                    framesSent: 0,
+                    packetsSent: 0,
+                  },
+                  {
+                    type: 'outbound-rtp',
+                    bytesSent: 0,
+                    framesSent: 0,
+                    packetsSent: 0,
+                  },
+                  {
+                    type: 'outbound-rtp',
+                    bytesSent: 1000,
+                    framesSent: 1,
+                    packetsSent: 1,
+                  },
+                  {
+                    type: 'remote-inbound-rtp',
+                    packetsLost: 0,
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'succeeded',
+                    localCandidateId: 'fake-candidate-id',
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'failed',
+                    localCandidateId: 'bad-candidate-id',
+                  },
+                  {
+                    type: 'local-candidate',
+                    id: 'fake-candidate-id',
+                    protocol: 'tcp',
+                  },
+                ],
+              },
+            ],
+            receivers: [fakeStats.video.receivers[0]],
+          },
+          screenShareAudio: {
+            senders: [fakeStats.audio.senders[0]],
+            receivers: [fakeStats.audio.receivers[0]],
+          },
+          screenShareVideo: {
+            senders: [fakeStats.video.senders[0]],
+            receivers: [fakeStats.video.receivers[0]],
+          },
+        });
+
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await progressTime();
+
+        assert.deepEqual(mqeData.videoTransmit[0].streams, [
+          {
+            common: {
+              codec: 'H264',
+              csi: [],
+              duplicateSsci: 0,
+              requestedBitrate: 0,
+              requestedFrames: 0,
+              rtpPackets: 0,
+              ssci: 0,
+              transmittedBitrate: 0.13333333333333333,
+              transmittedFrameRate: 0
+            },
+            h264CodecProfile: 'BP',
+            isAvatar: false,
+            isHardwareEncoded: false,
+            localConfigurationChanges: 2,
+            maxFrameQp: 0,
+            maxNoiseLevel: 0,
+            minRegionQp: 0,
+            remoteConfigurationChanges: 0,
+            requestedFrameSize: 0,
+            requestedKeyFrames: 0,
+            transmittedFrameSize: 0,
+            transmittedHeight: 0,
+            transmittedKeyFrames: 0,
+            transmittedKeyFramesClient: 0,
+            transmittedKeyFramesConfigurationChange: 0,
+            transmittedKeyFramesFeedback: 0,
+            transmittedKeyFramesLocalDrop: 0,
+            transmittedKeyFramesOtherLayer: 0,
+            transmittedKeyFramesPeriodic: 0,
+            transmittedKeyFramesSceneChange: 0,
+            transmittedKeyFramesStartup: 0,
+            transmittedKeyFramesUnknown: 0,
+            transmittedWidth: 0,
+          },
+          {
+            common: {
+              codec: 'H264',
+              csi: [],
+              duplicateSsci: 0,
+              requestedBitrate: 0,
+              requestedFrames: 0,
+              rtpPackets: 0,
+              ssci: 0,
+              transmittedBitrate: 0,
+              transmittedFrameRate: 0,
+            },
+            h264CodecProfile: 'BP',
+            isAvatar: false,
+            isHardwareEncoded: false,
+            localConfigurationChanges: 2,
+            maxFrameQp: 0,
+            maxNoiseLevel: 0,
+            minRegionQp: 0,
+            remoteConfigurationChanges: 0,
+            requestedFrameSize: 0,
+            requestedKeyFrames: 0,
+            transmittedFrameSize: 0,
+            transmittedHeight: 0,
+            transmittedKeyFrames: 0,
+            transmittedKeyFramesClient: 0,
+            transmittedKeyFramesConfigurationChange: 0,
+            transmittedKeyFramesFeedback: 0,
+            transmittedKeyFramesLocalDrop: 0,
+            transmittedKeyFramesOtherLayer: 0,
+            transmittedKeyFramesPeriodic: 0,
+            transmittedKeyFramesSceneChange: 0,
+            transmittedKeyFramesStartup: 0,
+            transmittedKeyFramesUnknown: 0,
+            transmittedWidth: 0,
+          },
+          {
+            common: {
+              codec: 'H264',
+              csi: [],
+              duplicateSsci: 0,
+              requestedBitrate: 0,
+              requestedFrames: 0,
+              rtpPackets: 1,
+              ssci: 0,
+              transmittedBitrate: 133.33333333333334,
+              transmittedFrameRate: 0,
+            },
+            h264CodecProfile: 'BP',
+            isAvatar: false,
+            isHardwareEncoded: false,
+            localConfigurationChanges: 2,
+            maxFrameQp: 0,
+            maxNoiseLevel: 0,
+            minRegionQp: 0,
+            remoteConfigurationChanges: 0,
+            requestedFrameSize: 0,
+            requestedKeyFrames: 0,
+            transmittedFrameSize: 0,
+            transmittedHeight: 0,
+            transmittedKeyFrames: 0,
+            transmittedKeyFramesClient: 0,
+            transmittedKeyFramesConfigurationChange: 0,
+            transmittedKeyFramesFeedback: 0,
+            transmittedKeyFramesLocalDrop: 0,
+            transmittedKeyFramesOtherLayer: 0,
+            transmittedKeyFramesPeriodic: 0,
+            transmittedKeyFramesSceneChange: 0,
+            transmittedKeyFramesStartup: 0,
+            transmittedKeyFramesUnknown: 0,
+            transmittedWidth: 0,
+          }
+        ]);
+      });
     });
   });
 });

package/dist/member/member.types.d.ts

@@ -1,11 +0,0 @@
-export declare enum MediaStatus {
-    RECVONLY = "RECVONLY",
-    SENDONLY = "SENDONLY",
-    SENDRECV = "SENDRECV",
-    INACTIVE = "INACTIVE",
-    UNKNOWN = "UNKNOWN"
-}
-export interface IMediaStatus {
-    audio: MediaStatus;
-    video: MediaStatus;
-}

package/dist/member/member.types.js

@@ -1,17 +0,0 @@
-"use strict";
-
-var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
-_Object$defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.MediaStatus = void 0;
-// values are inherited from locus so don't update these
-var MediaStatus = exports.MediaStatus = /*#__PURE__*/function (MediaStatus) {
-  MediaStatus["RECVONLY"] = "RECVONLY";
-  MediaStatus["SENDONLY"] = "SENDONLY";
-  MediaStatus["SENDRECV"] = "SENDRECV";
-  MediaStatus["INACTIVE"] = "INACTIVE";
-  MediaStatus["UNKNOWN"] = "UNKNOWN";
-  return MediaStatus;
-}({}); // participant has not added media in the meeting
-//# sourceMappingURL=member.types.js.map

package/dist/member/member.types.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["MediaStatus","exports"],"sources":["member.types.ts"],"sourcesContent":["// values are inherited from locus so don't update these\nexport enum MediaStatus {\n  RECVONLY = 'RECVONLY', // participant only receiving and not sending\n  SENDONLY = 'SENDONLY', // participant only sending and not receiving\n  SENDRECV = 'SENDRECV', // participant both sending and receiving\n  INACTIVE = 'INACTIVE', // participant is not connected to media source\n  UNKNOWN = 'UNKNOWN', // participant has not added media in the meeting\n}\n\nexport interface IMediaStatus {\n  audio: MediaStatus;\n  video: MediaStatus;\n}\n"],"mappings":";;;;;;;AAAA;AAAA,IACYA,WAAW,GAAAC,OAAA,CAAAD,WAAA,0BAAXA,WAAW;EAAXA,WAAW;EAAXA,WAAW;EAAXA,WAAW;EAAXA,WAAW;EAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA,OAKA"}

package/src/member/member.types.ts

@@ -1,13 +0,0 @@
-// values are inherited from locus so don't update these
-export enum MediaStatus {
-  RECVONLY = 'RECVONLY', // participant only receiving and not sending
-  SENDONLY = 'SENDONLY', // participant only sending and not receiving
-  SENDRECV = 'SENDRECV', // participant both sending and receiving
-  INACTIVE = 'INACTIVE', // participant is not connected to media source
-  UNKNOWN = 'UNKNOWN', // participant has not added media in the meeting
-}
-
-export interface IMediaStatus {
-  audio: MediaStatus;
-  video: MediaStatus;
-}