livekit-client 2.22.3 → 2.23.0

package/dist/ts4.2/room/statsSummary.d.ts

@@ -1,13 +1,13 @@
-/** one summarised stats entry; keys without a value are dropped */
-type Summary = Record<string, unknown>;
-/**
- * Picks the interesting fields out of a `getStats()` report and groups them by
- * RTP stream, so a stats dump can be read without unfolding the raw report.
- */
-export declare function summarizeStatsReport(report: RTCStatsReport): {
-    connection: Summary | undefined;
-    outbound: Summary[] | undefined;
-    inbound: Summary[] | undefined;
-};
-export {};
-//# sourceMappingURL=statsSummary.d.ts.map
+/** one summarised stats entry; keys without a value are dropped */
+type Summary = Record<string, unknown>;
+/**
+ * Picks the interesting fields out of a `getStats()` report and groups them by
+ * RTP stream, so a stats dump can be read without unfolding the raw report.
+ */
+export declare function summarizeStatsReport(report: RTCStatsReport): {
+    connection: Summary | undefined;
+    outbound: Summary[] | undefined;
+    inbound: Summary[] | undefined;
+};
+export {};
+//# sourceMappingURL=statsSummary.d.ts.map

package/dist/ts4.2/room/timers.d.ts

@@ -1,12 +1,12 @@
-/**
- * Timers that can be overridden with platform specific implementations
- * that ensure that they are fired. These should be used when it is critical
- * that the timer fires on time.
- */
-export default class CriticalTimers {
-    static setTimeout: (...args: Parameters<typeof setTimeout>) => ReturnType<typeof setTimeout>;
-    static setInterval: (...args: Parameters<typeof setInterval>) => ReturnType<typeof setInterval>;
-    static clearTimeout: (...args: Parameters<typeof clearTimeout>) => ReturnType<typeof clearTimeout>;
-    static clearInterval: (...args: Parameters<typeof clearInterval>) => ReturnType<typeof clearInterval>;
-}
-//# sourceMappingURL=timers.d.ts.map
+/**
+ * Timers that can be overridden with platform specific implementations
+ * that ensure that they are fired. These should be used when it is critical
+ * that the timer fires on time.
+ */
+export default class CriticalTimers {
+    static setTimeout: (...args: Parameters<typeof setTimeout>) => ReturnType<typeof setTimeout>;
+    static setInterval: (...args: Parameters<typeof setInterval>) => ReturnType<typeof setInterval>;
+    static clearTimeout: (...args: Parameters<typeof clearTimeout>) => ReturnType<typeof clearTimeout>;
+    static clearInterval: (...args: Parameters<typeof clearInterval>) => ReturnType<typeof clearInterval>;
+}
+//# sourceMappingURL=timers.d.ts.map

package/dist/ts4.2/room/token-source/TokenSource.d.ts

