@stream-io/video-client 1.14.0 → 1.15.0

package/dist/src/Call.d.ts

@@ -1,7 +1,7 @@
 import { Publisher, Subscriber } from './rtc';
 import { CallState } from './store';
-import type { AcceptCallResponse, BlockUserResponse, CallRingEvent, CollectUserFeedbackResponse, EndCallResponse, GetCallResponse, GetCallStatsResponse, GetOrCreateCallRequest, GetOrCreateCallResponse, GoLiveRequest, GoLiveResponse, JoinCallResponse, ListRecordingsResponse, ListTranscriptionsResponse, MuteUsersResponse, PinRequest, PinResponse, QueryCallMembersRequest, QueryCallMembersResponse, RejectCallResponse, RequestPermissionRequest, RequestPermissionResponse, SendCallEventResponse, SendReactionRequest, SendReactionResponse, StartClosedCaptionsRequest, StartClosedCaptionsResponse, StartHLSBroadcastingResponse, StartRecordingRequest, StartRecordingResponse, StartTranscriptionRequest, StartTranscriptionResponse, StopClosedCaptionsRequest, StopClosedCaptionsResponse, StopHLSBroadcastingResponse, StopLiveResponse, StopRecordingResponse, StopTranscriptionResponse, UnblockUserResponse, UnpinRequest, UnpinResponse, UpdateCallMembersRequest, UpdateCallMembersResponse, UpdateCallRequest, UpdateCallResponse, UpdateUserPermissionsRequest, UpdateUserPermissionsResponse, VideoDimension } from './gen/coordinator';
-import { AudioTrackType, CallConstructor, CallLeaveOptions, ClosedCaptionsSettings, JoinCallData, PublishOptions, TrackMuteType, VideoTrackType } from './types';
+import type { AcceptCallResponse, BlockUserResponse, CallRingEvent, CallSettingsResponse, CollectUserFeedbackResponse, EndCallResponse, GetCallResponse, GetCallStatsResponse, GetOrCreateCallRequest, GetOrCreateCallResponse, GoLiveRequest, GoLiveResponse, JoinCallResponse, ListRecordingsResponse, ListTranscriptionsResponse, MuteUsersResponse, PinRequest, PinResponse, QueryCallMembersRequest, QueryCallMembersResponse, RejectCallResponse, RequestPermissionRequest, RequestPermissionResponse, SendCallEventResponse, SendReactionRequest, SendReactionResponse, StartClosedCaptionsRequest, StartClosedCaptionsResponse, StartHLSBroadcastingResponse, StartRecordingRequest, StartRecordingResponse, StartTranscriptionRequest, StartTranscriptionResponse, StopClosedCaptionsRequest, StopClosedCaptionsResponse, StopHLSBroadcastingResponse, StopLiveResponse, StopRecordingResponse, StopTranscriptionResponse, UnblockUserResponse, UnpinRequest, UnpinResponse, UpdateCallMembersRequest, UpdateCallMembersResponse, UpdateCallRequest, UpdateCallResponse, UpdateUserPermissionsRequest, UpdateUserPermissionsResponse, VideoDimension } from './gen/coordinator';
+import { AudioTrackType, CallConstructor, CallLeaveOptions, ClientPublishOptions, ClosedCaptionsSettings, JoinCallData, TrackMuteType, VideoTrackType } from './types';
 import { TrackType } from './gen/video/sfu/models/models';
 import { DynascaleManager } from './helpers/DynascaleManager';
 import { PermissionsContext } from './permissions';
