livekit-client 1.4.4 → 1.6.0

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

@@ -0,0 +1,52 @@
+import type { SignalClient } from '../../api/SignalClient';
+import type { ParticipantInfo } from '../../proto/livekit_models';
+import type { AudioOutputOptions } from '../track/options';
+import RemoteTrackPublication from '../track/RemoteTrackPublication';
+import { Track } from '../track/Track';
+import type { AdaptiveStreamSettings } from '../track/types';
+import Participant, { ParticipantEventCallbacks } from './Participant';
+export default class RemoteParticipant extends Participant {
+    audioTracks: Map<string, RemoteTrackPublication>;
+    videoTracks: Map<string, RemoteTrackPublication>;
+    tracks: Map<string, RemoteTrackPublication>;
+    signalClient: SignalClient;
+    private volume?;
+    private audioContext?;
+    private audioOutput?;
+    /** @internal */
+    static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo): RemoteParticipant;
+    /** @internal */
+    constructor(signalClient: SignalClient, sid: string, identity?: string, name?: string, metadata?: string);
+    protected addTrackPublication(publication: RemoteTrackPublication): void;
+    getTrack(source: Track.Source): RemoteTrackPublication | undefined;
+    getTrackByName(name: string): RemoteTrackPublication | undefined;
+    /**
+     * sets the volume on the participant's microphone track
+     * if no track exists the volume will be applied when the microphone track is added
+     */
+    setVolume(volume: number): void;
+    /**
+     * gets the volume on the participant's microphone track
+     */
+    getVolume(): number | undefined;
+    /** @internal */
+    addSubscribedMediaTrack(mediaTrack: MediaStreamTrack, sid: Track.SID, mediaStream: MediaStream, receiver?: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings, triesLeft?: number): RemoteTrackPublication | undefined;
+    /** @internal */
+    get hasMetadata(): boolean;
+    getTrackPublication(sid: Track.SID): RemoteTrackPublication | undefined;
+    /** @internal */
+    updateInfo(info: ParticipantInfo): void;
+    /** @internal */
+    unpublishTrack(sid: Track.SID, sendUnpublish?: boolean): void;
+    /**
+     * @internal
+     */
+    setAudioContext(ctx: AudioContext | undefined): void;
+    /**
+     * @internal
+     */
+    setAudioOutput(output: AudioOutputOptions): Promise<void>;
+    /** @internal */
+    emit<E extends keyof ParticipantEventCallbacks>(event: E, ...args: Parameters<ParticipantEventCallbacks[E]>): boolean;
+}
+//# sourceMappingURL=RemoteParticipant.d.ts.map

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

@@ -0,0 +1,19 @@
+import LocalAudioTrack from '../track/LocalAudioTrack';
+import LocalVideoTrack from '../track/LocalVideoTrack';
+import { BackupVideoCodec, TrackPublishOptions, VideoCodec, VideoEncoding, VideoPreset } from '../track/options';
+/** @internal */
+export declare function mediaTrackToLocalTrack(mediaStreamTrack: MediaStreamTrack, constraints?: MediaTrackConstraints): LocalVideoTrack | LocalAudioTrack;
+export declare const presets169: VideoPreset[];
+export declare const presets43: VideoPreset[];
+export declare const presetsScreenShare: VideoPreset[];
+export declare const defaultSimulcastPresets169: VideoPreset[];
+export declare const defaultSimulcastPresets43: VideoPreset[];
+export declare const computeDefaultScreenShareSimulcastPresets: (fromPreset: VideoPreset) => VideoPreset[];
+export declare function computeVideoEncodings(isScreenShare: boolean, width?: number, height?: number, options?: TrackPublishOptions): RTCRtpEncodingParameters[];
+export declare function computeTrackBackupEncodings(track: LocalVideoTrack, videoCodec: BackupVideoCodec, opts: TrackPublishOptions): RTCRtpEncodingParameters[] | undefined;
+export declare function determineAppropriateEncoding(isScreenShare: boolean, width: number, height: number, codec?: VideoCodec): VideoEncoding;
+export declare function presetsForResolution(isScreenShare: boolean, width: number, height: number): VideoPreset[];
+export declare function defaultSimulcastLayers(isScreenShare: boolean, original: VideoPreset): VideoPreset[];
+/** @internal */
+export declare function sortPresets(presets: Array<VideoPreset> | undefined): VideoPreset[] | undefined;
+//# sourceMappingURL=publishUtils.d.ts.map

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

