@stream-io/video-client 1.13.1 → 1.15.0

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

@@ -4,10 +4,10 @@ import { GoAwayReason } from '../models/models';
 import { CallGrants } from '../models/models';
 import { Codec } from '../models/models';
 import { ConnectionQuality } from '../models/models';
-import { PublishOptions } from '../models/models';
 import { CallState } from '../models/models';
 import { TrackSubscriptionDetails } from '../signal_rpc/signal';
 import { TrackInfo } from '../models/models';
+import { SubscribeOption } from '../models/models';
 import { ClientDetails } from '../models/models';
 import { TrackUnpublishReason } from '../models/models';
 import { Participant } from '../models/models';
@@ -218,15 +218,6 @@ export interface SfuEvent {
          * @generated from protobuf field: stream.video.sfu.event.ParticipantMigrationComplete participant_migration_complete = 25;
          */
         participantMigrationComplete: ParticipantMigrationComplete;
-    } | {
-        oneofKind: 'codecNegotiationComplete';
-        /**
-         * CodecNegotiationComplete is sent to signal the completion of a codec negotiation.
-         * SDKs can safely stop previous transceivers
-         *
-         * @generated from protobuf field: stream.video.sfu.event.CodecNegotiationComplete codec_negotiation_complete = 26;
-         */
-        codecNegotiationComplete: CodecNegotiationComplete;
     } | {
         oneofKind: 'changePublishOptions';
         /**
@@ -244,14 +235,18 @@ export interface SfuEvent {
  */
 export interface ChangePublishOptions {
     /**
-     * @generated from protobuf field: stream.video.sfu.models.PublishOption publish_option = 1;
+     * @generated from protobuf field: repeated stream.video.sfu.models.PublishOption publish_options = 1;
+     */
+    publishOptions: PublishOption[];
+    /**
+     * @generated from protobuf field: string reason = 2;
      */
-    publishOption?: PublishOption;
+    reason: string;
 }
 /**
- * @generated from protobuf message stream.video.sfu.event.CodecNegotiationComplete
+ * @generated from protobuf message stream.video.sfu.event.ChangePublishOptionsComplete
  */
-export interface CodecNegotiationComplete {
+export interface ChangePublishOptionsComplete {
 }
 /**
  * @generated from protobuf message stream.video.sfu.event.ParticipantMigrationComplete
@@ -475,6 +470,14 @@ export interface JoinRequest {
      * @generated from protobuf field: stream.video.sfu.event.ReconnectDetails reconnect_details = 7;
      */
     reconnectDetails?: ReconnectDetails;
+    /**
+     * @generated from protobuf field: repeated stream.video.sfu.models.PublishOption preferred_publish_options = 9;
+     */
+    preferredPublishOptions: PublishOption[];
+    /**
+     * @generated from protobuf field: repeated stream.video.sfu.models.SubscribeOption preferred_subscribe_options = 10;
+     */
+    preferredSubscribeOptions: SubscribeOption[];
 }
 /**
  * @generated from protobuf message stream.video.sfu.event.ReconnectDetails
@@ -541,9 +544,9 @@ export interface JoinResponse {
      */
     fastReconnectDeadlineSeconds: number;
     /**
-     * @generated from protobuf field: stream.video.sfu.models.PublishOptions publish_options = 4;
+     * @generated from protobuf field: repeated stream.video.sfu.models.PublishOption publish_options = 4;
      */
-    publishOptions?: PublishOptions;
+    publishOptions: PublishOption[];
 }
 /**
  * ParticipantJoined is fired when a user joins a call
@@ -700,6 +703,14 @@ export interface AudioSender {
      * @generated from protobuf field: stream.video.sfu.models.Codec codec = 2;
      */
     codec?: Codec;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.TrackType track_type = 3;
+     */
+    trackType: TrackType;
+    /**
+     * @generated from protobuf field: int32 publish_option_id = 4;
+     */
+    publishOptionId: number;
 }
 /**
  * VideoLayerSetting is used to specify various parameters of a particular encoding in simulcast.
@@ -750,6 +761,14 @@ export interface VideoSender {
      * @generated from protobuf field: repeated stream.video.sfu.event.VideoLayerSetting layers = 3;
      */
     layers: VideoLayerSetting[];
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.TrackType track_type = 4;
+     */
+    trackType: TrackType;
+    /**
+     * @generated from protobuf field: int32 publish_option_id = 5;
+     */
+    publishOptionId: number;
 }
 /**
  * sent to users when they need to change the quality of their video
@@ -834,13 +853,13 @@ declare class ChangePublishOptions$Type extends MessageType<ChangePublishOptions
  * @generated MessageType for protobuf message stream.video.sfu.event.ChangePublishOptions
  */
 export declare const ChangePublishOptions: ChangePublishOptions$Type;