@@ -69,7 +69,8 @@ export declare class Call {
      * @private
      */
     private readonly dispatcher;
-    private publishOptions?;
+    private clientPublishOptions?;
+    private currentPublishOptions?;
     private statsReporter?;
     private sfuStatsReporter?;
     private dropTimeout;
@@ -210,6 +211,18 @@ export declare class Call {
      * @internal
      */
     private getReconnectDetails;
+    /**
+     * Prepares the preferred codec for the call.
+     * This is an experimental client feature and subject to change.
+     * @internal
+     */
+    private getPreferredPublishOptions;
+    /**
+     * Prepares the preferred options for subscribing to tracks.
+     * This is an experimental client feature and subject to change.
+     * @internal
+     */
+    private getPreferredSubscribeOptions;
     /**
      * Performs an ICE restart on both the Publisher and Subscriber Peer Connections.
      * Uses the provided SFU client to restore the ICE connection.
@@ -282,48 +295,47 @@ export declare class Call {
     private restoreSubscribedTracks;
     /**
      * Starts publishing the given video stream to the call.
-     * The stream will be stopped if the user changes an input device, or if the user leaves the call.
-     *
-     * Consecutive calls to this method will replace the previously published stream.
-     * The previous video stream will be stopped.
-     *
-     * @param videoStream the video stream to publish.
+     * @deprecated use `call.publish()`.
      */
     publishVideoStream: (videoStream: MediaStream) => Promise<void>;
     /**
      * Starts publishing the given audio stream to the call.
-     * The stream will be stopped if the user changes an input device, or if the user leaves the call.
-     *
-     * Consecutive calls to this method will replace the audio stream that is currently being published.
-     * The previous audio stream will be stopped.
-     *
-     * @param audioStream the audio stream to publish.
+     * @deprecated use `call.publish()`
      */
     publishAudioStream: (audioStream: MediaStream) => Promise<void>;
     /**
      * Starts publishing the given screen-share stream to the call.
-     *
-     * Consecutive calls to this method will replace the previous screen-share stream.
-     * The previous screen-share stream will be stopped.
-     *
-     * @param screenShareStream the screen-share stream to publish.
+     * @deprecated use `call.publish()`
      */
     publishScreenShareStream: (screenShareStream: MediaStream) => Promise<void>;
+    /**
+     * Publishes the given media stream.
+     *
+     * @param mediaStream the media stream to publish.
+     * @param trackType the type of the track to announce.
+     */
+    publish: (mediaStream: MediaStream, trackType: TrackType) => Promise<void>;
     /**
      * Stops publishing the given track type to the call, if it is currently being published.
-     * Underlying track will be stopped and removed from the publisher.
      *
-     * @param trackType the track type to stop publishing.
-     * @param stopTrack if `true` the track will be stopped, else it will be just disabled
+     * @param trackTypes the track types to stop publishing.
+     */
+    stopPublish: (...trackTypes: TrackType[]) => Promise<void>;
+    /**
+     * Updates the call state with the new stream.
+     *
+     * @param mediaStream the new stream to update the call state with.
+     * If undefined, the stream will be removed from the call state.
+     * @param trackTypes the track types to update the call state with.
      */
-    stopPublish: (trackType: TrackType, stopTrack?: boolean) => Promise<void>;
+    private updateLocalStreamState;
     /**
      * Updates the preferred publishing options
      *
      * @internal
      * @param options the options to use.
      */
-    updatePublishOptions(options: PublishOptions): void;
+    updatePublishOptions: (options: ClientPublishOptions) => void;
     /**
      * Notifies the SFU that a noise cancellation process has started.
      *
@@ -336,6 +348,11 @@ export declare class Call {
      * @internal
      */
     notifyNoiseCancellationStopped: () => Promise<void | import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationRequest, import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationResponse> | undefined>;
+    /**
+     * Notifies the SFU about the mute state of the given track types.
+     * @internal
+     */
+    notifyTrackMuteState: (muted: boolean, ...trackTypes: TrackType[]) => Promise<void>;
     /**
      * Will enhance the reported stats with additional participant-specific information (`callStatsReport$` state [store variable](./StreamVideoClient.md/#readonlystatestore)).
      * This is usually helpful when detailed stats for a specific participant are needed.
@@ -608,9 +625,7 @@ export declare class Call {
      *
      * @internal
      */
-    applyDeviceConfig: (status: boolean) => Promise<void>;
-    private initCamera;
-    private initMic;
+    applyDeviceConfig: (settings: CallSettingsResponse, publish: boolean) => Promise<void>;
     /**
      * Will begin tracking the given element for visibility changes within the
      * configured viewport element (`call.setViewport`).

package/dist/src/StreamSfuClient.d.ts

@@ -1,7 +1,7 @@
 import { Dispatcher, IceTrickleBuffer } from './rtc';
 import { JoinRequest, JoinResponse } from './gen/video/sfu/event/events';
-import { ICERestartRequest, SendAnswerRequest, SendStatsRequest, SetPublisherRequest, TrackSubscriptionDetails, UpdateMuteStatesRequest } from './gen/video/sfu/signal_rpc/signal';
-import { ICETrickle, TrackType } from './gen/video/sfu/models/models';
+import { ICERestartRequest, SendAnswerRequest, SendStatsRequest, SetPublisherRequest, TrackMuteState, TrackSubscriptionDetails } from './gen/video/sfu/signal_rpc/signal';
+import { ICETrickle } from './gen/video/sfu/models/models';
 import { StreamClient } from './coordinator/connection/client';
 import { Credentials } from './gen/coordinator';
 export type StreamSfuClientConstructor = {
@@ -122,15 +122,14 @@ export declare class StreamSfuClient {
     get joinTask(): Promise<JoinResponse>;
     private handleWebSocketClose;
     close: (code?: number, reason?: string) => void;
-    dispose: () => void;
+    private dispose;
     leaveAndClose: (reason: string) => Promise<void>;
     updateSubscriptions: (tracks: TrackSubscriptionDetails[]) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").UpdateSubscriptionsRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateSubscriptionsResponse>>;
     setPublisher: (data: Omit<SetPublisherRequest, "sessionId">) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<SetPublisherRequest, import("./gen/video/sfu/signal_rpc/signal").SetPublisherResponse>>;
     sendAnswer: (data: Omit<SendAnswerRequest, "sessionId">) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<SendAnswerRequest, import("./gen/video/sfu/signal_rpc/signal").SendAnswerResponse>>;
     iceTrickle: (data: Omit<ICETrickle, "sessionId">) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<ICETrickle, import("./gen/video/sfu/signal_rpc/signal").ICETrickleResponse>>;
     iceRestart: (data: Omit<ICERestartRequest, "sessionId">) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<ICERestartRequest, import("./gen/video/sfu/signal_rpc/signal").ICERestartResponse>>;
-    updateMuteState: (trackType: TrackType, muted: boolean) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<UpdateMuteStatesRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesResponse>>;
-    updateMuteStates: (data: Omit<UpdateMuteStatesRequest, "sessionId">) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<UpdateMuteStatesRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesResponse>>;
+    updateMuteStates: (muteStates: TrackMuteState[]) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesResponse>>;
     sendStats: (stats: Omit<SendStatsRequest, "sessionId">) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<SendStatsRequest, import("./gen/video/sfu/signal_rpc/signal").SendStatsResponse>>;
     startNoiseCancellation: () => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").StartNoiseCancellationRequest, import("./gen/video/sfu/signal_rpc/signal").StartNoiseCancellationResponse>>;
     stopNoiseCancellation: () => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationRequest, import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationResponse>>;

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

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { Call } from '../Call';
 import { CameraDirection, CameraManagerState } from './CameraManagerState';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
-import { PreferredCodec } from '../types';
+import { VideoSettingsResponse } from '../gen/coordinator';
 export declare class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
     private targetResolution;
     /**
@@ -33,15 +33,12 @@ export declare class CameraManager extends InputMediaDeviceManager<CameraManager
         height: number;
     }): Promise<void>;
     /**
-     * Sets the preferred codec for encoding the video.
+     * Applies the video settings to the camera.
      *
-     * @internal internal use only, not part of the public API.
-     * @deprecated use {@link call.updatePublishOptions} instead.
-     * @param codec the codec to use for encoding the video.
+     * @param settings the video settings to apply.
+     * @param publish whether to publish the stream after applying the settings.
      */
-    setPreferredCodec(codec: PreferredCodec | undefined): void;
+    apply(settings: VideoSettingsResponse, publish: boolean): Promise<void>;
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
-    protected publishStream(stream: MediaStream): Promise<void>;
-    protected stopPublishStream(stopTracks: boolean): Promise<void>;
 }

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

@@ -85,16 +85,16 @@ export declare abstract class InputMediaDeviceManager<T extends InputMediaDevice
     protected applySettingsToStream(): Promise<void>;
     protected abstract getDevices(): Observable<MediaDeviceInfo[]>;
     protected abstract getStream(constraints: C): Promise<MediaStream>;
-    protected abstract publishStream(stream: MediaStream): Promise<void>;
-    protected abstract stopPublishStream(stopTracks: boolean): Promise<void>;
+    protected publishStream(stream: MediaStream): Promise<void>;
+    protected stopPublishStream(): Promise<void>;
     protected getTracks(): MediaStreamTrack[];
     protected muteStream(stopTracks?: boolean): Promise<void>;
-    private muteTracks;
-    private unmuteTracks;
+    private disableTracks;
+    private enableTracks;
     private stopTracks;
     private muteLocalStream;
     protected unmuteStream(): Promise<void>;
     private get mediaDeviceKind();
     private handleDisconnectedOrReplacedDevices;
-    private findDeviceInList;
+    private findDevice;
 }

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

