@stream-io/video-client 1.49.0 → 1.51.0

package/dist/src/Call.d.ts

@@ -5,7 +5,11 @@ import type { AcceptCallResponse, BlockUserResponse, CallRingEvent, CallSettings
 import { AudioTrackType, CallConstructor, CallLeaveOptions, CallRecordingType, ClientPublishOptions, ClosedCaptionsSettings, JoinCallData, StartCallRecordingFnType, TrackMuteType, VideoTrackType } from './types';
 import { ClientCapability, TrackType, VideoDimension } from './gen/video/sfu/models/models';
 import { Tracer } from './stats';
+import { AudioBindingsWatchdog } from './helpers/AudioBindingsWatchdog';
+import { BlockedAudioTracker } from './helpers/BlockedAudioTracker';
+import { TrackSubscriptionManager } from './helpers/TrackSubscriptionManager';
 import { DynascaleManager } from './helpers/DynascaleManager';
+import { ViewportTracker } from './helpers/ViewportTracker';
 import { PermissionsContext } from './permissions';
 import { StreamClient } from './coordinator/connection/client';
 import { AllCallEvents, CallEventListener, RejectReason } from './coordinator/connection/types';
@@ -55,7 +59,28 @@ export declare class Call {
     /**
      * The DynascaleManager instance.
      */
-    readonly dynascaleManager: DynascaleManager;
+    readonly dynascaleManager: DynascaleManager | undefined;
+    /**
+     * Tracks viewport visibility for participant video elements.
+     * Available only in DOM environments.
+     */
+    readonly viewportTracker: ViewportTracker | undefined;
+    /**
+     * Owns the SFU-side video-subscription state (per-session and global overrides).
+     */
+    readonly trackSubscriptionManager: TrackSubscriptionManager;
+    /**
+     * Warns periodically when a remote participant is publishing audio, but no
+     * `<audio>` element has been bound for them.
+     */
+    readonly audioBindingsWatchdog: AudioBindingsWatchdog | undefined;
+    /**
+     * Tracks audio elements blocked by the browser's autoplay policy.
+     * Subscribe to `blockedAudioTracker.autoplayBlocked$` to react to the
+     * blocked state, and call {@link Call.resumeAudio} inside a user gesture
+     * to retry playback.
+     */
+    readonly blockedAudioTracker: BlockedAudioTracker;
     subscriber?: Subscriber;
     publisher?: Publisher;
     /**
@@ -78,6 +103,7 @@ export declare class Call {
     private statsReportingIntervalInMs;
     private statsReporter?;
     private sfuStatsReporter?;
+    private lastStatsOptions?;
     private dropTimeout;
     private readonly clientStore;
     readonly streamClient: StreamClient;
@@ -376,6 +402,16 @@ export declare class Call {
      * @param trackTypes the track types to update the call state with.
      */
     private updateLocalStreamState;
+    /**
+     * Re-arms the encoder for a currently published track type. Useful for
+     * working around WebKit's stalled sender bug after an iOS audio session
+     * interruption (Siri, PSTN call).
+     *
+     * @internal
+     *
+     * @param trackType the track type to refresh.
+     */
+    refreshPublishedTrack: (trackType: TrackType) => Promise<void>;
     /**
      * Updates the preferred publishing options
      *
@@ -777,13 +813,13 @@ export declare class Call {
      * @param sessionId the session id.
      * @param trackType the video mode.
      */
-    trackElementVisibility: <T extends HTMLElement>(element: T, sessionId: string, trackType: VideoTrackType) => () => void;
+    trackElementVisibility: <T extends HTMLElement>(element: T, sessionId: string, trackType: VideoTrackType) => (() => void) | undefined;
     /**
      * Sets the viewport element to track bound video elements for visibility.
      *
      * @param element the viewport element.
      */
-    setViewport: <T extends HTMLElement>(element: T) => () => void;
+    setViewport: <T extends HTMLElement>(element: T) => (() => void) | undefined;
     /**
      * Binds a DOM <video> element to the given session id.
      * This method will make sure that the video element will play
@@ -813,6 +849,10 @@ export declare class Call {
     bindAudioElement: (audioElement: HTMLAudioElement, sessionId: string, trackType?: AudioTrackType) => (() => void) | undefined;
     /**
      * Plays all audio elements blocked by the browser's autoplay policy.
+     * Must be called from within a user gesture (e.g., click handler).
+     *
+     * Subscribe to `call.blockedAudioTracker.autoplayBlocked$` to know when a
+     * gesture is required.
      */
     resumeAudio: () => Promise<void>;
     /**

package/dist/src/coordinator/connection/client.d.ts

@@ -113,7 +113,7 @@ export declare class StreamClient {
      */
     _setupConnectionIdPromise: () => void;
     get connectionIdPromise(): Promise<string | undefined> | undefined;
-    get isConnectionIsPromisePending(): boolean;
+    get isConnectionIdPromisePending(): boolean;
     get wsPromise(): Promise<ConnectedEvent | undefined> | undefined;
     _logApiRequest: (type: string, url: string, data: unknown, config: AxiosRequestConfig & {
         config?: AxiosRequestConfig & {

package/dist/src/coordinator/connection/connection.d.ts

@@ -1,5 +1,5 @@
 import { StreamClient } from './client';
-import type { UR } from './types';
+import type { UR, WSConnectionError } from './types';
 import type { LogLevel } from '@stream-io/logger';
 import type { ConnectedEvent } from '../../gen/coordinator';
 /**
@@ -20,43 +20,48 @@ import type { ConnectedEvent } from '../../gen/coordinator';
  * - if the servers fails to publish a message to the client, the WS connection is destroyed
  */
 export declare class StableWSConnection {
+    client: StreamClient;
+    ws?: WebSocket;
+    /** Incremented when a new WS connection is made */
+    wsID: number;
+    /** We only make 1 attempt to reconnect at the same time.. */
+    isConnecting: boolean;
+    /** To avoid reconnect if client is disconnected */
+    isDisconnected: boolean;
+    /** Boolean that indicates if we have a working connection to the server */
+    isHealthy: boolean;
     connectionID?: string;
     private connectionOpenSafe?;
+    resolveConnectionOpen?: (value: ConnectedEvent) => void;
+    rejectConnectionOpen?: (reason?: WSConnectionError) => void;
+    /** Boolean that indicates if the connection promise is resolved */
+    isConnectionOpenResolved?: boolean;
+    /** consecutive failures influence the duration of the timeout */
     consecutiveFailures: number;
+    /** keep track of the total number of failures */
+    totalFailures: number;
+    /** Send a health check message every 25 seconds */
     pingInterval: number;
     healthCheckTimeoutRef?: number;
-    isConnecting: boolean;
-    isDisconnected: boolean;
-    isHealthy: boolean;
-    isConnectionOpenResolved?: boolean;
-    lastEvent: Date | null;
     connectionCheckTimeout: number;
     connectionCheckTimeoutRef?: NodeJS.Timeout;
-    rejectConnectionOpen?: (reason?: Error & {
-        code?: string | number;
-        isWSFailure?: boolean;
-        StatusCode?: string | number;
-    }) => void;
-    resolveConnectionOpen?: (value: ConnectedEvent) => void;
-    totalFailures: number;
-    ws?: WebSocket;
-    wsID: number;
-    client: StreamClient;
+    /** Store the last event time for health checks */
+    lastEvent: Date | null;
     constructor(client: StreamClient);
-    _log: (msg: string, extra?: UR, level?: LogLevel) => void;
+    _log: (msg: string, extra?: UR | Error, level?: LogLevel) => void;
     setClient: (client: StreamClient) => void;
     /**
      * connect - Connect to the WS URL
      * the default 15s timeout allows between 2~3 tries
-     * @return {ConnectAPIResponse<ConnectedEvent>} Promise that completes once the first health check message is received
+     * @return Promise that completes once the first health check message is received
      */
-    connect(timeout?: number): Promise<ConnectedEvent | undefined>;
+    connect: (timeout?: number) => Promise<ConnectedEvent | undefined>;
     /**
      * _waitForHealthy polls the promise connection to see if its resolved until it times out
      * the default 15s timeout allows between 2~3 tries
      * @param timeout duration(ms)
      */
-    _waitForHealthy(timeout?: number): Promise<ConnectedEvent | undefined>;
+    _waitForHealthy: (timeout?: number) => Promise<ConnectedEvent | undefined>;
     /**
      * Builds and returns the url for websocket.
      * @private
@@ -65,15 +70,17 @@ export declare class StableWSConnection {
     _buildUrl: () => string;
     /**
      * disconnect - Disconnect the connection and doesn't recover...
-     *
      */
-    disconnect(timeout?: number): Promise<void>;
+    disconnect: (timeout?: number) => Promise<void>;
     /**
      * _connect - Connect to the WS endpoint
      *
-     * @return {ConnectAPIResponse<ConnectedEvent>} Promise that completes once the first health check message is received
+     * @param timeoutMs handshake watchdog deadline in ms. Defaults to
+     *   `client.defaultWSTimeout` when not provided. Top-level `connect(timeout)`
+     *   passes its own timeout through so caller-supplied deadlines are honored.
+     * @return Promise that completes once the first health check message is received
      */
-    _connect(): Promise<ConnectedEvent | undefined>;
+    _connect: (timeoutMs?: number) => Promise<ConnectedEvent | undefined>;
     /**
      * _reconnect - Retry the connection to WS endpoint
      *
@@ -90,7 +97,6 @@ export declare class StableWSConnection {
      * onlineStatusChanged - this function is called when the browser connects or disconnects from the internet.
      *
      * @param {Event} event Event with type online or offline
-     *
      */
     onlineStatusChanged: (event: Event) => void;
     onopen: (wsID: number) => void;

package/dist/src/coordinator/connection/types.d.ts

@@ -36,6 +36,20 @@ export type APIErrorResponse = {
     details?: ErrorResponseDetails;
     unrecoverable?: boolean;
 };
+/**
+ * A standard `Error` augmented with the metadata that the coordinator
+ * WebSocket connection layer attaches to rejection causes.
+ * `isWSFailure: true` marks transient/retriable failures; absent or `false`
+ * indicates a permanent failure that should not be retried.
+ */
+export type WSConnectionError = Error & {
+    code?: string | number;
+    isWSFailure?: boolean;
+    StatusCode?: string | number;
+    reason?: string;
+    wasClean?: boolean;
+    target?: EventTarget | null;
+};
 export declare class ErrorFromResponse<T> extends Error {
     code: number | null;
     status: number;

package/dist/src/coordinator/connection/utils.d.ts

@@ -2,6 +2,7 @@ import type { AxiosResponse } from 'axios';
 import type { APIErrorResponse } from './types';
 import type { ConnectionErrorEvent } from '../../gen/coordinator';
 export declare const sleep: (m: number) => Promise<unknown>;
+export declare const timeboxed: <T extends Promise<unknown>[]>(promises: [...T], ms: number) => Promise<{ [K in keyof T]: Awaited<T[K]>; }>;
 export declare function isFunction<T>(value: Function | T): value is Function;
 /**
  * A map of known error codes.

package/dist/src/devices/CameraManager.d.ts

@@ -45,5 +45,6 @@ export declare class CameraManager extends DeviceManager<CameraManagerState> {
      */
     apply(settings: VideoSettingsResponse, publish: boolean): Promise<void>;
     protected getDevices(): Observable<MediaDeviceInfo[]>;
+    protected getResolvedConstraints(constraints: MediaTrackConstraints): MediaTrackConstraints;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
 }

package/dist/src/devices/DeviceManager.d.ts

@@ -6,6 +6,7 @@ import { ScopedLogger } from '../logger';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { MediaStreamFilter, MediaStreamFilterRegistrationResult } from './filters';
 import { DevicePersistenceOptions } from './devicePersistence';
+import { VirtualDevice, VirtualDeviceEntry, VirtualDeviceHandle } from './VirtualDevice';
 export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C = MediaTrackConstraints> {
     /**
      * if true, stops the media stream when call is left
@@ -16,10 +17,14 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     protected readonly call: Call;
     protected readonly trackType: TrackType;
     protected subscriptions: (() => void)[];
+    protected currentStreamCleanups: (() => void)[];
     protected devicePersistence: Required<DevicePersistenceOptions>;
     protected areSubscriptionsSetUp: boolean;
     private isTrackStoppedDueToTrackEnd;
     private filters;
+    private virtualDevicesSubject;
+    private activeVirtualSession;
+    private virtualDeviceConcurrencyTag;
     private statusChangeConcurrencyTag;
     private filterRegistrationConcurrencyTag;
     protected constructor(call: Call, state: S, trackType: TrackType, devicePersistence: Required<DevicePersistenceOptions>);
@@ -32,6 +37,21 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
      * @returns an Observable that will be updated if a device is connected or disconnected
      */
     listDevices(): Observable<MediaDeviceInfo[]>;
+    /**
+     * Registers a virtual camera or microphone backed by a caller-supplied
+     * stream factory. The device appears in `listDevices()` and can be selected
+     * via `select()` like any real device.
+     *
+     * Web only. React Native is not supported.
+     *
+     * Only supported for camera and microphone managers; calling on any other
+     * manager throws.
+     */
+    registerVirtualDevice(virtualDevice: VirtualDevice<C>): VirtualDeviceHandle;
+    protected sanitizeVirtualStream(stream: MediaStream): MediaStream;
+    protected findVirtualDevice(deviceId: string | undefined): VirtualDeviceEntry<C> | undefined;
+    private stopActiveVirtualSession;
+    protected getSelectedStream(constraints: C): Promise<MediaStream>;
     /**
      * Returns `true` when this device is in enabled state.
      */
@@ -89,8 +109,10 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
      * @internal
      */
     dispose: () => void;
+    private runCurrentStreamCleanups;
     protected applySettingsToStream(): Promise<void>;
     protected abstract getDevices(): Observable<MediaDeviceInfo[]>;
+    protected getResolvedConstraints(constraints: C): C;
     protected abstract getStream(constraints: C): Promise<MediaStream>;
     protected publishStream(stream: MediaStream, options?: TrackPublishOptions): Promise<void>;
     protected stopPublishStream(): Promise<void>;
@@ -101,6 +123,7 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     private stopTracks;
     private muteLocalStream;
     protected unmuteStream(): Promise<void>;
+    private setLocalInterrupted;
     private get mediaDeviceKind();
     private handleDisconnectedOrReplacedDevices;
     protected findDevice(devices: MediaDeviceInfo[], deviceId: string): MediaDeviceInfo | undefined;

package/dist/src/devices/DeviceManagerState.d.ts

@@ -15,7 +15,6 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
     prevStatus: InputDeviceStatus;
     /**
      * An Observable that emits the current media stream, or `undefined` if the device is currently disabled.
-     *
      */
     mediaStream$: Observable<MediaStream | undefined>;
     /**

package/dist/src/devices/VirtualDevice.d.ts

@@ -0,0 +1,59 @@
+/**
+ * A MediaStream produced for a virtual device session, along with an optional
+ * cleanup callback. Returned by {@link VirtualDevice.getUserMedia}.
+ */
+export interface VirtualDeviceSession {
+    readonly stream: MediaStream;
+    readonly stop?: () => void | Promise<void>;
+}
+/**
+ * A virtual camera or microphone definition supplied by the integrator.
+ *
+ * Pass this to `camera.registerVirtualDevice()` /
+ * `microphone.registerVirtualDevice()` to make it appear in the device list
+ * and become selectable.
+ */
+export interface VirtualDevice<C = MediaTrackConstraints> {
+    /**
+     * Human-readable label shown in device dropdowns.
+     */
+    label: string;
+    /**
+     * Called when the virtual device is selected and the SDK needs media.
+     * Returns the MediaStream to publish along with an optional `stop`
+     * callback that runs when the session is replaced, the tracks end, or
+     * the device is unregistered.
+     *
+     * `constraints` is the resolved set the SDK would otherwise pass to
+     * `getUserMedia` for a real device.
+     */
+    getUserMedia: (constraints: C) => VirtualDeviceSession | Promise<VirtualDeviceSession>;
+}
+/**
+ * @internal Internal entry stored in the device manager's registry.
+ */
+export interface VirtualDeviceEntry<C = MediaTrackConstraints> extends VirtualDevice<C> {
+    readonly deviceId: string;
+    readonly kind: 'audioinput' | 'videoinput';
+}
+/**
+ * @internal Tracks the currently active virtual device session inside the
+ * device manager so its `stop` callback can be invoked when the session is
+ * replaced or torn down.
+ */
+export interface ActiveVirtualSession {
+    deviceId: string;
+    stop?: () => void | Promise<void>;
+}
+export interface VirtualDeviceHandle {
+    /**
+     * The device id under which the virtual device was registered. Pass this
+     * to `camera.select()` / `microphone.select()` to switch to it.
+     */
+    readonly deviceId: string;
+    /**
+     * Removes the virtual device from the manager. If it is currently selected,
+     * the selection is reset so the SDK falls back to the default device.
+     */
+    unregister: () => Promise<void>;
+}

package/dist/src/devices/devicePersistence.d.ts

@@ -21,7 +21,7 @@ export type LocalDevicePreferences = {
 };
 export declare const defaultDeviceId = "default";
 export declare const normalize: (options: DevicePersistenceOptions | undefined) => Required<DevicePersistenceOptions>;
-export declare const createSyntheticDevice: (deviceId: string, kind: MediaDeviceKind) => MediaDeviceInfo;
+export declare const createSyntheticDevice: (deviceId: string, kind: MediaDeviceKind, label?: string) => MediaDeviceInfo;
 export declare const readPreferences: (storageKey: string) => LocalDevicePreferences;
 export declare const writePreferences: (currentDevice: MediaDeviceInfo | undefined, deviceKey: DevicePreferenceKey, muted: boolean | undefined, storageKey: string) => void;
 export declare const toPreferenceList: (preference?: LocalDevicePreference | LocalDevicePreference[]) => LocalDevicePreference[];

package/dist/src/devices/index.d.ts

@@ -10,3 +10,4 @@ export * from './ScreenShareManager';
 export * from './ScreenShareState';
 export * from './SpeakerManager';
 export * from './SpeakerState';
+export * from './VirtualDevice';

package/dist/src/gen/video/sfu/event/events.d.ts

@@ -1,5 +1,5 @@
 import { MessageType } from '@protobuf-ts/runtime';
-import { CallEndedReason, CallGrants, CallState, ClientCapability, ClientDetails, Codec, ConnectionQuality, Error as Error$, GoAwayReason, ICETrickle as ICETrickle$, Participant, ParticipantCount, ParticipantSource, PeerType, Pin, PublishOption, SubscribeOption, TrackInfo, TrackType, TrackUnpublishReason, WebsocketReconnectStrategy } from '../models/models';
+import { CallEndedReason, CallGrants, CallState, ClientCapability, ClientDetails, Codec, ConnectionQuality, DegradationPreference, Error as Error$, GoAwayReason, ICETrickle as ICETrickle$, Participant, ParticipantCount, ParticipantSource, PeerType, Pin, PublishOption, SubscribeOption, TrackInfo, TrackType, TrackUnpublishReason, WebsocketReconnectStrategy } from '../models/models';
 import { TrackSubscriptionDetails } from '../signal_rpc/signal';
 /**
  * SFUEvent is a message that is sent from the SFU to the client.
@@ -785,6 +785,10 @@ export interface VideoSender {
      * @generated from protobuf field: int32 publish_option_id = 5;
      */
     publishOptionId: number;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.DegradationPreference degradation_preference = 6;
+     */
+    degradationPreference: DegradationPreference;
 }
 /**
  * sent to users when they need to change the quality of their video

package/dist/src/gen/video/sfu/models/models.d.ts

@@ -303,6 +303,12 @@ export interface PublishOption {
      * @generated from protobuf field: repeated stream.video.sfu.models.AudioBitrate audio_bitrate_profiles = 10;
      */
     audioBitrateProfiles: AudioBitrate[];
+    /**
+     * The degradation preference for video encoding.
+     *
+     * @generated from protobuf field: stream.video.sfu.models.DegradationPreference degradation_preference = 11;
+     */
+    degradationPreference: DegradationPreference;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Codec
@@ -1168,6 +1174,34 @@ export declare enum ClientCapability {
      */
     SUBSCRIBER_VIDEO_PAUSE = 1
 }
+/**
+ * DegradationPreference represents the RTCDegradationPreference from WebRTC.
+ * See https://developer.mozilla.org/en-US/docs/Web/API/RTCRtpSender/setParameters#degradationpreference
+ *
+ * @generated from protobuf enum stream.video.sfu.models.DegradationPreference
+ */
+export declare enum DegradationPreference {
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_BALANCED = 1;
+     */
+    BALANCED = 1,
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE = 2;
+     */
+    MAINTAIN_FRAMERATE = 2,
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_MAINTAIN_RESOLUTION = 3;
+     */
+    MAINTAIN_RESOLUTION = 3,
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE_AND_RESOLUTION = 4;
+     */
+    MAINTAIN_FRAMERATE_AND_RESOLUTION = 4
+}
 declare class CallState$Type extends MessageType<CallState> {
     constructor();
 }

package/dist/src/helpers/AudioBindingsWatchdog.d.ts

@@ -6,19 +6,19 @@ import { Tracer } from '../stats';
  * remote participants whose audio streams have no bound element.
  */
 export declare class AudioBindingsWatchdog {
-    private state;
-    private tracer;
     private bindings;
     private enabled;
     private watchdogInterval?;
     private readonly unsubscribeCallingState;
     private logger;
+    private readonly state;
+    private readonly tracer;
     constructor(state: CallState, tracer: Tracer);
     /**
      * Registers an audio element binding for the given session and track type.
      * Warns if a different element is already bound to the same key.
      */
-    register: (audioElement: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => void;
+    register: (element: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => void;
     /**
      * Removes the audio element binding for the given session and track type.
      */

package/dist/src/helpers/BlockedAudioTracker.d.ts

@@ -0,0 +1,30 @@
+import { Tracer } from '../stats';
+/**
+ * Tracks audio elements that the browser's autoplay policy has blocked.
+ */
+export declare class BlockedAudioTracker {
+    private logger;
+    private tracer;
+    private blockedElementsSubject;
+    /**
+     * Whether the browser's autoplay policy is blocking audio playback.
+     * Will be `true` when at least one audio element is currently blocked.
+     * Use {@link resumeAudio} within a user gesture to unblock.
+     */
+    autoplayBlocked$: import("rxjs").Observable<boolean>;
+    constructor(tracer: Tracer);
+    /**
+     * Registers an audio element as blocked by the browser's autoplay policy.
+     */
+    markBlocked: (audioElement: HTMLAudioElement, blocked: boolean) => void;
+    /**
+     * Returns whether the given audio element is currently flagged as blocked
+     * by the browser's autoplay policy.
+     */
+    isBlocked: (audioElement: HTMLAudioElement) => boolean;
+    /**
+     * Plays all audio elements blocked by the browser's autoplay policy.
+     * Must be called from within a user gesture (e.g., click handler).
+     */
+    resumeAudio: () => Promise<void>;
+}

package/dist/src/helpers/DynascaleManager.d.ts

@@ -1,102 +1,32 @@
-import { AudioTrackType, DebounceType, VideoTrackType } from '../types';
-import { VideoDimension } from '../gen/video/sfu/models/models';
-import { ViewportTracker } from './ViewportTracker';
-import { AudioBindingsWatchdog } from './AudioBindingsWatchdog';
-import type { TrackSubscriptionDetails } from '../gen/video/sfu/signal_rpc/signal';
+import { AudioTrackType, VideoTrackType } from '../types';
+import type { BlockedAudioTracker } from './BlockedAudioTracker';
+import type { TrackSubscriptionManager } from './TrackSubscriptionManager';
 import { CallState } from '../store';
-import type { StreamSfuClient } from '../StreamSfuClient';
 import { SpeakerManager } from '../devices';
 import { Tracer } from '../stats';
-type VideoTrackSubscriptionOverride = {
-    enabled: true;
-    dimension: VideoDimension;
-} | {
-    enabled: false;
-};
-declare const globalOverrideKey: unique symbol;
-interface VideoTrackSubscriptionOverrides {
-    [sessionId: string]: VideoTrackSubscriptionOverride | undefined;
-    [globalOverrideKey]?: VideoTrackSubscriptionOverride;
-}
 /**
  * A manager class that handles dynascale related tasks like:
  *
  * - binding video elements to session ids
  * - binding audio elements to session ids
- * - tracking element visibility
- * - updating subscriptions based on viewport visibility
- * - updating subscriptions based on video element dimensions
- * - updating subscriptions based on published tracks
  */
 export declare class DynascaleManager {
-    /**
-     * The viewport tracker instance.
-     */
-    readonly viewportTracker: ViewportTracker;
     private logger;
     private callState;
     private speaker;
-    private tracer;
+    private readonly tracer;
     private useWebAudio;
     private audioContext;
-    private sfuClient;
-    private pendingSubscriptionsUpdate;
-    readonly audioBindingsWatchdog: AudioBindingsWatchdog | undefined;
-    /**
-     * Audio elements that were blocked by the browser's autoplay policy.
-     * These can be retried by calling `resumeAudio()` from a user gesture.
-     */
-    private blockedAudioElementsSubject;
-    /**
-     * Whether the browser's autoplay policy is blocking audio playback.
-     * Will be `true` when the browser blocks autoplay (e.g., no prior user interaction).
-     * Use `resumeAudio()` within a user gesture to unblock.
-     */
-    autoplayBlocked$: import("rxjs").Observable<boolean>;
-    private addBlockedAudioElement;
-    private removeBlockedAudioElement;
-    private videoTrackSubscriptionOverridesSubject;
-    videoTrackSubscriptionOverrides$: import("rxjs").Observable<VideoTrackSubscriptionOverrides>;
-    incomingVideoSettings$: import("rxjs").Observable<{
-        enabled: boolean;
-        preferredResolution: VideoDimension | undefined;
-        participants: {
-            [k: string]: {
-                enabled: boolean;
-                preferredResolution: VideoDimension | undefined;
-            };
-        };
-        isParticipantVideoEnabled: (sessionId: string) => boolean;
-    }>;
+    private trackSubscriptionManager;
+    private blockedAudioTracker;
     /**
      * Creates a new DynascaleManager instance.
      */
-    constructor(callState: CallState, speaker: SpeakerManager, tracer: Tracer);
+    constructor(callState: CallState, speaker: SpeakerManager, tracer: Tracer, trackSubscriptionManager: TrackSubscriptionManager, blockedAudioTracker: BlockedAudioTracker);
     /**
-     * Disposes the allocated resources and closes the audio context if it was created.
+     * Closes the audio context if it was created.
      */
     dispose: () => Promise<void>;
-    setSfuClient(sfuClient: StreamSfuClient | undefined): void;
-    get trackSubscriptions(): TrackSubscriptionDetails[];
-    get videoTrackSubscriptionOverrides(): VideoTrackSubscriptionOverrides;
-    setVideoTrackSubscriptionOverrides: (override: VideoTrackSubscriptionOverride | undefined, sessionIds?: string[]) => VideoTrackSubscriptionOverrides;
-    applyTrackSubscriptions: (debounceType?: DebounceType) => void;
-    /**
-     * Will begin tracking the given element for visibility changes within the
-     * configured viewport element (`call.setViewport`).
-     *
-     * @param element the element to track.
-     * @param sessionId the session id.
-     * @param trackType the kind of video.
-     * @returns Untrack.
-     */
-    trackElementVisibility: <T extends HTMLElement>(element: T, sessionId: string, trackType: VideoTrackType) => () => void;
-    /**
-     * Sets the viewport element to track bound video elements for visibility.
-     *
-     * @param element the viewport element.
-     */
-    setViewport: <T extends HTMLElement>(element: T) => () => void;
     /**
      * Sets whether to use WebAudio API for audio playback.
      * Must be set before joining the call.
@@ -134,14 +64,6 @@ export declare class DynascaleManager {
      * @returns a cleanup function that will unbind the audio element.
      */
     bindAudioElement: (audioElement: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => (() => void) | undefined;
-    /**
-     * Plays all audio elements blocked by the browser's autoplay policy.
-     * Must be called from within a user gesture (e.g., click handler).
-     *
-     * @returns a promise that resolves when all blocked elements have been retried.
-     */
-    resumeAudio: () => Promise<void>;
     private getOrCreateAudioContext;
     private resumeAudioContext;
 }
-export {};