livekit-client 2.22.3 → 2.22.4

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

@@ -1,166 +1,156 @@
-import { AudioTrackFeature, StreamState as ProtoStreamState, TrackSource, TrackType } from '@livekit/protocol';
-import type TypedEventEmitter from 'typed-emitter';
-import type { SignalClient } from '../../api/SignalClient';
-import type { StructuredLogger } from '../../logger';
-import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
-import type { LoggerOptions } from '../types';
-import type { TrackProcessor } from './processor/types';
-export declare enum VideoQuality {
-    LOW = 0,
-    MEDIUM = 1,
-    HIGH = 2
-}
-declare const Track_base: new () => TypedEventEmitter<TrackEventCallbacks>;
-export declare abstract class Track<TrackKind extends Track.Kind = Track.Kind> extends Track_base {
-    readonly kind: TrackKind;
-    attachedElements: HTMLMediaElement[];
-    isMuted: boolean;
-    source: Track.Source;
-    private _streamState;
-    /**
-     * 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, it'll indicate `paused` if the track
-     * has been paused by congestion controller
-     */
-    get streamState(): Track.StreamState;
-    /** @internal */
-    setStreamState(value: Track.StreamState): void;
-    /** @internal */
-    rtpTimestamp: number | undefined;
-    protected _mediaStreamTrack: MediaStreamTrack;
-    protected _mediaStreamID: string;
-    protected isInBackground: boolean;
-    private backgroundTimeout;
-    private loggerContextCb;
-    protected timeSyncHandle: number | undefined;
-    protected _currentBitrate: number;
-    protected monitorInterval?: ReturnType<typeof setInterval>;
-    private finalStatsLogged;
-    protected log: StructuredLogger;
-    protected constructor(mediaTrack: MediaStreamTrack, kind: TrackKind, loggerOptions?: LoggerOptions);
-    protected get logContext(): {
-        [x: string]: unknown;
-    };
-    /** current receive bits per second */
-    get currentBitrate(): number;
-    get mediaStreamTrack(): MediaStreamTrack;
-    abstract get isLocal(): boolean;
-    /**
-     * @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;
-    /**
-     * Raw stats of the sender or receiver this track is attached to.
-     */
-    abstract getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
-    stopMonitor(): void;
-    /**
-     * Dumps the raw stats of the track as it ends, once: a track that stops
-     * between two of the room's stats dumps is gone by the time the next one runs.
-     */
-    private logFinalStats;
-    /** @internal */
-    updateLoggerOptions(loggerOptions: LoggerOptions): void;
-    private recycleElement;
-    protected appVisibilityChangedListener: () => void;
-    protected handleAppVisibilityChanged(): Promise<void>;
-    protected addAppVisibilityListener(): void;
-    protected removeAppVisibilityListener(): void;
-}
-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;
-    videoPlaybackStarted: () => void;
-    videoPlaybackFailed: (error?: Error) => void;
-    elementAttached: (element: HTMLMediaElement) => void;
-    elementDetached: (element: HTMLMediaElement) => void;
-    upstreamPaused: (track: any) => void;
-    upstreamResumed: (track: any) => void;
-    trackProcessorUpdate: (processor?: TrackProcessor<Track.Kind, any>) => void;
-    audioTrackFeatureUpdate: (track: any, feature: AudioTrackFeature, enabled: boolean) => void;
-    timeSyncUpdate: (update: {
-        timestamp: number;
-        rtpTimestamp: number;
-    }) => void;
-    preConnectBufferFlushed: (buffer: NonSharedUint8Array[]) => void;
-    cpuConstrained: () => void;
-};
-export {};
-//# sourceMappingURL=Track.d.ts.map
+import { AudioTrackFeature, StreamState as ProtoStreamState, TrackSource, TrackType } from '@livekit/protocol';
+import type TypedEventEmitter from 'typed-emitter';
+import type { SignalClient } from '../../api/SignalClient';
+import type { StructuredLogger } from '../../logger';
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
+import type { LoggerOptions } from '../types';
+import type { TrackProcessor } from './processor/types';
+export declare enum VideoQuality {
+    LOW = 0,
+    MEDIUM = 1,
+    HIGH = 2
+}
+declare const Track_base: new () => TypedEventEmitter<TrackEventCallbacks>;
+export declare abstract class Track<TrackKind extends Track.Kind = Track.Kind> extends Track_base {
+    readonly kind: TrackKind;
+    attachedElements: HTMLMediaElement[];
+    isMuted: boolean;
+    source: Track.Source;
+    private _streamState;
+    /**
+     * sid is set after track is published to server, or if it's a remote track
+     */
+    sid?: Track.SID;
+    /**
+     * @internal
+     */
+    mediaStream?: MediaStream;
+    get streamState(): Track.StreamState;
+    /** @internal */
+    setStreamState(value: Track.StreamState): void;
+    /** @internal */
+    rtpTimestamp: number | undefined;
+    protected _mediaStreamTrack: MediaStreamTrack;
+    protected _mediaStreamID: string;
+    protected isInBackground: boolean;
+    private backgroundTimeout;
+    private loggerContextCb;
+    protected timeSyncHandle: number | undefined;
+    protected _currentBitrate: number;
+    protected monitorInterval?: ReturnType<typeof setInterval>;
+    private finalStatsLogged;
+    protected log: StructuredLogger;
+    protected constructor(mediaTrack: MediaStreamTrack, kind: TrackKind, loggerOptions?: LoggerOptions);
+    protected get logContext(): {
+        [x: string]: unknown;
+    };
+    get currentBitrate(): number;
+    get mediaStreamTrack(): MediaStreamTrack;
+    abstract get isLocal(): boolean;
+    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;
+    /**
+     * Raw stats of the sender or receiver this track is attached to.
+     */
+    abstract getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
+    stopMonitor(): void;
+    /**
+     * Dumps the raw stats of the track as it ends, once: a track that stops
+     * between two of the room's stats dumps is gone by the time the next one runs.
+     */
+    private logFinalStats;
+    /** @internal */
+    updateLoggerOptions(loggerOptions: LoggerOptions): void;
+    private recycleElement;
+    protected appVisibilityChangedListener: () => void;
+    protected handleAppVisibilityChanged(): Promise<void>;
+    protected addAppVisibilityListener(): void;
+    protected removeAppVisibilityListener(): void;
+}
+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;
+    videoPlaybackStarted: () => void;
+    videoPlaybackFailed: (error?: Error) => void;
+    elementAttached: (element: HTMLMediaElement) => void;
+    elementDetached: (element: HTMLMediaElement) => void;
+    upstreamPaused: (track: any) => void;
+    upstreamResumed: (track: any) => void;
+    trackProcessorUpdate: (processor?: TrackProcessor<Track.Kind, any>) => void;
+    audioTrackFeatureUpdate: (track: any, feature: AudioTrackFeature, enabled: boolean) => void;
+    timeSyncUpdate: (update: {
+        timestamp: number;
+        rtpTimestamp: number;
+    }) => void;
+    preConnectBufferFlushed: (buffer: NonSharedUint8Array[]) => void;
+    cpuConstrained: () => void;
+};
+export {};
+//# sourceMappingURL=Track.d.ts.map

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