@@ -0,0 +1,67 @@
+export declare const monitorFrequency = 2000;
+interface SenderStats {
+    /** number of packets sent */
+    packetsSent?: number;
+    /** number of bytes sent */
+    bytesSent?: number;
+    /** jitter as perceived by remote */
+    jitter?: number;
+    /** packets reported lost by remote */
+    packetsLost?: number;
+    /** RTT reported by remote */
+    roundTripTime?: number;
+    /** ID of the outbound stream */
+    streamId?: string;
+    timestamp: number;
+}
+export interface AudioSenderStats extends SenderStats {
+    type: 'audio';
+}
+export interface VideoSenderStats extends SenderStats {
+    type: 'video';
+    firCount: number;
+    pliCount: number;
+    nackCount: number;
+    rid: string;
+    frameWidth: number;
+    frameHeight: number;
+    framesSent: number;
+    qualityLimitationReason: string;
+    qualityLimitationResolutionChanges: number;
+    retransmittedPacketsSent: number;
+}
+interface ReceiverStats {
+    jitterBufferDelay?: number;
+    /** packets reported lost by remote */
+    packetsLost?: number;
+    /** number of packets sent */
+    packetsReceived?: number;
+    bytesReceived?: number;
+    streamId?: string;
+    jitter?: number;
+    timestamp: number;
+}
+export interface AudioReceiverStats extends ReceiverStats {
+    type: 'audio';
+    concealedSamples?: number;
+    concealmentEvents?: number;
+    silentConcealedSamples?: number;
+    silentConcealmentEvents?: number;
+    totalAudioEnergy?: number;
+    totalSamplesDuration?: number;
+}
+export interface VideoReceiverStats extends ReceiverStats {
+    type: 'video';
+    framesDecoded: number;
+    framesDropped: number;
+    framesReceived: number;
+    frameWidth?: number;
+    frameHeight?: number;
+    firCount?: number;
+    pliCount?: number;
+    nackCount?: number;
+    decoderImplementation?: string;
+}
+export declare function computeBitrate<T extends ReceiverStats | SenderStats>(currentStats: T, prevStats?: T): number;
+export {};
+//# sourceMappingURL=stats.d.ts.map

package/dist/ts4.2/src/room/track/LocalAudioTrack.d.ts

@@ -0,0 +1,25 @@
+import { AudioSenderStats } from '../stats';
+import LocalTrack from './LocalTrack';
+import type { AudioCaptureOptions } from './options';
+export default class LocalAudioTrack extends LocalTrack {
+    /** @internal */
+    stopOnMute: boolean;
+    private prevStats?;
+    /**
+     *
+     * @param mediaTrack
+     * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
+     * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
+     */
+    constructor(mediaTrack: MediaStreamTrack, constraints?: MediaTrackConstraints, userProvidedTrack?: boolean);
+    setDeviceId(deviceId: string): Promise<void>;
+    mute(): Promise<LocalAudioTrack>;
+    unmute(): Promise<LocalAudioTrack>;
+    restartTrack(options?: AudioCaptureOptions): Promise<void>;
+    protected restart(constraints?: MediaTrackConstraints): Promise<LocalTrack>;
+    startMonitor(): void;
+    protected monitorSender: () => Promise<void>;
+    getSenderStats(): Promise<AudioSenderStats | undefined>;
+    checkForSilence(): Promise<void>;
+}
+//# sourceMappingURL=LocalAudioTrack.d.ts.map

package/dist/ts4.2/src/room/track/LocalTrack.d.ts