@@ -1,82 +1,82 @@
-import { TokenSourceResponse } from '@livekit/protocol';
-import type { TokenSourceFetchOptions, TokenSourceResponseObject } from './types';
-import { TokenSourceConfigurable, TokenSourceFixed } from './types';
-import { areTokenSourceFetchOptionsEqual, decodeTokenPayload } from './utils';
-/** A TokenSourceCached is a TokenSource which caches the last {@link TokenSourceResponseObject} value and returns it
- * until a) it expires or b) the {@link TokenSourceFetchOptions} provided to .fetch(...) change. */
-declare abstract class TokenSourceCached extends TokenSourceConfigurable {
-    private cachedFetchOptions;
-    private cachedResponse;
-    private fetchMutex;
-    private isSameAsCachedFetchOptions;
-    private shouldReturnCachedValueFromFetch;
-    getCachedResponseJwtPayload(): import("./types").TokenPayload | null;
-    fetch(options: TokenSourceFetchOptions, force?: boolean): Promise<TokenSourceResponseObject>;
-    protected abstract update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
-}
-type LiteralOrFn = TokenSourceResponseObject | (() => TokenSourceResponseObject | Promise<TokenSourceResponseObject>);
-declare class TokenSourceLiteral extends TokenSourceFixed {
-    private literalOrFn;
-    constructor(literalOrFn: LiteralOrFn);
-    fetch(): Promise<TokenSourceResponseObject>;
-}
-type CustomFn = (options: TokenSourceFetchOptions) => TokenSourceResponseObject | Promise<TokenSourceResponseObject>;
-declare class TokenSourceCustom extends TokenSourceCached {
-    private customFn;
-    constructor(customFn: CustomFn);
-    protected update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
-}
-export type EndpointOptions = Omit<RequestInit, 'body'>;
-declare class TokenSourceEndpoint extends TokenSourceCached {
-    private url;
-    private endpointOptions;
-    constructor(url: string, options?: EndpointOptions);
-    private createRequestFromOptions;
-    protected update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
-}
-export type DevelopmentTokenServerOptions = {
-    baseUrl?: string;
-};
-declare class TokenSourceDevelopmentTokenServer extends TokenSourceEndpoint {
-    constructor(tokenServerId: string, options: DevelopmentTokenServerOptions);
-}
-/** @deprecated use {@link DevelopmentTokenServerOptions} instead */
-export type SandboxTokenServerOptions = DevelopmentTokenServerOptions;
-/** @deprecated Use {@link TokenSourceDevelopmentTokenServer} instead */
-declare class TokenSourceSandboxTokenServer extends TokenSourceDevelopmentTokenServer {
-}
-export type { TokenSourceLiteral, TokenSourceCustom, TokenSourceEndpoint, TokenSourceSandboxTokenServer, TokenSourceDevelopmentTokenServer };
-export { decodeTokenPayload, areTokenSourceFetchOptionsEqual };
-export declare const TokenSource: {
-    /** TokenSource.literal contains a single, literal set of {@link TokenSourceResponseObject}
-     * credentials, either provided directly or returned from a provided function. */
-    literal(literalOrFn: LiteralOrFn): TokenSourceLiteral;
-    /**
-     * TokenSource.custom allows a user to define a manual function which generates new
-     * {@link TokenSourceResponseObject} values on demand.
-     *
-     * Use this to get credentials from custom backends / etc.
-     */
-    custom(customFn: CustomFn): TokenSourceCustom;
-    /**
-     * TokenSource.endpoint creates a token source that fetches credentials from a given URL using
-     * the standard endpoint format:
-     * @see https://docs.livekit.io/frontends/build/authentication/endpoint/
-     */
-    endpoint(url: string, options?: EndpointOptions): TokenSourceEndpoint;
-    /**
-     * @deprecated Use {@link TokenSource.developmentTokenServer} instead
-     */
-    sandboxTokenServer(sandboxId: string, options?: SandboxTokenServerOptions): TokenSourceSandboxTokenServer;
-    /**
-     * TokenSource.developmentTokenServer queries a development token server for credentials,
-     * which supports quick prototyping / getting started types of use cases.
-     *
-     * This token provider is INSECURE and should NOT be used in production.
-     *
-     * For more info:
-     * @see https://docs.livekit.io/frontends/build/authentication/sandbox-token-server/
-     */
-    developmentTokenServer(tokenServerId: string, options?: DevelopmentTokenServerOptions): TokenSourceDevelopmentTokenServer;
-};
-//# sourceMappingURL=TokenSource.d.ts.map
+import { TokenSourceResponse } from '@livekit/protocol';
+import type { TokenSourceFetchOptions, TokenSourceResponseObject } from './types';
+import { TokenSourceConfigurable, TokenSourceFixed } from './types';
+import { areTokenSourceFetchOptionsEqual, decodeTokenPayload } from './utils';
+/** A TokenSourceCached is a TokenSource which caches the last {@link TokenSourceResponseObject} value and returns it
+ * until a) it expires or b) the {@link TokenSourceFetchOptions} provided to .fetch(...) change. */
+declare abstract class TokenSourceCached extends TokenSourceConfigurable {
+    private cachedFetchOptions;
+    private cachedResponse;
+    private fetchMutex;
+    private isSameAsCachedFetchOptions;
+    private shouldReturnCachedValueFromFetch;
+    getCachedResponseJwtPayload(): import("./types").TokenPayload | null;
+    fetch(options: TokenSourceFetchOptions, force?: boolean): Promise<TokenSourceResponseObject>;
+    protected abstract update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
+}
+type LiteralOrFn = TokenSourceResponseObject | (() => TokenSourceResponseObject | Promise<TokenSourceResponseObject>);
+declare class TokenSourceLiteral extends TokenSourceFixed {
+    private literalOrFn;
+    constructor(literalOrFn: LiteralOrFn);
+    fetch(): Promise<TokenSourceResponseObject>;
+}
+type CustomFn = (options: TokenSourceFetchOptions) => TokenSourceResponseObject | Promise<TokenSourceResponseObject>;
+declare class TokenSourceCustom extends TokenSourceCached {
+    private customFn;
+    constructor(customFn: CustomFn);
+    protected update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
+}
+export type EndpointOptions = Omit<RequestInit, 'body'>;
+declare class TokenSourceEndpoint extends TokenSourceCached {
+    private url;
+    private endpointOptions;
+    constructor(url: string, options?: EndpointOptions);
+    private createRequestFromOptions;
+    protected update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
+}
+export type DevelopmentTokenServerOptions = {
+    baseUrl?: string;
+};
+declare class TokenSourceDevelopmentTokenServer extends TokenSourceEndpoint {
+    constructor(tokenServerId: string, options: DevelopmentTokenServerOptions);
+}
+/** @deprecated use {@link DevelopmentTokenServerOptions} instead */
+export type SandboxTokenServerOptions = DevelopmentTokenServerOptions;
+/** @deprecated Use {@link TokenSourceDevelopmentTokenServer} instead */
+declare class TokenSourceSandboxTokenServer extends TokenSourceDevelopmentTokenServer {
+}
+export type { TokenSourceLiteral, TokenSourceCustom, TokenSourceEndpoint, TokenSourceSandboxTokenServer, TokenSourceDevelopmentTokenServer };
+export { decodeTokenPayload, areTokenSourceFetchOptionsEqual };
+export declare const TokenSource: {
+    /** TokenSource.literal contains a single, literal set of {@link TokenSourceResponseObject}
+     * credentials, either provided directly or returned from a provided function. */
+    literal(literalOrFn: LiteralOrFn): TokenSourceLiteral;
+    /**
+     * TokenSource.custom allows a user to define a manual function which generates new
+     * {@link TokenSourceResponseObject} values on demand.
+     *
+     * Use this to get credentials from custom backends / etc.
+     */
+    custom(customFn: CustomFn): TokenSourceCustom;
+    /**
+     * TokenSource.endpoint creates a token source that fetches credentials from a given URL using
+     * the standard endpoint format:
+     * @see https://docs.livekit.io/frontends/build/authentication/endpoint/
+     */
+    endpoint(url: string, options?: EndpointOptions): TokenSourceEndpoint;
+    /**
+     * @deprecated Use {@link TokenSource.developmentTokenServer} instead
+     */
+    sandboxTokenServer(sandboxId: string, options?: SandboxTokenServerOptions): TokenSourceSandboxTokenServer;
+    /**
+     * TokenSource.developmentTokenServer queries a development token server for credentials,
+     * which supports quick prototyping / getting started types of use cases.
+     *
+     * This token provider is INSECURE and should NOT be used in production.
+     *
+     * For more info:
+     * @see https://docs.livekit.io/frontends/build/authentication/sandbox-token-server/
+     */
+    developmentTokenServer(tokenServerId: string, options?: DevelopmentTokenServerOptions): TokenSourceDevelopmentTokenServer;
+};
+//# sourceMappingURL=TokenSource.d.ts.map

