@stream-io/video-client 1.26.1 → 1.27.1

package/src/StreamSfuClient.ts

@@ -51,6 +51,11 @@ export type StreamSfuClientConstructor = {
    */
   credentials: Credentials;
 
+  /**
+   * The `cid` (call ID) to use for the connection.
+   */
+  cid: string;
+
   /**
    * `sessionId` to use for the connection.
    */
@@ -59,7 +64,7 @@ export type StreamSfuClientConstructor = {
   /**
    * A log tag to use for logging. Useful for debugging multiple instances.
    */
-  logTag: string;
+  tag: string;
 
   /**
    * The timeout in milliseconds for waiting for the `joinResponse`.
@@ -83,6 +88,14 @@ export type StreamSfuClientConstructor = {
   enableTracing: boolean;
 };
 
+type SfuWebSocketParams = {
+  attempt: string; // the reconnect attempt, start with 0
+  user_id: string;
+  api_key: string;
+  user_session_id: string;
+  cid: string;
+};
+
 /**
  * The client used for exchanging information with the SFU.
  */
@@ -140,7 +153,7 @@ export class StreamSfuClient {
   private readonly unsubscribeNetworkChanged: () => void;
   private readonly onSignalClose: ((reason: string) => void) | undefined;
   private readonly logger: Logger;
-  private readonly logTag: string;
+  readonly tag: string;
   private readonly credentials: Credentials;
   private readonly dispatcher: Dispatcher;
   private readonly joinResponseTimeout: number;
@@ -191,7 +204,8 @@ export class StreamSfuClient {
     dispatcher,
     credentials,
     sessionId,
-    logTag,
+    cid,
+    tag,
     joinResponseTimeout = 5000,
     onSignalClose,
     streamClient,
@@ -204,10 +218,10 @@ export class StreamSfuClient {
     const { server, token } = credentials;
     this.edgeName = server.edge_name;
     this.joinResponseTimeout = joinResponseTimeout;
-    this.logTag = logTag;
-    this.logger = getLogger(['SfuClient', logTag]);
+    this.tag = tag;
+    this.logger = getLogger(['SfuClient', tag]);
     this.tracer = enableTracing
-      ? new Tracer(`${logTag}-${this.edgeName}`)
+      ? new Tracer(`${tag}-${this.edgeName}`)
       : undefined;
     this.rpc = createSignalClient({
       baseUrl: server.url,
@@ -238,10 +252,16 @@ export class StreamSfuClient {
       }
     });
 
-    this.createWebSocket();
+    this.createWebSocket({
+      attempt: tag,
+      user_id: streamClient.user?.id || '',
+      api_key: streamClient.key,
+      user_session_id: this.sessionId,
+      cid,
+    });
   }
 
-  private createWebSocket = () => {
+  private createWebSocket = (params: SfuWebSocketParams) => {
     const eventsToTrace: Partial<Record<SfuEventKinds, boolean>> = {
       callEnded: true,
       changePublishQuality: true,
@@ -249,10 +269,11 @@ export class StreamSfuClient {
       connectionQualityChanged: true,
       error: true,
       goAway: true,
+      inboundStateNotification: true,
     };
     this.signalWs = createWebSocketSignalChannel({
-      logTag: this.logTag,
-      endpoint: `${this.credentials.server.ws_endpoint}?tag=${this.logTag}`,
+      tag: this.tag,
+      endpoint: `${this.credentials.server.ws_endpoint}?${new URLSearchParams(params).toString()}`,
       onMessage: (message) => {
         this.lastMessageTimestamp = new Date();
         this.scheduleConnectionCheck();
@@ -260,7 +281,7 @@ export class StreamSfuClient {
         if (eventsToTrace[eventKind]) {
           this.tracer?.trace(eventKind, message);
         }
-        this.dispatcher.dispatch(message, this.logTag);
+        this.dispatcher.dispatch(message, this.tag);
       },
     });
 
@@ -443,9 +464,7 @@ export class StreamSfuClient {
     this.migrateAwayTimeout = setTimeout(() => {
       unsubscribe();
       task.reject(
-        new Error(
-          `Migration (${this.logTag}) failed to complete in ${timeout}ms`,
-        ),
+        new Error(`Migration (${this.tag}) failed to complete in ${timeout}ms`),
       );
     }, timeout);
 

package/src/coordinator/connection/connection.ts

@@ -471,7 +471,6 @@ export class StableWSConnection {
   onmessage = (wsID: number, event: MessageEvent) => {
     if (this.wsID !== wsID) return;
 
-    this._log('onmessage() - onmessage callback', { event, wsID });
     const data =
       typeof event.data === 'string'
         ? (JSON.parse(event.data) as StreamVideoEvent)
@@ -581,7 +580,6 @@ export class StableWSConnection {
     this.totalFailures += 1;
     this._setHealth(false);
     this.isConnecting = false;
-    this.rejectConnectionOpen?.(new Error(`WebSocket error: ${event}`));
     this._log(`onerror() - WS connection resulted into error`, { event });
 
     this._reconnect();

package/src/devices/CameraManager.ts

@@ -149,7 +149,7 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
   }
 
   protected getDevices(): Observable<MediaDeviceInfo[]> {
-    return getVideoDevices();
+    return getVideoDevices(this.call.tracer);
   }
 
   protected getStream(

package/src/devices/InputMediaDeviceManager.ts

@@ -198,6 +198,10 @@ export abstract class InputMediaDeviceManager<
           entry.stop?.();
           this.filters = this.filters.filter((f) => f !== entry);
           await this.applySettingsToStream();
+          this.call.tracer.trace(
+            `unregisterFilter.${TrackType[this.trackType]}`,
+            null,
+          );
         }),
     };
   }
@@ -219,9 +223,7 @@ export abstract class InputMediaDeviceManager<
    */
   async select(deviceId: string | undefined) {
     if (isReactNative()) {
-      throw new Error(
-        'This method is not supported in React Native. Please visit https://getstream.io/video/docs/reactnative/core/camera-and-microphone/#speaker-management for reference.',
-      );
+      throw new Error('This method is not supported in React Native.');
     }
     const prevDeviceId = this.state.selectedDevice;
     if (deviceId === prevDeviceId) {

package/src/devices/MicrophoneManager.ts

@@ -195,6 +195,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
         this.logger('warn', 'Failed to unregister noise cancellation', err);
       });
 
+    this.call.tracer.trace('noiseCancellation.disabled', true);
     await this.call.notifyNoiseCancellationStopped();
   }
 
@@ -245,7 +246,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
   }
 
   protected getDevices(): Observable<MediaDeviceInfo[]> {
-    return getAudioDevices();
+    return getAudioDevices(this.call.tracer);
   }
 
   protected getStream(

package/src/devices/SpeakerManager.ts

@@ -56,7 +56,7 @@ export class SpeakerManager {
         'This feature is not supported in React Native. Please visit https://getstream.io/video/docs/reactnative/core/camera-and-microphone/#speaker-management for more details',
       );
     }
-    return getAudioOutputDevices();
+    return getAudioOutputDevices(this.call.tracer);
   }
 
   /**

package/src/devices/devices.ts

@@ -7,6 +7,7 @@ import {
   merge,
   shareReplay,
   startWith,
+  tap,
 } from 'rxjs';
 import { getLogger } from '../logger';
 import { BrowserPermission } from './BrowserPermission';
@@ -21,8 +22,13 @@ import { getCurrentValue } from '../store/rxUtils';
  *
  * @param permission a BrowserPermission instance.
  * @param kind the kind of devices to enumerate.
+ * @param tracer the tracer to use for tracing the device enumeration.
  */
-const getDevices = (permission: BrowserPermission, kind: MediaDeviceKind) => {
+const getDevices = (
+  permission: BrowserPermission,
+  kind: MediaDeviceKind,
+  tracer: Tracer | undefined,
+) => {
   return from(
     (async () => {
       let devices = await navigator.mediaDevices.enumerateDevices();
@@ -34,6 +40,11 @@ const getDevices = (permission: BrowserPermission, kind: MediaDeviceKind) => {
       if (shouldPromptForBrowserPermission && (await permission.prompt())) {
         devices = await navigator.mediaDevices.enumerateDevices();
       }
+      tracer?.traceOnce(
+        'device-enumeration',
+        'navigator.mediaDevices.enumerateDevices',
+        devices,
+      );
       return devices.filter(
         (device) =>
           device.kind === kind &&
@@ -99,11 +110,12 @@ export const getVideoBrowserPermission = lazy(
     }),
 );
 
-const getDeviceChangeObserver = lazy(() => {
+const getDeviceChangeObserver = lazy((tracer: Tracer | undefined) => {
   // 'addEventListener' is not available in React Native, returning
   // an observable that will never fire
   if (!navigator.mediaDevices.addEventListener) return from([]);
   return fromEvent(navigator.mediaDevices, 'devicechange').pipe(
+    tap(() => tracer?.resetTrace('device-enumeration')),
     map(() => undefined),
     debounceTime(500),
   );
@@ -115,13 +127,15 @@ const getDeviceChangeObserver = lazy(() => {
  * if devices are added/removed the list is updated, and if the permission is revoked,
  * the observable errors.
  */
-export const getAudioDevices = lazy(() => {
+export const getAudioDevices = lazy((tracer?: Tracer) => {
   return merge(
-    getDeviceChangeObserver(),
+    getDeviceChangeObserver(tracer),
     getAudioBrowserPermission().asObservable(),
   ).pipe(
     startWith(undefined),
-    concatMap(() => getDevices(getAudioBrowserPermission(), 'audioinput')),
+    concatMap(() =>
+      getDevices(getAudioBrowserPermission(), 'audioinput', tracer),
+    ),
     shareReplay(1),
   );
 });
@@ -132,13 +146,15 @@ export const getAudioDevices = lazy(() => {
  * if devices are added/removed the list is updated, and if the permission is revoked,
  * the observable errors.
  */
-export const getVideoDevices = lazy(() => {
+export const getVideoDevices = lazy((tracer?: Tracer) => {
   return merge(
-    getDeviceChangeObserver(),
+    getDeviceChangeObserver(tracer),
     getVideoBrowserPermission().asObservable(),
   ).pipe(
     startWith(undefined),
-    concatMap(() => getDevices(getVideoBrowserPermission(), 'videoinput')),
+    concatMap(() =>
+      getDevices(getVideoBrowserPermission(), 'videoinput', tracer),
+    ),
     shareReplay(1),
   );
 });
@@ -149,13 +165,15 @@ export const getVideoDevices = lazy(() => {
  * if devices are added/removed the list is updated, and if the permission is revoked,
  * the observable errors.
  */
-export const getAudioOutputDevices = lazy(() => {
+export const getAudioOutputDevices = lazy((tracer?: Tracer) => {
   return merge(
-    getDeviceChangeObserver(),
+    getDeviceChangeObserver(tracer),
     getAudioBrowserPermission().asObservable(),
   ).pipe(
     startWith(undefined),
-    concatMap(() => getDevices(getAudioBrowserPermission(), 'audiooutput')),
+    concatMap(() =>
+      getDevices(getAudioBrowserPermission(), 'audiooutput', tracer),
+    ),
     shareReplay(1),
   );
 });

package/src/events/__tests__/internal.test.ts

@@ -2,8 +2,10 @@ import { describe, expect, it, vi } from 'vitest';
 import { Call } from '../../Call';
 import { Dispatcher } from '../../rtc';
 import { CallState } from '../../store';
+import { noopComparator } from '../../sorting';
 import {
   watchConnectionQualityChanged,
+  watchInboundStateNotification,
   watchLiveEnded,
   watchParticipantCountChanged,
   watchPinsUpdated,
@@ -11,6 +13,7 @@ import {
 import {
   ConnectionQuality,
   ErrorCode,
+  TrackType,
 } from '../../gen/video/sfu/models/models';
 
 describe('internal events', () => {
@@ -131,4 +134,79 @@ describe('internal events', () => {
       { userId: 'u2', sessionId: 'session-2', pin: undefined },
     ]);
   });
+
+  it('handles InboundStateNotification', () => {
+    const state = new CallState();
+    state.setSortParticipantsBy(noopComparator());
+    state.setParticipants([
+      // @ts-expect-error incomplete data
+      { sessionId: 'session-1' },
+      // @ts-expect-error incomplete data
+      { sessionId: 'session-2' },
+    ]);
+
+    const update = watchInboundStateNotification(state);
+    update({
+      inboundVideoStates: [
+        {
+          userId: '1',
+          sessionId: 'session-1',
+          trackType: TrackType.VIDEO,
+          paused: true,
+        },
+        {
+          userId: '2',
+          sessionId: 'session-2',
+          trackType: TrackType.VIDEO,
+          paused: false,
+        },
+      ],
+    });
+    expect(
+      state.findParticipantBySessionId('session-1')?.pausedTracks,
+    ).toContain(TrackType.VIDEO);
+    expect(
+      state.findParticipantBySessionId('session-2')?.pausedTracks,
+    ).not.toContain(TrackType.VIDEO);
+
+    update({
+      inboundVideoStates: [
+        {
+          userId: '2',
+          sessionId: 'session-2',
+          trackType: TrackType.VIDEO,
+          paused: true,
+        },
+      ],
+    });
+    expect(
+      state.findParticipantBySessionId('session-1')?.pausedTracks,
+    ).toContain(TrackType.VIDEO);
+    expect(
+      state.findParticipantBySessionId('session-2')?.pausedTracks,
+    ).toContain(TrackType.VIDEO);
+
+    update({
+      inboundVideoStates: [
+        {
+          userId: '1',
+          sessionId: 'session-1',
+          trackType: TrackType.VIDEO,
+          paused: false,
+        },
+        {
+          userId: '2',
+          sessionId: 'session-2',
+          trackType: TrackType.VIDEO,
+          paused: false,
+        },
+      ],
+    });
+    expect(
+      state.findParticipantBySessionId('session-1')?.pausedTracks,
+    ).not.toContain(TrackType.VIDEO);
+    expect(
+      state.findParticipantBySessionId('session-2')?.pausedTracks,
+    ).not.toContain(TrackType.VIDEO);
+  });
 });

package/src/events/__tests__/participant.test.ts

@@ -247,6 +247,72 @@ describe('Participant events', () => {
       });
     });
 
+    it('resets the paused track list if the track is unpublished', () => {
+      const state = new CallState();
+      state.setParticipants([
+        // @ts-expect-error setup one participant
+        {
+          sessionId: 'session-id',
+          publishedTracks: [TrackType.VIDEO, TrackType.SCREEN_SHARE],
+          pausedTracks: [TrackType.VIDEO, TrackType.SCREEN_SHARE],
+        },
+      ]);
+
+      const trackUnpublish = watchTrackUnpublished(state);
+      // @ts-expect-error incomplete data
+      trackUnpublish({ sessionId: 'session-id', type: TrackType.VIDEO });
+      expect(state.findParticipantBySessionId('session-id')).toEqual({
+        sessionId: 'session-id',
+        publishedTracks: [TrackType.SCREEN_SHARE],
+        pausedTracks: [TrackType.SCREEN_SHARE],
+      });
+
+      // @ts-expect-error incomplete data
+      trackUnpublish({ sessionId: 'session-id', type: TrackType.SCREEN_SHARE });
+      expect(state.findParticipantBySessionId('session-id')).toEqual({
+        sessionId: 'session-id',
+        publishedTracks: [],
+        pausedTracks: [],
+      });
+    });
+
+    it('resets the paused track list if the track is unpublished on full participant update', () => {
+      const state = new CallState();
+      state.setParticipants([
+        // @ts-expect-error setup one participant
+        {
+          sessionId: 'session-id',
+          publishedTracks: [TrackType.VIDEO, TrackType.SCREEN_SHARE],
+          pausedTracks: [TrackType.VIDEO, TrackType.SCREEN_SHARE],
+        },
+      ]);
+
+      const trackUnpublished = watchTrackUnpublished(state);
+      trackUnpublished({
+        sessionId: 'session-id',
+        type: TrackType.VIDEO,
+        // @ts-expect-error incomplete data
+        participant: { publishedTracks: [TrackType.SCREEN_SHARE] },
+      });
+      expect(state.findParticipantBySessionId('session-id')).toEqual({
+        sessionId: 'session-id',
+        publishedTracks: [TrackType.SCREEN_SHARE],
+        pausedTracks: [TrackType.SCREEN_SHARE],
+      });
+
+      trackUnpublished({
+        sessionId: 'session-id',
+        type: TrackType.SCREEN_SHARE,
+        // @ts-expect-error incomplete data
+        participant: { publishedTracks: [] },
+      });
+      expect(state.findParticipantBySessionId('session-id')).toEqual({
+        sessionId: 'session-id',
+        publishedTracks: [],
+        pausedTracks: [],
+      });
+    });
+
     it('adds the participant to the list of participants if provided', () => {
       const state = new CallState();
       const handler = watchTrackUnpublished(state);

package/src/events/callEventHandlers.ts

@@ -9,6 +9,7 @@ import {
   watchCallRejected,
   watchConnectionQualityChanged,
   watchDominantSpeakerChanged,
+  watchInboundStateNotification,
   watchLiveEnded,
   watchParticipantCountChanged,
   watchParticipantJoined,
@@ -60,6 +61,7 @@ export const registerEventHandlers = (call: Call, dispatcher: Dispatcher) => {
 
     call.on('callGrantsUpdated', watchCallGrantsUpdated(state)),
     call.on('pinsUpdated', watchPinsUpdated(state)),
+    call.on('inboundStateNotification', watchInboundStateNotification(state)),
 
     handleRemoteSoftMute(call),
   ];

package/src/events/internal.ts

@@ -3,7 +3,11 @@ import { Call } from '../Call';
 import { CallState } from '../store';
 import { StreamVideoParticipantPatches } from '../types';
 import { getLogger } from '../logger';
-import type { PinsChanged } from '../gen/video/sfu/event/events';
+import { pushToIfMissing, removeFromIfPresent } from '../helpers/array';
+import type {
+  InboundStateNotification,
+  PinsChanged,
+} from '../gen/video/sfu/event/events';
 import {
   ErrorCode,
   WebsocketReconnectStrategy,
@@ -89,3 +93,26 @@ export const watchPinsUpdated = (state: CallState) => {
     state.setServerSidePins(pins);
   };
 };
+
+/**
+ * Watches for inbound state notifications and updates the paused tracks
+ *
+ * @param state the call state to update.
+ */
+export const watchInboundStateNotification = (state: CallState) => {
+  return function onInboundStateNotification(e: InboundStateNotification) {
+    const { inboundVideoStates } = e;
+    const current = state.getParticipantLookupBySessionId();
+    const patches: StreamVideoParticipantPatches = {};
+    for (const { sessionId, trackType, paused } of inboundVideoStates) {
+      const pausedTracks = [...(current[sessionId]?.pausedTracks ?? [])];
+      if (paused) {
+        pushToIfMissing(pausedTracks, trackType);
+      } else {
+        removeFromIfPresent(pausedTracks, trackType);
+      }
+      patches[sessionId] = { pausedTracks };
+    }
+    state.updateParticipants(patches);
+  };
+};

package/src/events/participant.ts

@@ -106,10 +106,13 @@ export const watchTrackUnpublished = (state: CallState) => {
     if (e.participant) {
       const orphanedTracks = reconcileOrphanedTracks(state, e.participant);
       const participant = Object.assign(e.participant, orphanedTracks);
-      state.updateOrAddParticipant(sessionId, participant);
+      state.updateOrAddParticipant(sessionId, participant, (p) => ({
+        pausedTracks: p.pausedTracks?.filter((t) => t !== type),
+      }));
     } else {
       state.updateParticipant(sessionId, (p) => ({
         publishedTracks: p.publishedTracks.filter((t) => t !== type),
+        pausedTracks: p.pausedTracks?.filter((t) => t !== type),
       }));
     }
   };

package/src/gen/video/sfu/event/events.ts

@@ -6,6 +6,7 @@ import {
   CallEndedReason,
   CallGrants,
   CallState,
+  ClientCapability,
   ClientDetails,
   Codec,
   ConnectionQuality,
@@ -255,6 +256,15 @@ export interface SfuEvent {
          */
         changePublishOptions: ChangePublishOptions;
       }
+    | {
+        oneofKind: 'inboundStateNotification';
+        /**
+         * InboundStateNotification
+         *
+         * @generated from protobuf field: stream.video.sfu.event.InboundStateNotification inbound_state_notification = 28;
+         */
+        inboundStateNotification: InboundStateNotification;
+      }
     | {
         oneofKind: undefined;
       };
@@ -508,6 +518,10 @@ export interface JoinRequest {
    * @generated from protobuf field: repeated stream.video.sfu.models.SubscribeOption preferred_subscribe_options = 10;
    */
   preferredSubscribeOptions: SubscribeOption[];
+  /**
+   * @generated from protobuf field: repeated stream.video.sfu.models.ClientCapability capabilities = 11;
+   */
+  capabilities: ClientCapability[];
 }
 /**
  * @generated from protobuf message stream.video.sfu.event.ReconnectDetails
@@ -875,6 +889,36 @@ export interface CallEnded {
    */
   reason: CallEndedReason;
 }
+/**
+ * @generated from protobuf message stream.video.sfu.event.InboundStateNotification
+ */
+export interface InboundStateNotification {
+  /**
+   * @generated from protobuf field: repeated stream.video.sfu.event.InboundVideoState inbound_video_states = 1;
+   */
+  inboundVideoStates: InboundVideoState[];
+}
+/**
+ * @generated from protobuf message stream.video.sfu.event.InboundVideoState
+ */
+export interface InboundVideoState {
+  /**
+   * @generated from protobuf field: string user_id = 1;
+   */
+  userId: string;
+  /**
+   * @generated from protobuf field: string session_id = 2;
+   */
+  sessionId: string;
+  /**
+   * @generated from protobuf field: stream.video.sfu.models.TrackType track_type = 3;
+   */
+  trackType: TrackType;
+  /**
+   * @generated from protobuf field: bool paused = 4;
+   */
+  paused: boolean;
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class SfuEvent$Type extends MessageType<SfuEvent> {
   constructor() {
@@ -1033,6 +1077,13 @@ class SfuEvent$Type extends MessageType<SfuEvent> {
         oneof: 'eventPayload',
         T: () => ChangePublishOptions,
       },
+      {
+        no: 28,
+        name: 'inbound_state_notification',
+        kind: 'message',
+        oneof: 'eventPayload',
+        T: () => InboundStateNotification,
+      },
     ]);
   }
 }
@@ -1342,6 +1393,17 @@ class JoinRequest$Type extends MessageType<JoinRequest> {
         repeat: 2 /*RepeatType.UNPACKED*/,
         T: () => SubscribeOption,
       },
+      {
+        no: 11,
+        name: 'capabilities',
+        kind: 'enum',
+        repeat: 1 /*RepeatType.PACKED*/,
+        T: () => [
+          'stream.video.sfu.models.ClientCapability',
+          ClientCapability,
+          'CLIENT_CAPABILITY_',
+        ],
+      },
     ]);
   }
 }
@@ -1787,3 +1849,45 @@ class CallEnded$Type extends MessageType<CallEnded> {
  * @generated MessageType for protobuf message stream.video.sfu.event.CallEnded
  */
 export const CallEnded = new CallEnded$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InboundStateNotification$Type extends MessageType<InboundStateNotification> {
+  constructor() {
+    super('stream.video.sfu.event.InboundStateNotification', [
+      {
+        no: 1,
+        name: 'inbound_video_states',
+        kind: 'message',
+        repeat: 2 /*RepeatType.UNPACKED*/,
+        T: () => InboundVideoState,
+      },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.InboundStateNotification
+ */
+export const InboundStateNotification = new InboundStateNotification$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InboundVideoState$Type extends MessageType<InboundVideoState> {
+  constructor() {
+    super('stream.video.sfu.event.InboundVideoState', [
+      { no: 1, name: 'user_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+      { no: 2, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+      {
+        no: 3,
+        name: 'track_type',
+        kind: 'enum',
+        T: () => [
+          'stream.video.sfu.models.TrackType',
+          TrackType,
+          'TRACK_TYPE_',
+        ],
+      },
+      { no: 4, name: 'paused', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.InboundVideoState
+ */
+export const InboundVideoState = new InboundVideoState$Type();