@@ -4,6 +4,7 @@ import { Call } from '../Call';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
 import { TrackDisableMode } from './InputMediaDeviceManagerState';
+import { AudioSettingsResponse } from '../gen/coordinator';
 export declare class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
     private speakingWhileMutedNotificationEnabled;
     private soundDetectorConcurrencyTag;
@@ -35,10 +36,14 @@ export declare class MicrophoneManager extends InputMediaDeviceManager<Microphon
      * Disables speaking while muted notification.
      */
     disableSpeakingWhileMutedNotification(): Promise<void>;
+    /**
+     * Applies the audio settings to the microphone.
+     * @param settings the audio settings to apply.
+     * @param publish whether to publish the stream after applying the settings.
+     */
+    apply(settings: AudioSettingsResponse, publish: boolean): Promise<void>;
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
-    protected publishStream(stream: MediaStream): Promise<void>;
-    protected stopPublishStream(stopTracks: boolean): Promise<void>;
     private startSpeakingWhileMutedDetection;
     private stopSpeakingWhileMutedDetection;
 }

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

@@ -28,8 +28,7 @@ export declare class ScreenShareManager extends InputMediaDeviceManager<ScreenSh
     setSettings(settings: ScreenShareSettings | undefined): void;
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: DisplayMediaStreamOptions): Promise<MediaStream>;
-    protected publishStream(stream: MediaStream): Promise<void>;
-    protected stopPublishStream(stopTracks: boolean): Promise<void>;
+    protected stopPublishStream(): Promise<void>;
     /**
      * Overrides the default `select` method to throw an error.
      *

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;
 }