@fishjam-cloud/ts-client 0.10.1 → 0.11.0

package/dist/index.d.mts

@@ -1,5 +1,9 @@
-import TypedEmitter from 'typed-emitter';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
+import TypedEmitter from 'typed-emitter';
+
+declare const AUTH_ERROR_REASONS: readonly ["missing token", "invalid token", "expired token", "room not found", "peer not found"];
+type AuthErrorReason = (typeof AUTH_ERROR_REASONS)[number];
+declare const isAuthError: (error: string) => error is AuthErrorReason;
 
 declare enum Variant {
     VARIANT_UNSPECIFIED = 0,
@@ -35,36 +39,6 @@ interface MessageFns$2<T> {
     fromPartial<I extends Exact$2<DeepPartial$2<T>, I>>(object: I): T;
 }
 
-interface MediaEvent_Track_SimulcastConfig {
-    enabled: boolean;
-    enabledVariants: Variant[];
-    disabledVariants: Variant[];
-}
-declare const MediaEvent_Track_SimulcastConfig: MessageFns$1<MediaEvent_Track_SimulcastConfig>;
-interface MediaEvent_OfferData_TrackTypes {
-    audio: number;
-    video: number;
-}
-declare const MediaEvent_OfferData_TrackTypes: MessageFns$1<MediaEvent_OfferData_TrackTypes>;
-type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$1<T[K]>;
-} : Partial<T>;
-type KeysOfUnion$1<T> = T extends T ? keyof T : never;
-type Exact$1<P, I extends P> = P extends Builtin$1 ? P : P & {
-    [K in keyof P]: Exact$1<P[K], I[K]>;
-} & {
-    [K in Exclude<keyof I, KeysOfUnion$1<P>>]: never;
-};
-interface MessageFns$1<T> {
-    encode(message: T, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): T;
-    fromJSON(object: any): T;
-    toJSON(message: T): unknown;
-    create<I extends Exact$1<DeepPartial$1<T>, I>>(base?: I): T;
-    fromPartial<I extends Exact$1<DeepPartial$1<T>, I>>(object: I): T;
-}
-
 /** Defines any type of message sent from Peer to Membrane RTC Engine */
 interface MediaEvent$1 {
     connect?: MediaEvent_Connect | undefined;
@@ -79,36 +53,36 @@ interface MediaEvent$1 {
     disableTrackVariant?: MediaEvent_DisableTrackVariant | undefined;
     setTargetTrackVariant?: MediaEvent_SetTargetTrackVariant | undefined;
 }
-declare const MediaEvent$1: MessageFns<MediaEvent$1>;
+declare const MediaEvent$1: MessageFns$1<MediaEvent$1>;
 interface MediaEvent_VariantBitrate {
     variant: Variant;
     bitrate: number;
 }
-declare const MediaEvent_VariantBitrate: MessageFns<MediaEvent_VariantBitrate>;
+declare const MediaEvent_VariantBitrate: MessageFns$1<MediaEvent_VariantBitrate>;
 /** Sent when a peer wants to join WebRTC Endpoint. */
 interface MediaEvent_Connect {
     metadataJson: string;
 }
-declare const MediaEvent_Connect: MessageFns<MediaEvent_Connect>;
+declare const MediaEvent_Connect: MessageFns$1<MediaEvent_Connect>;
 /** Sent when a peer disconnects from WebRTC Endpoint. */
 interface MediaEvent_Disconnect {
 }
-declare const MediaEvent_Disconnect: MessageFns<MediaEvent_Disconnect>;
+declare const MediaEvent_Disconnect: MessageFns$1<MediaEvent_Disconnect>;
 /** Sent when a peer wants to update its metadata */
 interface MediaEvent_UpdateEndpointMetadata {
     metadataJson: string;
 }
-declare const MediaEvent_UpdateEndpointMetadata: MessageFns<MediaEvent_UpdateEndpointMetadata>;
+declare const MediaEvent_UpdateEndpointMetadata: MessageFns$1<MediaEvent_UpdateEndpointMetadata>;
 /** Sent when a peer wants to update its track's metadata */
 interface MediaEvent_UpdateTrackMetadata {
     trackId: string;
     metadataJson: string;
 }
-declare const MediaEvent_UpdateTrackMetadata: MessageFns<MediaEvent_UpdateTrackMetadata>;
+declare const MediaEvent_UpdateTrackMetadata: MessageFns$1<MediaEvent_UpdateTrackMetadata>;
 /** Sent when peer wants to renegatiate connection due to adding a track or removing a track */
 interface MediaEvent_RenegotiateTracks {
 }
-declare const MediaEvent_RenegotiateTracks: MessageFns<MediaEvent_RenegotiateTracks>;
+declare const MediaEvent_RenegotiateTracks: MessageFns$1<MediaEvent_RenegotiateTracks>;
 /**
  * Sent as a response to `offerData` media event during renegotiation
  * Maps contain only information about current peer's `sendonly` tracks.
@@ -128,31 +102,61 @@ interface MediaEvent_SdpOffer {
         [key: string]: string;
     };
 }
-declare const MediaEvent_SdpOffer: MessageFns<MediaEvent_SdpOffer>;
+declare const MediaEvent_SdpOffer: MessageFns$1<MediaEvent_SdpOffer>;
 /** Sent when Peer wants to update its track's bitrate */
 interface MediaEvent_TrackBitrates {
     trackId: string;
     /** Bitrate of each variant. For non-simulcast tracks use VARIANT_UNSPECIFIED. */
     variantBitrates: MediaEvent_VariantBitrate[];
 }
-declare const MediaEvent_TrackBitrates: MessageFns<MediaEvent_TrackBitrates>;
+declare const MediaEvent_TrackBitrates: MessageFns$1<MediaEvent_TrackBitrates>;
 /** Sent when client disables one of the track variants */
 interface MediaEvent_DisableTrackVariant {
     trackId: string;
     variant: Variant;
 }
-declare const MediaEvent_DisableTrackVariant: MessageFns<MediaEvent_DisableTrackVariant>;
+declare const MediaEvent_DisableTrackVariant: MessageFns$1<MediaEvent_DisableTrackVariant>;
 /** Sent when client enables one of the track variants */
 interface MediaEvent_EnableTrackVariant {
     trackId: string;
     variant: Variant;
 }
-declare const MediaEvent_EnableTrackVariant: MessageFns<MediaEvent_EnableTrackVariant>;
+declare const MediaEvent_EnableTrackVariant: MessageFns$1<MediaEvent_EnableTrackVariant>;
 interface MediaEvent_SetTargetTrackVariant {
     trackId: string;
     variant: Variant;
 }
-declare const MediaEvent_SetTargetTrackVariant: MessageFns<MediaEvent_SetTargetTrackVariant>;
+declare const MediaEvent_SetTargetTrackVariant: MessageFns$1<MediaEvent_SetTargetTrackVariant>;
+type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$1<T[K]>;
+} : Partial<T>;
+type KeysOfUnion$1<T> = T extends T ? keyof T : never;
+type Exact$1<P, I extends P> = P extends Builtin$1 ? P : P & {
+    [K in keyof P]: Exact$1<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion$1<P>>]: never;
+};
+interface MessageFns$1<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact$1<DeepPartial$1<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact$1<DeepPartial$1<T>, I>>(object: I): T;
+}
+
+interface MediaEvent_Track_SimulcastConfig {
+    enabled: boolean;
+    enabledVariants: Variant[];
+    disabledVariants: Variant[];
+}
+declare const MediaEvent_Track_SimulcastConfig: MessageFns<MediaEvent_Track_SimulcastConfig>;
+interface MediaEvent_OfferData_TrackTypes {
+    audio: number;
+    video: number;
+}
+declare const MediaEvent_OfferData_TrackTypes: MessageFns<MediaEvent_OfferData_TrackTypes>;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
@@ -430,6 +434,21 @@ interface Endpoint {
     tracks: Map<string, TrackContext>;
 }
 