package/dist/ts4.2/room/token-source/types.d.ts

@@ -1,70 +1,70 @@
-import { RoomConfiguration, TokenSourceRequest, TokenSourceResponse } from '@livekit/protocol';
-import type { JWTPayload } from 'jose';
-import type { ValueToSnakeCase } from '../../utils/camelToSnakeCase';
-export type TokenSourceRequestObject = Required<NonNullable<ConstructorParameters<typeof TokenSourceRequest>[0]>>;
-export type TokenSourceResponseObject = Required<NonNullable<ConstructorParameters<typeof TokenSourceResponse>[0]>>;
-/** The `TokenSource` request object sent to the server as part of fetching a configurable
- * `TokenSource` like {@link TokenSourceEndpoint}.
- *
- * Use this as a type for your request body if implementing a server endpoint in node.js.
- */
-export type TokenSourceRequestPayload = ValueToSnakeCase<TokenSourceRequestObject>;
-/** The `TokenSource` response object sent from the server as part of fetching a configurable
- * `TokenSource` like {@link TokenSourceEndpoint}.
- *
- * Use this as a type for your response body if implementing a server endpoint in node.js.
- */
-export type TokenSourceResponsePayload = ValueToSnakeCase<TokenSourceResponseObject>;
-/** The payload of a LiveKit JWT token. */
-export type TokenPayload = JWTPayload & {
-    name?: string;
-    metadata?: string;
-    attributes?: Record<string, string>;
-    video?: {
-        room?: string;
-        roomJoin?: boolean;
-        canPublish?: boolean;
-        canPublishData?: boolean;
-        canSubscribe?: boolean;
-    };
-    roomConfig?: RoomConfigurationObject;
-};
-export type RoomConfigurationObject = NonNullable<ConstructorParameters<typeof RoomConfiguration>[0]>;
-/** A Fixed TokenSource is a token source that takes no parameters and returns a completely
- * independently derived value on each fetch() call.
- *
- * The most common downstream implementer is {@link TokenSourceLiteral}.
- */
-export declare abstract class TokenSourceFixed {
-    abstract fetch(): Promise<TokenSourceResponseObject>;
-}
-export type TokenSourceFetchOptions = {
-    roomName?: string;
-    participantName?: string;
-    participantIdentity?: string;
-    participantMetadata?: string;
-    participantAttributes?: {
-        [key: string]: string;
-    };
-    agentName?: string;
-    agentMetadata?: string;
-    deployment?: string;
-};
-/** A Configurable TokenSource is a token source that takes a
- * {@link TokenSourceFetchOptions} object as input and returns a deterministic
- * {@link TokenSourceResponseObject} output based on the options specified.
- *
- * For example, if options.participantName is set, it should be expected that
- * all tokens that are generated will have participant name field set to the
- * provided value.
- *
- * A few common downstream implementers are {@link TokenSourceEndpoint}
- * and {@link TokenSourceCustom}.
- */
-export declare abstract class TokenSourceConfigurable {
-    abstract fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
-    abstract fetch(options: TokenSourceFetchOptions, force?: boolean): Promise<TokenSourceResponseObject>;
-}
-/** A TokenSource is a mechanism for fetching credentials required to connect to a LiveKit Room. */
-export type TokenSourceBase = TokenSourceFixed | TokenSourceConfigurable;
-//# sourceMappingURL=types.d.ts.map
+import { RoomConfiguration, TokenSourceRequest, TokenSourceResponse } from '@livekit/protocol';
+import type { JWTPayload } from 'jose';
+import type { ValueToSnakeCase } from '../../utils/camelToSnakeCase';
+export type TokenSourceRequestObject = Required<NonNullable<ConstructorParameters<typeof TokenSourceRequest>[0]>>;
+export type TokenSourceResponseObject = Required<NonNullable<ConstructorParameters<typeof TokenSourceResponse>[0]>>;
+/** The `TokenSource` request object sent to the server as part of fetching a configurable
+ * `TokenSource` like {@link TokenSourceEndpoint}.
+ *
+ * Use this as a type for your request body if implementing a server endpoint in node.js.
+ */
+export type TokenSourceRequestPayload = ValueToSnakeCase<TokenSourceRequestObject>;
+/** The `TokenSource` response object sent from the server as part of fetching a configurable
+ * `TokenSource` like {@link TokenSourceEndpoint}.
+ *
+ * Use this as a type for your response body if implementing a server endpoint in node.js.
+ */
+export type TokenSourceResponsePayload = ValueToSnakeCase<TokenSourceResponseObject>;
+/** The payload of a LiveKit JWT token. */
+export type TokenPayload = JWTPayload & {
+    name?: string;
+    metadata?: string;
+    attributes?: Record<string, string>;
+    video?: {
+        room?: string;
+        roomJoin?: boolean;
+        canPublish?: boolean;
+        canPublishData?: boolean;
+        canSubscribe?: boolean;
+    };
+    roomConfig?: RoomConfigurationObject;
+};
+export type RoomConfigurationObject = NonNullable<ConstructorParameters<typeof RoomConfiguration>[0]>;
+/** A Fixed TokenSource is a token source that takes no parameters and returns a completely
+ * independently derived value on each fetch() call.
+ *
+ * The most common downstream implementer is {@link TokenSourceLiteral}.
+ */
+export declare abstract class TokenSourceFixed {
+    abstract fetch(): Promise<TokenSourceResponseObject>;
+}
+export type TokenSourceFetchOptions = {
+    roomName?: string;
+    participantName?: string;
+    participantIdentity?: string;
+    participantMetadata?: string;
+    participantAttributes?: {
+        [key: string]: string;
+    };
+    agentName?: string;
+    agentMetadata?: string;
+    deployment?: string;
+};
+/** A Configurable TokenSource is a token source that takes a
+ * {@link TokenSourceFetchOptions} object as input and returns a deterministic
+ * {@link TokenSourceResponseObject} output based on the options specified.
+ *
+ * For example, if options.participantName is set, it should be expected that
+ * all tokens that are generated will have participant name field set to the
+ * provided value.
+ *
+ * A few common downstream implementers are {@link TokenSourceEndpoint}
+ * and {@link TokenSourceCustom}.
+ */
+export declare abstract class TokenSourceConfigurable {
+    abstract fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+    abstract fetch(options: TokenSourceFetchOptions, force?: boolean): Promise<TokenSourceResponseObject>;
+}
+/** A TokenSource is a mechanism for fetching credentials required to connect to a LiveKit Room. */
+export type TokenSourceBase = TokenSourceFixed | TokenSourceConfigurable;
+//# sourceMappingURL=types.d.ts.map

