livekit-client 2.22.3 → 2.23.0

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

@@ -1,125 +1,143 @@
-import { Mutex } from '@livekit/mutex';
-import type { LoggerOptions } from '../types';
-import { Track } from './Track';
-import type { VideoCodec } from './options';
-import type { TrackProcessor } from './processor/types';
-import { LocalTrackRecorder } from './record';
-import type { ReplaceTrackOptions } from './types';
-export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Kind> extends Track<TrackKind> {
-    protected _sender?: RTCRtpSender;
-    private autoStopPreConnectBuffer;
-    /** @internal */
-    get sender(): RTCRtpSender | undefined;
-    /** @internal */
-    set sender(sender: RTCRtpSender | undefined);
-    /** @internal */
-    codec?: VideoCodec;
-    get constraints(): MediaTrackConstraints;
-    get hasPreConnectBuffer(): boolean;
-    protected _constraints: MediaTrackConstraints;
-    protected reacquireTrack: boolean;
-    protected providedByUser: boolean;
-    protected muteLock: Mutex;
-    protected pauseUpstreamLock: Mutex;
-    protected processorElement?: HTMLMediaElement;
-    protected processor?: TrackProcessor<TrackKind, any>;
-    protected audioContext?: AudioContext;
-    protected manuallyStopped: boolean;
-    protected localTrackRecorder: LocalTrackRecorder<typeof this> | undefined;
-    protected trackChangeLock: Mutex;
-    protected pendingDeviceChange: boolean;
-    /**
-     *
-     * @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: TrackKind, constraints?: MediaTrackConstraints, userProvidedTrack?: boolean, loggerOptions?: LoggerOptions);
-    get id(): string;
-    get dimensions(): Track.Dimensions | undefined;
-    private _isUpstreamPaused;
-    get isUpstreamPaused(): boolean;
-    get isUserProvided(): boolean;
-    get mediaStreamTrack(): MediaStreamTrack;
-    get isLocal(): boolean;
-    /**
-     * @internal
-     * returns mediaStreamTrack settings of the capturing mediastreamtrack source - ignoring processors
-     */
-    getSourceTrackSettings(): MediaTrackSettings;
-    private setMediaStreamTrack;
-    waitForDimensions(timeout?: number): Promise<Track.Dimensions>;
-    setDeviceId(deviceId: ConstrainDOMString): Promise<boolean>;
-    abstract restartTrack(constraints?: unknown): Promise<void>;
-    /**
-     * @returns DeviceID of the device that is currently being used for this track
-     */
-    getDeviceId(normalize?: boolean): Promise<string | undefined>;
-    mute(): Promise<this>;
-    unmute(): Promise<this>;
-    replaceTrack(track: MediaStreamTrack, options?: ReplaceTrackOptions): Promise<typeof this>;
-    replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<typeof this>;
-    /**
-     * Hook invoked after the MediaStreamTrack on the sender has been swapped
-     * (via replaceTrack, setProcessor, or stopProcessor). Fires outside the
-     * trackChangeLock so subclasses can do asynchronous work such as polling
-     * for new dimensions without blocking other track operations.
-     */
-    protected onSenderTrackSwapped(): Promise<void>;
-    protected restart(constraints?: MediaTrackConstraints, isUnmuting?: boolean): Promise<this>;
-    protected setTrackMuted(muted: boolean): void;
-    protected get needsReAcquisition(): boolean;
-    protected handleAppVisibilityChanged(): Promise<void>;
-    private handleTrackMuteEvent;
-    private debouncedTrackMuteHandler;
-    private handleTrackUnmuteEvent;
-    private handleEnded;
-    stop(): void;
-    /**
-     * pauses publishing to the server without disabling the local MediaStreamTrack
-     * this is used to display a user's own video locally while pausing publishing to
-     * the server.
-     * this API is unsupported on Safari < 12 due to a bug
-     **/
-    pauseUpstream(): Promise<void>;
-    resumeUpstream(): Promise<void>;
-    /**
-     * Gets the RTCStatsReport for the LocalTrack's underlying RTCRtpSender
-     * See https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport
-     *
-     * @returns Promise<RTCStatsReport> | undefined
-     */
-    getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
-    /**
-     * Sets a processor on this track.
-     * See https://github.com/livekit/track-processors-js for example usage
-     *
-     * @param processor
-     * @param showProcessedStreamLocally
-     * @returns
-     */
-    setProcessor(processor: TrackProcessor<TrackKind>, showProcessedStreamLocally?: boolean): Promise<void>;
-    getProcessor(): TrackProcessor<TrackKind, any> | undefined;
-    /**
-     * Stops the track processor
-     * See https://github.com/livekit/track-processors-js for example usage
-     *
-     */
-    stopProcessor(keepElement?: boolean): Promise<void>;
-    /**
-     * @internal
-     * This method assumes the caller has acquired a trackChangeLock already.
-     * The public facing method for stopping the processor is `stopProcessor` and it wraps this method in the trackChangeLock.
-     */
-    protected internalStopProcessor(keepElement?: boolean): Promise<void>;
-    /** @internal */
-    startPreConnectBuffer(timeslice?: number): void;
-    /** @internal */
-    stopPreConnectBuffer(): void;
-    /** @internal */
-    getPreConnectBuffer(): ReadableStream<Uint8Array> | undefined;
-    getPreConnectBufferMimeType(): string | undefined;
-    protected abstract monitorSender(): void;
-}
-//# sourceMappingURL=LocalTrack.d.ts.map
+import { Mutex } from '@livekit/mutex';
+import type { LoggerOptions } from '../types';
+import { Track } from './Track';
+import type { VideoCodec } from './options';
+import type { TrackProcessor } from './processor/types';
+import { LocalTrackRecorder } from './record';
+import type { ReplaceTrackOptions } from './types';
+export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Kind> extends Track<TrackKind> {
+    protected _sender?: RTCRtpSender;
+    private autoStopPreConnectBuffer;
+    /** @internal */
+    get sender(): RTCRtpSender | undefined;
+    /** @internal */
+    set sender(sender: RTCRtpSender | undefined);
+    /** @internal */
+    codec?: VideoCodec;
+    get constraints(): MediaTrackConstraints;
+    get hasPreConnectBuffer(): boolean;
+    protected _constraints: MediaTrackConstraints;
+    protected reacquireTrack: boolean;
+    protected providedByUser: boolean;
+    protected muteLock: Mutex;
+    protected pauseUpstreamLock: Mutex;
+    protected processorElement?: HTMLMediaElement;
+    protected processor?: TrackProcessor<TrackKind, any>;
+    protected audioContext?: AudioContext;
+    protected manuallyStopped: boolean;
+    protected localTrackRecorder: LocalTrackRecorder<typeof this> | undefined;
+    protected trackChangeLock: Mutex;
+    protected pendingDeviceChange: boolean;
+    /**
+     *
+     * @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: TrackKind, constraints?: MediaTrackConstraints, userProvidedTrack?: boolean, loggerOptions?: LoggerOptions);
+    get id(): string;
+    get dimensions(): (Track.Dimensions | undefined);
+    private _isUpstreamPaused;
+    get isUpstreamPaused(): boolean;
+    get isUserProvided(): boolean;
+    get isStopped(): boolean;
+    get mediaStreamTrack(): MediaStreamTrack;
+    get isLocal(): boolean;
+    /**
+     * @internal
+     * returns mediaStreamTrack settings of the capturing mediastreamtrack source - ignoring processors
+     */
+    getSourceTrackSettings(): MediaTrackSettings;
+    private setMediaStreamTrack;
+    /**
+     * Hook invoked after the underlying MediaStreamTrack has been swapped and the processor has
+     * been restarted around it, so `processor.processedTrack` already holds the new track.
+     * Unlike `onSenderTrackSwapped` this also fires on the restart and unmute paths.
+     */
+    protected onMediaStreamTrackChanged(): Promise<void>;
+    waitForDimensions(timeout?: number): Promise<Track.Dimensions>;
+    setDeviceId(deviceId: ConstrainDOMString): Promise<boolean>;
+    abstract restartTrack(constraints?: unknown): Promise<void>;
+    /**
+     * @returns DeviceID of the device that is currently being used for this track
+     */
+    getDeviceId(normalize?: boolean): Promise<string | undefined>;
+    mute(): Promise<this>;
+    unmute(): Promise<this>;
+    replaceTrack(track: MediaStreamTrack, options?: ReplaceTrackOptions): Promise<typeof this>;
+    replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<typeof this>;
+    /**
+     * Hook invoked after the MediaStreamTrack on the sender has been swapped
+     * (via replaceTrack, setProcessor, or stopProcessor). Fires outside the
+     * trackChangeLock so subclasses can do asynchronous work such as polling
+     * for new dimensions without blocking other track operations.
+     */
+    protected onSenderTrackSwapped(): Promise<void>;
+    protected restart(constraints?: MediaTrackConstraints, isUnmuting?: boolean): Promise<this>;
+    protected setTrackMuted(muted: boolean): void;
+    protected get needsReAcquisition(): boolean;
+    protected handleAppVisibilityChanged(): Promise<void>;
+    private handleTrackMuteEvent;
+    private debouncedTrackMuteHandler;
+    private handleTrackUnmuteEvent;
+    private handleEnded;
+    stop(): void;
+    /**
+     * pauses publishing to the server without disabling the local MediaStreamTrack
+     * this is used to display a user's own video locally while pausing publishing to
+     * the server.
+     * this API is unsupported on Safari < 12 due to a bug
+     **/
+    pauseUpstream(): Promise<void>;
+    resumeUpstream(): Promise<void>;
+    /**
+     * Gets the RTCStatsReport for the LocalTrack's underlying RTCRtpSender
+     * See https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport
+     *
+     * @returns Promise<RTCStatsReport> | undefined
+     */
+    getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
+    /**
+     * Sets a processor on this track.
+     * See https://github.com/livekit/track-processors-js for example usage
+     *
+     * The processor lives on the track, so stopping the track destroys it. Unpublishing and
+     * disconnecting both stop the track by default, which means a processor has to be set again on
+     * the track published after a reconnect. See {@link TrackProcessor} for the full lifecycle,
+     * including what `stopLocalTrackOnUnpublish: false` changes.
+     *
+     * @param processor
+     * @param showProcessedStreamLocally
+     * @returns
+     */
+    setProcessor(processor: TrackProcessor<TrackKind>, showProcessedStreamLocally?: boolean): Promise<void>;
+    /**
+     * Returns the processor currently set on this track, or `undefined` if there is none. A track
+     * that was stopped by an unpublish or a disconnect has none. See {@link TrackProcessor}.
+     */
+    getProcessor(): TrackProcessor<TrackKind, any> | undefined;
+    /**
+     * Stops the track processor
+     * See https://github.com/livekit/track-processors-js for example usage
+     *
+     * Only needed to remove a processor from a track that stays published. Unpublishing or
+     * disconnecting already destroys it. See {@link TrackProcessor}.
+     */
+    stopProcessor(keepElement?: boolean): Promise<void>;
+    /**
+     * @internal
+     * This method assumes the caller has acquired a trackChangeLock already.
+     * The public facing method for stopping the processor is `stopProcessor` and it wraps this method in the trackChangeLock.
+     */
+    protected internalStopProcessor(keepElement?: boolean): Promise<void>;
+    /** @internal */
+    startPreConnectBuffer(timeslice?: number): void;
+    /** @internal */
+    stopPreConnectBuffer(): void;
+    /** @internal */
+    getPreConnectBuffer(): ReadableStream<Uint8Array> | undefined;
+    getPreConnectBufferMimeType(): string | undefined;
+    protected abstract monitorSender(): void;
+}
+//# sourceMappingURL=LocalTrack.d.ts.map

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