@@ -0,0 +1,42 @@
+import Queue from 'async-await-queue';
+import type { VideoCodec } from './options';
+import { Track } from './Track';
+export default abstract class LocalTrack extends Track {
+    /** @internal */
+    sender?: RTCRtpSender;
+    /** @internal */
+    codec?: VideoCodec;
+    protected constraints: MediaTrackConstraints;
+    protected reacquireTrack: boolean;
+    protected providedByUser: boolean;
+    protected muteQueue: Queue;
+    /**
+     *
+     * @param mediaTrack
+     * @param kind
+     * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
+     * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
+     */
+    protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind, constraints?: MediaTrackConstraints, userProvidedTrack?: boolean);
+    get id(): string;
+    get dimensions(): Track.Dimensions | undefined;
+    private _isUpstreamPaused;
+    get isUpstreamPaused(): boolean;
+    get isUserProvided(): boolean;
+    /**
+     * @returns DeviceID of the device that is currently being used for this track
+     */
+    getDeviceId(): Promise<string | undefined>;
+    mute(): Promise<LocalTrack>;
+    unmute(): Promise<LocalTrack>;
+    replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<LocalTrack>;
+    protected restart(constraints?: MediaTrackConstraints): Promise<LocalTrack>;
+    protected setTrackMuted(muted: boolean): void;
+    protected get needsReAcquisition(): boolean;
+    protected handleAppVisibilityChanged(): Promise<void>;
+    private handleEnded;
+    pauseUpstream(): Promise<void>;
+    resumeUpstream(): Promise<void>;
+    protected abstract monitorSender(): void;
+}
+//# sourceMappingURL=LocalTrack.d.ts.map

package/dist/ts4.2/src/room/track/LocalTrackPublication.d.ts

@@ -0,0 +1,38 @@
+import type { TrackInfo } from '../../proto/livekit_models';
+import type LocalAudioTrack from './LocalAudioTrack';
+import type LocalTrack from './LocalTrack';
+import type LocalVideoTrack from './LocalVideoTrack';
+import type { TrackPublishOptions } from './options';
+import type { Track } from './Track';
+import { TrackPublication } from './TrackPublication';
+export default class LocalTrackPublication extends TrackPublication {
+    track?: LocalTrack;
+    options?: TrackPublishOptions;
+    get isUpstreamPaused(): boolean | undefined;
+    constructor(kind: Track.Kind, ti: TrackInfo, track?: LocalTrack);
+    setTrack(track?: Track): void;
+    get isMuted(): boolean;
+    get audioTrack(): LocalAudioTrack | undefined;
+    get videoTrack(): LocalVideoTrack | undefined;
+    /**
+     * Mute the track associated with this publication
+     */
+    mute(): Promise<LocalTrack | undefined>;
+    /**
+     * Unmute track associated with this publication
+     */
+    unmute(): Promise<LocalTrack | undefined>;
+    /**
+     * Pauses the media stream track associated with this publication from being sent to the server
+     * and signals "muted" event to other participants
+     * Useful if you want to pause the stream without pausing the local media stream track
+     */
+    pauseUpstream(): Promise<void>;
+    /**
+     * Resumes sending the media stream track associated with this publication to the server after a call to [[pauseUpstream()]]
+     * and signals "unmuted" event to other participants (unless the track is explicitly muted)
+     */
+    resumeUpstream(): Promise<void>;
+    handleTrackEnded: () => void;
+}
+//# sourceMappingURL=LocalTrackPublication.d.ts.map

package/dist/ts4.2/src/room/track/LocalVideoTrack.d.ts

