@fishjam-cloud/ts-client 0.5.1

package/README.md

@@ -0,0 +1,134 @@
+[![NPM Version](https://img.shields.io/npm/v/@fishjam-cloud/ts-client)](https://www.npmjs.com/package/@fishjam-cloud/ts-client)
+[![TypeScript Strict](https://badgen.net/badge/TS/Strict)](https://www.typescriptlang.org)
+[![TypeDoc](https://img.shields.io/badge/TypeDoc-8A2BE2)](https://fishjam-cloud.github.io/web-client-sdk/)
+
+# Fishjam TS Client
+
+TypeScript client library for [Fishjam Cloud](https://cloud.fishjam.stream).
+
+## Installation
+
+You can install this package using `npm`:
+
+```bash
+npm install @fishjam-cloud/ts-client
+```
+
+or `yarn`:
+
+```bash
+yarn @fishjam-cloud/react-client
+```
+
+## Documentation
+
+Documentation is available
+[here](https://fishjam-cloud.github.io/web-client-sdk/modules/_fishjam_dev_ts_client.html/).
+
+For a more comprehensive tutorial on Fishjam, its capabilities and usage in
+production, refer to the [Fishjam Cloud Docs](https://cloud.fishjam.stream/).
+
+## Usage
+
+Prerequisites:
+
+- Account on Fishjam Cloud with App configured.
+- Created room and token of peer in that room. You can use Room Manager to
+  create room and peer token.
+
+The following code snippet is based on the
+[minimal](../../examples/ts-client//minimal/) example.
+
+```ts
+import { FishjamClient, WebRTCEndpoint } from '@fishjam-cloud/ts-client';
+
+const SCREEN_SHARING_MEDIA_CONSTRAINTS = {
+  video: {
+    frameRate: { ideal: 20, max: 25 },
+    width: { max: 1920, ideal: 1920 },
+    height: { max: 1080, ideal: 1080 },
+  },
+};
+
+// Example metadata types for peer and track
+// You can define your own metadata types, just make sure they are serializable
+type PeerMetadata = {
+  name: string;
+};
+
+type TrackMetadata = {
+  type: 'camera' | 'screen';
+};
+
+// Create a new FishjamClient object to interact with Fishjam
+const client = new FishjamClient<PeerMetadata, TrackMetadata>();
+
+const peerToken = prompt('Enter peer token') ?? 'YOUR_PEER_TOKEN';
+
+// Start the peer connection
+client.connect({
+  peerMetadata: { name: 'peer' },
+  token: peerToken,
+  // if the 'signaling' field is missing, the client will connect to ws://localhost:5002/socket/peer/websocket
+});
+
+// You can listen to events emitted by the client
+client.on('joined', (peerId, peersInRoom) => {
+  // Check if webrtc is initialized
+  if (!client.webrtc) return console.error('webrtc is not initialized');
+
+  // To start broadcasting your media, you will need a source of MediaStream like a camera, microphone, or screen
+  // In this example, we will use screen sharing
+  startScreenSharing(client.webrtc);
+});
+
+// To receive media from other peers, you need to listen to the onTrackReady event
+client.on('trackReady', (ctx) => {
+  const peerId = ctx.peer.id;
+
+  document.getElementById(peerId)?.remove(); // remove previous video element if it exists
+
+  // Create a new video element to display the media
+  const videoPlayer = document.createElement('video');
+  videoPlayer.id = peerId;
+  videoPlayer.oncanplaythrough = function () {
+    // Chrome blocks autoplay of unmuted video
+    videoPlayer.muted = true;
+    videoPlayer.play();
+  };
+  document.body.appendChild(videoPlayer);
+
+  videoPlayer.srcObject = ctx.stream; // assign MediaStream to video element
+});
+
+// Cleanup video element when track is removed
+client.on('trackRemoved', (ctx) => {
+  const peerId = ctx.peer.id;
+  document.getElementById(peerId)?.remove(); // remove video element
+});
+
+async function startScreenSharing(webrtc: WebRTCEndpoint) {
+  // Get screen sharing MediaStream
+  const screenStream = await navigator.mediaDevices.getDisplayMedia(
+    SCREEN_SHARING_MEDIA_CONSTRAINTS,
+  );
+
+  // Add local MediaStream to webrtc
+  screenStream
+    .getTracks()
+    .forEach((track) => webrtc.addTrack(track, { type: 'screen' }));
+}
+```
+
+## Examples
+
+For more examples, see the [examples](../../examples/ts-client/) folder.
+
+## Copyright and License
+
+Copyright 2024,
+[Software Mansion](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=fishjam-ts)
+
+[![Software Mansion](https://logo.swmansion.com/logo?color=white&variant=desktop&width=200&tag=fishjam-github)](https://swmansion.com/?utm_source=git&utm_medium=readme&utm_campaign=fishjam-ts)
+
+Licensed under the [Apache License, Version 2.0](LICENSE)

package/dist/src/FishjamClient.d.ts

@@ -0,0 +1,523 @@
+import type { BandwidthLimit, Endpoint, SimulcastConfig, TrackBandwidthLimit, TrackContext, Encoding, MetadataParser, WebRTCEndpointEvents } from './webrtc';
+import type TypedEmitter from 'typed-emitter';
+import type { ReconnectConfig } from './reconnection';
+import type { AuthErrorReason } from './auth';
+export type Peer<PeerMetadata, TrackMetadata> = Endpoint<PeerMetadata, TrackMetadata> & {
+    type: 'webrtc';
+};
+export type Component<PeerMetadata, TrackMetadata> = Omit<Endpoint<PeerMetadata, TrackMetadata>, 'type'> & {
+    type: 'recording' | 'hls' | 'file' | 'rtsp' | 'sip';
+};
+/**
+ * Events emitted by the client with their arguments.
+ */
+export interface MessageEvents<PeerMetadata, TrackMetadata> {
+    /**
+     * 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<PeerMetadata, TrackMetadata>[], components: Component<PeerMetadata, TrackMetadata>[]) => 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: TrackContext<PeerMetadata, TrackMetadata>) => 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: TrackContext<PeerMetadata, TrackMetadata>) => 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: TrackContext<PeerMetadata, TrackMetadata>) => void;
+    /**
+     * Called each time peer has its track metadata updated.
+     */
+    trackUpdated: (ctx: TrackContext<PeerMetadata, TrackMetadata>) => void;
+    /**
+     * Called each time new peer joins the room.
+     */
+    peerJoined: (peer: Peer<PeerMetadata, TrackMetadata>) => void;
+    /**
+     * Called each time peer leaves the room.
+     */
+    peerLeft: (peer: Peer<PeerMetadata, TrackMetadata>) => void;
+    /**
+     * Called each time peer has its metadata updated.
+     */
+    peerUpdated: (peer: Peer<PeerMetadata, TrackMetadata>) => void;
+    /**
+     * Called each time new peer joins the room.
+     */
+    componentAdded: (peer: Component<PeerMetadata, TrackMetadata>) => void;
+    /**
+     * Called each time peer leaves the room.
+     */
+    componentRemoved: (peer: Component<PeerMetadata, TrackMetadata>) => void;
+    /**
+     * Called each time peer has its metadata updated.
+     */
+    componentUpdated: (peer: Component<PeerMetadata, TrackMetadata>) => 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: TrackContext<PeerMetadata, TrackMetadata>[], disabledTracks: TrackContext<PeerMetadata, TrackMetadata>[]) => 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<PeerMetadata, TrackMetadata>['targetTrackEncodingRequested']>[0]) => void;
+    localTrackAdded: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackAdded']>[0]) => void;
+    localTrackRemoved: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackRemoved']>[0]) => void;
+    localTrackReplaced: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackReplaced']>[0]) => void;
+    localTrackMuted: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackMuted']>[0]) => void;
+    localTrackUnmuted: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackUnmuted']>[0]) => void;
+    localTrackBandwidthSet: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackBandwidthSet']>[0]) => void;
+    localTrackEncodingBandwidthSet: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackEncodingBandwidthSet']>[0]) => void;
+    localTrackEncodingEnabled: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackEncodingEnabled']>[0]) => void;
+    localTrackEncodingDisabled: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackEncodingDisabled']>[0]) => void;
+    localPeerMetadataChanged: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localEndpointMetadataChanged']>[0]) => void;
+    localTrackMetadataChanged: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['localTrackMetadataChanged']>[0]) => void;
+    disconnectRequested: (event: Parameters<WebRTCEndpointEvents<PeerMetadata, TrackMetadata>['disconnectRequested']>[0]) => void;
+}
+export type SignalingUrl = {
+    /**
+     * Protocol of the websocket server
+     * Default is `"ws"`
+     */
+    protocol?: string;
+    /**
+     * Host of the websocket server
+     * Default is `"localhost:5002"`
+     */
+    host?: string;
+    /**
+     * Path of the websocket server
+     * Default is `"/socket/peer/websocket"`
+     */
+    path?: string;
+};
+/** Configuration object for the client */
+export interface ConnectConfig<PeerMetadata> {
+    /** Metadata for the peer */
+    peerMetadata: PeerMetadata;
+    /** Token for authentication */
+    token: string;
+    signaling?: SignalingUrl;
+}
+export type CreateConfig<PeerMetadata, TrackMetadata> = {
+    peerMetadataParser?: MetadataParser<PeerMetadata>;
+    trackMetadataParser?: MetadataParser<TrackMetadata>;
+    reconnect?: ReconnectConfig | boolean;
+};
+declare const FishjamClient_base: new <PeerMetadata_1, TrackMetadata_1>() => TypedEmitter<Required<MessageEvents<PeerMetadata_1, TrackMetadata_1>>>;
+/**
+ * FishjamClient is the main class to interact with Fishjam.
+ *
+ * @example
+ * ```typescript
+ * const client = new FishjamClient<PeerMetadata, TrackMetadata>();
+ * const peerToken = "YOUR_PEER_TOKEN";
+ *
+ * // You can listen to events emitted by the client
+ * client.on("joined", (peerId, peersInRoom) => {
+ *  console.log("join success");
+ * });
+ *
+ * // Start the peer connection
+ * client.connect({
+ *  peerMetadata: {},
+ *  isSimulcastOn: false,
+ *  token: peerToken
+ * });
+ *
+ * // Close the peer connection
+ * client.disconnect();
+ * ```
+ *
+ * You can register callbacks to handle the events emitted by the Client.
+ *
+ * @example
+ * ```typescript
+ *
+ * client.on("trackReady", (ctx) => {
+ *  console.log("On track ready");
+ * });
+ * ```
+ */
+export declare class FishjamClient<PeerMetadata, TrackMetadata> extends FishjamClient_base<PeerMetadata, TrackMetadata> {
+    private websocket;
+    private webrtc;
+    private removeEventListeners;
+    status: 'new' | 'initialized';
+    private connectConfig;
+    private reconnectManager;
+    private sendStatisticsInterval;
+    private readonly peerMetadataParser;
+    private readonly trackMetadataParser;
+    constructor(config?: CreateConfig<PeerMetadata, TrackMetadata>);
+    /**
+     * Uses the {@link !WebSocket} connection and {@link !WebRTCEndpoint | WebRTCEndpoint} to join to the room. Registers the callbacks to
+     * handle the events emitted by the {@link !WebRTCEndpoint | WebRTCEndpoint}. Make sure that peer metadata is serializable.
+     *
+     * @example
+     * ```typescript
+     * const client = new FishjamClient<PeerMetadata, TrackMetadata>();
+     *
+     * client.connect({
+     *  peerMetadata: {},
+     *  token: peerToken
+     * });
+     * ```
+     *
+     * @param {ConnectConfig} config - Configuration object for the client
+     */
+    connect(config: ConnectConfig<PeerMetadata>): void;
+    private initConnection;
+    private initWebsocket;
+    /**
+     * Retrieves statistics related to the RTCPeerConnection.
+     * These statistics provide insights into the performance and status of the connection.
+     *
+     * @return {Promise<RTCStatsReport>}
+     *
+     * @external RTCPeerConnection#getStats()
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/getStats | MDN Web Docs: RTCPeerConnection.getStats()}
+     */
+    getStatistics(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
+    /**
+     * Returns a snapshot of currently received remote tracks.
+     *
+     * @example
+     * if (client.getRemoteTracks()[trackId]?.simulcastConfig?.enabled) {
+     *   client.setTargetTrackEncoding(trackId, encoding);
+     * }
+     */
+    getRemoteTracks(): Readonly<Record<string, TrackContext<PeerMetadata, TrackMetadata>>>;
+    /**
+     * Returns a snapshot of currently received remote peers.
+     */
+    getRemotePeers(): Record<string, Peer<PeerMetadata, TrackMetadata>>;
+    getRemoteComponents(): Record<string, Component<PeerMetadata, TrackMetadata>>;
+    getLocalPeer(): Endpoint<PeerMetadata, TrackMetadata> | null;
+    getBandwidthEstimation(): bigint;
+    private setupCallbacks;
+    private sendStatistics;
+    /**
+     * Register a callback to be called when the event is emitted.
+     * Full list of callbacks can be found here {@link MessageEvents}.
+     *
+     * @example
+     * ```ts
+     * const callback = ()=>{  };
+     *
+     * client.on("onJoinSuccess", callback);
+     * ```
+     *
+     * @param event - Event name from {@link MessageEvents}
+     * @param listener - Callback function to be called when the event is emitted
+     * @returns This
+     */
+    on<E extends keyof MessageEvents<PeerMetadata, TrackMetadata>>(event: E, listener: Required<MessageEvents<PeerMetadata, TrackMetadata>>[E]): this;
+    /**
+     * Remove a callback from the list of callbacks to be called when the event is emitted.
+     *
+     * @example
+     * ```ts
+     * const callback = ()=>{  };
+     *
+     * client.on("onJoinSuccess", callback);
+     *
+     * client.off("onJoinSuccess", callback);
+     * ```
+     *
+     * @param event - Event name from {@link MessageEvents}
+     * @param listener - Reference to function to be removed from called callbacks
+     * @returns This
+     */
+    off<E extends keyof MessageEvents<PeerMetadata, TrackMetadata>>(event: E, listener: Required<MessageEvents<PeerMetadata, TrackMetadata>>[E]): this;
+    private handleWebRTCNotInitialized;
+    /**
+     * Adds track that will be sent to the RTC Engine.
+     *
+     * @example
+     * ```ts
+     * const localStream: MediaStream = new MediaStream();
+     * try {
+     *   const localAudioStream = await navigator.mediaDevices.getUserMedia(
+     *     { audio: true }
+     *   );
+     *   localAudioStream
+     *     .getTracks()
+     *     .forEach((track) => localStream.addTrack(track));
+     * } catch (error) {
+     *   console.error("Couldn't get microphone permission:", error);
+     * }
+     *
+     * try {
+     *   const localVideoStream = await navigator.mediaDevices.getUserMedia(
+     *     { video: true }
+     *   );
+     *   localVideoStream
+     *     .getTracks()
+     *     .forEach((track) => localStream.addTrack(track));
+     * } catch (error) {
+     *  console.error("Couldn't get camera permission:", error);
+     * }
+     *
+     * localStream
+     *  .getTracks()
+     *  .forEach((track) => client.addTrack(track, localStream));
+     * ```
+     *
+     * @param track - Audio or video track e.g. from your microphone or camera.
+     * @param stream - Stream that this track belongs to.
+     * @param trackMetadata - Any information about this track that other peers will receive in
+     * {@link MessageEvents.peerJoined}. E.g. this can source of the track - wheather it's screensharing, webcam or some
+     * other media device.
+     * @param simulcastConfig - Simulcast configuration. By default, simulcast is disabled. For more information refer to
+     * {@link !SimulcastConfig | SimulcastConfig}.
+     * @param maxBandwidth - Maximal bandwidth this track can use. Defaults to 0 which is unlimited. This option has no
+     * effect for simulcast and audio tracks. For simulcast tracks use {@link FishjamClient.setTrackBandwidth}.
+     * @returns {string} Returns id of added track
+     */
+    addTrack(track: MediaStreamTrack, trackMetadata?: TrackMetadata, simulcastConfig?: SimulcastConfig, maxBandwidth?: TrackBandwidthLimit): Promise<string>;
+    /**
+     * Replaces a track that is being sent to the RTC Engine.
+     *
+     * @example
+     * ```ts
+     * // setup camera
+     * let localStream: MediaStream = new MediaStream();
+     * try {
+     *   localVideoStream = await navigator.mediaDevices.getUserMedia(
+     *     VIDEO_CONSTRAINTS
+     *   );
+     *   localVideoStream
+     *     .getTracks()
+     *     .forEach((track) => localStream.addTrack(track));
+     * } catch (error) {
+     *   console.error("Couldn't get camera permission:", error);
+     * }
+     * let oldTrackId;
+     * localStream
+     *  .getTracks()
+     *  .forEach((track) => trackId = webrtc.addTrack(track, localStream));
+     *
+     * // change camera
+     * const oldTrack = localStream.getVideoTracks()[0];
+     * let videoDeviceId = "abcd-1234";
+     * navigator.mediaDevices.getUserMedia({
+     *      video: {
+     *        ...(VIDEO_CONSTRAINTS as {}),
+     *        deviceId: {
+     *          exact: videoDeviceId,
+     *        },
+     *      }
+     *   })
+     *   .then((stream) => {
+     *     let videoTrack = stream.getVideoTracks()[0];
+     *     webrtc.replaceTrack(oldTrackId, videoTrack);
+     *   })
+     *   .catch((error) => {
+     *     console.error('Error switching camera', error);
+     *   })
+     * ```
+     *
+     * @param {string} trackId - Id of audio or video track to replace.
+     * @param {MediaStreamTrack} newTrack - New audio or video track.
+     * @param {TrackMetadata} [newTrackMetadata] - Optional track metadata to apply to the new track. If no track metadata is passed, the
+     * old track metadata is retained.
+     * @returns {Promise<boolean>} Success
+     */
+    replaceTrack(trackId: string, newTrack: MediaStreamTrack | null, newTrackMetadata?: TrackMetadata): Promise<void>;
+    /**
+     * Updates maximum bandwidth for the track identified by trackId. This value directly translates to quality of the
+     * stream and, in case of video, to the amount of RTP packets being sent. In case trackId points at the simulcast
+     * track bandwidth is split between all of the variant streams proportionally to their resolution.
+     *
+     * @param {string} trackId
+     * @param {BandwidthLimit} bandwidth In kbps
+     * @returns {Promise<boolean>} Success
+     */
+    setTrackBandwidth(trackId: string, bandwidth: BandwidthLimit): Promise<boolean>;
+    /**
+     * Updates maximum bandwidth for the given simulcast encoding of the given track.
+     *
+     * @param {string} trackId - Id of the track
+     * @param {string} rid - Rid of the encoding
+     * @param {BandwidthLimit} bandwidth - Desired max bandwidth used by the encoding (in kbps)
+     * @returns
+     */
+    setEncodingBandwidth(trackId: string, rid: string, bandwidth: BandwidthLimit): Promise<boolean>;
+    /**
+     * Removes a track from connection that was being sent to the RTC Engine.
+     *
+     * @example
+     * ```ts
+     * // setup camera
+     * let localStream: MediaStream = new MediaStream();
+     * try {
+     *   localVideoStream = await navigator.mediaDevices.getUserMedia(
+     *     VIDEO_CONSTRAINTS
+     *   );
+     *   localVideoStream
+     *     .getTracks()
+     *     .forEach((track) => localStream.addTrack(track));
+     * } catch (error) {
+     *   console.error("Couldn't get camera permission:", error);
+     * }
+     *
+     * let trackId
+     * localStream
+     *  .getTracks()
+     *  .forEach((track) => trackId = webrtc.addTrack(track, localStream));
+     *
+     * // remove track
+     * webrtc.removeTrack(trackId)
+     * ```
+     *
+     * @param {string} trackId - Id of audio or video track to remove.
+     */
+    removeTrack(trackId: string): Promise<void>;
+    /**
+     * Sets track encoding that server should send to the client library.
+     *
+     * The encoding will be sent whenever it is available. If chosen encoding is temporarily unavailable, some other
+     * encoding will be sent until chosen encoding becomes active again.
+     *
+     * @example
+     * ```ts
+     * webrtc.setTargetTrackEncoding(incomingTrackCtx.trackId, "l")
+     * ```
+     *
+     * @param {string} trackId - Id of track
+     * @param {Encoding} encoding - Encoding to receive
+     */
+    setTargetTrackEncoding(trackId: string, encoding: Encoding): void;
+    /**
+     * Enables track encoding so that it will be sent to the server.
+     *
+     * @example
+     * ```ts
+     * const trackId = webrtc.addTrack(track, stream, {}, {enabled: true, active_encodings: ["l", "m", "h"]});
+     * webrtc.disableTrackEncoding(trackId, "l");
+     * // wait some time
+     * webrtc.enableTrackEncoding(trackId, "l");
+     * ```
+     *
+     * @param {string} trackId - Id of track
+     * @param {Encoding} encoding - Encoding that will be enabled
+     */
+    enableTrackEncoding(trackId: string, encoding: Encoding): Promise<void>;
+    /**
+     * Disables track encoding so that it will be no longer sent to the server.
+     *
+     * @example
+     * ```ts
+     * const trackId = webrtc.addTrack(track, stream, {}, {enabled: true, active_encodings: ["l", "m", "h"]});
+     * webrtc.disableTrackEncoding(trackId, "l");
+     * ```
+     *
+     * @param {string} trackId - Id of track
+     * @param {rackEncoding} encoding - Encoding that will be disabled
+     */
+    disableTrackEncoding(trackId: string, encoding: Encoding): Promise<void>;
+    /**
+     * Updates the metadata for the current peer.
+     *
+     * @param peerMetadata - Data about this peer that other peers will receive upon joining.
+     *
+     * If the metadata is different from what is already tracked in the room, the event {@link MessageEvents.peerUpdated} will
+     * be emitted for other peers in the room.
+     */
+    updatePeerMetadata: (peerMetadata: PeerMetadata) => void;
+    /**
+     * Updates the metadata for a specific track.
+     *
+     * @param trackId - TrackId (generated in addTrack) of audio or video track.
+     * @param trackMetadata - Data about this track that other peers will receive upon joining.
+     *
+     * If the metadata is different from what is already tracked in the room, the event {@link MessageEvents.trackUpdated} will
+     * be emitted for other peers in the room.
+     */
+    updateTrackMetadata: (trackId: string, trackMetadata: TrackMetadata) => void;
+    isReconnecting(): boolean;
+    /**
+     * Leaves the room. This function should be called when user leaves the room in a clean way e.g. by clicking a
+     * dedicated, custom button `disconnect`. As a result there will be generated one more media event that should be sent
+     * to the RTC Engine. Thanks to it each other peer will be notified that peer left in {@link MessageEvents.peerLeft},
+     */
+    leave: () => void;
+    private isOpen;
+    /**
+     * Disconnect from the room, and close the websocket connection. Tries to leave the room gracefully, but if it fails,
+     * it will close the websocket anyway.
+     *
+     * @example
+     * ```typescript
+     * const client = new FishjamClient<PeerMetadata, TrackMetadata>();
+     *
+     * client.connect({ ... });
+     *
+     * client.disconnect();
+     * ```
+     */
+    disconnect(): void;
+    cleanup(): void;
+}
+export {};