livekit-client 0.16.5 → 0.17.1

package/src/room/RTCEngine.ts

@@ -1,7 +1,12 @@
 import { EventEmitter } from 'events';
+import type TypedEventEmitter from 'typed-emitter';
 import { SignalClient, SignalOptions } from '../api/SignalClient';
 import log from '../logger';
-import { DataPacket, DataPacket_Kind, TrackInfo } from '../proto/livekit_models';
+import {
+  ClientConfigSetting,
+  ClientConfiguration,
+  DataPacket, DataPacket_Kind, SpeakerInfo, TrackInfo, UserPacket,
+} from '../proto/livekit_models';
 import {
   AddTrackRequest, JoinResponse,
   LeaveRequest,
@@ -21,7 +26,9 @@ const maxReconnectDuration = 60 * 1000;
 export const maxICEConnectTimeout = 15 * 1000;
 
 /** @internal */
-export default class RTCEngine extends EventEmitter {
+export default class RTCEngine extends (
+  EventEmitter as new () => TypedEventEmitter<EngineEventCallbacks>
+) {
   publisher?: PCTransport;
 
   subscriber?: PCTransport;
@@ -65,7 +72,9 @@ export default class RTCEngine extends EventEmitter {
 
   private reconnectStart: number = 0;
 
-  private fullReconnect: boolean = false;
+  private fullReconnectOnNext: boolean = false;
+
+  private clientConfiguration?: ClientConfiguration;
 
   private connectedServerAddr?: string;
 
@@ -91,6 +100,7 @@ export default class RTCEngine extends EventEmitter {
     if (!this.subscriberPrimary) {
       this.negotiate();
     }
+    this.clientConfiguration = joinResponse.clientConfiguration;
 
     return joinResponse;
   }
@@ -164,6 +174,8 @@ export default class RTCEngine extends EventEmitter {
     this.publisher = new PCTransport(this.rtcConfig);
     this.subscriber = new PCTransport(this.rtcConfig);
 
+    this.emit(EngineEvent.TransportsCreated, this.publisher, this.subscriber);
+
     this.publisher.pc.onicecandidate = (ev) => {
       if (!ev.candidate) return;
       log.trace('adding ICE candidate for peer', ev.candidate);
@@ -296,7 +308,7 @@ export default class RTCEngine extends EventEmitter {
 
     this.client.onLeave = (leave?: LeaveRequest) => {
       if (leave?.canReconnect) {
-        this.fullReconnect = true;
+        this.fullReconnectOnNext = true;
         this.primaryPC = undefined;
       } else {
         this.emit(EngineEvent.Disconnected);
@@ -369,19 +381,19 @@ export default class RTCEngine extends EventEmitter {
       if (this.isClosed) {
         return;
       }
-      if (isFireFox()) {
-        // FF does not support DTLS restart.
-        this.fullReconnect = true;
+      if (isFireFox() // TODO remove once clientConfiguration handles firefox case server side
+        || this.clientConfiguration?.resumeConnection === ClientConfigSetting.DISABLED) {
+        this.fullReconnectOnNext = true;
       }
 
       try {
-        if (this.fullReconnect) {
+        if (this.fullReconnectOnNext) {
           await this.restartConnection();
         } else {
           await this.resumeConnection();
         }
         this.reconnectAttempts = 0;
-        this.fullReconnect = false;
+        this.fullReconnectOnNext = false;
       } catch (e) {
         this.reconnectAttempts += 1;
         let recoverable = true;
@@ -391,7 +403,7 @@ export default class RTCEngine extends EventEmitter {
           recoverable = false;
         } else if (!(e instanceof SignalReconnectError)) {
           // cannot resume
-          this.fullReconnect = true;
+          this.fullReconnectOnNext = true;
         }
 
         const duration = Date.now() - this.reconnectStart;
@@ -437,6 +449,7 @@ export default class RTCEngine extends EventEmitter {
     }
 
     await this.waitForPCConnected();
+    this.client.setReconnected();
 
     // reconnect success
     this.emit(EngineEvent.Restarted, joinResponse);
@@ -471,6 +484,7 @@ export default class RTCEngine extends EventEmitter {
     }
 
     await this.waitForPCConnected();
+    this.client.setReconnected();
 
     // resume success
     this.emit(EngineEvent.Resumed);
@@ -557,7 +571,7 @@ export default class RTCEngine extends EventEmitter {
     this.publisher.negotiate();
   }
 
-  private dataChannelForKind(kind: DataPacket_Kind): RTCDataChannel | undefined {
+  dataChannelForKind(kind: DataPacket_Kind): RTCDataChannel | undefined {
     if (kind === DataPacket_Kind.LOSSY) {
       return this.lossyDC;
     } if (kind === DataPacket_Kind.RELIABLE) {
@@ -602,3 +616,21 @@ async function getConnectedAddress(pc: RTCPeerConnection): Promise<string | unde
 
 class SignalReconnectError extends Error {
 }
+
+export type EngineEventCallbacks = {
+  connected: () => void,
+  disconnected: () => void,
+  resuming: () => void,
+  resumed: () => void,
+  restarting: () => void,
+  restarted: (joinResp: JoinResponse) => void,
+  signalResumed: () => void,
+  mediaTrackAdded: (
+    track: MediaStreamTrack,
+    streams: MediaStream,
+    receiver: RTCRtpReceiver
+  ) => void,
+  activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void,
+  dataPacketReceived: (userPacket: UserPacket, kind: DataPacket_Kind) => void,
+  transportsCreated: (publisher: PCTransport, subscriber: PCTransport) => void,
+};

package/src/room/Room.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'events';
+import type TypedEmitter from 'typed-emitter';
 import { toProtoSessionDescription } from '../api/SignalClient';
 import log from '../logger';
 import { RoomConnectOptions, RoomOptions } from '../options';
@@ -27,7 +28,8 @@ import LocalTrackPublication from './track/LocalTrackPublication';
 import RemoteTrackPublication from './track/RemoteTrackPublication';
 import { Track } from './track/Track';
 import { TrackPublication } from './track/TrackPublication';
-import { RemoteTrack } from './track/types';
+import { AdaptiveStreamSettings, RemoteTrack } from './track/types';
+import { getNewAudioContext } from './track/utils';
 import { unpackStreamId } from './utils';
 
 export enum RoomState {
@@ -44,7 +46,7 @@ export enum RoomState {
  *
  * @noInheritDoc
  */
-class Room extends EventEmitter {
+class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>) {
   state: RoomState = RoomState.Disconnected;
 
   /** map of sid: [[RemoteParticipant]] */
@@ -145,10 +147,12 @@ class Room extends EventEmitter {
       .on(EngineEvent.Resuming, () => {
         this.state = RoomState.Reconnecting;
         this.emit(RoomEvent.Reconnecting);
+        this.emit(RoomEvent.StateChanged, this.state);
       })
       .on(EngineEvent.Resumed, () => {
         this.state = RoomState.Connected;
         this.emit(RoomEvent.Reconnected);
+        this.emit(RoomEvent.StateChanged, this.state);
         this.updateSubscriptions();
       })
       .on(EngineEvent.SignalResumed, () => {
@@ -192,7 +196,7 @@ class Room extends EventEmitter {
 
     try {
       const joinResponse = await this.engine.join(url, token, opts);
-      log.debug('connected to Livekit Server', joinResponse.serverVersion);
+      log.debug(`connected to Livekit Server version: ${joinResponse.serverVersion}, region: ${joinResponse.serverRegion}`);
 
       if (!joinResponse.serverVersion) {
         throw new UnsupportedServer('unknown server version');
@@ -205,6 +209,7 @@ class Room extends EventEmitter {
       }
 
       this.state = RoomState.Connected;
+      this.emit(RoomEvent.StateChanged, this.state);
       const pi = joinResponse.participant!;
       this.localParticipant = new LocalParticipant(
         pi.sid,
@@ -216,10 +221,10 @@ class Room extends EventEmitter {
       this.localParticipant.updateInfo(pi);
       // forward metadata changed for the local participant
       this.localParticipant
-        .on(ParticipantEvent.MetadataChanged, (metadata: object) => {
+        .on(ParticipantEvent.MetadataChanged, (metadata: string | undefined) => {
           this.emit(RoomEvent.MetadataChanged, metadata, this.localParticipant);
         })
-        .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: object) => {
+        .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
           this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
         })
         .on(ParticipantEvent.TrackMuted, (pub: TrackPublication) => {
@@ -433,18 +438,27 @@ class Room extends EventEmitter {
     if (!trackId || trackId === '') trackId = mediaTrack.id;
 
     const participant = this.getOrCreateParticipant(participantId);
+    let adaptiveStreamSettings: AdaptiveStreamSettings | undefined;
+    if (this.options.adaptiveStream) {
+      if (typeof this.options.adaptiveStream === 'object') {
+        adaptiveStreamSettings = this.options.adaptiveStream;
+      } else {
+        adaptiveStreamSettings = {};
+      }
+    }
     participant.addSubscribedMediaTrack(
       mediaTrack,
       trackId,
       stream,
       receiver,
-      this.options.adaptiveStream,
+      adaptiveStreamSettings,
     );
   }
 
   private handleRestarting = () => {
     this.state = RoomState.Reconnecting;
     this.emit(RoomEvent.Reconnecting);
+    this.emit(RoomEvent.StateChanged, this.state);
 
     // also unwind existing participants & existing subscriptions
     for (const p of this.participants.values()) {
@@ -453,8 +467,10 @@ class Room extends EventEmitter {
   };
 
   private handleRestarted = async (joinResponse: JoinResponse) => {
+    log.debug('reconnected to server region', joinResponse.serverRegion);
     this.state = RoomState.Connected;
     this.emit(RoomEvent.Reconnected);
+    this.emit(RoomEvent.StateChanged, this.state);
 
     // rehydrate participants
     if (joinResponse.participant) {
@@ -509,6 +525,7 @@ class Room extends EventEmitter {
     navigator.mediaDevices.removeEventListener('devicechange', this.handleDeviceChange);
     this.state = RoomState.Disconnected;
     this.emit(RoomEvent.Disconnected);
+    this.emit(RoomEvent.StateChanged, this.state);
   }
 
   private handleParticipantUpdates = (participantInfos: ParticipantInfo[]) => {
@@ -710,73 +727,78 @@ class Room extends EventEmitter {
     }
     // by using an AudioContext, it reduces lag on audio elements
     // https://stackoverflow.com/questions/9811429/html5-audio-tag-on-safari-has-a-delay/54119854#54119854
-    // @ts-ignore
-    const AudioContext = window.AudioContext || window.webkitAudioContext;
-    if (AudioContext) {
-      this.audioContext = new AudioContext();
+    const ctx = getNewAudioContext();
+    if (ctx) {
+      this.audioContext = ctx;
     }
   }
 
+  private createParticipant(id: string, info?: ParticipantInfo): RemoteParticipant {
+    let participant: RemoteParticipant;
+    if (info) {
+      participant = RemoteParticipant.fromParticipantInfo(
+        this.engine.client,
+        info,
+      );
+    } else {
+      participant = new RemoteParticipant(this.engine.client, id, '');
+    }
+    return participant;
+  }
+
   private getOrCreateParticipant(
     id: string,
     info?: ParticipantInfo,
   ): RemoteParticipant {
-    let participant = this.participants.get(id);
-    if (!participant) {
-      // it's possible for the RTC track to arrive before signaling data
-      // when this happens, we'll create the participant and make the track work
-      if (info) {
-        participant = RemoteParticipant.fromParticipantInfo(
-          this.engine.client,
-          info,
-        );
-      } else {
-        participant = new RemoteParticipant(this.engine.client, id, '');
-      }
-      this.participants.set(id, participant);
-      // also forward events
-
-      // trackPublished is only fired for tracks added after both local participant
-      // and remote participant joined the room
-      participant
-        .on(ParticipantEvent.TrackPublished, (trackPublication: RemoteTrackPublication) => {
-          this.emit(RoomEvent.TrackPublished, trackPublication, participant);
-        })
-        .on(ParticipantEvent.TrackSubscribed,
-          (track: RemoteTrack, publication: RemoteTrackPublication) => {
-            // monitor playback status
-            if (track.kind === Track.Kind.Audio) {
-              track.on(TrackEvent.AudioPlaybackStarted, this.handleAudioPlaybackStarted);
-              track.on(TrackEvent.AudioPlaybackFailed, this.handleAudioPlaybackFailed);
-            }
-            this.emit(RoomEvent.TrackSubscribed, track, publication, participant);
-          })
-        .on(ParticipantEvent.TrackUnpublished, (publication: RemoteTrackPublication) => {
-          this.emit(RoomEvent.TrackUnpublished, publication, participant);
-        })
-        .on(ParticipantEvent.TrackUnsubscribed,
-          (track: RemoteTrack, publication: RemoteTrackPublication) => {
-            this.emit(RoomEvent.TrackUnsubscribed, track, publication, participant);
-          })
-        .on(ParticipantEvent.TrackSubscriptionFailed, (sid: string) => {
-          this.emit(RoomEvent.TrackSubscriptionFailed, sid, participant);
-        })
-        .on(ParticipantEvent.TrackMuted, (pub: TrackPublication) => {
-          this.emit(RoomEvent.TrackMuted, pub, participant);
-        })
-        .on(ParticipantEvent.TrackUnmuted, (pub: TrackPublication) => {
-          this.emit(RoomEvent.TrackUnmuted, pub, participant);
-        })
-        .on(ParticipantEvent.MetadataChanged, (metadata: any) => {
-          this.emit(RoomEvent.MetadataChanged, metadata, participant);
+    if (this.participants.has(id)) {
+      return (this.participants.get(id) as RemoteParticipant);
+    }
+    // it's possible for the RTC track to arrive before signaling data
+    // when this happens, we'll create the participant and make the track work
+    const participant = this.createParticipant(id, info);
+    this.participants.set(id, participant);
+
+    // also forward events
+    // trackPublished is only fired for tracks added after both local participant
+    // and remote participant joined the room
+    participant
+      .on(ParticipantEvent.TrackPublished, (trackPublication: RemoteTrackPublication) => {
+        this.emit(RoomEvent.TrackPublished, trackPublication, participant);
+      })
+      .on(ParticipantEvent.TrackSubscribed,
+        (track: RemoteTrack, publication: RemoteTrackPublication) => {
+          // monitor playback status
+          if (track.kind === Track.Kind.Audio) {
+            track.on(TrackEvent.AudioPlaybackStarted, this.handleAudioPlaybackStarted);
+            track.on(TrackEvent.AudioPlaybackFailed, this.handleAudioPlaybackFailed);
+          }
+          this.emit(RoomEvent.TrackSubscribed, track, publication, participant);
         })
-        .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: any) => {
-          this.emit(RoomEvent.ParticipantMetadataChanged, metadata, participant);
+      .on(ParticipantEvent.TrackUnpublished, (publication: RemoteTrackPublication) => {
+        this.emit(RoomEvent.TrackUnpublished, publication, participant);
+      })
+      .on(ParticipantEvent.TrackUnsubscribed,
+        (track: RemoteTrack, publication: RemoteTrackPublication) => {
+          this.emit(RoomEvent.TrackUnsubscribed, track, publication, participant);
         })
-        .on(ParticipantEvent.ConnectionQualityChanged, (quality: ConnectionQuality) => {
-          this.emit(RoomEvent.ConnectionQualityChanged, quality, participant);
-        });
-    }
+      .on(ParticipantEvent.TrackSubscriptionFailed, (sid: string) => {
+        this.emit(RoomEvent.TrackSubscriptionFailed, sid, participant);
+      })
+      .on(ParticipantEvent.TrackMuted, (pub: TrackPublication) => {
+        this.emit(RoomEvent.TrackMuted, pub, participant);
+      })
+      .on(ParticipantEvent.TrackUnmuted, (pub: TrackPublication) => {
+        this.emit(RoomEvent.TrackUnmuted, pub, participant);
+      })
+      .on(ParticipantEvent.MetadataChanged, (metadata: string | undefined) => {
+        this.emit(RoomEvent.MetadataChanged, metadata, participant);
+      })
+      .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
+        this.emit(RoomEvent.ParticipantMetadataChanged, metadata, participant);
+      })
+      .on(ParticipantEvent.ConnectionQualityChanged, (quality: ConnectionQuality) => {
+        this.emit(RoomEvent.ConnectionQualityChanged, quality, participant);
+      });
     return participant;
   }
 
@@ -813,6 +835,7 @@ class Room extends EventEmitter {
         participantTracks: [],
       },
       publishTracks: this.localParticipant.publishedTracksInfo(),
+      dataChannels: this.localParticipant.dataChannelsInfo(),
     });
   }
 
@@ -830,11 +853,74 @@ class Room extends EventEmitter {
     }
   }
 
-  /** @internal */
-  emit(event: string | symbol, ...args: any[]): boolean {
+  // /** @internal */
+  emit<E extends keyof RoomEventCallbacks>(
+    event: E, ...args: Parameters<RoomEventCallbacks[E]>
+  ): boolean {
     log.debug('room event', event, ...args);
     return super.emit(event, ...args);
   }
 }
 
 export default Room;
+
+export type RoomEventCallbacks = {
+  reconnecting: () => void,
+  reconnected: () => void,
+  disconnected: () => void,
+  stateChanged: (state: RoomState) => void,
+  mediaDevicesChanged: () => void,
+  participantConnected: (participant: RemoteParticipant) => void,
+  participantDisconnected: (participant: RemoteParticipant) => void,
+  trackPublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void,
+  trackSubscribed: (
+    track: RemoteTrack,
+    publication: RemoteTrackPublication,
+    participant: RemoteParticipant
+  ) => void,
+  trackSubscriptionFailed: (trackSid: string, participant: RemoteParticipant) => void,
+  trackUnpublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void,
+  trackUnsubscribed: (
+    track: RemoteTrack,
+    publication: RemoteTrackPublication,
+    participant: RemoteParticipant,
+  ) => void,
+  trackMuted: (publication: TrackPublication, participant: Participant) => void,
+  trackUnmuted: (publication: TrackPublication, participant: Participant) => void,
+  localTrackPublished: (publication: LocalTrackPublication, participant: LocalParticipant) => void,
+  localTrackUnpublished: (
+    publication: LocalTrackPublication,
+    participant: LocalParticipant
+  ) => void,
+  /**
+   * @deprecated use [[participantMetadataChanged]] instead
+  */
+  metadataChanged: (
+    metadata: string | undefined,
+    participant?: RemoteParticipant | LocalParticipant
+  ) => void,
+  participantMetadataChanged: (
+    metadata: string | undefined,
+    participant: RemoteParticipant | LocalParticipant
+  ) => void,
+  activeSpeakersChanged: (speakers: Array<Participant>) => void,
+  roomMetadataChanged: (metadata: string) => void,
+  dataReceived: (
+    payload: Uint8Array,
+    participant?: RemoteParticipant,
+    kind?: DataPacket_Kind
+  ) => void,
+  connectionQualityChanged: (quality: ConnectionQuality, participant: Participant) => void,
+  mediaDevicesError: (error: Error) => void,
+  trackStreamStateChanged: (
+    publication: RemoteTrackPublication,
+    streamState: Track.StreamState,
+    participant: RemoteParticipant,
+  ) => void,
+  trackSubscriptionPermissionChanged: (
+    publication: RemoteTrackPublication,
+    status: TrackPublication.SubscriptionStatus,
+    participant: RemoteParticipant,
+  ) => void,
+  audioPlaybackChanged: (playing: boolean) => void,
+};

package/src/room/events.ts

@@ -7,6 +7,7 @@
  * room.on(RoomEvent.TrackPublished, (track, publication, participant) => {})
  * ```
  */
+
 export enum RoomEvent {
   /**
    * When the connection to the server has been interrupted and it's attempting
@@ -25,6 +26,13 @@ export enum RoomEvent {
    */
   Disconnected = 'disconnected',
 
+  /**
+   * Whenever the connection state of the room changes
+   *
+   * args: ([[RoomState]])
+   */
+  StateChanged = 'stateChanged',
+
   /**
    * When input or output devices on the machine have changed.
    */
@@ -146,7 +154,7 @@ export enum RoomEvent {
    * args: (prevMetadata: string, [[Participant]])
    *
    */
-  ParticipantMetadataChanged = 'participantMetaDataChanged',
+  ParticipantMetadataChanged = 'participantMetadataChanged',
 
   /**
    * Room metadata is a simple way for app-specific state to be pushed to
@@ -177,7 +185,7 @@ export enum RoomEvent {
   ConnectionQualityChanged = 'connectionQualityChanged',
 
   /**
-   * StreamState indicates if a subscribed track has been paused by the SFU
+   * StreamState indicates if a subscribed (remote) track has been paused by the SFU
    * (typically this happens because of subscriber's bandwidth constraints)
    *
    * When bandwidth conditions allow, the track will be resumed automatically.
@@ -366,6 +374,7 @@ export enum ParticipantEvent {
 
 /** @internal */
 export enum EngineEvent {
+  TransportsCreated = 'transportsCreated',
   Connected = 'connected',
   Disconnected = 'disconnected',
   Resuming = 'resuming',
@@ -391,6 +400,11 @@ export enum TrackEvent {
   AudioPlaybackStarted = 'audioPlaybackStarted',
   /** @internal */
   AudioPlaybackFailed = 'audioPlaybackFailed',
+  /**
+   * @internal
+   * Only fires on LocalAudioTrack instances
+  */
+  AudioSilenceDetected = 'audioSilenceDetected',
   /** @internal */
   VisibilityChanged = 'visibilityChanged',
   /** @internal */

package/src/room/participant/LocalParticipant.ts

@@ -3,7 +3,9 @@ import { RoomOptions } from '../../options';
 import {
   DataPacket, DataPacket_Kind,
 } from '../../proto/livekit_models';
-import { AddTrackRequest, SubscribedQualityUpdate, TrackPublishedResponse } from '../../proto/livekit_rtc';
+import {
+  AddTrackRequest, DataChannelInfo, SubscribedQualityUpdate, TrackPublishedResponse,
+} from '../../proto/livekit_rtc';
 import {
   TrackInvalidError,
   UnexpectedConnectionState,
@@ -17,7 +19,8 @@ import LocalVideoTrack, { videoLayersFromEncodings } from '../track/LocalVideoTr
 import {
   CreateLocalTracksOptions,
   ScreenShareCaptureOptions,
-  TrackPublishOptions, VideoCodec, VideoPresets,
+  ScreenSharePresets,
+  TrackPublishOptions, VideoCodec,
 } from '../track/options';
 import { Track } from '../track/Track';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
@@ -272,7 +275,7 @@ export default class LocalParticipant extends Participant {
       options = {};
     }
     if (options.resolution === undefined) {
-      options.resolution = VideoPresets.fhd.resolution;
+      options.resolution = ScreenSharePresets.h1080fps15.resolution;
     }
 
     let videoConstraints: MediaTrackConstraints | boolean = true;
@@ -525,7 +528,7 @@ export default class LocalParticipant extends Participant {
     destination?: RemoteParticipant[] | string[]) {
     const dest: string[] = [];
     if (destination !== undefined) {
-      destination.forEach((val : any) => {
+      destination.forEach((val: any) => {
         if (val instanceof RemoteParticipant) {
           dest.push(val.sid);
         } else {
@@ -681,4 +684,20 @@ export default class LocalParticipant extends Participant {
     });
     return infos;
   }
+
+  /** @internal */
+  dataChannelsInfo(): DataChannelInfo[] {
+    const infos: DataChannelInfo[] = [];
+    const getInfo = (dc: RTCDataChannel | undefined) => {
+      if (dc?.id !== undefined && dc.id !== null) {
+        infos.push({
+          label: dc.label,
+          id: dc.id,
+        });
+      }
+    };
+    getInfo(this.engine.dataChannelForKind(DataPacket_Kind.LOSSY));
+    getInfo(this.engine.dataChannelForKind(DataPacket_Kind.RELIABLE));
+    return infos;
+  }
 }

package/src/room/participant/Participant.ts

@@ -1,8 +1,12 @@
 import { EventEmitter } from 'events';
-import { ConnectionQuality as ProtoQuality, ParticipantInfo } from '../../proto/livekit_models';
+import type TypedEmitter from 'typed-emitter';
+import { ConnectionQuality as ProtoQuality, DataPacket_Kind, ParticipantInfo } from '../../proto/livekit_models';
 import { ParticipantEvent, TrackEvent } from '../events';
+import LocalTrackPublication from '../track/LocalTrackPublication';
+import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
 import { TrackPublication } from '../track/TrackPublication';
+import { RemoteTrack } from '../track/types';
 
 export enum ConnectionQuality {
   Excellent = 'excellent',
@@ -24,7 +28,9 @@ function qualityFromProto(q: ProtoQuality): ConnectionQuality {
   }
 }
 
-export default class Participant extends EventEmitter {
+export default class Participant extends (
+  EventEmitter as new () => TypedEmitter<ParticipantEventCallbacks>
+) {
   protected participantInfo?: ParticipantInfo;
 
   audioTracks: Map<string, TrackPublication>;
@@ -158,8 +164,8 @@ export default class Participant extends EventEmitter {
     this.metadata = md;
 
     if (changed) {
-      this.emit(ParticipantEvent.MetadataChanged, prevMetadata, this);
-      this.emit(ParticipantEvent.ParticipantMetadataChanged, prevMetadata, this);
+      this.emit(ParticipantEvent.MetadataChanged, prevMetadata);
+      this.emit(ParticipantEvent.ParticipantMetadataChanged, prevMetadata);
     }
   }
 
@@ -212,3 +218,32 @@ export default class Participant extends EventEmitter {
     }
   }
 }
+
+export type ParticipantEventCallbacks = {
+  trackPublished: (publication: RemoteTrackPublication) => void,
+  trackSubscribed: (track: RemoteTrack, publication: RemoteTrackPublication) => void,
+  trackSubscriptionFailed: (trackSid: string) => void,
+  trackUnpublished: (publication: RemoteTrackPublication) => void,
+  trackUnsubscribed: (track: RemoteTrack, publication: RemoteTrackPublication) => void,
+  trackMuted: (publication: TrackPublication) => void,
+  trackUnmuted: (publication: TrackPublication) => void,
+  localTrackPublished: (publication: LocalTrackPublication) => void,
+  localTrackUnpublished: (publication: LocalTrackPublication) => void,
+  /**
+   * @deprecated use [[participantMetadataChanged]] instead
+   */
+  metadataChanged: (prevMetadata: string | undefined, participant?: any) => void,
+  participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void,
+  dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void,
+  isSpeakingChanged: (speaking: boolean) => void,
+  connectionQualityChanged: (connectionQuality: ConnectionQuality) => void,
+  trackStreamStateChanged: (
+    publication: RemoteTrackPublication,
+    streamState: Track.StreamState
+  ) => void,
+  trackSubscriptionPermissionChanged: (
+    publication: RemoteTrackPublication,
+    status: TrackPublication.SubscriptionStatus
+  ) => void,
+  mediaDevicesError: (error: Error) => void,
+};