@@ -0,0 +1,53 @@
+import type { SignalClient } from '../../api/SignalClient';
+import { VideoLayer, VideoQuality } from '../../proto/livekit_models';
+import type { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc';
+import { VideoSenderStats } from '../stats';
+import LocalTrack from './LocalTrack';
+import type { VideoCaptureOptions, VideoCodec } from './options';
+export declare class SimulcastTrackInfo {
+    codec: VideoCodec;
+    mediaStreamTrack: MediaStreamTrack;
+    sender?: RTCRtpSender;
+    encodings?: RTCRtpEncodingParameters[];
+    constructor(codec: VideoCodec, mediaStreamTrack: MediaStreamTrack);
+}
+export default class LocalVideoTrack extends LocalTrack {
+    signalClient?: SignalClient;
+    private prevStats?;
+    private encodings?;
+    simulcastCodecs: Map<VideoCodec, SimulcastTrackInfo>;
+    private subscribedCodecs?;
+    /**
+     *
+     * @param mediaTrack
+     * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
+     * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
+     */
+    constructor(mediaTrack: MediaStreamTrack, constraints?: MediaTrackConstraints, userProvidedTrack?: boolean);
+    get isSimulcast(): boolean;
+    startMonitor(signalClient: SignalClient): void;
+    stop(): void;
+    mute(): Promise<LocalVideoTrack>;
+    unmute(): Promise<LocalVideoTrack>;
+    getSenderStats(): Promise<VideoSenderStats[]>;
+    setPublishingQuality(maxQuality: VideoQuality): void;
+    setDeviceId(deviceId: string): Promise<void>;
+    restartTrack(options?: VideoCaptureOptions): Promise<void>;
+    addSimulcastTrack(codec: VideoCodec, encodings?: RTCRtpEncodingParameters[]): SimulcastTrackInfo;
+    setSimulcastTrackSender(codec: VideoCodec, sender: RTCRtpSender): void;
+    /**
+     * @internal
+     * Sets codecs that should be publishing
+     */
+    setPublishingCodecs(codecs: SubscribedCodec[]): Promise<VideoCodec[]>;
+    /**
+     * @internal
+     * Sets layers that should be publishing
+     */
+    setPublishingLayers(qualities: SubscribedQuality[]): Promise<void>;
+    protected monitorSender: () => Promise<void>;
+    protected handleAppVisibilityChanged(): Promise<void>;
+}
+export declare function videoQualityForRid(rid: string): VideoQuality;
+export declare function videoLayersFromEncodings(width: number, height: number, encodings?: RTCRtpEncodingParameters[]): VideoLayer[];
+//# sourceMappingURL=LocalVideoTrack.d.ts.map

package/dist/ts4.2/src/room/track/RemoteAudioTrack.d.ts

@@ -0,0 +1,53 @@
+import { AudioReceiverStats } from '../stats';
+import type { AudioOutputOptions } from './options';
+import RemoteTrack from './RemoteTrack';
+export default class RemoteAudioTrack extends RemoteTrack {
+    private prevStats?;
+    private elementVolume;
+    private audioContext?;
+    private gainNode?;
+    private sourceNode?;
+    private webAudioPluginNodes;
+    private sinkId?;
+    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver?: RTCRtpReceiver, audioContext?: AudioContext, audioOutput?: AudioOutputOptions);
+    /**
+     * sets the volume for all attached audio elements
+     */
+    setVolume(volume: number): void;
+    /**
+     * gets the volume of attached audio elements (loudest)
+     */
+    getVolume(): number;
+    /**
+     * calls setSinkId on all attached elements, if supported
+     * @param deviceId audio output device
+     */
+    setSinkId(deviceId: string): Promise<void>;
+    attach(): HTMLMediaElement;
+    attach(element: HTMLMediaElement): HTMLMediaElement;
+    /**
+     * Detaches from all attached elements
+     */
+    detach(): HTMLMediaElement[];
+    /**
+     * Detach from a single element
+     * @param element
+     */
+    detach(element: HTMLMediaElement): HTMLMediaElement;
+    /**
+     * @internal
+     * @experimental
+     */
+    setAudioContext(audioContext: AudioContext | undefined): void;
+    /**
+     * @internal
+     * @experimental
+     * @param {AudioNode[]} nodes - An array of WebAudio nodes. These nodes should not be connected to each other when passed, as the sdk will take care of connecting them in the order of the array.
+     */
+    setWebAudioPlugins(nodes: AudioNode[]): void;
+    private connectWebAudio;
+    private disconnectWebAudio;
+    protected monitorReceiver: () => Promise<void>;
+    protected getReceiverStats(): Promise<AudioReceiverStats | undefined>;
+}
+//# sourceMappingURL=RemoteAudioTrack.d.ts.map

package/dist/ts4.2/src/room/track/RemoteTrack.d.ts

@@ -0,0 +1,15 @@
+import { Track } from './Track';
+export default abstract class RemoteTrack extends Track {
+    /** @internal */
+    receiver?: RTCRtpReceiver;
+    constructor(mediaTrack: MediaStreamTrack, sid: string, kind: Track.Kind, receiver?: RTCRtpReceiver);
+    /** @internal */
+    setMuted(muted: boolean): void;
+    /** @internal */
+    setMediaStream(stream: MediaStream): void;
+    start(): void;
+    stop(): void;
+    startMonitor(): void;
+    protected abstract monitorReceiver(): void;
+}
+//# sourceMappingURL=RemoteTrack.d.ts.map

