@stream-io/video-client 0.0.1-alpha.7

package/dist/src/gen/video/sfu/signal_rpc/signal.d.ts

@@ -0,0 +1,320 @@
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { TrackInfo } from "../models/models";
+import { PeerType } from "../models/models";
+import { VideoDimension } from "../models/models";
+import { TrackType } from "../models/models";
+import { Error } from "../models/models";
+/**
+ * @generated from protobuf message stream.video.sfu.signal.UpdateMuteStatesRequest
+ */
+export interface UpdateMuteStatesRequest {
+    /**
+     * @generated from protobuf field: string session_id = 1;
+     */
+    sessionId: string;
+    /**
+     * @generated from protobuf field: repeated stream.video.sfu.signal.TrackMuteState mute_states = 3;
+     */
+    muteStates: TrackMuteState[];
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.UpdateMuteStatesResponse
+ */
+export interface UpdateMuteStatesResponse {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Error error = 4;
+     */
+    error?: Error;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.TrackMuteState
+ */
+export interface TrackMuteState {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.TrackType track_type = 1;
+     */
+    trackType: TrackType;
+    /**
+     * @generated from protobuf field: bool muted = 2;
+     */
+    muted: boolean;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.AudioMuteChanged
+ */
+export interface AudioMuteChanged {
+    /**
+     * @generated from protobuf field: bool muted = 1;
+     */
+    muted: boolean;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.VideoMuteChanged
+ */
+export interface VideoMuteChanged {
+    /**
+     * @generated from protobuf field: bool muted = 2;
+     */
+    muted: boolean;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.UpdateSubscriptionsRequest
+ */
+export interface UpdateSubscriptionsRequest {
+    /**
+     * @generated from protobuf field: string session_id = 2;
+     */
+    sessionId: string;
+    /**
+     * @generated from protobuf field: repeated stream.video.sfu.signal.TrackSubscriptionDetails tracks = 3;
+     */
+    tracks: TrackSubscriptionDetails[];
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.UpdateSubscriptionsResponse
+ */
+export interface UpdateSubscriptionsResponse {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Error error = 4;
+     */
+    error?: Error;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.TrackSubscriptionDetails
+ */
+export interface TrackSubscriptionDetails {
+    /**
+     * @generated from protobuf field: string user_id = 1;
+     */
+    userId: string;
+    /**
+     * @generated from protobuf field: string session_id = 2;
+     */
+    sessionId: string;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.TrackType track_type = 3;
+     */
+    trackType: TrackType;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.VideoDimension dimension = 4;
+     */
+    dimension?: VideoDimension;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.SendAnswerRequest
+ */
+export interface SendAnswerRequest {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.PeerType peer_type = 1;
+     */
+    peerType: PeerType;
+    /**
+     * @generated from protobuf field: string sdp = 2;
+     */
+    sdp: string;
+    /**
+     * @generated from protobuf field: string session_id = 3;
+     */
+    sessionId: string;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.SendAnswerResponse
+ */
+export interface SendAnswerResponse {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Error error = 4;
+     */
+    error?: Error;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.ICETrickleResponse
+ */
+export interface ICETrickleResponse {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Error error = 4;
+     */
+    error?: Error;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.SetPublisherRequest
+ */
+export interface SetPublisherRequest {
+    /**
+     * sdp offer
+     *
+     * @generated from protobuf field: string sdp = 1;
+     */
+    sdp: string;
+    /**
+     * @generated from protobuf field: string session_id = 2;
+     */
+    sessionId: string;
+    /**
+     * @generated from protobuf field: repeated stream.video.sfu.models.TrackInfo tracks = 3;
+     */
+    tracks: TrackInfo[];
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.SetPublisherResponse
+ */
+export interface SetPublisherResponse {
+    /**
+     * sdp answer
+     *
+     * @generated from protobuf field: string sdp = 1;
+     */
+    sdp: string;
+    /**
+     * @generated from protobuf field: string session_id = 2;
+     */
+    sessionId: string;
+    /**
+     * @generated from protobuf field: bool ice_restart = 3;
+     */
+    iceRestart: boolean;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Error error = 4;
+     */
+    error?: Error;
+}
+declare class UpdateMuteStatesRequest$Type extends MessageType<UpdateMuteStatesRequest> {
+    constructor();
+    create(value?: PartialMessage<UpdateMuteStatesRequest>): UpdateMuteStatesRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateMuteStatesRequest): UpdateMuteStatesRequest;
+    internalBinaryWrite(message: UpdateMuteStatesRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.UpdateMuteStatesRequest
+ */
+export declare const UpdateMuteStatesRequest: UpdateMuteStatesRequest$Type;
+declare class UpdateMuteStatesResponse$Type extends MessageType<UpdateMuteStatesResponse> {
+    constructor();
+    create(value?: PartialMessage<UpdateMuteStatesResponse>): UpdateMuteStatesResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateMuteStatesResponse): UpdateMuteStatesResponse;
+    internalBinaryWrite(message: UpdateMuteStatesResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.UpdateMuteStatesResponse
+ */
+export declare const UpdateMuteStatesResponse: UpdateMuteStatesResponse$Type;
+declare class TrackMuteState$Type extends MessageType<TrackMuteState> {
+    constructor();
+    create(value?: PartialMessage<TrackMuteState>): TrackMuteState;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackMuteState): TrackMuteState;
+    internalBinaryWrite(message: TrackMuteState, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.TrackMuteState
+ */
+export declare const TrackMuteState: TrackMuteState$Type;
+declare class AudioMuteChanged$Type extends MessageType<AudioMuteChanged> {
+    constructor();
+    create(value?: PartialMessage<AudioMuteChanged>): AudioMuteChanged;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AudioMuteChanged): AudioMuteChanged;
+    internalBinaryWrite(message: AudioMuteChanged, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.AudioMuteChanged
+ */
+export declare const AudioMuteChanged: AudioMuteChanged$Type;
+declare class VideoMuteChanged$Type extends MessageType<VideoMuteChanged> {
+    constructor();
+    create(value?: PartialMessage<VideoMuteChanged>): VideoMuteChanged;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: VideoMuteChanged): VideoMuteChanged;
+    internalBinaryWrite(message: VideoMuteChanged, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.VideoMuteChanged
+ */
+export declare const VideoMuteChanged: VideoMuteChanged$Type;
+declare class UpdateSubscriptionsRequest$Type extends MessageType<UpdateSubscriptionsRequest> {
+    constructor();
+    create(value?: PartialMessage<UpdateSubscriptionsRequest>): UpdateSubscriptionsRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateSubscriptionsRequest): UpdateSubscriptionsRequest;
+    internalBinaryWrite(message: UpdateSubscriptionsRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.UpdateSubscriptionsRequest
+ */
+export declare const UpdateSubscriptionsRequest: UpdateSubscriptionsRequest$Type;
+declare class UpdateSubscriptionsResponse$Type extends MessageType<UpdateSubscriptionsResponse> {
+    constructor();
+    create(value?: PartialMessage<UpdateSubscriptionsResponse>): UpdateSubscriptionsResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateSubscriptionsResponse): UpdateSubscriptionsResponse;
+    internalBinaryWrite(message: UpdateSubscriptionsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.UpdateSubscriptionsResponse
+ */
+export declare const UpdateSubscriptionsResponse: UpdateSubscriptionsResponse$Type;
+declare class TrackSubscriptionDetails$Type extends MessageType<TrackSubscriptionDetails> {
+    constructor();
+    create(value?: PartialMessage<TrackSubscriptionDetails>): TrackSubscriptionDetails;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackSubscriptionDetails): TrackSubscriptionDetails;
+    internalBinaryWrite(message: TrackSubscriptionDetails, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.TrackSubscriptionDetails
+ */
+export declare const TrackSubscriptionDetails: TrackSubscriptionDetails$Type;
+declare class SendAnswerRequest$Type extends MessageType<SendAnswerRequest> {
+    constructor();
+    create(value?: PartialMessage<SendAnswerRequest>): SendAnswerRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SendAnswerRequest): SendAnswerRequest;
+    internalBinaryWrite(message: SendAnswerRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.SendAnswerRequest
+ */
+export declare const SendAnswerRequest: SendAnswerRequest$Type;
+declare class SendAnswerResponse$Type extends MessageType<SendAnswerResponse> {
+    constructor();
+    create(value?: PartialMessage<SendAnswerResponse>): SendAnswerResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SendAnswerResponse): SendAnswerResponse;
+    internalBinaryWrite(message: SendAnswerResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.SendAnswerResponse
+ */
+export declare const SendAnswerResponse: SendAnswerResponse$Type;
+declare class ICETrickleResponse$Type extends MessageType<ICETrickleResponse> {
+    constructor();
+    create(value?: PartialMessage<ICETrickleResponse>): ICETrickleResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ICETrickleResponse): ICETrickleResponse;
+    internalBinaryWrite(message: ICETrickleResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.ICETrickleResponse
+ */
+export declare const ICETrickleResponse: ICETrickleResponse$Type;
+declare class SetPublisherRequest$Type extends MessageType<SetPublisherRequest> {
+    constructor();
+    create(value?: PartialMessage<SetPublisherRequest>): SetPublisherRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SetPublisherRequest): SetPublisherRequest;
+    internalBinaryWrite(message: SetPublisherRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.SetPublisherRequest
+ */
+export declare const SetPublisherRequest: SetPublisherRequest$Type;
+declare class SetPublisherResponse$Type extends MessageType<SetPublisherResponse> {
+    constructor();
+    create(value?: PartialMessage<SetPublisherResponse>): SetPublisherResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SetPublisherResponse): SetPublisherResponse;
+    internalBinaryWrite(message: SetPublisherResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.SetPublisherResponse
+ */
+export declare const SetPublisherResponse: SetPublisherResponse$Type;
+/**
+ * @generated ServiceType for protobuf service stream.video.sfu.signal.SignalServer
+ */
+export declare const SignalServer: ServiceType;
+export {};

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

@@ -0,0 +1,8 @@
+/**
+ * Checks whether the current browser is Safari.
+ */
+export declare const isSafari: () => boolean;
+/**
+ * Checks whether the current browser is Firefox.
+ */
+export declare const isFirefox: () => boolean;

package/dist/src/helpers/sound-detector.d.ts

@@ -0,0 +1,34 @@
+export type SoundDetectorOptions = {
+    /**
+     * Defines how often the detector should check whether a sound is present.
+     * Defaults to 500ms.
+     */
+    detectionFrequencyInMs?: number;
+    /**
+     * Defines the audio level threshold before a "change" is emitted.
+     * Defaults to 150. This value should be in the range of 0-255.
+     */
+    audioLevelThreshold?: number;
+    /**
+     * See https://developer.mozilla.org/en-US/docs/web/api/analysernode/fftsize
+     *
+     * Defaults to 128.
+     */
+    fftSize?: number;
+    /**
+     * Defines whether the provided audio stream should be stopped (destroyed)
+     * when the sound detector is stopped.
+     *
+     * Defaults to `true`.
+     */
+    destroyStreamOnStop?: boolean;
+};
+/**
+ * Creates a new sound detector.
+ *
+ * @param audioStream the audio stream to observe. Depending on the provided configuration, this stream might be destroyed when the sound detector is stopped.
+ * @param onSoundDetectedStateChanged a callback which is called when the sound state changes.
+ * @param options custom options for the sound detector.
+ * @returns a clean-up function which once invoked stops the sound detector.
+ */
+export declare const createSoundDetector: (audioStream: MediaStream, onSoundDetectedStateChanged: (isSoundDetected: boolean) => void, options?: SoundDetectorOptions) => () => Promise<void>;

package/dist/src/rpc/createClient.d.ts

@@ -0,0 +1,10 @@
+import type { RpcInterceptor } from '@protobuf-ts/runtime-rpc';
+import { TwirpOptions } from '@protobuf-ts/twirp-transport';
+import { SignalServerClient } from '../gen/video/sfu/signal_rpc/signal.client';
+export declare const withHeaders: (headers: Record<string, string>) => RpcInterceptor;
+/**
+ * Creates new SignalServerClient instance.
+ *
+ * @param options the twirp options.
+ */
+export declare const createSignalClient: (options?: TwirpOptions) => SignalServerClient;

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

@@ -0,0 +1,2 @@
+export * from './createClient';
+export * from './latency';

package/dist/src/rpc/latency.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Measures the latency of the current client to the given endpoint.
+ * Uses HTML Image tag in order to avoid CORS issues.
+ *
+ * @param endpoint the endpoint.
+ * @param rounds the number of measuring rounds to perform.
+ * @param timeoutAfterMs the request cancellation period.
+ */
+export declare const measureResourceLoadLatencyTo: (endpoint: string, rounds?: number, timeoutAfterMs?: number) => Promise<number[]>;

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

@@ -0,0 +1,180 @@
+import { StreamSfuClient } from '../StreamSfuClient';
+import { CallState, TrackType } from '../gen/video/sfu/models/models';
+import { SfuEventListener } from './Dispatcher';
+import { StreamVideoWriteableStateStore } from '../store';
+import type { CallOptions, PublishOptions, SubscriptionChanges } from './types';
+import { Batcher } from '../Batcher';
+import { CallMetadata } from './CallMetadata';
+/**
+ * A `Call` object represents the active call the user is part of. It's not enough to have a `Call` instance, you will also need to call the [`join`](#join) method.
+ */
+export declare class Call {
+    private readonly client;
+    private readonly options;
+    private readonly stateStore;
+    private readonly userBatcher;
+    /**
+     * Contains metadata about the call, for example who created the call. You can also extract the call ID from this object, which you'll need for certain API calls (for example to start a recording).
+     */
+    data: CallMetadata;
+    private readonly subscriber;
+    private readonly publisher;
+    private readonly trackSubscriptionsSubject;
+    private statsReporter;
+    private joined$;
+    /**
+     * Don't call the constructor directly, use the [`StreamVideoClient.joinCall`](./StreamVideoClient.md/#joincall) method to construct a `Call` instance.
+     * @param client
+     * @param data
+     * @param options
+     * @param stateStore
+     * @param userBatcher
+     */
+    constructor(data: CallMetadata, client: StreamSfuClient, options: CallOptions, stateStore: StreamVideoWriteableStateStore, userBatcher: Batcher<string>);
+    /**
+     * You can subscribe to WebSocket events provided by the API. To remove a subscription, call the `off` method.
+     * Please note that subscribing to WebSocket events is an advanced use-case, for most use-cases it should be enough to watch for changes in the [reactive state store](./StreamVideoClient.md/#readonlystatestore).
+     * @param eventName
+     * @param fn
+     * @returns
+     */
+    on: (eventName: string, fn: SfuEventListener) => () => void;
+    /**
+     * Remove subscription for WebSocket events that were created by the `on` method.
+     * @param eventName
+     * @param fn
+     * @returns
+     */
+    off: (eventName: string, fn: SfuEventListener) => void;
+    /**
+     * Leave the call and stop the media streams that were published by the call.
+     */
+    leave: () => void;
+    /**
+     * Will initiate a call session with the server and return the call state. Don't call this method directly, use the [`StreamVideoClient.joinCall`](./StreamVideoClient.md/#joincall) method that takes care of this operation.
+     *
+     * If the join was successful the [`activeCall$` state variable](./StreamVideClient/#readonlystatestore) will be set
+     *
+     * @returns a promise which resolves once the call join-flow has finished.
+     */
+    join: () => Promise<CallState | undefined>;
+    /**
+     * 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.
+     *
+     * If the method was successful the [`activeCall$` state variable](./StreamVideClient/#readonlystatestore) will be cleared
+     *
+     * Consecutive calls to this method will replace the previously published stream.
+     * The previous video stream will be stopped.
+     *
+     * @angular It's recommended to use the [`InCallDeviceManagerService`](./InCallDeviceManagerService.md) that takes care of this operation for you.
+     *
+     * @param videoStream the video stream to publish.
+     * @param opts the options to use when publishing the stream.
+     */
+    publishVideoStream: (videoStream: MediaStream, opts?: PublishOptions) => 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.
+     *
+     * @angular It's recommended to use the [`InCallDeviceManagerService`](./InCallDeviceManagerService.md) that takes care of this operation for you.
+     *
+     * @param audioStream the audio stream to 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.
+     *
+     * @angular It's recommended to use the [`InCallDeviceManagerService`](./InCallDeviceManagerService.md) that takes care of this operation for you.
+     *
+     * @param screenShareStream the screen-share stream to publish.
+     */
+    publishScreenShareStream: (screenShareStream: MediaStream) => 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.
+     *
+     * The `audioDeviceId`/`videoDeviceId` property of the [`localParticipant$`](./StreamVideoClient.md/#readonlystatestore) won't be updated, you can do that by calling the [`setAudioDevice`](#setaudiodevice)/[`setVideoDevice`](#setvideodevice) method.
+     *
+     * @angular It's recommended to use the [`InCallDeviceManagerService`](./InCallDeviceManagerService.md) that takes care of this operation for you.
+     *
+     * @param trackType the track type to stop publishing.
+     */
+    stopPublish: (trackType: TrackType) => Promise<void>;
+    /**
+     * Update track subscription configuration for one or more participants.
+     * You have to create a subscription for each participant for all the different kinds of tracks you want to receive.
+     * You can only subscribe for tracks after the participant started publishing the given kind of track.
+     *
+     * @param kind the kind of subscription to update.
+     * @param changes the list of subscription changes to do.
+     */
+    updateSubscriptionsPartial: (kind: 'video' | 'screen', changes: SubscriptionChanges) => void;
+    private updateSubscriptions;
+    /**
+     * @deprecated use the `callStatsReport$` state [store variable](./StreamVideoClient.md/#readonlystatestore) instead
+     * @param kind
+     * @param selector
+     * @returns
+     */
+    getStats: (kind: 'subscriber' | 'publisher', selector?: MediaStreamTrack) => Promise<RTCStatsReport | undefined>;
+    /**
+     * 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.
+     *
+     * @param sessionId the sessionId to start reporting for.
+     */
+    startReportingStatsFor: (sessionId: string) => void;
+    /**
+     * Opposite of `startReportingStatsFor`.
+     * Will turn off stats reporting for a specific participant.
+     *
+     * @param sessionId the sessionId to stop reporting for.
+     */
+    stopReportingStatsFor: (sessionId: string) => void;
+    /**
+     * Sets the used audio output device (`audioOutputDeviceId` of the [`localParticipant$`](./StreamVideoClient.md/#readonlystatestore).
+     *
+     * This method only stores the selection, if you're using custom UI components, you'll have to implement the audio switching, for more information see: https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/sinkId.
+     *
+     * @angular It's recommended to use the [`InCallDeviceManagerService`](./InCallDeviceManagerService.md) that takes care of this operation for you.
+     *
+     * @param deviceId the selected device, `undefined` means the user wants to use the system's default audio output
+     */
+    setAudioOutputDevice: (deviceId?: string) => void;
+    /**
+     * Sets the `audioDeviceId` property of the [`localParticipant$`](./StreamVideoClient.md/#readonlystatestore)).
+     *
+     * This method only stores the selection, if you want to start publishing a media stream call the [`publishAudioStream` method](#publishaudiostream) that will set `audioDeviceId` as well.
+     *
+     * @angular It's recommended to use the [`InCallDeviceManagerService`](./InCallDeviceManagerService.md) that takes care of this operation for you.
+     *
+     * @param deviceId the selected device, pass `undefined` to clear the device selection
+     */
+    setAudioDevice: (deviceId?: string) => void;
+    /**
+     * Sets the `videoDeviceId` property of the [`localParticipant$`](./StreamVideoClient.md/#readonlystatestore).
+     *
+     * This method only stores the selection, if you want to start publishing a media stream call the [`publishVideoStream` method](#publishvideostream) that will set `videoDeviceId` as well.
+     *
+     * @angular It's recommended to use the [`InCallDeviceManagerService`](./InCallDeviceManagerService.md) that takes care of this operation for you.
+     *
+     * @param deviceId the selected device, pass `undefined` to clear the device selection
+     */
+    setVideoDevice: (deviceId?: string) => void;
+    /**
+     * @internal
+     * @param enabledRids
+     * @returns
+     */
+    updatePublishQuality: (enabledRids: string[]) => Promise<void>;
+    private get participants();
+    private handleOnTrack;
+    private assertCallJoined;
+}

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

@@ -0,0 +1,9 @@
+import type { CallResponse, MemberResponse, UserResponse } from '../gen/coordinator';
+export type UserResponseMap = {
+    [userId: string]: UserResponse;
+};
+export declare class CallMetadata {
+    call: CallResponse;
+    users: UserResponseMap;
+    constructor(call: CallResponse, members?: MemberResponse[]);
+}

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

@@ -0,0 +1,9 @@
+import type { SfuEvent } from '../gen/video/sfu/event/events';
+export type SfuEventListener = (event: SfuEvent) => void;
+export declare class Dispatcher {
+    private subscribers;
+    dispatch: (message: SfuEvent) => void;
+    on: (eventName: string, fn: SfuEventListener) => () => void;
+    off: (eventName: string, fn: SfuEventListener) => void;
+    offAll: (eventName?: string) => void;
+}

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

@@ -0,0 +1,11 @@
+import { ReplaySubject } from 'rxjs';
+import { ICETrickle } from '../gen/video/sfu/models/models';
+/**
+ * A buffer for ICE Candidates. Used for ICE Trickle:
+ * - https://bloggeek.me/webrtcglossary/trickle-ice/
+ */
+export declare class IceTrickleBuffer {
+    readonly subscriberCandidates: ReplaySubject<ICETrickle>;
+    readonly publisherCandidates: ReplaySubject<ICETrickle>;
+    push: (iceTrickle: ICETrickle) => void;
+}

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

@@ -0,0 +1,5 @@
+import { Call } from './Call';
+import { Dispatcher } from './Dispatcher';
+import { StreamVideoWriteableStateStore } from '../store';
+import { Batcher } from '../Batcher';
+export declare const registerEventHandlers: (call: Call, store: StreamVideoWriteableStateStore, dispatcher: Dispatcher, userBatcher: Batcher<string>) => void;

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

@@ -0,0 +1,2 @@
+export declare const getPreferredCodecs: (kind: 'audio' | 'video', videoCodec: string) => RTCRtpCodecCapability[] | undefined;
+export declare const getGenericSdp: (direction: RTCRtpTransceiverDirection) => Promise<string | undefined>;

package/dist/src/rtc/helpers/iceCandidate.d.ts

@@ -0,0 +1,2 @@
+import { ICETrickle } from '../../gen/video/sfu/models/models';
+export declare function getIceCandidate(candidate: RTCIceCandidate): ICETrickle['iceCandidate'];

package/dist/src/rtc/helpers/tracks.d.ts

@@ -0,0 +1,3 @@
+import { TrackType } from '../../gen/video/sfu/models/models';
+import type { StreamVideoParticipant } from '../types';
+export declare const trackTypeToParticipantStreamKey: (trackType: TrackType) => keyof StreamVideoParticipant | undefined;