@@ -1,42 +1,42 @@
-import { AudioTrackFeature, TrackInfo } from '@livekit/protocol';
-import type { LoggerOptions } from '../types';
-import LocalAudioTrack from './LocalAudioTrack';
-import type LocalTrack from './LocalTrack';
-import type LocalVideoTrack from './LocalVideoTrack';
-import type { Track } from './Track';
-import { TrackPublication } from './TrackPublication';
-import type { TrackPublishOptions } from './options';
-export default class LocalTrackPublication extends TrackPublication {
-    track?: LocalTrack;
-    options?: TrackPublishOptions;
-    get isUpstreamPaused(): boolean | undefined;
-    constructor(kind: Track.Kind, ti: TrackInfo, track?: LocalTrack, loggerOptions?: LoggerOptions);
-    setTrack(track?: Track): void;
-    get isMuted(): boolean;
-    get audioTrack(): LocalAudioTrack | undefined;
-    get videoTrack(): LocalVideoTrack | undefined;
-    get isLocal(): boolean;
-    /**
-     * Mute the track associated with this publication
-     */
-    mute(): Promise<LocalTrack<Track.Kind> | undefined>;
-    /**
-     * Unmute track associated with this publication
-     */
-    unmute(): Promise<LocalTrack<Track.Kind> | 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>;
-    getTrackFeatures(): AudioTrackFeature[];
-    handleTrackEnded: () => void;
-    private handleCpuConstrained;
-}
-//# sourceMappingURL=LocalTrackPublication.d.ts.map
+import { AudioTrackFeature, TrackInfo } from '@livekit/protocol';
+import type { LoggerOptions } from '../types';
+import LocalAudioTrack from './LocalAudioTrack';
+import type LocalTrack from './LocalTrack';
+import type LocalVideoTrack from './LocalVideoTrack';
+import type { Track } from './Track';
+import { TrackPublication } from './TrackPublication';
+import type { TrackPublishOptions } from './options';
+export default class LocalTrackPublication extends TrackPublication {
+    track?: LocalTrack;
+    options?: TrackPublishOptions;
+    get isUpstreamPaused(): (boolean | undefined);
+    constructor(kind: Track.Kind, ti: TrackInfo, track?: LocalTrack, loggerOptions?: LoggerOptions);
+    setTrack(track?: Track): void;
+    get isMuted(): boolean;
+    get audioTrack(): (LocalAudioTrack | undefined);
+    get videoTrack(): (LocalVideoTrack | undefined);
+    get isLocal(): boolean;
+    /**
+     * Mute the track associated with this publication
+     */
+    mute(): Promise<LocalTrack<Track.Kind> | undefined>;
+    /**
+     * Unmute track associated with this publication
+     */
+    unmute(): Promise<LocalTrack<Track.Kind> | 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>;
+    getTrackFeatures(): AudioTrackFeature[];
+    handleTrackEnded: () => void;
+    private handleCpuConstrained;
+}
+//# sourceMappingURL=LocalTrackPublication.d.ts.map

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