@@ -1,81 +1,75 @@
-import { Encryption_Type } from '@livekit/protocol';
-import type { SubscriptionError, TrackInfo, UpdateSubscription, UpdateTrackSettings } from '@livekit/protocol';
-import type TypedEventEmitter from 'typed-emitter';
-import type { LoggerOptions, TranscriptionSegment } from '../types';
-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 abstract 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;
-    protected encryption: Encryption_Type;
-    protected log: import("../../logger").StructuredLogger;
-    private loggerContextCb?;
-    constructor(kind: Track.Kind, id: string, name: string, loggerOptions?: LoggerOptions);
-    /** @internal */
-    setTrack(track?: Track): void;
-    protected get logContext(): {
-        [x: string]: unknown;
-    };
-    get isMuted(): boolean;
-    get isEnabled(): boolean;
-    get isSubscribed(): boolean;
-    get isEncrypted(): boolean;
-    abstract get isLocal(): 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;
-    subscriptionFailed: (error: SubscriptionError) => void;
-    transcriptionReceived: (transcription: TranscriptionSegment[]) => void;
-    timeSyncUpdate: (timestamp: number) => void;
-    cpuConstrained: (track: LocalVideoTrack) => void;
-};
-export {};
-//# sourceMappingURL=TrackPublication.d.ts.map
+import { Encryption_Type } from '@livekit/protocol';
+import type { SubscriptionError, TrackInfo, UpdateSubscription, UpdateTrackSettings } from '@livekit/protocol';
+import type TypedEventEmitter from 'typed-emitter';
+import type { LoggerOptions, TranscriptionSegment } from '../types';
+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 abstract 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;
+    protected encryption: Encryption_Type;
+    protected log: import("../../logger").StructuredLogger;
+    private loggerContextCb?;
+    constructor(kind: Track.Kind, id: string, name: string, loggerOptions?: LoggerOptions);
+    /** @internal */
+    setTrack(track?: Track): void;
+    protected get logContext(): {
+        [x: string]: unknown;
+    };
+    get isMuted(): boolean;
+    get isEnabled(): boolean;
+    get isSubscribed(): boolean;
+    get isEncrypted(): boolean;
+    abstract get isLocal(): boolean;
+    get audioTrack(): (LocalAudioTrack | RemoteAudioTrack | undefined);
+    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;
+    subscriptionFailed: (error: SubscriptionError) => void;
+    transcriptionReceived: (transcription: TranscriptionSegment[]) => void;
+    timeSyncUpdate: (timestamp: number) => void;
+    cpuConstrained: (track: LocalVideoTrack) => void;
+};
+export {};
+//# sourceMappingURL=TrackPublication.d.ts.map

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