package/dist/ts4.2/room/token-source/utils.d.ts

@@ -1,8 +1,8 @@
-import type { TokenSourceResponse } from '@livekit/protocol';
-import type { TokenPayload, TokenSourceFetchOptions } from './types';
-export declare function isResponseTokenValid(response: TokenSourceResponse): boolean;
-/** Given a LiveKit generated participant token, decodes and returns the associated {@link TokenPayload} data. */
-export declare function decodeTokenPayload(token: string): TokenPayload;
-/** Given two TokenSourceFetchOptions values, check to see if they are deep equal. */
-export declare function areTokenSourceFetchOptionsEqual(a: TokenSourceFetchOptions, b: TokenSourceFetchOptions): boolean;
-//# sourceMappingURL=utils.d.ts.map
+import type { TokenSourceResponse } from '@livekit/protocol';
+import type { TokenPayload, TokenSourceFetchOptions } from './types';
+export declare function isResponseTokenValid(response: TokenSourceResponse): boolean;
+/** Given a LiveKit generated participant token, decodes and returns the associated {@link TokenPayload} data. */
+export declare function decodeTokenPayload(token: string): TokenPayload;
+/** Given two TokenSourceFetchOptions values, check to see if they are deep equal. */
+export declare function areTokenSourceFetchOptionsEqual(a: TokenSourceFetchOptions, b: TokenSourceFetchOptions): boolean;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,19 +1,19 @@
-import type { FrameMetadata } from '../../frameMetadata/types';
-/**
- * Caches frame metadata extracted from received video frames,
- * keyed by RTP timestamp so it can be looked up when the frame is displayed.
- *
- * Metadata is populated either by the frame metadata worker managed by
- * `FrameMetadataManager` (non-E2EE) or by the E2EE FrameCryptor worker
- * after decryption (E2EE).
- *
- * @experimental
- */
-export declare class FrameMetadataExtractor {
-    private metadataMap;
-    private activeSsrc;
-    storeMetadata(rtpTimestamp: number, ssrc: number, metadata: FrameMetadata): void;
-    lookupMetadata(rtpTimestamp: number): FrameMetadata | undefined;
-    dispose(): void;
-}
-//# sourceMappingURL=FrameMetadataExtractor.d.ts.map
+import type { FrameMetadata } from '../../frameMetadata/types';
+/**
+ * Caches frame metadata extracted from received video frames,
+ * keyed by RTP timestamp so it can be looked up when the frame is displayed.
+ *
+ * Metadata is populated either by the frame metadata worker managed by
+ * `FrameMetadataManager` (non-E2EE) or by the E2EE FrameCryptor worker
+ * after decryption (E2EE).
+ *
+ * @experimental
+ */
+export declare class FrameMetadataExtractor {
+    private metadataMap;
+    private activeSsrc;
+    storeMetadata(rtpTimestamp: number, ssrc: number, metadata: FrameMetadata): void;
+    lookupMetadata(rtpTimestamp: number): FrameMetadata | undefined;
+    dispose(): void;
+}
+//# sourceMappingURL=FrameMetadataExtractor.d.ts.map

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