package/dist/ts4.2/src/room/track/RemoteTrackPublication.d.ts

@@ -0,0 +1,61 @@
+import { TrackInfo, VideoQuality } from '../../proto/livekit_models';
+import type RemoteTrack from './RemoteTrack';
+import type { Track } from './Track';
+import { TrackPublication } from './TrackPublication';
+export default class RemoteTrackPublication extends TrackPublication {
+    track?: RemoteTrack;
+    /** @internal */
+    protected allowed: boolean;
+    protected subscribed?: boolean;
+    protected disabled: boolean;
+    protected currentVideoQuality?: VideoQuality;
+    protected videoDimensions?: Track.Dimensions;
+    protected fps?: number;
+    constructor(kind: Track.Kind, id: string, name: string, autoSubscribe: boolean | undefined);
+    /**
+     * Subscribe or unsubscribe to this remote track
+     * @param subscribed true to subscribe to a track, false to unsubscribe
+     */
+    setSubscribed(subscribed: boolean): void;
+    get subscriptionStatus(): TrackPublication.SubscriptionStatus;
+    get permissionStatus(): TrackPublication.PermissionStatus;
+    /**
+     * Returns true if track is subscribed, and ready for playback
+     */
+    get isSubscribed(): boolean;
+    get isDesired(): boolean;
+    get isEnabled(): boolean;
+    /**
+     * disable server from sending down data for this track. this is useful when
+     * the participant is off screen, you may disable streaming down their video
+     * to reduce bandwidth requirements
+     * @param enabled
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * for tracks that support simulcasting, adjust subscribed quality
+     *
+     * This indicates the highest quality the client can accept. if network
+     * bandwidth does not allow, server will automatically reduce quality to
+     * optimize for uninterrupted video
+     */
+    setVideoQuality(quality: VideoQuality): void;
+    setVideoDimensions(dimensions: Track.Dimensions): void;
+    setVideoFPS(fps: number): void;
+    get videoQuality(): VideoQuality | undefined;
+    /** @internal */
+    setTrack(track?: RemoteTrack): void;
+    /** @internal */
+    setAllowed(allowed: boolean): void;
+    /** @internal */
+    updateInfo(info: TrackInfo): void;
+    private emitSubscriptionUpdateIfChanged;
+    private emitPermissionUpdateIfChanged;
+    private isManualOperationAllowed;
+    protected handleEnded: (track: RemoteTrack) => void;
+    protected get isAdaptiveStream(): boolean;
+    protected handleVisibilityChange: (visible: boolean) => void;
+    protected handleVideoDimensionsChange: (dimensions: Track.Dimensions) => void;
+    emitTrackUpdate(): void;
+}
+//# sourceMappingURL=RemoteTrackPublication.d.ts.map

package/dist/ts4.2/src/room/track/RemoteVideoTrack.d.ts

@@ -0,0 +1,52 @@
+import RemoteTrack from './RemoteTrack';
+import type { AdaptiveStreamSettings } from './types';
+export default class RemoteVideoTrack extends RemoteTrack {
+    private prevStats?;
+    private elementInfos;
+    private adaptiveStreamSettings?;
+    private lastVisible?;
+    private lastDimensions?;
+    private hasUsedAttach;
+    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver?: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings);
+    get isAdaptiveStream(): boolean;
+    get mediaStreamTrack(): MediaStreamTrack;
+    /** @internal */
+    setMuted(muted: boolean): void;
+    attach(): HTMLMediaElement;
+    attach(element: HTMLMediaElement): HTMLMediaElement;
+    /**
+     * Observe an ElementInfo for changes when adaptive streaming.
+     * @param elementInfo
+     * @internal
+     */
+    observeElementInfo(elementInfo: ElementInfo): void;
+    /**
+     * Stop observing an ElementInfo for changes.
+     * @param elementInfo
+     * @internal
+     */
+    stopObservingElementInfo(elementInfo: ElementInfo): void;
+    detach(): HTMLMediaElement[];
+    detach(element: HTMLMediaElement): HTMLMediaElement;
+    /** @internal */
+    getDecoderImplementation(): string | undefined;
+    protected monitorReceiver: () => Promise<void>;
+    private getReceiverStats;
+    private stopObservingElement;
+    protected handleAppVisibilityChanged(): Promise<void>;
+    private readonly debouncedHandleResize;
+    private updateVisibility;
+    private updateDimensions;
+}
+export interface ElementInfo {
+    element: object;
+    width(): number;
+    height(): number;
+    visible: boolean;
+    visibilityChangedAt: number | undefined;
+    handleResize?: () => void;
+    handleVisibilityChanged?: () => void;
+    observe(): void;
+    stopObserving(): void;
+}
+//# sourceMappingURL=RemoteVideoTrack.d.ts.map