-declare class CodecNegotiationComplete$Type extends MessageType<CodecNegotiationComplete> {
+declare class ChangePublishOptionsComplete$Type extends MessageType<ChangePublishOptionsComplete> {
     constructor();
 }
 /**
- * @generated MessageType for protobuf message stream.video.sfu.event.CodecNegotiationComplete
+ * @generated MessageType for protobuf message stream.video.sfu.event.ChangePublishOptionsComplete
  */
-export declare const CodecNegotiationComplete: CodecNegotiationComplete$Type;
+export declare const ChangePublishOptionsComplete: ChangePublishOptionsComplete$Type;
 declare class ParticipantMigrationComplete$Type extends MessageType<ParticipantMigrationComplete> {
     constructor();
 }

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

@@ -190,49 +190,108 @@ export interface VideoLayer {
     quality: VideoQuality;
 }
 /**
- * @generated from protobuf message stream.video.sfu.models.PublishOptions
+ * SubscribeOption represents the configuration options for subscribing to a track.
+ *
+ * @generated from protobuf message stream.video.sfu.models.SubscribeOption
  */
-export interface PublishOptions {
+export interface SubscribeOption {
     /**
-     * @generated from protobuf field: repeated stream.video.sfu.models.PublishOption codecs = 1;
+     * The type of the track being subscribed (e.g., video, screenshare).
+     *
+     * @generated from protobuf field: stream.video.sfu.models.TrackType track_type = 1;
+     */
+    trackType: TrackType;
+    /**
+     * The codecs supported by the subscriber for decoding tracks.
+     *
+     * @generated from protobuf field: repeated stream.video.sfu.models.Codec codecs = 2;
      */
-    codecs: PublishOption[];
+    codecs: Codec[];
 }
 /**
+ * PublishOption represents the configuration options for publishing a track.
+ *
  * @generated from protobuf message stream.video.sfu.models.PublishOption
  */
 export interface PublishOption {
     /**
+     * The type of the track being published (e.g., video, screenshare).
+     *
      * @generated from protobuf field: stream.video.sfu.models.TrackType track_type = 1;
      */
     trackType: TrackType;
     /**
+     * The codec to be used for encoding the track (e.g., VP8, VP9, H264).
+     *
      * @generated from protobuf field: stream.video.sfu.models.Codec codec = 2;
      */
     codec?: Codec;
     /**
+     * The target bitrate for the published track, in bits per second.
+     *
      * @generated from protobuf field: int32 bitrate = 3;
      */
     bitrate: number;
     /**
+     * The target frames per second (FPS) for video encoding.
+     *
      * @generated from protobuf field: int32 fps = 4;
      */
     fps: number;
     /**
+     * The maximum number of spatial layers to send.
+     * - For SVC (e.g., VP9), spatial layers downscale by a factor of 2:
+     *   - 1 layer: full resolution
+     *   - 2 layers: full resolution + half resolution
+     *   - 3 layers: full resolution + half resolution + quarter resolution
+     * - For non-SVC codecs (e.g., VP8/H264), this determines the number of
+     *   encoded resolutions (e.g., quarter, half, full) sent for simulcast.
+     *
      * @generated from protobuf field: int32 max_spatial_layers = 5;
      */
     maxSpatialLayers: number;
     /**
+     * The maximum number of temporal layers for scalable video coding (SVC).
+     * Temporal layers allow varying frame rates for different bandwidths.
+     *
      * @generated from protobuf field: int32 max_temporal_layers = 6;
      */
     maxTemporalLayers: number;
+    /**
+     * The dimensions of the video (e.g., width and height in pixels).
+     * Spatial layers are based on this base resolution. For example, if the base
+     * resolution is 1280x720:
+     * - Full resolution (1 layer) = 1280x720
+     * - Half resolution (2 layers) = 640x360
+     * - Quarter resolution (3 layers) = 320x180
+     *
+     * @generated from protobuf field: stream.video.sfu.models.VideoDimension video_dimension = 7;
+     */
+    videoDimension?: VideoDimension;
+    /**
+     * The unique identifier for the publish request.
+     * - This `id` is assigned exclusively by the SFU. Any `id` set by the client
+     *   in the `PublishOption` will be ignored and overwritten by the SFU.
+     * - The primary purpose of this `id` is to uniquely identify each publish
+     *   request, even in scenarios where multiple publish requests for the same
+     *   `track_type` and `codec` are active simultaneously.
+     *   For example:
+     *     - A user may publish two tracks of the same type (e.g., video) and codec
+     *       (e.g., VP9) concurrently.
+     * - This uniqueness ensures that individual requests can be managed
+     *   independently. For instance, an `id` is critical when stopping a specific
+     *   publish request without affecting others.
+     *
+     * @generated from protobuf field: int32 id = 8;
+     */
+    id: number;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Codec
  */
 export interface Codec {
     /**
-     * @generated from protobuf field: uint32 payload_type = 11;
+     * @generated from protobuf field: uint32 payload_type = 16;
      */
     payloadType: number;
     /**
@@ -244,7 +303,7 @@ export interface Codec {
      */
     clockRate: number;
     /**
-     * @generated from protobuf field: string encoding_parameters = 13;
+     * @generated from protobuf field: string encoding_parameters = 15;
      */
     encodingParameters: string;
     /**
@@ -307,6 +366,14 @@ export interface TrackInfo {
      * @generated from protobuf field: bool muted = 10;
      */
     muted: boolean;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Codec codec = 11;
+     */
+    codec?: Codec;
+    /**
+     * @generated from protobuf field: int32 publish_option_id = 12;
+     */
+    publishOptionId: number;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Error
@@ -964,13 +1031,13 @@ declare class VideoLayer$Type extends MessageType<VideoLayer> {
  * @generated MessageType for protobuf message stream.video.sfu.models.VideoLayer
  */
 export declare const VideoLayer: VideoLayer$Type;
-declare class PublishOptions$Type extends MessageType<PublishOptions> {
+declare class SubscribeOption$Type extends MessageType<SubscribeOption> {
     constructor();
 }
 /**
- * @generated MessageType for protobuf message stream.video.sfu.models.PublishOptions
+ * @generated MessageType for protobuf message stream.video.sfu.models.SubscribeOption
  */
-export declare const PublishOptions: PublishOptions$Type;
+export declare const SubscribeOption: SubscribeOption$Type;
 declare class PublishOption$Type extends MessageType<PublishOption> {
     constructor();
 }

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

@@ -0,0 +1,7 @@
+/**
+ * Adds unique values to an array.
+ *
+ * @param arr the array to add to.
+ * @param values the values to add.
+ */
+export declare const pushToIfMissing: <T>(arr: T[], ...values: T[]) => T[];

package/dist/src/permissions/PermissionsContext.d.ts

@@ -1,4 +1,5 @@
 import { CallSettingsResponse, OwnCapability } from '../gen/coordinator';
+import { TrackType } from '../gen/video/sfu/models/models';
 /**
  * Stores the permissions for the current user and exposes
  * a few helper methods which make it easier to work with permissions.
@@ -28,6 +29,11 @@ export declare class PermissionsContext {
      * @param permission the permission to check for.
      */
     hasPermission: (permission: OwnCapability) => boolean;
+    /**
+     * Helper method that checks whether the current user has the permission
+     * to publish the given track type.
+     */
+    canPublish: (trackType: TrackType) => boolean | undefined;
     /**
      * Checks if the current user can request a specific permission
      * within the call.

package/dist/src/rtc/BasePeerConnection.d.ts

@@ -0,0 +1,90 @@
+import type { CallEventListener, Logger } from '../coordinator/connection/types';
+import { CallState } from '../store';
+import { PeerType } from '../gen/video/sfu/models/models';
+import { StreamSfuClient } from '../StreamSfuClient';
+import { AllSfuEvents, Dispatcher } from './Dispatcher';
+export type BasePeerConnectionOpts = {
+    sfuClient: StreamSfuClient;
+    state: CallState;
+    connectionConfig?: RTCConfiguration;
+    dispatcher: Dispatcher;
+    onUnrecoverableError?: () => void;
+    logTag: string;
+};
+/**
+ * A base class for the `Publisher` and `Subscriber` classes.
+ * @internal
+ */
+export declare abstract class BasePeerConnection {
+    protected readonly logger: Logger;
+    protected readonly peerType: PeerType;
+    protected readonly pc: RTCPeerConnection;
+    protected readonly state: CallState;
+    protected readonly dispatcher: Dispatcher;
+    protected sfuClient: StreamSfuClient;
+    protected readonly onUnrecoverableError?: () => void;
+    protected isIceRestarting: boolean;
+    private readonly subscriptions;
+    private unsubscribeIceTrickle?;
+    /**
+     * Constructs a new `BasePeerConnection` instance.
+     */
+    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onUnrecoverableError, logTag, }: BasePeerConnectionOpts);
+    /**
+     * Disposes the `RTCPeerConnection` instance.
+     */
+    dispose: () => void;
+    /**
+     * Detaches the event handlers from the `RTCPeerConnection`.
+     */
+    protected detachEventHandlers(): void;
+    /**
+     * Performs an ICE restart on the `RTCPeerConnection`.
+     */
+    protected abstract restartIce(): Promise<void>;
+    /**
+     * Handles events synchronously.
+     * Consecutive events are queued and executed one after the other.
+     */
+    protected on: <E extends keyof AllSfuEvents>(event: E, fn: CallEventListener<E>) => void;
+    /**
+     * Appends the trickled ICE candidates to the `RTCPeerConnection`.
+     */
+    protected addTrickledIceCandidates: () => void;
+    /**
+     * Sets the SFU client to use.
+     *
+     * @param sfuClient the SFU client to use.
+     */
+    setSfuClient: (sfuClient: StreamSfuClient) => void;
+    /**
+     * Returns the result of the `RTCPeerConnection.getStats()` method
+     * @param selector an optional `MediaStreamTrack` to get the stats for.
+     */
+    getStats: (selector?: MediaStreamTrack | null) => Promise<RTCStatsReport>;
+    /**
+     * Handles the ICECandidate event and
+     * Initiates an ICE Trickle process with the SFU.
+     */
+    private onIceCandidate;
+    /**
+     * Converts the ICE candidate to a JSON string.
+     */
+    private toJSON;
+    /**
+     * Handles the ICE connection state change event.
+     */
+    private onIceConnectionStateChange;
+    /**
+     * Handles the ICE candidate error event.
+     */
+    private onIceCandidateError;
+    /**
+     * Handles the ICE gathering state change event.
+     */
+    private onIceGatherChange;
+    /**
+     * Handles the signaling state change event.
+     */
+    private onSignalingChange;
+}

package/dist/src/rtc/Dispatcher.d.ts

@@ -22,5 +22,4 @@ export declare class Dispatcher {
     dispatch: <K extends SfuEventKinds>(message: DispatchableMessage<K>, logTag?: string) => void;
     on: <E extends keyof AllSfuEvents>(eventName: E, fn: CallEventListener<E>) => () => void;
     off: <E extends keyof AllSfuEvents>(eventName: E, fn: CallEventListener<E>) => void;
-    offAll: (eventName?: SfuEventKinds) => void;
 }

package/dist/src/rtc/IceTrickleBuffer.d.ts

@@ -5,7 +5,8 @@ import { ICETrickle } from '../gen/video/sfu/event/events';
  * - https://bloggeek.me/webrtcglossary/trickle-ice/
  */
 export declare class IceTrickleBuffer {
-    readonly subscriberCandidates: ReplaySubject<ICETrickle>;
-    readonly publisherCandidates: ReplaySubject<ICETrickle>;
+    readonly subscriberCandidates: ReplaySubject<RTCIceCandidateInit>;
+    readonly publisherCandidates: ReplaySubject<RTCIceCandidateInit>;
     push: (iceTrickle: ICETrickle) => void;
+    dispose: () => void;
 }

package/dist/src/rtc/Publisher.d.ts

@@ -1,118 +1,59 @@
-import { StreamSfuClient } from '../StreamSfuClient';
-import { TrackInfo, TrackType } from '../gen/video/sfu/models/models';
-import { CallState } from '../store';
-import { PublishOptions } from '../types';
-import { Dispatcher } from './Dispatcher';
-export type PublisherConstructorOpts = {
-    sfuClient: StreamSfuClient;
-    state: CallState;
-    dispatcher: Dispatcher;
-    connectionConfig?: RTCConfiguration;
-    isDtxEnabled: boolean;
-    isRedEnabled: boolean;
-    onUnrecoverableError?: () => void;
-    logTag: string;
+import { BasePeerConnection, BasePeerConnectionOpts } from './BasePeerConnection';
+import { PublishOption, TrackInfo, TrackType } from '../gen/video/sfu/models/models';
+export type PublisherConstructorOpts = BasePeerConnectionOpts & {
+    publishOptions: PublishOption[];
 };
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
  *
  * @internal
  */
-export declare class Publisher {
-    private readonly logger;
-    private pc;
-    private readonly state;
+export declare class Publisher extends BasePeerConnection {
     private readonly transceiverCache;
-    private readonly trackLayersCache;
-    private readonly publishOptsForTrack;
-    /**
-     * An array maintaining the order how transceivers were added to the peer connection.
-     * This is needed because some browsers (Firefox) don't reliably report
-     * trackId and `mid` parameters.
-     *
-     * @internal
-     */
-    private readonly transceiverInitOrder;
-    private readonly isDtxEnabled;
-    private readonly isRedEnabled;
-    private readonly unsubscribeOnIceRestart;
-    private readonly unsubscribeChangePublishQuality;
-    private readonly onUnrecoverableError?;
-    private isIceRestarting;
-    private sfuClient;
+    private publishOptions;
     /**
      * Constructs a new `Publisher` instance.
      */
-    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, onUnrecoverableError, logTag, }: PublisherConstructorOpts);
-    private createPeerConnection;
-    /**
-     * Closes the publisher PeerConnection and cleans up the resources.
-     */
-    close: ({ stopTracks }: {
-        stopTracks: boolean;
-    }) => void;
+    constructor({ publishOptions, ...baseOptions }: PublisherConstructorOpts);
     /**
      * Detaches the event handlers from the `RTCPeerConnection`.
      * This is useful when we want to replace the `RTCPeerConnection`
      * instance with a new one (in case of migration).
      */
-    detachEventHandlers: () => void;
+    detachEventHandlers(): void;
     /**
      * Starts publishing the given track of the given media stream.
      *
      * Consecutive calls to this method will replace the stream.
      * The previous stream will be stopped.
      *
-     * @param mediaStream the media stream to publish.
      * @param track the track to publish.
      * @param trackType the track type to publish.
-     * @param opts the optional publish options to use.
      */
-    publishStream: (mediaStream: MediaStream, track: MediaStreamTrack, trackType: TrackType, opts?: PublishOptions) => Promise<void>;
+    publish: (track: MediaStreamTrack, trackType: TrackType) => Promise<void>;
     /**
-     * Adds a new transceiver to the peer connection.
-     * This needs to be called when a new track kind is added to the peer connection.
-     * In other cases, use `updateTransceiver` method.
+     * Adds a new transceiver carrying the given track to the peer connection.
      */
     private addTransceiver;
     /**
-     * Updates the given transceiver with the new track.
-     * Stops the previous track and replaces it with the new one.
+     * Synchronizes the current Publisher state with the provided publish options.
      */
-    private updateTransceiver;
-    /**
-     * Stops publishing the given track type to the SFU, if it is currently being published.
-     * Underlying track will be stopped and removed from the publisher.
-     * @param trackType the track type to unpublish.
-     * @param stopTrack specifies whether track should be stopped or just disabled
-     */
-    unpublishStream: (trackType: TrackType, stopTrack: boolean) => Promise<void>;
+    private syncPublishOptions;
     /**
      * Returns true if the given track type is currently being published to the SFU.
      *
      * @param trackType the track type to check.
      */
     isPublishing: (trackType: TrackType) => boolean;
-    private notifyTrackMuteStateChanged;
     /**
-     * Stops publishing all tracks and stop all tracks.
+     * Maps the given track ID to the corresponding track type.
      */
-    private stopPublishing;
-    private changePublishQuality;
+    getTrackType: (trackId: string) => TrackType | undefined;
     /**
-     * Returns the result of the `RTCPeerConnection.getStats()` method
-     * @param selector
-     * @returns
-     */
-    getStats: (selector?: MediaStreamTrack | null | undefined) => Promise<RTCStatsReport>;
-    private getCodecPreferences;
-    private onIceCandidate;
-    /**
-     * Sets the SFU client to use.
-     *
-     * @param sfuClient the SFU client to use.
+     * Stops the cloned track that is being published to the SFU.
      */
-    setSfuClient: (sfuClient: StreamSfuClient) => void;
+    stopTracks: (...trackTypes: TrackType[]) => void;
+    private changePublishQuality;
     /**
      * Restarts the ICE connection and renegotiates with the SFU.
      */
@@ -124,18 +65,23 @@ export declare class Publisher {
      * @param options the optional offer options to use.
      */
     private negotiate;
-    private removeUnpreferredCodecs;
-    private enableHighQualityAudio;
     /**
      * Returns a list of tracks that are currently being published.
-     *
-     * @internal
+     */
+    getPublishedTracks: () => MediaStreamTrack[];
+    /**
+     * Returns a list of tracks that are currently being published.
      * @param sdp an optional SDP to extract the `mid` from.
      */
-    getAnnouncedTracks: (sdp?: string) => TrackInfo[];
-    private computeLayers;
-    private onIceCandidateError;
-    private onIceConnectionStateChange;
-    private onIceGatheringStateChange;
-    private onSignalingStateChange;
+    getAnnouncedTracks: (sdp: string | undefined) => TrackInfo[];
+    /**
+     * Returns a list of tracks that are currently being published.
+     * This method shall be used for the reconnection flow.
+     * There we shouldn't announce the tracks that have been stopped due to a codec switch.
+     */
+    getAnnouncedTracksForReconnect: () => TrackInfo[];
+    /**
+     * Converts the given transceiver to a `TrackInfo` object.
+     */
+    private toTrackInfo;
 }

package/dist/src/rtc/Subscriber.d.ts

@@ -1,77 +1,25 @@
-import { StreamSfuClient } from '../StreamSfuClient';
-import { Dispatcher } from './Dispatcher';
-import { CallState } from '../store';
-export type SubscriberOpts = {
-    sfuClient: StreamSfuClient;
-    dispatcher: Dispatcher;
-    state: CallState;
-    connectionConfig?: RTCConfiguration;
-    onUnrecoverableError?: () => void;
-    logTag: string;
-};
+import { BasePeerConnection, BasePeerConnectionOpts } from './BasePeerConnection';
 /**
  * A wrapper around the `RTCPeerConnection` that handles the incoming
  * media streams from the SFU.
  *
  * @internal
  */
-export declare class Subscriber {
-    private readonly logger;
-    private pc;
-    private sfuClient;
-    private state;
-    private readonly unregisterOnSubscriberOffer;
-    private readonly unregisterOnIceRestart;
-    private readonly onUnrecoverableError?;
-    private isIceRestarting;
+export declare class Subscriber extends BasePeerConnection {
     /**
      * Constructs a new `Subscriber` instance.
-     *
-     * @param sfuClient the SFU client to use.
-     * @param dispatcher the dispatcher to use.
-     * @param state the state of the call.
-     * @param connectionConfig the connection configuration to use.
-     * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE when connection goes to `disconnected` state.
-     * @param onUnrecoverableError a callback to call when an unrecoverable error occurs.
-     * @param logTag a tag to use for logging.
      */
-    constructor({ sfuClient, dispatcher, state, connectionConfig, onUnrecoverableError, logTag, }: SubscriberOpts);
-    /**
-     * Creates a new `RTCPeerConnection` instance with the given configuration.
-     *
-     * @param connectionConfig the connection configuration to use.
-     */
-    private createPeerConnection;
-    /**
-     * Closes the `RTCPeerConnection` and unsubscribes from the dispatcher.
-     */
-    close: () => void;
+    constructor(opts: BasePeerConnectionOpts);
     /**
      * Detaches the event handlers from the `RTCPeerConnection`.
      * This is useful when we want to replace the `RTCPeerConnection`
      * instance with a new one (in case of migration).
      */
-    detachEventHandlers: () => void;
-    /**
-     * Returns the result of the `RTCPeerConnection.getStats()` method
-     * @param selector
-     * @returns
-     */
-    getStats: (selector?: MediaStreamTrack | null | undefined) => Promise<RTCStatsReport>;
-    /**
-     * Sets the SFU client to use.
-     *
-     * @param sfuClient the SFU client to use.
-     */
-    setSfuClient: (sfuClient: StreamSfuClient) => void;
+    detachEventHandlers(): void;
     /**
      * Restarts the ICE connection and renegotiates with the SFU.
      */
     restartIce: () => Promise<void>;
     private handleOnTrack;
-    private onIceCandidate;
     private negotiate;
-    private onIceConnectionStateChange;
-    private onIceGatheringStateChange;
-    private onIceCandidateError;
 }