@@ -1,100 +1,109 @@
-import { SubscribedCodec, SubscribedQuality, VideoLayer } from '@livekit/protocol';
-import type { SignalClient } from '../../api/SignalClient';
-import type { VideoSenderStats } from '../stats';
-import type { LoggerOptions } from '../types';
-import LocalTrack from './LocalTrack';
-import { Track, VideoQuality } from './Track';
-import type { TrackPublishOptions, VideoCaptureOptions, VideoCodec } from './options';
-import type { TrackProcessor } from './processor/types';
-export declare class SimulcastTrackInfo {
-    codec: VideoCodec;
-    mediaStreamTrack: MediaStreamTrack;
-    sender?: RTCRtpSender;
-    encodings?: RTCRtpEncodingParameters[];
-    constructor(codec: VideoCodec, mediaStreamTrack: MediaStreamTrack);
-}
-export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
-    signalClient?: SignalClient;
-    private prevStats?;
-    private encodings?;
-    simulcastCodecs: Map<VideoCodec, SimulcastTrackInfo>;
-    private subscribedCodecs?;
-    private senderLock;
-    private degradationPreference;
-    private isCpuConstrained;
-    private optimizeForPerformance;
-    publishOptions?: TrackPublishOptions;
-    lastEncodedDimensions?: Track.Dimensions;
-    get sender(): RTCRtpSender | undefined;
-    set sender(sender: RTCRtpSender | undefined);
-    /**
-     *
-     * @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, loggerOptions?: LoggerOptions);
-    get isSimulcast(): boolean;
-    startMonitor(signalClient: SignalClient): void;
-    stop(): void;
-    pauseUpstream(): Promise<void>;
-    resumeUpstream(): Promise<void>;
-    mute(): Promise<typeof this>;
-    unmute(): Promise<typeof this>;
-    protected setTrackMuted(muted: boolean): void;
-    getSenderStats(): Promise<VideoSenderStats[]>;
-    /**
-     * Whether `codec` is being published as SVC (a single stream carrying all spatial
-     * layers) as opposed to rid based simulcast. VP9/AV1 are SVC unless the publisher
-     * opted into simulcast, in which case each rid is an independent stream and the
-     * layers can be enabled/disabled individually.
-     */
-    private isSvcPublish;
-    setPublishingQuality(maxQuality: VideoQuality): void;
-    restartTrack(options?: VideoCaptureOptions): Promise<void>;
-    protected onSenderTrackSwapped(): Promise<void>;
-    /**
-     * Recomputes encoding parameters for this track's senders based on the current
-     * MediaStreamTrack dimensions and reapplies them via setParameters. This is a no-op
-     * if the track hasn't been published yet or if the track is in performance-optimized
-     * mode (which manages its own encodings).
-     */
-    private refreshSenderEncodings;
-    private applyEncodingsToSender;
-    setProcessor(processor: TrackProcessor<Track.Kind.Video>, showProcessedStreamLocally?: boolean): Promise<void>;
-    setDegradationPreference(preference: RTCDegradationPreference): Promise<void>;
-    /**
-     * Degradation preference is a property of the sender, not of the track, so every sender
-     * publishing this track needs it applied separately. A backup codec publishes over its
-     * own sender, which would otherwise let the browser resolve a preference implicitly and
-     * diverge from the primary encoder.
-     *
-     * Callers apply this sequentially rather than concurrently: `setParameters` is only valid
-     * against the parameters most recently returned by `getParameters`, which is why this file
-     * serializes other sender parameter updates through `senderLock`.
-     */
-    private applyDegradationPreference;
-    addSimulcastTrack(codec: VideoCodec, encodings?: RTCRtpEncodingParameters[]): SimulcastTrackInfo | undefined;
-    setSimulcastTrackSender(codec: VideoCodec, sender: RTCRtpSender): Promise<void>;
-    /**
-     * @internal
-     * Sets codecs that should be publishing, returns new codecs that have not yet
-     * been published
-     */
-    setPublishingCodecs(codecs: SubscribedCodec[]): Promise<VideoCodec[]>;
-    /**
-     * @internal
-     * Sets layers that should be publishing
-     */
-    setPublishingLayers(isSvc: boolean, qualities: SubscribedQuality[]): Promise<void>;
-    /**
-     * Designed for lower powered devices, reduces video publishing quality and disables simulcast.
-     * @experimental
-     */
-    prioritizePerformance(): 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[], svc?: boolean): VideoLayer[];
-//# sourceMappingURL=LocalVideoTrack.d.ts.map
+import { SubscribedCodec, SubscribedQuality, VideoLayer } from '@livekit/protocol';
+import type { SignalClient } from '../../api/SignalClient';
+import type { VideoSenderStats } from '../stats';
+import type { LoggerOptions } from '../types';
+import LocalTrack from './LocalTrack';
+import { Track, VideoQuality } from './Track';
+import type { TrackPublishOptions, VideoCaptureOptions, VideoCodec } from './options';
+import type { TrackProcessor } from './processor/types';
+export declare class SimulcastTrackInfo {
+    codec: VideoCodec;
+    mediaStreamTrack: MediaStreamTrack;
+    sender?: RTCRtpSender;
+    encodings?: RTCRtpEncodingParameters[];
+    constructor(codec: VideoCodec, mediaStreamTrack: MediaStreamTrack);
+}
+export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
+    signalClient?: SignalClient;
+    private prevStats?;
+    private encodings?;
+    simulcastCodecs: Map<VideoCodec, SimulcastTrackInfo>;
+    private subscribedCodecs?;
+    private senderLock;
+    private degradationPreference;
+    private isCpuConstrained;
+    private optimizeForPerformance;
+    publishOptions?: TrackPublishOptions;
+    lastEncodedDimensions?: Track.Dimensions;
+    get sender(): RTCRtpSender | undefined;
+    set sender(sender: RTCRtpSender | undefined);
+    /**
+     *
+     * @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, loggerOptions?: LoggerOptions);
+    get isSimulcast(): boolean;
+    startMonitor(signalClient: SignalClient): void;
+    stop(): void;
+    pauseUpstream(): Promise<void>;
+    resumeUpstream(): Promise<void>;
+    mute(): Promise<typeof this>;
+    unmute(): Promise<typeof this>;
+    protected setTrackMuted(muted: boolean): void;
+    getSenderStats(): Promise<VideoSenderStats[]>;
+    /**
+     * Whether `codec` is being published as SVC (a single stream carrying all spatial
+     * layers) as opposed to rid based simulcast. VP9/AV1 are SVC unless the publisher
+     * opted into simulcast, in which case each rid is an independent stream and the
+     * layers can be enabled/disabled individually.
+     */
+    private isSvcPublish;
+    setPublishingQuality(maxQuality: VideoQuality): void;
+    restartTrack(options?: VideoCaptureOptions): Promise<void>;
+    protected onSenderTrackSwapped(): Promise<void>;
+    /**
+     * Recomputes encoding parameters for this track's senders based on the current
+     * MediaStreamTrack dimensions and reapplies them via setParameters. This is a no-op
+     * if the track hasn't been published yet or if the track is in performance-optimized
+     * mode (which manages its own encodings).
+     */
+    private refreshSenderEncodings;
+    private applyEncodingsToSender;
+    /**
+     * Sets a processor on this track, and wires its processed track into the simulcast codecs.
+     *
+     * The processor is destroyed when the track is stopped, which unpublishing and disconnecting
+     * both do by default, so it has to be set again after reconnecting. See {@link TrackProcessor}
+     * for the full lifecycle.
+     */
+    setProcessor(processor: TrackProcessor<Track.Kind.Video>, showProcessedStreamLocally?: boolean): Promise<void>;
+    setDegradationPreference(preference: RTCDegradationPreference): Promise<void>;
+    /**
+     * Degradation preference is a property of the sender, not of the track, so every sender
+     * publishing this track needs it applied separately. A backup codec publishes over its
+     * own sender, which would otherwise let the browser resolve a preference implicitly and
+     * diverge from the primary encoder.
+     *
+     * Callers apply this sequentially rather than concurrently: `setParameters` is only valid
+     * against the parameters most recently returned by `getParameters`, which is why this file
+     * serializes other sender parameter updates through `senderLock`.
+     */
+    private applyDegradationPreference;
+    addSimulcastTrack(codec: VideoCodec, encodings?: RTCRtpEncodingParameters[]): SimulcastTrackInfo | undefined;
+    setSimulcastTrackSender(codec: VideoCodec, sender: RTCRtpSender): Promise<void>;
+    /** @interal */
+    refreshSubscribedCodecs(): Promise<void | ("vp8" | "h264" | "vp9" | "av1" | "h265")[]>;
+    /**
+     * @internal
+     * Sets codecs that should be publishing, returns new codecs that have not yet
+     * been published
+     */
+    setPublishingCodecs(codecs: SubscribedCodec[]): Promise<VideoCodec[]>;
+    /**
+     * @internal
+     * Sets layers that should be publishing
+     */
+    setPublishingLayers(isSvc: boolean, qualities: SubscribedQuality[]): Promise<void>;
+    /**
+     * Designed for lower powered devices, reduces video publishing quality and disables simulcast.
+     * @experimental
+     */
+    prioritizePerformance(): 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[], svc?: boolean): VideoLayer[];
+//# sourceMappingURL=LocalVideoTrack.d.ts.map