+declare class ConnectionManager {
+    private readonly connection;
+    constructor(iceServers: RTCIceServer[]);
+    isConnectionUnstable: () => boolean;
+    getConnection: () => RTCPeerConnection;
+    addTransceiversIfNeeded: (serverTracks: MediaEvent_OfferData_TrackTypes) => void;
+    addTransceiver: (track: MediaStreamTrack, transceiverConfig: RTCRtpTransceiverInit) => void;
+    setOnTrackReady: (onTrackReady: (event: RTCTrackEvent) => void) => void;
+    setRemoteDescription: (data: RTCSessionDescriptionInit) => Promise<void>;
+    isTrackInUse: (track: MediaStreamTrack) => boolean;
+    removeTrack: (sender: RTCRtpSender) => void;
+    findSender: (mediaStreamTrackId: MediaStreamTrackId) => RTCRtpSender;
+    addIceCandidate: (iceCandidate: RTCIceCandidate) => Promise<void>;
+}
+
 declare const TrackContextImpl_base: new () => TypedEmitter<Required<TrackContextEvents$1>>;
 declare class TrackContextImpl extends TrackContextImpl_base implements TrackContext {
     endpoint: Endpoint;
@@ -452,21 +471,6 @@ type EndpointWithTrackContext = Omit<Endpoint, 'tracks'> & {
     tracks: Map<string, TrackContextImpl>;
 };
 
-declare class ConnectionManager {
-    private readonly connection;
-    constructor(iceServers: RTCIceServer[]);
-    isConnectionUnstable: () => boolean;
-    getConnection: () => RTCPeerConnection;
-    addTransceiversIfNeeded: (serverTracks: MediaEvent_OfferData_TrackTypes) => void;
-    addTransceiver: (track: MediaStreamTrack, transceiverConfig: RTCRtpTransceiverInit) => void;
-    setOnTrackReady: (onTrackReady: (event: RTCTrackEvent) => void) => void;
-    setRemoteDescription: (data: RTCSessionDescriptionInit) => Promise<void>;
-    isTrackInUse: (track: MediaStreamTrack) => boolean;
-    removeTrack: (sender: RTCRtpSender) => void;
-    findSender: (mediaStreamTrackId: MediaStreamTrackId) => RTCRtpSender;
-    addIceCandidate: (iceCandidate: RTCIceCandidate) => Promise<void>;
-}
-
 declare const WebRTCEndpoint_base: new () => TypedEmitter<Required<WebRTCEndpointEvents>>;
 /**
  * Main class that is responsible for connecting to the RTC Engine, sending and receiving media.
@@ -759,12 +763,201 @@ declare class WebRTCEndpoint extends WebRTCEndpoint_base {
     private onIceConnectionStateChange;
 }
 
-declare const AUTH_ERROR_REASONS: readonly ["missing token", "invalid token", "expired token", "room not found", "peer not found"];
-type AuthErrorReason = (typeof AUTH_ERROR_REASONS)[number];
-declare const isAuthError: (error: string) => error is AuthErrorReason;
+type ReconnectionStatus = 'reconnecting' | 'idle' | 'error';
+type ReconnectConfig = {
+    maxAttempts?: number;
+    initialDelay?: number;
+    delay?: number;
+    addTracksOnReconnect?: boolean;
+};
+
+type TrackMetadata = {
+    type: 'camera' | 'microphone' | 'screenShareVideo' | 'screenShareAudio';
+    paused: boolean;
+    displayName?: string;
+};
+type GenericMetadata = Record<string, unknown> | undefined;
+/**
+ *
+ * @category Connection
+ * @typeParam PeerMetadata Type of metadata set by peer while connecting to a room.
+ * @typeParam ServerMetadata Type of metadata set by the server while creating a peer.
+ */
+type Metadata<PeerMetadata = GenericMetadata, ServerMetadata = GenericMetadata> = {
+    peer: PeerMetadata;
+    server: ServerMetadata;
+};
+type TrackContextEvents = {
+    encodingChanged: (context: FishjamTrackContext) => void;
+    voiceActivityChanged: (context: FishjamTrackContext) => void;
+};
+interface FishjamTrackContext extends TypedEmitter<TrackContextEvents> {
+    readonly track: MediaStreamTrack | null;
+    readonly stream: MediaStream | null;
+    readonly endpoint: Endpoint;
+    readonly trackId: string;
+    readonly simulcastConfig?: MediaEvent_Track_SimulcastConfig;
+    readonly metadata?: TrackMetadata;
+    readonly maxBandwidth?: TrackBandwidthLimit;
+    readonly vadStatus: VadStatus;
+    readonly encoding?: Variant;
+    readonly encodingReason?: EncodingReason;
+}
+type Peer<PeerMetadata = GenericMetadata, ServerMetadata = GenericMetadata> = {
+    id: string;
+    type: string;
+    metadata?: Metadata<PeerMetadata, ServerMetadata>;
+    tracks: Map<string, FishjamTrackContext>;
+};
+type Component = Omit<Endpoint, 'type'> & {
+    type: 'recording' | 'hls' | 'file' | 'rtsp' | 'sip';
+};
+/**
+ * Events emitted by the client with their arguments.
+ */
+type MessageEvents<P, S> = {
+    /**
+     * Emitted when connect method invoked
+     *
+     */
+    connectionStarted: () => void;
+    /**
+     * Emitted when the websocket connection is closed
+     *
+     * @param {CloseEvent} event - Close event object from the websocket
+     */
+    socketClose: (event: CloseEvent) => void;
+    /**
+     * Emitted when occurs an error in the websocket connection
+     *
+     * @param {Event} event - Event object from the websocket
+     */
+    socketError: (event: Event) => void;
+    /**
+     * Emitted when the websocket connection is opened
+     *
+     * @param {Event} event - Event object from the websocket
+     */
+    socketOpen: (event: Event) => void;
+    /** Emitted when authentication is successful */
+    authSuccess: () => void;
+    /** Emitted when authentication fails */
+    authError: (reason: AuthErrorReason) => void;
+    /** Emitted when the connection is closed */
+    disconnected: () => void;
+    /** Emitted when the process of reconnection starts */
+    reconnectionStarted: () => void;
+    /** Emitted on successful reconnection */
+    reconnected: () => void;
+    /** Emitted when the maximum number of reconnection retries is reached */
+    reconnectionRetriesLimitReached: () => void;
+    /**
+     * Called when peer was accepted.
+     */
+    joined: (peerId: string, peers: Peer<P, S>[], components: Component[]) => void;
+    /**
+     * Called when peer was not accepted
+     * @param metadata - Pass through for client application to communicate further actions to frontend
+     */
+    joinError: (metadata: any) => void;
+    /**
+     * Called when data in a new track arrives.
+     *
+     * This callback is always called after {@link MessageEvents.trackAdded}.
+     * It informs user that data related to the given track arrives and can be played or displayed.
+     */
+    trackReady: (ctx: FishjamTrackContext) => void;
+    /**
+     * Called each time the peer which was already in the room, adds new track. Fields track and stream will be set to null.
+     * These fields will be set to non-null value in {@link MessageEvents.trackReady}
+     */
+    trackAdded: (ctx: FishjamTrackContext) => void;
+    /**
+     * Called when some track will no longer be sent.
+     *
+     * It will also be called before {@link MessageEvents.peerLeft} for each track of this peer.
+     */
+    trackRemoved: (ctx: FishjamTrackContext) => void;
+    /**
+     * Called each time peer has its track metadata updated.
+     */
+    trackUpdated: (ctx: FishjamTrackContext) => void;
+    /**
+     * Called each time new peer joins the room.
+     */
+    peerJoined: (peer: Peer<P, S>) => void;
+    /**
+     * Called each time peer leaves the room.
+     */
+    peerLeft: (peer: Peer<P, S>) => void;
+    /**
+     * Called each time peer has its metadata updated.
+     */
+    peerUpdated: (peer: Peer<P, S>) => void;
+    /**
+     * Called each time new peer joins the room.
+     */
+    componentAdded: (peer: Component) => void;
+    /**
+     * Called each time peer leaves the room.
+     */
+    componentRemoved: (peer: Component) => void;
+    /**
+     * Called each time peer has its metadata updated.
+     */
+    componentUpdated: (peer: Component) => void;
+    /**
+     * Called in case of errors related to multimedia session e.g. ICE connection.
+     */
+    connectionError: (error: {
+        message: string;
+        event?: Event;
+    }) => void;
+    /**
+     * Currently, this callback is only invoked when DisplayManager in RTC Engine is
+     * enabled and simulcast is disabled.
+     *
+     * Called when priority of video tracks have changed.
+     * @param enabledTracks - list of tracks which will be sent to client from SFU
+     * @param disabledTracks - list of tracks which will not be sent to client from SFU
+     */
+    tracksPriorityChanged: (enabledTracks: FishjamTrackContext[], disabledTracks: FishjamTrackContext[]) => void;
+    /**
+     * Called every time the server estimates client's bandiwdth.
+     *
+     * @param {bigint} estimation - client's available incoming bitrate estimated
+     * by the server. It's measured in bits per second.
+     */
+    bandwidthEstimationChanged: (estimation: bigint) => void;
+    targetTrackEncodingRequested: (event: Parameters<WebRTCEndpointEvents['targetTrackEncodingRequested']>[0]) => void;
+    localTrackAdded: (event: Parameters<WebRTCEndpointEvents['localTrackAdded']>[0]) => void;
+    localTrackRemoved: (event: Parameters<WebRTCEndpointEvents['localTrackRemoved']>[0]) => void;
+    localTrackReplaced: (event: Parameters<WebRTCEndpointEvents['localTrackReplaced']>[0]) => void;
+    localTrackMuted: (event: Parameters<WebRTCEndpointEvents['localTrackMuted']>[0]) => void;
+    localTrackUnmuted: (event: Parameters<WebRTCEndpointEvents['localTrackUnmuted']>[0]) => void;
+    localTrackBandwidthSet: (event: Parameters<WebRTCEndpointEvents['localTrackBandwidthSet']>[0]) => void;
+    localTrackEncodingBandwidthSet: (event: Parameters<WebRTCEndpointEvents['localTrackEncodingBandwidthSet']>[0]) => void;
+    localTrackEncodingEnabled: (event: Parameters<WebRTCEndpointEvents['localTrackEncodingEnabled']>[0]) => void;
+    localTrackEncodingDisabled: (event: Parameters<WebRTCEndpointEvents['localTrackEncodingDisabled']>[0]) => void;
+    localPeerMetadataChanged: (event: Parameters<WebRTCEndpointEvents['localEndpointMetadataChanged']>[0]) => void;
+    localTrackMetadataChanged: (event: Parameters<WebRTCEndpointEvents['localTrackMetadataChanged']>[0]) => void;
+    disconnectRequested: (event: Parameters<WebRTCEndpointEvents['disconnectRequested']>[0]) => void;
+};
+/** Configuration object for the client */
+interface ConnectConfig<PeerMetadata> {
+    /** Metadata for the peer */
+    peerMetadata: PeerMetadata;
+    /** Token for authentication */
+    token: string;
+    /** Fishjam url */
+    url: string;
+}
+type CreateConfig = {
+    reconnect?: ReconnectConfig | boolean;
+};
 
 declare const FishjamClient_base: {
-    new <PeerMetadata_1, ServerMetadata_1>(): TypedEmitter<MessageEvents<PeerMetadata_1, ServerMetadata_1>>;
+    new <P, S>(): TypedEmitter<MessageEvents<P, S>>;
 };
 /**
  * FishjamClient is the main class to interact with Fishjam.
@@ -807,6 +1000,7 @@ declare class FishjamClient<PeerMetadata = GenericMetadata, ServerMetadata = Gen
     status: 'new' | 'initialized';
     private connectConfig;
     private reconnectManager;
+    private peerMessageQueue;
     private sendStatisticsInterval;
     constructor(config?: CreateConfig);
     /**
@@ -855,6 +1049,7 @@ declare class FishjamClient<PeerMetadata = GenericMetadata, ServerMetadata = Gen
     getRemoteComponents(): Record<string, Component>;
     getLocalPeer(): Peer<PeerMetadata, ServerMetadata> | null;
     getBandwidthEstimation(): bigint;
+    private isConnectingRelatedEvent;
     private setupCallbacks;
     private sendStatistics;
     /**
@@ -1118,191 +1313,4 @@ declare class FishjamClient<PeerMetadata = GenericMetadata, ServerMetadata = Gen
     cleanup(): void;
 }
 
-type ReconnectionStatus = 'reconnecting' | 'idle' | 'error';
-type ReconnectConfig = {
-    maxAttempts?: number;
-    initialDelay?: number;
-    delay?: number;
-    addTracksOnReconnect?: boolean;
-};
-
-type TrackMetadata = {
-    type: 'camera' | 'microphone' | 'screenShareVideo' | 'screenShareAudio';
-    paused: boolean;
-    displayName?: string;
-};
-type GenericMetadata = Record<string, unknown> | undefined;
-type Metadata<P = GenericMetadata, S = GenericMetadata> = {
-    peer: P;
-    server: S;
-};
-type TrackContextEvents = {
-    encodingChanged: (context: FishjamTrackContext) => void;
-    voiceActivityChanged: (context: FishjamTrackContext) => void;
-};
-interface FishjamTrackContext extends TypedEmitter<TrackContextEvents> {
-    readonly track: MediaStreamTrack | null;
-    readonly stream: MediaStream | null;
-    readonly endpoint: Endpoint;
-    readonly trackId: string;
-    readonly simulcastConfig?: MediaEvent_Track_SimulcastConfig;
-    readonly metadata?: TrackMetadata;
-    readonly maxBandwidth?: TrackBandwidthLimit;
-    readonly vadStatus: VadStatus;
-    readonly encoding?: Variant;
-    readonly encodingReason?: EncodingReason;
-}
-type Peer<PeerMetadata = GenericMetadata, ServerMetadata = GenericMetadata> = {
-    id: string;
-    type: string;
-    metadata?: Metadata<PeerMetadata, ServerMetadata>;
-    tracks: Map<string, FishjamTrackContext>;
-};
-type Component = Omit<Endpoint, 'type'> & {
-    type: 'recording' | 'hls' | 'file' | 'rtsp' | 'sip';
-};
-/**
- * Events emitted by the client with their arguments.
- */
-type MessageEvents<P, S> = {
-    /**
-     * Emitted when connect method invoked
-     *
-     */
-    connectionStarted: () => void;
-    /**
-     * Emitted when the websocket connection is closed
-     *
-     * @param {CloseEvent} event - Close event object from the websocket
-     */
-    socketClose: (event: CloseEvent) => void;
-    /**
-     * Emitted when occurs an error in the websocket connection
-     *
-     * @param {Event} event - Event object from the websocket
-     */
-    socketError: (event: Event) => void;
-    /**
-     * Emitted when the websocket connection is opened
-     *
-     * @param {Event} event - Event object from the websocket
-     */
-    socketOpen: (event: Event) => void;
-    /** Emitted when authentication is successful */
-    authSuccess: () => void;
-    /** Emitted when authentication fails */
-    authError: (reason: AuthErrorReason) => void;
-    /** Emitted when the connection is closed */
-    disconnected: () => void;
-    /** Emitted when the process of reconnection starts */
-    reconnectionStarted: () => void;
-    /** Emitted on successful reconnection */
-    reconnected: () => void;
-    /** Emitted when the maximum number of reconnection retries is reached */
-    reconnectionRetriesLimitReached: () => void;
-    /**
-     * Called when peer was accepted.
-     */
-    joined: (peerId: string, peers: Peer<P, S>[], components: Component[]) => void;
-    /**
-     * Called when peer was not accepted
-     * @param metadata - Pass through for client application to communicate further actions to frontend
-     */
-    joinError: (metadata: any) => void;
-    /**
-     * Called when data in a new track arrives.
-     *
-     * This callback is always called after {@link MessageEvents.trackAdded}.
-     * It informs user that data related to the given track arrives and can be played or displayed.
-     */
-    trackReady: (ctx: FishjamTrackContext) => void;
-    /**
-     * Called each time the peer which was already in the room, adds new track. Fields track and stream will be set to null.
-     * These fields will be set to non-null value in {@link MessageEvents.trackReady}
-     */
-    trackAdded: (ctx: FishjamTrackContext) => void;
-    /**
-     * Called when some track will no longer be sent.
-     *
-     * It will also be called before {@link MessageEvents.peerLeft} for each track of this peer.
-     */
-    trackRemoved: (ctx: FishjamTrackContext) => void;
-    /**
-     * Called each time peer has its track metadata updated.
-     */
-    trackUpdated: (ctx: FishjamTrackContext) => void;
-    /**
-     * Called each time new peer joins the room.
-     */
-    peerJoined: (peer: Peer<P, S>) => void;
-    /**
-     * Called each time peer leaves the room.
-     */
-    peerLeft: (peer: Peer<P, S>) => void;
-    /**
-     * Called each time peer has its metadata updated.
-     */
-    peerUpdated: (peer: Peer<P, S>) => void;
-    /**
-     * Called each time new peer joins the room.
-     */
-    componentAdded: (peer: Component) => void;
-    /**
-     * Called each time peer leaves the room.
-     */
-    componentRemoved: (peer: Component) => void;
-    /**
-     * Called each time peer has its metadata updated.
-     */
-    componentUpdated: (peer: Component) => void;
-    /**
-     * Called in case of errors related to multimedia session e.g. ICE connection.
-     */
-    connectionError: (error: {
-        message: string;
-        event?: Event;
-    }) => void;
-    /**
-     * Currently, this callback is only invoked when DisplayManager in RTC Engine is
-     * enabled and simulcast is disabled.
-     *
-     * Called when priority of video tracks have changed.
-     * @param enabledTracks - list of tracks which will be sent to client from SFU
-     * @param disabledTracks - list of tracks which will not be sent to client from SFU
-     */
-    tracksPriorityChanged: (enabledTracks: FishjamTrackContext[], disabledTracks: FishjamTrackContext[]) => void;
-    /**
-     * Called every time the server estimates client's bandiwdth.
-     *
-     * @param {bigint} estimation - client's available incoming bitrate estimated
-     * by the server. It's measured in bits per second.
-     */
-    bandwidthEstimationChanged: (estimation: bigint) => void;
-    targetTrackEncodingRequested: (event: Parameters<WebRTCEndpointEvents['targetTrackEncodingRequested']>[0]) => void;
-    localTrackAdded: (event: Parameters<WebRTCEndpointEvents['localTrackAdded']>[0]) => void;
-    localTrackRemoved: (event: Parameters<WebRTCEndpointEvents['localTrackRemoved']>[0]) => void;
-    localTrackReplaced: (event: Parameters<WebRTCEndpointEvents['localTrackReplaced']>[0]) => void;
-    localTrackMuted: (event: Parameters<WebRTCEndpointEvents['localTrackMuted']>[0]) => void;
-    localTrackUnmuted: (event: Parameters<WebRTCEndpointEvents['localTrackUnmuted']>[0]) => void;
-    localTrackBandwidthSet: (event: Parameters<WebRTCEndpointEvents['localTrackBandwidthSet']>[0]) => void;
-    localTrackEncodingBandwidthSet: (event: Parameters<WebRTCEndpointEvents['localTrackEncodingBandwidthSet']>[0]) => void;
-    localTrackEncodingEnabled: (event: Parameters<WebRTCEndpointEvents['localTrackEncodingEnabled']>[0]) => void;
-    localTrackEncodingDisabled: (event: Parameters<WebRTCEndpointEvents['localTrackEncodingDisabled']>[0]) => void;
-    localPeerMetadataChanged: (event: Parameters<WebRTCEndpointEvents['localEndpointMetadataChanged']>[0]) => void;
-    localTrackMetadataChanged: (event: Parameters<WebRTCEndpointEvents['localTrackMetadataChanged']>[0]) => void;
-    disconnectRequested: (event: Parameters<WebRTCEndpointEvents['disconnectRequested']>[0]) => void;
-};
-/** Configuration object for the client */
-interface ConnectConfig<PeerMetadata> {
-    /** Metadata for the peer */
-    peerMetadata: PeerMetadata;
-    /** Token for authentication */
-    token: string;
-    /** Fishjam url */
-    url: string;
-}
-type CreateConfig = {
-    reconnect?: ReconnectConfig | boolean;
-};
-
 export { AUTH_ERROR_REASONS, type AuthErrorReason, type BandwidthLimit, type Component, type ConnectConfig, type CreateConfig, type EncodingReason, type Endpoint, FishjamClient, type FishjamTrackContext, type GenericMetadata, type MediaEvent, type MessageEvents, type Metadata, type Peer, type ReconnectConfig, type ReconnectionStatus, type SerializedMediaEvent, type SimulcastBandwidthLimit, MediaEvent_Track_SimulcastConfig as SimulcastConfig, type TrackBandwidthLimit, type TrackContext, type TrackContextEvents$1 as TrackContextEvents, type TrackKind, type TrackMetadata, type VadStatus, Variant, WebRTCEndpoint, type WebRTCEndpointEvents, isAuthError };