package/dist/ts4.2/src/room/track/Track.d.ts

@@ -0,0 +1,122 @@
+import type TypedEventEmitter from 'typed-emitter';
+import type { SignalClient } from '../../api/SignalClient';
+import { TrackSource, TrackType } from '../../proto/livekit_models';
+import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc';
+declare const Track_base: new () => TypedEventEmitter<TrackEventCallbacks>;
+export declare abstract class Track extends Track_base {
+    kind: Track.Kind;
+    attachedElements: HTMLMediaElement[];
+    isMuted: boolean;
+    source: Track.Source;
+    /**
+     * sid is set after track is published to server, or if it's a remote track
+     */
+    sid?: Track.SID;
+    /**
+     * @internal
+     */
+    mediaStream?: MediaStream;
+    /**
+     * indicates current state of stream
+     */
+    streamState: Track.StreamState;
+    protected _mediaStreamTrack: MediaStreamTrack;
+    protected _mediaStreamID: string;
+    protected isInBackground: boolean;
+    private backgroundTimeout;
+    protected _currentBitrate: number;
+    protected monitorInterval?: ReturnType<typeof setInterval>;
+    protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind);
+    /** current receive bits per second */
+    get currentBitrate(): number;
+    get mediaStreamTrack(): MediaStreamTrack;
+    /**
+     * @internal
+     * used for keep mediaStream's first id, since it's id might change
+     * if we disable/enable a track
+     */
+    get mediaStreamID(): string;
+    /**
+     * creates a new HTMLAudioElement or HTMLVideoElement, attaches to it, and returns it
+     */
+    attach(): HTMLMediaElement;
+    /**
+     * attaches track to an existing HTMLAudioElement or HTMLVideoElement
+     */
+    attach(element: HTMLMediaElement): HTMLMediaElement;
+    /**
+     * Detaches from all attached elements
+     */
+    detach(): HTMLMediaElement[];
+    /**
+     * Detach from a single element
+     * @param element
+     */
+    detach(element: HTMLMediaElement): HTMLMediaElement;
+    stop(): void;
+    protected enable(): void;
+    protected disable(): void;
+    abstract startMonitor(signalClient?: SignalClient): void;
+    protected stopMonitor(): void;
+    private recycleElement;
+    protected appVisibilityChangedListener: () => void;
+    protected handleAppVisibilityChanged(): Promise<void>;
+}
+/** @internal */
+export declare function attachToElement(track: MediaStreamTrack, element: HTMLMediaElement): void;
+/** @internal */
+export declare function detachTrack(track: MediaStreamTrack, element: HTMLMediaElement): void;
+export declare namespace Track {
+    enum Kind {
+        Audio = "audio",
+        Video = "video",
+        Unknown = "unknown"
+    }
+    type SID = string;
+    enum Source {
+        Camera = "camera",
+        Microphone = "microphone",
+        ScreenShare = "screen_share",
+        ScreenShareAudio = "screen_share_audio",
+        Unknown = "unknown"
+    }
+    enum StreamState {
+        Active = "active",
+        Paused = "paused",
+        Unknown = "unknown"
+    }
+    interface Dimensions {
+        width: number;
+        height: number;
+    }
+    /** @internal */
+    function kindToProto(k: Kind): TrackType;
+    /** @internal */
+    function kindFromProto(t: TrackType): Kind | undefined;
+    /** @internal */
+    function sourceToProto(s: Source): TrackSource;
+    /** @internal */
+    function sourceFromProto(s: TrackSource): Source;
+    /** @internal */
+    function streamStateFromProto(s: ProtoStreamState): StreamState;
+}
+export type TrackEventCallbacks = {
+    message: () => void;
+    muted: (track?: any) => void;
+    unmuted: (track?: any) => void;
+    restarted: (track?: any) => void;
+    ended: (track?: any) => void;
+    updateSettings: () => void;
+    updateSubscription: () => void;
+    audioPlaybackStarted: () => void;
+    audioPlaybackFailed: (error: Error) => void;
+    audioSilenceDetected: () => void;
+    visibilityChanged: (visible: boolean, track?: any) => void;
+    videoDimensionsChanged: (dimensions: Track.Dimensions, track?: any) => void;
+    elementAttached: (element: HTMLMediaElement) => void;
+    elementDetached: (element: HTMLMediaElement) => void;
+    upstreamPaused: (track: any) => void;
+    upstreamResumed: (track: any) => void;
+};
+export {};
+//# sourceMappingURL=Track.d.ts.map

