livekit-client 1.4.4 → 1.6.0

package/dist/ts4.2/src/room/events.d.ts

@@ -0,0 +1,426 @@
+/**
+ * Events are the primary way LiveKit notifies your application of changes.
+ *
+ * The following are events emitted by [[Room]], listen to room events like
+ *
+ * ```typescript
+ * room.on(RoomEvent.TrackPublished, (track, publication, participant) => {})
+ * ```
+ */
+export declare enum RoomEvent {
+    /**
+     * When the connection to the server has been established
+     */
+    Connected = "connected",
+    /**
+     * When the connection to the server has been interrupted and it's attempting
+     * to reconnect.
+     */
+    Reconnecting = "reconnecting",
+    /**
+     * Fires when a reconnection has been successful.
+     */
+    Reconnected = "reconnected",
+    /**
+     * When disconnected from room. This fires when room.disconnect() is called or
+     * when an unrecoverable connection issue had occured
+     */
+    Disconnected = "disconnected",
+    /**
+     * Whenever the connection state of the room changes
+     *
+     * args: ([[ConnectionState]])
+     */
+    ConnectionStateChanged = "connectionStateChanged",
+    /**
+     * @deprecated StateChanged has been renamed to ConnectionStateChanged
+     */
+    StateChanged = "connectionStateChanged",
+    /**
+     * When input or output devices on the machine have changed.
+     */
+    MediaDevicesChanged = "mediaDevicesChanged",
+    /**
+     * When a [[RemoteParticipant]] joins *after* the local
+     * participant. It will not emit events for participants that are already
+     * in the room
+     *
+     * args: ([[RemoteParticipant]])
+     */
+    ParticipantConnected = "participantConnected",
+    /**
+     * When a [[RemoteParticipant]] leaves *after* the local
+     * participant has joined.
+     *
+     * args: ([[RemoteParticipant]])
+     */
+    ParticipantDisconnected = "participantDisconnected",
+    /**
+     * When a new track is published to room *after* the local
+     * participant has joined. It will not fire for tracks that are already published.
+     *
+     * A track published doesn't mean the participant has subscribed to it. It's
+     * simply reflecting the state of the room.
+     *
+     * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
+     */
+    TrackPublished = "trackPublished",
+    /**
+     * The [[LocalParticipant]] has subscribed to a new track. This event will **always**
+     * fire as long as new tracks are ready for use.
+     *
+     * args: ([[RemoteTrack]], [[RemoteTrackPublication]], [[RemoteParticipant]])
+     */
+    TrackSubscribed = "trackSubscribed",
+    /**
+     * Could not subscribe to a track
+     *
+     * args: (track sid, [[RemoteParticipant]])
+     */
+    TrackSubscriptionFailed = "trackSubscriptionFailed",
+    /**
+     * A [[RemoteParticipant]] has unpublished a track
+     *
+     * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
+     */
+    TrackUnpublished = "trackUnpublished",
+    /**
+     * A subscribed track is no longer available. Clients should listen to this
+     * event and ensure they detach tracks.
+     *
+     * args: ([[Track]], [[RemoteTrackPublication]], [[RemoteParticipant]])
+     */
+    TrackUnsubscribed = "trackUnsubscribed",
+    /**
+     * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+     *
+     * args: ([[TrackPublication]], [[Participant]])
+     */
+    TrackMuted = "trackMuted",
+    /**
+     * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+     *
+     * args: ([[TrackPublication]], [[Participant]])
+     */
+    TrackUnmuted = "trackUnmuted",
+    /**
+     * A local track was published successfully. This event is helpful to know
+     * when to update your local UI with the newly published track.
+     *
+     * args: ([[LocalTrackPublication]], [[LocalParticipant]])
+     */
+    LocalTrackPublished = "localTrackPublished",
+    /**
+     * A local track was unpublished. This event is helpful to know when to remove
+     * the local track from your UI.
+     *
+     * When a user stops sharing their screen by pressing "End" on the browser UI,
+     * this event will also fire.
+     *
+     * args: ([[LocalTrackPublication]], [[LocalParticipant]])
+     */
+    LocalTrackUnpublished = "localTrackUnpublished",
+    /**
+     * Active speakers changed. List of speakers are ordered by their audio level.
+     * loudest speakers first. This will include the LocalParticipant too.
+     *
+     * Speaker updates are sent only to the publishing participant and their subscribers.
+     *
+     * args: (Array<[[Participant]]>)
+     */
+    ActiveSpeakersChanged = "activeSpeakersChanged",
+    /**
+     * Participant metadata is a simple way for app-specific state to be pushed to
+     * all users.
+     * When RoomService.UpdateParticipantMetadata is called to change a participant's
+     * state, *all*  participants in the room will fire this event.
+     *
+     * args: (prevMetadata: string, [[Participant]])
+     *
+     */
+    ParticipantMetadataChanged = "participantMetadataChanged",
+    /**
+     * Room metadata is a simple way for app-specific state to be pushed to
+     * all users.
+     * When RoomService.UpdateRoomMetadata is called to change a room's state,
+     * *all*  participants in the room will fire this event.
+     *
+     * args: (string)
+     */
+    RoomMetadataChanged = "roomMetadataChanged",
+    /**
+     * Data received from another participant.
+     * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
+     * All participants in the room will receive the messages sent to the room.
+     *
+     * args: (payload: Uint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]])
+     */
+    DataReceived = "dataReceived",
+    /**
+     * Connection quality was changed for a Participant. It'll receive updates
+     * from the local participant, as well as any [[RemoteParticipant]]s that we are
+     * subscribed to.
+     *
+     * args: (connectionQuality: [[ConnectionQuality]], participant: [[Participant]])
+     */
+    ConnectionQualityChanged = "connectionQualityChanged",
+    /**
+     * 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.
+     * TrackStreamStateChanged will also be emitted when that happens.
+     *
+     * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]],
+     *        participant: [[RemoteParticipant]])
+     */
+    TrackStreamStateChanged = "trackStreamStateChanged",
+    /**
+     * One of subscribed tracks have changed its permissions for the current
+     * participant. If permission was revoked, then the track will no longer
+     * be subscribed. If permission was granted, a TrackSubscribed event will
+     * be emitted.
+     *
+     * args: (pub: [[RemoteTrackPublication]],
+     *        status: [[TrackPublication.SubscriptionStatus]],
+     *        participant: [[RemoteParticipant]])
+     */
+    TrackSubscriptionPermissionChanged = "trackSubscriptionPermissionChanged",
+    /**
+     * One of subscribed tracks have changed its status for the current
+     * participant.
+     *
+     * args: (pub: [[RemoteTrackPublication]],
+     *        status: [[TrackPublication.SubscriptionStatus]],
+     *        participant: [[RemoteParticipant]])
+     */
+    TrackSubscriptionStatusChanged = "trackSubscriptionStatusChanged",
+    /**
+     * LiveKit will attempt to autoplay all audio tracks when you attach them to
+     * audio elements. However, if that fails, we'll notify you via AudioPlaybackStatusChanged.
+     * `Room.canPlayAudio` will indicate if audio playback is permitted.
+     */
+    AudioPlaybackStatusChanged = "audioPlaybackChanged",
+    /**
+     * When we have encountered an error while attempting to create a track.
+     * The errors take place in getUserMedia().
+     * Use MediaDeviceFailure.getFailure(error) to get the reason of failure.
+     * [[LocalParticipant.lastCameraError]] and [[LocalParticipant.lastMicrophoneError]]
+     * will indicate if it had an error while creating the audio or video track respectively.
+     *
+     * args: (error: Error)
+     */
+    MediaDevicesError = "mediaDevicesError",
+    /**
+     * A participant's permission has changed. Currently only fired on LocalParticipant.
+     * args: (prevPermissions: [[ParticipantPermission]], participant: [[Participant]])
+     */
+    ParticipantPermissionsChanged = "participantPermissionsChanged",
+    /**
+     * Signal connected, can publish tracks.
+     */
+    SignalConnected = "signalConnected",
+    /**
+     * Recording of a room has started/stopped.
+     */
+    RecordingStatusChanged = "recordingStatusChanged"
+}
+export declare enum ParticipantEvent {
+    /**
+     * When a new track is published to room *after* the local
+     * participant has joined. It will not fire for tracks that are already published.
+     *
+     * A track published doesn't mean the participant has subscribed to it. It's
+     * simply reflecting the state of the room.
+     *
+     * args: ([[RemoteTrackPublication]])
+     */
+    TrackPublished = "trackPublished",
+    /**
+     * Successfully subscribed to the [[RemoteParticipant]]'s track.
+     * This event will **always** fire as long as new tracks are ready for use.
+     *
+     * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
+     */
+    TrackSubscribed = "trackSubscribed",
+    /**
+     * Could not subscribe to a track
+     *
+     * args: (track sid)
+     */
+    TrackSubscriptionFailed = "trackSubscriptionFailed",
+    /**
+     * A [[RemoteParticipant]] has unpublished a track
+     *
+     * args: ([[RemoteTrackPublication]])
+     */
+    TrackUnpublished = "trackUnpublished",
+    /**
+     * A subscribed track is no longer available. Clients should listen to this
+     * event and ensure they detach tracks.
+     *
+     * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
+     */
+    TrackUnsubscribed = "trackUnsubscribed",
+    /**
+     * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+     *
+     * args: ([[TrackPublication]])
+     */
+    TrackMuted = "trackMuted",
+    /**
+     * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+     *
+     * args: ([[TrackPublication]])
+     */
+    TrackUnmuted = "trackUnmuted",
+    /**
+     * A local track was published successfully. This event is helpful to know
+     * when to update your local UI with the newly published track.
+     *
+     * args: ([[LocalTrackPublication]])
+     */
+    LocalTrackPublished = "localTrackPublished",
+    /**
+     * A local track was unpublished. This event is helpful to know when to remove
+     * the local track from your UI.
+     *
+     * When a user stops sharing their screen by pressing "End" on the browser UI,
+     * this event will also fire.
+     *
+     * args: ([[LocalTrackPublication]])
+     */
+    LocalTrackUnpublished = "localTrackUnpublished",
+    /**
+     * Participant metadata is a simple way for app-specific state to be pushed to
+     * all users.
+     * When RoomService.UpdateParticipantMetadata is called to change a participant's
+     * state, *all*  participants in the room will fire this event.
+     * To access the current metadata, see [[Participant.metadata]].
+     *
+     * args: (prevMetadata: string)
+     *
+     */
+    ParticipantMetadataChanged = "participantMetadataChanged",
+    /**
+     * Data received from this participant as sender.
+     * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
+     * All participants in the room will receive the messages sent to the room.
+     *
+     * args: (payload: Uint8Array, kind: [[DataPacket_Kind]])
+     */
+    DataReceived = "dataReceived",
+    /**
+     * Has speaking status changed for the current participant
+     *
+     * args: (speaking: boolean)
+     */
+    IsSpeakingChanged = "isSpeakingChanged",
+    /**
+     * Connection quality was changed for a Participant. It'll receive updates
+     * from the local participant, as well as any [[RemoteParticipant]]s that we are
+     * subscribed to.
+     *
+     * args: (connectionQuality: [[ConnectionQuality]])
+     */
+    ConnectionQualityChanged = "connectionQualityChanged",
+    /**
+     * StreamState indicates if a subscribed 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.
+     * TrackStreamStateChanged will also be emitted when that happens.
+     *
+     * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]])
+     */
+    TrackStreamStateChanged = "trackStreamStateChanged",
+    /**
+     * One of subscribed tracks have changed its permissions for the current
+     * participant. If permission was revoked, then the track will no longer
+     * be subscribed. If permission was granted, a TrackSubscribed event will
+     * be emitted.
+     *
+     * args: (pub: [[RemoteTrackPublication]],
+     *        status: [[TrackPublication.SubscriptionStatus]])
+     */
+    TrackSubscriptionPermissionChanged = "trackSubscriptionPermissionChanged",
+    /**
+     * One of the remote participants publications has changed its subscription status.
+     *
+     */
+    TrackSubscriptionStatusChanged = "trackSubscriptionStatusChanged",
+    /** @internal */
+    MediaDevicesError = "mediaDevicesError",
+    /**
+     * A participant's permission has changed. Currently only fired on LocalParticipant.
+     * args: (prevPermissions: [[ParticipantPermission]])
+     */
+    ParticipantPermissionsChanged = "participantPermissionsChanged"
+}
+/** @internal */
+export declare enum EngineEvent {
+    TransportsCreated = "transportsCreated",
+    Connected = "connected",
+    Disconnected = "disconnected",
+    Resuming = "resuming",
+    Resumed = "resumed",
+    Restarting = "restarting",
+    Restarted = "restarted",
+    SignalResumed = "signalResumed",
+    MediaTrackAdded = "mediaTrackAdded",
+    ActiveSpeakersUpdate = "activeSpeakersUpdate",
+    DataPacketReceived = "dataPacketReceived"
+}
+export declare enum TrackEvent {
+    Message = "message",
+    Muted = "muted",
+    Unmuted = "unmuted",
+    /**
+     * Only fires on LocalTracks
+     */
+    Restarted = "restarted",
+    Ended = "ended",
+    Subscribed = "subscribed",
+    Unsubscribed = "unsubscribed",
+    /** @internal */
+    UpdateSettings = "updateSettings",
+    /** @internal */
+    UpdateSubscription = "updateSubscription",
+    /** @internal */
+    AudioPlaybackStarted = "audioPlaybackStarted",
+    /** @internal */
+    AudioPlaybackFailed = "audioPlaybackFailed",
+    /**
+     * @internal
+     * Only fires on LocalAudioTrack instances
+     */
+    AudioSilenceDetected = "audioSilenceDetected",
+    /** @internal */
+    VisibilityChanged = "visibilityChanged",
+    /** @internal */
+    VideoDimensionsChanged = "videoDimensionsChanged",
+    /** @internal */
+    ElementAttached = "elementAttached",
+    /** @internal */
+    ElementDetached = "elementDetached",
+    /**
+     * @internal
+     * Only fires on LocalTracks
+     */
+    UpstreamPaused = "upstreamPaused",
+    /**
+     * @internal
+     * Only fires on LocalTracks
+     */
+    UpstreamResumed = "upstreamResumed",
+    /**
+     * @internal
+     * Fires on RemoteTrackPublication
+     */
+    SubscriptionPermissionChanged = "subscriptionPermissionChanged",
+    /**
+     * Fires on RemoteTrackPublication
+     */
+    SubscriptionStatusChanged = "subscriptionStatusChanged"
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/ts4.2/src/room/participant/LocalParticipant.d.ts

@@ -0,0 +1,141 @@
+import 'webrtc-adapter';
+import type { InternalRoomOptions } from '../../options';
+import { DataPacket_Kind, ParticipantInfo, ParticipantPermission } from '../../proto/livekit_models';
+import { DataChannelInfo, TrackPublishedResponse } from '../../proto/livekit_rtc';
+import type RTCEngine from '../RTCEngine';
+import LocalTrack from '../track/LocalTrack';
+import LocalTrackPublication from '../track/LocalTrackPublication';
+import { AudioCaptureOptions, BackupVideoCodec, CreateLocalTracksOptions, ScreenShareCaptureOptions, TrackPublishOptions, VideoCaptureOptions } from '../track/options';
+import { Track } from '../track/Track';
+import Participant from './Participant';
+import { ParticipantTrackPermission } from './ParticipantTrackPermission';
+import RemoteParticipant from './RemoteParticipant';
+export default class LocalParticipant extends Participant {
+    audioTracks: Map<string, LocalTrackPublication>;
+    videoTracks: Map<string, LocalTrackPublication>;
+    /** map of track sid => all published tracks */
+    tracks: Map<string, LocalTrackPublication>;
+    /** @internal */
+    engine: RTCEngine;
+    private pendingPublishing;
+    private cameraError;
+    private microphoneError;
+    private participantTrackPermissions;
+    private allParticipantsAllowedToSubscribe;
+    private roomOptions;
+    /** @internal */
+    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions);
+    get lastCameraError(): Error | undefined;
+    get lastMicrophoneError(): Error | undefined;
+    getTrack(source: Track.Source): LocalTrackPublication | undefined;
+    getTrackByName(name: string): LocalTrackPublication | undefined;
+    /**
+     * @internal
+     */
+    setupEngine(engine: RTCEngine): void;
+    /**
+     * Enable or disable a participant's camera track.
+     *
+     * If a track has already published, it'll mute or unmute the track.
+     * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
+     */
+    setCameraEnabled(enabled: boolean, options?: VideoCaptureOptions, publishOptions?: TrackPublishOptions): Promise<LocalTrackPublication | undefined>;
+    /**
+     * Enable or disable a participant's microphone track.
+     *
+     * If a track has already published, it'll mute or unmute the track.
+     * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
+     */
+    setMicrophoneEnabled(enabled: boolean, options?: AudioCaptureOptions, publishOptions?: TrackPublishOptions): Promise<LocalTrackPublication | undefined>;
+    /**
+     * Start or stop sharing a participant's screen
+     * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
+     */
+    setScreenShareEnabled(enabled: boolean, options?: ScreenShareCaptureOptions, publishOptions?: TrackPublishOptions): Promise<LocalTrackPublication | undefined>;
+    /** @internal */
+    setPermissions(permissions: ParticipantPermission): boolean;
+    /**
+     * Enable or disable publishing for a track by source. This serves as a simple
+     * way to manage the common tracks (camera, mic, or screen share).
+     * Resolves with LocalTrackPublication if successful and void otherwise
+     */
+    private setTrackEnabled;
+    /**
+     * Publish both camera and microphone at the same time. This is useful for
+     * displaying a single Permission Dialog box to the end user.
+     */
+    enableCameraAndMicrophone(): Promise<void>;
+    /**
+     * Create local camera and/or microphone tracks
+     * @param options
+     * @returns
+     */
+    createTracks(options?: CreateLocalTracksOptions): Promise<LocalTrack[]>;
+    /**
+     * Creates a screen capture tracks with getDisplayMedia().
+     * A LocalVideoTrack is always created and returned.
+     * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
+     */
+    createScreenTracks(options?: ScreenShareCaptureOptions): Promise<Array<LocalTrack>>;
+    /**
+     * Publish a new track to the room
+     * @param track
+     * @param options
+     */
+    publishTrack(track: LocalTrack | MediaStreamTrack, options?: TrackPublishOptions): Promise<LocalTrackPublication>;
+    get isLocal(): boolean;
+    /** @internal
+     * publish additional codec to existing track
+     */
+    publishAdditionalCodecForTrack(track: LocalTrack | MediaStreamTrack, videoCodec: BackupVideoCodec, options?: TrackPublishOptions): Promise<void>;
+    unpublishTrack(track: LocalTrack | MediaStreamTrack, stopOnUnpublish?: boolean): LocalTrackPublication | undefined;
+    unpublishTracks(tracks: LocalTrack[] | MediaStreamTrack[]): LocalTrackPublication[];
+    /**
+     * Publish a new data payload to the room. Data will be forwarded to each
+     * participant in the room if the destination argument is empty
+     *
+     * @param data Uint8Array of the payload. To send string data, use TextEncoder.encode
+     * @param kind whether to send this as reliable or lossy.
+     * For data that you need delivery guarantee (such as chat messages), use Reliable.
+     * For data that should arrive as quickly as possible, but you are ok with dropped
+     * packets, use Lossy.
+     * @param destination the participants who will receive the message
+     */
+    publishData(data: Uint8Array, kind: DataPacket_Kind, destination?: RemoteParticipant[] | string[]): Promise<void>;
+    /**
+     * Control who can subscribe to LocalParticipant's published tracks.
+     *
+     * By default, all participants can subscribe. This allows fine-grained control over
+     * who is able to subscribe at a participant and track level.
+     *
+     * Note: if access is given at a track-level (i.e. both [allParticipantsAllowed] and
+     * [ParticipantTrackPermission.allTracksAllowed] are false), any newer published tracks
+     * will not grant permissions to any participants and will require a subsequent
+     * permissions update to allow subscription.
+     *
+     * @param allParticipantsAllowed Allows all participants to subscribe all tracks.
+     *  Takes precedence over [[participantTrackPermissions]] if set to true.
+     *  By default this is set to true.
+     * @param participantTrackPermissions Full list of individual permissions per
+     *  participant/track. Any omitted participants will not receive any permissions.
+     */
+    setTrackSubscriptionPermissions(allParticipantsAllowed: boolean, participantTrackPermissions?: ParticipantTrackPermission[]): void;
+    /** @internal */
+    updateInfo(info: ParticipantInfo): void;
+    private updateTrackSubscriptionPermissions;
+    /** @internal */
+    private onTrackUnmuted;
+    /** @internal */
+    private onTrackMuted;
+    private onTrackUpstreamPaused;
+    private onTrackUpstreamResumed;
+    private handleSubscribedQualityUpdate;
+    private handleLocalTrackUnpublished;
+    private handleTrackEnded;
+    private getPublicationForTrack;
+    /** @internal */
+    publishedTracksInfo(): TrackPublishedResponse[];
+    /** @internal */
+    dataChannelsInfo(): DataChannelInfo[];
+}
+//# sourceMappingURL=LocalParticipant.d.ts.map