@@ -1,42 +1,62 @@
-import type { AudioSenderStats } from '../stats';
-import type { LoggerOptions } from '../types';
-import LocalTrack from './LocalTrack';
-import { Track } from './Track';
-import type { AudioCaptureOptions } from './options';
-import type { AudioProcessorOptions, TrackProcessor } from './processor/types';
-export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
-    /** @internal */
-    stopOnMute: boolean;
-    private prevStats?;
-    private isKrispNoiseFilterEnabled;
-    protected processor?: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions> | undefined;
-    /**
-     * boolean indicating whether enhanced noise cancellation is currently being used on this track
-     */
-    get enhancedNoiseCancellation(): boolean;
-    /**
-     *
-     * @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, audioContext?: AudioContext, loggerOptions?: LoggerOptions);
-    mute(): Promise<typeof this>;
-    unmute(): Promise<typeof this>;
-    restartTrack(options?: AudioCaptureOptions): Promise<void>;
-    applyConstraints(constraints: Pick<AudioCaptureOptions, 'autoGainControl' | 'noiseSuppression' | 'echoCancellation' | 'voiceIsolation'>): Promise<void>;
-    protected restart(constraints?: MediaTrackConstraints, isUnmuting?: boolean): Promise<typeof this>;
-    startMonitor(): void;
-    protected monitorSender: () => Promise<void>;
-    private handleKrispNoiseFilterEnable;
-    private handleKrispNoiseFilterDisable;
-    setProcessor(processor: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions>): Promise<void>;
-    /**
-     * @internal
-     * @experimental
-     */
-    setAudioContext(audioContext: AudioContext | undefined): void;
-    getSenderStats(): Promise<AudioSenderStats | undefined>;
-    checkForSilence(): Promise<boolean>;
-}
-//# sourceMappingURL=LocalAudioTrack.d.ts.map
+import type { AudioSenderStats } from '../stats';
+import type { LoggerOptions } from '../types';
+import LocalTrack from './LocalTrack';
+import { Track } from './Track';
+import type { AudioCaptureOptions } from './options';
+import type { AudioProcessorOptions, TrackProcessor } from './processor/types';
+export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
+    /** @internal */
+    stopOnMute: boolean;
+    private prevStats?;
+    private isKrispNoiseFilterEnabled;
+    /**
+     * the processed track we currently have krisp feature listeners registered on. Tracked
+     * separately, as `processor.processedTrack` can be swapped out while we hold the listeners.
+     */
+    private observedProcessedTrack?;
+    protected processor?: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions> | undefined;
+    get enhancedNoiseCancellation(): boolean;
+    /**
+     *
+     * @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, audioContext?: AudioContext, loggerOptions?: LoggerOptions);
+    mute(): Promise<typeof this>;
+    unmute(): Promise<typeof this>;
+    restartTrack(options?: AudioCaptureOptions): Promise<void>;
+    applyConstraints(constraints: Pick<AudioCaptureOptions, 'autoGainControl' | 'noiseSuppression' | 'echoCancellation' | 'voiceIsolation'>): Promise<void>;
+    protected restart(constraints?: MediaTrackConstraints, isUnmuting?: boolean): Promise<typeof this>;
+    startMonitor(): void;
+    protected monitorSender: () => Promise<void>;
+    private handleKrispNoiseFilterEnable;
+    private handleKrispNoiseFilterDisable;
+    /**
+     * registers the krisp feature listeners on the given processed track, moving them over from
+     * a previously observed one. Passing `undefined` just removes the existing listeners.
+     */
+    private observeProcessedTrack;
+    /**
+     * Sets a processor on this track.
+     *
+     * The processor is destroyed when the track is stopped, and also when the audio context goes
+     * away, so a disconnect ends it on both counts and it has to be set again after reconnecting.
+     * See {@link TrackProcessor} for the full lifecycle.
+     */
+    setProcessor(processor: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions>): Promise<void>;
+    protected onMediaStreamTrackChanged(): Promise<void>;
+    protected internalStopProcessor(keepElement?: boolean): Promise<void>;
+    stop(): void;
+    /**
+     * @internal
+     * @experimental
+     *
+     * A processor's nodes (`AudioWorkletNode`, ...) can't move between contexts, so the processor
+     * is rebuilt whenever the context changes and torn down when there is none left to run in.
+     */
+    setAudioContext(audioContext: AudioContext | undefined): Promise<void>;
+    getSenderStats(): Promise<AudioSenderStats | undefined>;
+    checkForSilence(): Promise<boolean>;
+}
+//# sourceMappingURL=LocalAudioTrack.d.ts.map