@@ -1,25 +1,25 @@
-import type { LoggerOptions } from '../types';
-import LocalAudioTrack from './LocalAudioTrack';
-import type LocalTrack from './LocalTrack';
-import LocalVideoTrack from './LocalVideoTrack';
-import type { AudioCaptureOptions, CreateLocalTracksOptions, ScreenShareCaptureOptions, VideoCaptureOptions } from './options';
-/**
- * Creates a local video and audio track at the same time. When acquiring both
- * audio and video tracks together, it'll display a single permission prompt to
- * the user instead of two separate ones.
- * @param options
- */
-export declare function createLocalTracks(options?: CreateLocalTracksOptions, loggerOptions?: LoggerOptions): Promise<Array<LocalTrack>>;
-/**
- * Creates a [[LocalVideoTrack]] with getUserMedia()
- * @param options
- */
-export declare function createLocalVideoTrack(options?: VideoCaptureOptions): Promise<LocalVideoTrack>;
-export declare function createLocalAudioTrack(options?: AudioCaptureOptions): Promise<LocalAudioTrack>;
-/**
- * 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.
- */
-export declare function createLocalScreenTracks(options?: ScreenShareCaptureOptions): Promise<Array<LocalTrack>>;
-//# sourceMappingURL=create.d.ts.map
+import type { LoggerOptions } from '../types';
+import LocalAudioTrack from './LocalAudioTrack';
+import type LocalTrack from './LocalTrack';
+import LocalVideoTrack from './LocalVideoTrack';
+import type { AudioCaptureOptions, CreateLocalTracksOptions, ScreenShareCaptureOptions, VideoCaptureOptions } from './options';
+/**
+ * Creates a local video and audio track at the same time. When acquiring both
+ * audio and video tracks together, it'll display a single permission prompt to
+ * the user instead of two separate ones.
+ * @param options
+ */
+export declare function createLocalTracks(options?: CreateLocalTracksOptions, loggerOptions?: LoggerOptions): Promise<Array<LocalTrack>>;
+/**
+ * Creates a [[LocalVideoTrack]] with getUserMedia()
+ * @param options
+ */
+export declare function createLocalVideoTrack(options?: VideoCaptureOptions): Promise<LocalVideoTrack>;
+export declare function createLocalAudioTrack(options?: AudioCaptureOptions): Promise<LocalAudioTrack>;
+/**
+ * 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.
+ */
+export declare function createLocalScreenTracks(options?: ScreenShareCaptureOptions): Promise<Array<LocalTrack>>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -1,41 +1,41 @@
-import LocalTrack from './LocalTrack';
-import type { VideoCaptureOptions } from './options';
-type FacingMode = NonNullable<VideoCaptureOptions['facingMode']>;
-type FacingModeFromLocalTrackOptions = {
-    /**
-     * If no facing mode can be determined, this value will be used.
-     * @defaultValue 'user'
-     */
-    defaultFacingMode?: FacingMode;
-};
-type FacingModeFromLocalTrackReturnValue = {
-    /**
-     * The (probable) facingMode of the track.
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
-     */
-    facingMode: FacingMode;
-    /**
-     * The confidence that the returned facingMode is correct.
-     */
-    confidence: 'high' | 'medium' | 'low';
-};
-/**
- * Try to analyze the local track to determine the facing mode of a track.
- *
- * @remarks
- * There is no property supported by all browsers to detect whether a video track originated from a user- or environment-facing camera device.
- * For this reason, we use the `facingMode` property when available, but will fall back on a string-based analysis of the device label to determine the facing mode.
- * If both methods fail, the default facing mode will be used.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
- * @experimental
- */
-export declare function facingModeFromLocalTrack(localTrack: LocalTrack | MediaStreamTrack, options?: FacingModeFromLocalTrackOptions): FacingModeFromLocalTrackReturnValue;
-/**
- * Attempt to analyze the device label to determine the facing mode.
- *
- * @experimental
- */
-export declare function facingModeFromDeviceLabel(deviceLabel: string): FacingModeFromLocalTrackReturnValue | undefined;
-export {};
-//# sourceMappingURL=facingMode.d.ts.map
+import LocalTrack from './LocalTrack';
+import type { VideoCaptureOptions } from './options';
+type FacingMode = NonNullable<VideoCaptureOptions['facingMode']>;
+type FacingModeFromLocalTrackOptions = {
+    /**
+     * If no facing mode can be determined, this value will be used.
+     * @defaultValue 'user'
+     */
+    defaultFacingMode?: FacingMode;
+};
+type FacingModeFromLocalTrackReturnValue = {
+    /**
+     * The (probable) facingMode of the track.
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
+     */
+    facingMode: FacingMode;
+    /**
+     * The confidence that the returned facingMode is correct.
+     */
+    confidence: 'high' | 'medium' | 'low';
+};
+/**
+ * Try to analyze the local track to determine the facing mode of a track.
+ *
+ * @remarks
+ * There is no property supported by all browsers to detect whether a video track originated from a user- or environment-facing camera device.
+ * For this reason, we use the `facingMode` property when available, but will fall back on a string-based analysis of the device label to determine the facing mode.
+ * If both methods fail, the default facing mode will be used.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
+ * @experimental
+ */
+export declare function facingModeFromLocalTrack(localTrack: LocalTrack | MediaStreamTrack, options?: FacingModeFromLocalTrackOptions): FacingModeFromLocalTrackReturnValue;
+/**
+ * Attempt to analyze the device label to determine the facing mode.
+ *
+ * @experimental
+ */
+export declare function facingModeFromDeviceLabel(deviceLabel: string): FacingModeFromLocalTrackReturnValue | undefined;
+export {};
+//# sourceMappingURL=facingMode.d.ts.map