package/dist/ts4.2/src/room/participant/Participant.d.ts

@@ -0,0 +1,92 @@
+import type TypedEmitter from 'typed-emitter';
+import { ConnectionQuality as ProtoQuality, DataPacket_Kind, ParticipantInfo, ParticipantPermission } from '../../proto/livekit_models';
+import type LocalTrackPublication from '../track/LocalTrackPublication';
+import type RemoteTrack from '../track/RemoteTrack';
+import type RemoteTrackPublication from '../track/RemoteTrackPublication';
+import { Track } from '../track/Track';
+import type { TrackPublication } from '../track/TrackPublication';
+export declare enum ConnectionQuality {
+    Excellent = "excellent",
+    Good = "good",
+    Poor = "poor",
+    Unknown = "unknown"
+}
+declare const Participant_base: new () => TypedEmitter<ParticipantEventCallbacks>;
+export default class Participant extends Participant_base {
+    protected participantInfo?: ParticipantInfo;
+    audioTracks: Map<string, TrackPublication>;
+    videoTracks: Map<string, TrackPublication>;
+    /** map of track sid => all published tracks */
+    tracks: Map<string, TrackPublication>;
+    /** audio level between 0-1.0, 1 being loudest, 0 being softest */
+    audioLevel: number;
+    /** if participant is currently speaking */
+    isSpeaking: boolean;
+    /** server assigned unique id */
+    sid: string;
+    /** client assigned identity, encoded in JWT token */
+    identity: string;
+    /** client assigned display name, encoded in JWT token */
+    name?: string;
+    /** client metadata, opaque to livekit */
+    metadata?: string;
+    lastSpokeAt?: Date | undefined;
+    permissions?: ParticipantPermission;
+    private _connectionQuality;
+    /** @internal */
+    constructor(sid: string, identity: string, name?: string, metadata?: string);
+    getTracks(): TrackPublication[];
+    /**
+     * Finds the first track that matches the source filter, for example, getting
+     * the user's camera track with getTrackBySource(Track.Source.Camera).
+     * @param source
+     * @returns
+     */
+    getTrack(source: Track.Source): TrackPublication | undefined;
+    /**
+     * Finds the first track that matches the track's name.
+     * @param name
+     * @returns
+     */
+    getTrackByName(name: string): TrackPublication | undefined;
+    get connectionQuality(): ConnectionQuality;
+    get isCameraEnabled(): boolean;
+    get isMicrophoneEnabled(): boolean;
+    get isScreenShareEnabled(): boolean;
+    get isLocal(): boolean;
+    /** when participant joined the room */
+    get joinedAt(): Date | undefined;
+    /** @internal */
+    updateInfo(info: ParticipantInfo): void;
+    /** @internal */
+    setMetadata(md: string): void;
+    /** @internal */
+    setPermissions(permissions: ParticipantPermission): boolean;
+    /** @internal */
+    setIsSpeaking(speaking: boolean): void;
+    /** @internal */
+    setConnectionQuality(q: ProtoQuality): void;
+    protected addTrackPublication(publication: TrackPublication): void;
+}
+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;
+    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.PermissionStatus) => void;
+    mediaDevicesError: (error: Error) => void;
+    participantPermissionsChanged: (prevPermissions: ParticipantPermission) => void;
+    trackSubscriptionStatusChanged: (publication: RemoteTrackPublication, status: TrackPublication.SubscriptionStatus) => void;
+};
+export {};
+//# sourceMappingURL=Participant.d.ts.map

package/dist/ts4.2/src/room/participant/ParticipantTrackPermission.d.ts

@@ -0,0 +1,26 @@
+import type { TrackPermission } from '../../proto/livekit_rtc';
+export interface ParticipantTrackPermission {
+    /**
+     * The participant identity this permission applies to.
+     * You can either provide this or `participantSid`
+     */
+    participantIdentity?: string;
+    /**
+     * The participant server id this permission applies to.
+     * You can either provide this or `participantIdentity`
+     */
+    participantSid?: string;
+    /**
+     * Grant permission to all all tracks. Takes precedence over allowedTrackSids.
+     * false if unset.
+     */
+    allowAll?: boolean;
+    /**
+     * The list of track ids that the target participant can subscribe to.
+     * When unset, it'll allow all tracks to be subscribed by the participant.
+     * When empty, this participant is disallowed from subscribing to any tracks.
+     */
+    allowedTrackSids?: string[];
+}
+export declare function trackPermissionToProto(perms: ParticipantTrackPermission): TrackPermission;
+//# sourceMappingURL=ParticipantTrackPermission.d.ts.map