package/dist/ts4.2/src/room/track/TrackPublication.d.ts

@@ -0,0 +1,68 @@
+import type TypedEventEmitter from 'typed-emitter';
+import type { TrackInfo } from '../../proto/livekit_models';
+import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc';
+import LocalAudioTrack from './LocalAudioTrack';
+import LocalVideoTrack from './LocalVideoTrack';
+import RemoteAudioTrack from './RemoteAudioTrack';
+import type RemoteTrack from './RemoteTrack';
+import RemoteVideoTrack from './RemoteVideoTrack';
+import { Track } from './Track';
+declare const TrackPublication_base: new () => TypedEventEmitter<PublicationEventCallbacks>;
+export declare class TrackPublication extends TrackPublication_base {
+    kind: Track.Kind;
+    trackName: string;
+    trackSid: Track.SID;
+    track?: Track;
+    source: Track.Source;
+    /** MimeType of the published track */
+    mimeType?: string;
+    /** dimension of the original published stream, video-only */
+    dimensions?: Track.Dimensions;
+    /** true if track was simulcasted to server, video-only */
+    simulcasted?: boolean;
+    /** @internal */
+    trackInfo?: TrackInfo;
+    protected metadataMuted: boolean;
+    constructor(kind: Track.Kind, id: string, name: string);
+    /** @internal */
+    setTrack(track?: Track): void;
+    get isMuted(): boolean;
+    get isEnabled(): boolean;
+    get isSubscribed(): boolean;
+    /**
+     * an [AudioTrack] if this publication holds an audio track
+     */
+    get audioTrack(): LocalAudioTrack | RemoteAudioTrack | undefined;
+    /**
+     * an [VideoTrack] if this publication holds a video track
+     */
+    get videoTrack(): LocalVideoTrack | RemoteVideoTrack | undefined;
+    handleMuted: () => void;
+    handleUnmuted: () => void;
+    /** @internal */
+    updateInfo(info: TrackInfo): void;
+}
+export declare namespace TrackPublication {
+    enum SubscriptionStatus {
+        Desired = "desired",
+        Subscribed = "subscribed",
+        Unsubscribed = "unsubscribed"
+    }
+    enum PermissionStatus {
+        Allowed = "allowed",
+        NotAllowed = "not_allowed"
+    }
+}
+export type PublicationEventCallbacks = {
+    muted: () => void;
+    unmuted: () => void;
+    ended: (track?: Track) => void;
+    updateSettings: (settings: UpdateTrackSettings) => void;
+    subscriptionPermissionChanged: (status: TrackPublication.PermissionStatus, prevStatus: TrackPublication.PermissionStatus) => void;
+    updateSubscription: (sub: UpdateSubscription) => void;
+    subscribed: (track: RemoteTrack) => void;
+    unsubscribed: (track: RemoteTrack) => void;
+    subscriptionStatusChanged: (status: TrackPublication.SubscriptionStatus, prevStatus: TrackPublication.SubscriptionStatus) => void;
+};
+export {};
+//# sourceMappingURL=TrackPublication.d.ts.map