@fishjam-cloud/ts-client 0.25.1 → 0.25.2

package/dist/ts-client/src/auth.d.ts

@@ -0,0 +1,3 @@
+export declare const AUTH_ERROR_REASONS: readonly ["missing token", "invalid token", "expired token", "room not found", "peer not found"];
+export type AuthErrorReason = (typeof AUTH_ERROR_REASONS)[number];
+export declare const isAuthError: (error: string) => error is AuthErrorReason;

package/dist/ts-client/src/auth.js

@@ -0,0 +1,8 @@
+export const AUTH_ERROR_REASONS = [
+    'missing token',
+    'invalid token',
+    'expired token',
+    'room not found',
+    'peer not found',
+];
+export const isAuthError = (error) => AUTH_ERROR_REASONS.includes(error);

package/dist/ts-client/src/connectEventsHandler.d.ts

@@ -0,0 +1,2 @@
+import type { FishjamClient } from './FishjamClient';
+export declare function connectEventsHandler<P, S>(fishjamClient: FishjamClient<P, S>): Promise<void>;

package/dist/ts-client/src/connectEventsHandler.js

@@ -0,0 +1,22 @@
+export function connectEventsHandler(fishjamClient) {
+    return new Promise((resolve, reject) => {
+        const onSuccess = () => {
+            clearCallbacks();
+            resolve();
+        };
+        const onError = () => {
+            clearCallbacks();
+            reject();
+        };
+        fishjamClient.on('joined', onSuccess);
+        fishjamClient.on('joinError', onError);
+        fishjamClient.on('authError', onError);
+        fishjamClient.on('socketError', onError);
+        const clearCallbacks = () => {
+            fishjamClient.removeListener('joined', onSuccess);
+            fishjamClient.removeListener('joinError', onError);
+            fishjamClient.removeListener('authError', onError);
+            fishjamClient.removeListener('socketError', onError);
+        };
+    });
+}

package/dist/ts-client/src/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class TrackTypeError extends Error {
+    constructor();
+}

package/dist/ts-client/src/errors.js

@@ -0,0 +1,5 @@
+export class TrackTypeError extends Error {
+    constructor() {
+        super(`Attempted to add video track to audio-only room. Please refer to the docs at https://docs.fishjam.io/audio-calls`);
+    }
+}

package/dist/ts-client/src/guards.d.ts

@@ -0,0 +1,7 @@
+import type { Endpoint } from '@fishjam-cloud/webrtc-client';
+import type { Component, Peer } from './types';
+export declare const isPeer: <PeerMetadata, TrackMetadata>(endpoint: Endpoint) => endpoint is Peer<PeerMetadata, TrackMetadata>;
+export declare const isComponent: (endpoint: Endpoint) => endpoint is Component;
+export declare const JOIN_ERRORS: readonly ["reached peers limit", "room not found", "node not found", "Invalid SDK version"];
+export type JoinErrorReason = (typeof JOIN_ERRORS)[number];
+export declare const isJoinError: (error: string) => error is JoinErrorReason;

package/dist/ts-client/src/guards.js

@@ -0,0 +1,8 @@
+export const isPeer = (endpoint) => endpoint.type === 'webrtc' || endpoint.type === 'exwebrtc';
+export const isComponent = (endpoint) => endpoint.type === 'recording' ||
+    endpoint.type === 'hls' ||
+    endpoint.type === 'file' ||
+    endpoint.type === 'rtsp' ||
+    endpoint.type === 'sip';
+export const JOIN_ERRORS = ['reached peers limit', 'room not found', 'node not found', 'Invalid SDK version'];
+export const isJoinError = (error) => JOIN_ERRORS.some((knownError) => error.trim().toLowerCase().includes(knownError.trim().toLowerCase()));

package/dist/ts-client/src/index.d.ts

@@ -0,0 +1,9 @@
+export { AUTH_ERROR_REASONS, type AuthErrorReason, isAuthError } from './auth';
+export { TrackTypeError } from './errors';
+export { FishjamClient } from './FishjamClient';
+export { isJoinError, JOIN_ERRORS, type JoinErrorReason } from './guards';
+export { type LivestreamCallbacks, LivestreamError, publishLivestream, type PublishLivestreamResult, receiveLivestream, type ReceiveLivestreamResult, } from './livestream';
+export type { ReconnectConfig, ReconnectionStatus } from './reconnection';
+export type { ClientType, Component, ConnectConfig, CreateConfig, FishjamTrackContext, GenericMetadata, MessageEvents, Metadata, Peer, TrackContextEvents, TrackMetadata, } from './types';
+export type { BandwidthLimit, DataCallback, DataChannelOptions, EncodingReason, Endpoint, Logger, SimulcastBandwidthLimit, SimulcastConfig, TrackBandwidthLimit, TrackContext, VadStatus, WebRTCEndpointEvents, } from '@fishjam-cloud/webrtc-client';
+export * from '@fishjam-cloud/webrtc-client';

package/dist/ts-client/src/index.js

@@ -0,0 +1,6 @@
+export { AUTH_ERROR_REASONS, isAuthError } from './auth';
+export { TrackTypeError } from './errors';
+export { FishjamClient } from './FishjamClient';
+export { isJoinError, JOIN_ERRORS } from './guards';
+export { LivestreamError, publishLivestream, receiveLivestream, } from './livestream';
+export * from '@fishjam-cloud/webrtc-client';

package/dist/ts-client/src/livestream.d.ts

@@ -0,0 +1,20 @@
+export type ReceiveLivestreamResult = {
+    stream: MediaStream;
+    stop: () => Promise<void>;
+    getStatistics: () => Promise<RTCStatsReport>;
+};
+export type PublishLivestreamResult = {
+    stopPublishing: () => Promise<void>;
+    getStatistics: () => Promise<RTCStatsReport>;
+};
+export declare enum LivestreamError {
+    UNAUTHORIZED = "unauthorized",
+    STREAM_NOT_FOUND = "stream_not_found",
+    UNKNOWN_ERROR = "unknown_error",
+    STREAMER_ALREADY_CONNECTED = "streamer_already_connected"
+}
+export type LivestreamCallbacks = {
+    onConnectionStateChange?: (pc: RTCPeerConnection) => void;
+};
+export declare function receiveLivestream(url: string, token?: string, callbacks?: LivestreamCallbacks): Promise<ReceiveLivestreamResult>;
+export declare function publishLivestream(stream: MediaStream, url: string, token: string, callbacks?: LivestreamCallbacks): Promise<PublishLivestreamResult>;

package/dist/ts-client/src/livestream.js

@@ -0,0 +1,78 @@
+export var LivestreamError;
+(function (LivestreamError) {
+    LivestreamError["UNAUTHORIZED"] = "unauthorized";
+    LivestreamError["STREAM_NOT_FOUND"] = "stream_not_found";
+    LivestreamError["UNKNOWN_ERROR"] = "unknown_error";
+    LivestreamError["STREAMER_ALREADY_CONNECTED"] = "streamer_already_connected";
+})(LivestreamError || (LivestreamError = {}));
+export async function receiveLivestream(url, token, callbacks) {
+    const pc = new RTCPeerConnection({ bundlePolicy: 'max-bundle' });
+    pc.addTransceiver('video', { direction: 'recvonly' });
+    pc.addTransceiver('audio', { direction: 'recvonly' });
+    pc.onconnectionstatechange = (_ev) => callbacks?.onConnectionStateChange?.(pc);
+    const { WHEPClient } = await import('@binbat/whip-whep/whep');
+    const whep = new WHEPClient();
+    return new Promise((resolve, reject) => {
+        pc.ontrack = (event) => {
+            const stream = event.streams[0];
+            if (stream) {
+                resolve({
+                    getStatistics: () => pc.getStats(),
+                    stream,
+                    stop: async () => {
+                        await whep.stop();
+                        callbacks?.onConnectionStateChange?.(pc);
+                    },
+                });
+            }
+        };
+        whep.view(pc, url, token).catch((e) => {
+            if (e instanceof Error) {
+                let error = LivestreamError.UNKNOWN_ERROR;
+                if (e.message.includes('401')) {
+                    error = LivestreamError.UNAUTHORIZED;
+                }
+                else if (e.message.includes('404')) {
+                    error = LivestreamError.STREAM_NOT_FOUND;
+                }
+                reject(error);
+            }
+        });
+    });
+}
+export async function publishLivestream(stream, url, token, callbacks) {
+    const pc = new RTCPeerConnection({ bundlePolicy: 'max-bundle' });
+    pc.onconnectionstatechange = (_ev) => callbacks?.onConnectionStateChange?.(pc);
+    const video = stream.getVideoTracks().at(0);
+    const audio = stream.getAudioTracks().at(0);
+    if (!video && !audio) {
+        throw Error('To publish a livestream with WHIP, you need to supply at least one video or audio track.');
+    }
+    if (video)
+        pc.addTransceiver(video, { direction: 'sendonly' });
+    if (audio)
+        pc.addTransceiver(audio, { direction: 'sendonly' });
+    const { WHIPClient } = await import('@binbat/whip-whep/whip');
+    const whip = new WHIPClient();
+    try {
+        await whip.publish(pc, url, token);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            if (e.message.includes('401'))
+                throw LivestreamError.UNAUTHORIZED;
+            if (e.message.includes('404'))
+                throw LivestreamError.STREAM_NOT_FOUND;
+            if (e.message.includes('409'))
+                throw LivestreamError.STREAMER_ALREADY_CONNECTED;
+        }
+        throw LivestreamError.UNKNOWN_ERROR;
+    }
+    return {
+        getStatistics: () => pc.getStats(),
+        stopPublishing: async () => {
+            await whip.stop();
+            callbacks?.onConnectionStateChange?.(pc);
+        },
+    };
+}

package/dist/ts-client/src/messageQueue.d.ts

@@ -0,0 +1,13 @@
+type MessageQueueParams = {
+    checkIsReconnecting: () => boolean;
+    sendMessage: (message: Uint8Array) => void;
+};
+export declare class MessageQueue {
+    private queuedMessages;
+    private checkIsReconnecting;
+    private sendMessage;
+    constructor({ checkIsReconnecting, sendMessage }: MessageQueueParams);
+    enqueueMessage(mediaEvent: Uint8Array): void;
+    attemptToSendAll(): void;
+}
+export {};

package/dist/ts-client/src/messageQueue.js

@@ -0,0 +1,23 @@
+export class MessageQueue {
+    queuedMessages = [];
+    checkIsReconnecting;
+    sendMessage;
+    constructor({ checkIsReconnecting, sendMessage }) {
+        this.checkIsReconnecting = checkIsReconnecting;
+        this.sendMessage = sendMessage;
+    }
+    enqueueMessage(mediaEvent) {
+        this.queuedMessages.push(mediaEvent);
+        this.attemptToSendAll();
+    }
+    attemptToSendAll() {
+        const isReconnecting = this.checkIsReconnecting();
+        if (isReconnecting)
+            return;
+        while (this.queuedMessages.length > 0) {
+            const oldestMessage = this.queuedMessages.shift();
+            if (oldestMessage)
+                this.sendMessage(oldestMessage);
+        }
+    }
+}

package/dist/ts-client/src/reconnection.d.ts

@@ -0,0 +1,27 @@
+import type { FishjamClient } from './FishjamClient';
+export type ReconnectionStatus = 'reconnecting' | 'idle' | 'error';
+export type ReconnectConfig = {
+    maxAttempts?: number;
+    initialDelay?: number;
+    delay?: number;
+    addTracksOnReconnect?: boolean;
+};
+export declare class ReconnectManager<PeerMetadata, ServerMetadata> {
+    private readonly reconnectConfig;
+    private readonly connect;
+    private readonly client;
+    private initialPeerMetadata;
+    private reconnectAttempt;
+    private reconnectTimeoutId;
+    private status;
+    private lastLocalEndpoint;
+    private removeEventListeners;
+    constructor(client: FishjamClient<PeerMetadata, ServerMetadata>, connect: (metadata: PeerMetadata) => Promise<void>, config?: ReconnectConfig | boolean);
+    isReconnecting(): boolean;
+    reset(initialPeerMetadata: PeerMetadata): void;
+    private getLastPeerMetadata;
+    private reconnect;
+    handleReconnect(): Promise<void>;
+    cleanup(): void;
+}
+export declare const createReconnectConfig: (config?: ReconnectConfig | boolean) => Required<ReconnectConfig>;

package/dist/ts-client/src/reconnection.js

@@ -0,0 +1,124 @@
+import { isAuthError } from './auth';
+import { isJoinError } from './guards';
+const DISABLED_RECONNECT_CONFIG = {
+    maxAttempts: 0,
+    initialDelay: 0,
+    delay: 0,
+    addTracksOnReconnect: false,
+};
+const DEFAULT_RECONNECT_CONFIG = {
+    maxAttempts: 3,
+    initialDelay: 500,
+    delay: 500,
+    addTracksOnReconnect: false,
+};
+export class ReconnectManager {
+    reconnectConfig;
+    connect;
+    client;
+    initialPeerMetadata = undefined;
+    reconnectAttempt = 0;
+    reconnectTimeoutId = null;
+    status = 'idle';
+    lastLocalEndpoint = null;
+    removeEventListeners = () => { };
+    constructor(client, connect, config) {
+        this.client = client;
+        this.connect = connect;
+        this.reconnectConfig = createReconnectConfig(config);
+        const onSocketError = () => {
+            this.reconnect();
+        };
+        this.client.on('socketError', onSocketError);
+        const onConnectionError = () => {
+            this.reconnect();
+        };
+        this.client.on('connectionError', onConnectionError);
+        const onSocketClose = (event) => {
+            if (isAuthError(event.reason))
+                return;
+            if (isJoinError(event.reason))
+                return;
+            this.reconnect();
+        };
+        this.client.on('socketClose', onSocketClose);
+        const onAuthSuccess = () => {
+            this.reset(this.initialPeerMetadata);
+        };
+        this.client.on('authSuccess', onAuthSuccess);
+        this.removeEventListeners = () => {
+            this.client.off('socketError', onSocketError);
+            this.client.off('connectionError', onConnectionError);
+            this.client.off('socketClose', onSocketClose);
+            this.client.off('authSuccess', onAuthSuccess);
+        };
+    }
+    isReconnecting() {
+        return this.status === 'reconnecting';
+    }
+    reset(initialPeerMetadata) {
+        this.initialPeerMetadata = initialPeerMetadata;
+        this.reconnectAttempt = 0;
+        if (this.reconnectTimeoutId)
+            clearTimeout(this.reconnectTimeoutId);
+        this.reconnectTimeoutId = null;
+    }
+    getLastPeerMetadata() {
+        const endpointMetadata = this.lastLocalEndpoint?.metadata;
+        return endpointMetadata?.peer;
+    }
+    reconnect() {
+        if (this.reconnectTimeoutId)
+            return;
+        if (this.reconnectAttempt >= this.reconnectConfig.maxAttempts) {
+            if (this.status === 'reconnecting') {
+                this.status = 'error';
+                this.client.emit('reconnectionRetriesLimitReached');
+            }
+            return;
+        }
+        if (this.status !== 'reconnecting') {
+            this.status = 'reconnecting';
+            this.client.emit('reconnectionStarted');
+            this.lastLocalEndpoint = this.client.getLocalPeer() || null;
+        }
+        const timeout = this.reconnectConfig.initialDelay + this.reconnectAttempt * this.reconnectConfig.delay;
+        this.reconnectAttempt += 1;
+        this.reconnectTimeoutId = setTimeout(() => {
+            this.reconnectTimeoutId = null;
+            const peerMetadata = this.getLastPeerMetadata() ?? this.initialPeerMetadata;
+            this.connect(peerMetadata);
+        }, timeout);
+    }
+    async handleReconnect() {
+        if (this.status !== 'reconnecting')
+            return;
+        if (this.lastLocalEndpoint && this.reconnectConfig.addTracksOnReconnect) {
+            for await (const element of this.lastLocalEndpoint.tracks) {
+                const [_, track] = element;
+                if (!track.track || track.track.readyState !== 'live')
+                    return;
+                await this.client.addTrack(track.track, track.metadata, track.simulcastConfig, track.maxBandwidth);
+            }
+        }
+        this.lastLocalEndpoint = null;
+        this.status = 'idle';
+        this.client.emit('reconnected');
+    }
+    cleanup() {
+        this.removeEventListeners();
+        this.removeEventListeners = () => { };
+    }
+}
+export const createReconnectConfig = (config) => {
+    if (!config)
+        return DISABLED_RECONNECT_CONFIG;
+    if (config === true)
+        return DEFAULT_RECONNECT_CONFIG;
+    return {
+        maxAttempts: config?.maxAttempts ?? DEFAULT_RECONNECT_CONFIG.maxAttempts,
+        initialDelay: config?.initialDelay ?? DEFAULT_RECONNECT_CONFIG.initialDelay,
+        delay: config?.delay ?? DEFAULT_RECONNECT_CONFIG.delay,
+        addTracksOnReconnect: config?.addTracksOnReconnect ?? DEFAULT_RECONNECT_CONFIG.addTracksOnReconnect,
+    };
+};

package/dist/ts-client/src/tests/messageQueue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ts-client/src/tests/messageQueue.test.js

@@ -0,0 +1,54 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { MessageQueue } from '../messageQueue';
+describe('Message queue tests', () => {
+    let isReconnecting = false;
+    beforeEach(() => {
+        isReconnecting = false;
+    });
+    const getQueueWithUtils = () => {
+        const sendMessage = vi.fn();
+        const queue = new MessageQueue({ sendMessage, checkIsReconnecting: () => isReconnecting });
+        const message1 = new Uint8Array([1, 2, 3]);
+        const message2 = new Uint8Array([4, 5, 6]);
+        return { sendMessage, queue, message1, message2 };
+    };
+    test('Queue dispatches messages while not reconnecting', () => {
+        const { queue, sendMessage, message1, message2 } = getQueueWithUtils();
+        queue.enqueueMessage(message1);
+        queue.enqueueMessage(message2);
+        expect(sendMessage).toHaveBeenCalledWith(message1);
+        expect(sendMessage).toHaveBeenCalledWith(message2);
+    });
+    test('Queue holds messages while reconnecting', () => {
+        const { queue, sendMessage, message1, message2 } = getQueueWithUtils();
+        isReconnecting = true;
+        queue.enqueueMessage(message1);
+        queue.enqueueMessage(message2);
+        expect(sendMessage).not.toHaveBeenCalled();
+    });
+    test('Queue dispatches all messages upon calling attemptToSendOut', async () => {
+        const { queue, sendMessage, message1, message2 } = getQueueWithUtils();
+        isReconnecting = true;
+        queue.enqueueMessage(message1);
+        queue.enqueueMessage(message2);
+        isReconnecting = false;
+        // attemptToSendOut not called yet
+        expect(sendMessage).not.toHaveBeenCalled();
+        queue.attemptToSendAll();
+        // all messages dispatched
+        expect(sendMessage).toHaveBeenCalledTimes(2);
+    });
+    test('Queue dispatches all messages upon enqueuing another event', async () => {
+        const { queue, sendMessage, message1, message2 } = getQueueWithUtils();
+        isReconnecting = true;
+        queue.enqueueMessage(message1);
+        queue.enqueueMessage(message2);
+        isReconnecting = false;
+        // no trigger to send out yet
+        expect(sendMessage).not.toHaveBeenCalled();
+        const anotherMessage = new Uint8Array([7, 8, 9]);
+        queue.enqueueMessage(anotherMessage);
+        // all messages dispatched
+        expect(sendMessage).toHaveBeenCalledTimes(3);
+    });
+});

package/dist/ts-client/src/types.d.ts

@@ -0,0 +1,216 @@
+import type { EncodingReason, Endpoint, SimulcastConfig, TrackBandwidthLimit, VadStatus, Variant, WebRTCEndpointEvents } from '@fishjam-cloud/webrtc-client';
+import type TypedEmitter from 'typed-emitter';
+import type { AuthErrorReason } from './auth';
+import type { JoinErrorReason } from './guards';
+import type { ReconnectConfig } from './reconnection';
+/**
+ * Metadata attached to a track published by a peer.
+ * Sent over the signaling channel so other peers know what kind of track they're receiving.
+ * @category Tracks
+ */
+export type TrackMetadata = {
+    /** The kind of media this track carries. */
+    type: 'camera' | 'microphone' | 'screenShareVideo' | 'screenShareAudio' | 'customVideo' | 'customAudio';
+    /** Whether the track is currently muted/disabled. */
+    paused: boolean;
+    /** The peer's display name, used in recordings. */
+    displayName?: string;
+};
+export 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.
+ */
+export type Metadata<PeerMetadata = GenericMetadata, ServerMetadata = GenericMetadata> = {
+    peer: PeerMetadata;
+    server: ServerMetadata;
+};
+export type TrackContextEvents = {
+    encodingChanged: (context: FishjamTrackContext) => void;
+    voiceActivityChanged: (context: FishjamTrackContext) => void;
+};
+export interface FishjamTrackContext extends TypedEmitter<TrackContextEvents> {
+    readonly track: MediaStreamTrack | null;
+    readonly stream: MediaStream | null;
+    readonly endpoint: Endpoint;
+    readonly trackId: string;
+    readonly simulcastConfig?: SimulcastConfig;
+    readonly metadata?: TrackMetadata;
+    readonly maxBandwidth?: TrackBandwidthLimit;
+    readonly vadStatus: VadStatus;
+    readonly encoding?: Variant;
+    readonly encodingReason?: EncodingReason;
+}
+export type Peer<PeerMetadata = GenericMetadata, ServerMetadata = GenericMetadata> = {
+    id: string;
+    type: string;
+    metadata?: Metadata<PeerMetadata, ServerMetadata>;
+    tracks: Map<string, FishjamTrackContext>;
+};
+export type Component = Omit<Endpoint, 'type'> & {
+    type: 'recording' | 'hls' | 'file' | 'rtsp' | 'sip';
+};
+/**
+ * Events emitted by the client with their arguments.
+ */
+export 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: JoinErrorReason | unknown) => 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 bandwidth.
+     *
+     * @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;
+    /**
+     * Emitted when data channel publishers (both reliable and lossy) are created and ready to send data.
+     */
+    dataChannelsReady: () => void;
+    /**
+     * Emitted when data channel publishers (both reliable or lossy) fail.
+     */
+    dataChannelsError: (error: Error) => void;
+};
+/**
+ * Represents the type of client used.
+ * @category Connection
+ */
+export type ClientType = 'web' | 'mobile';
+/** Configuration object for the client */
+export interface ConnectConfig<PeerMetadata> {
+    /** Metadata for the peer */
+    peerMetadata: PeerMetadata;
+    /** Token for authentication */
+    token: string;
+    /** Fishjam url */
+    url: string;
+}
+export type CreateConfig = {
+    reconnect?: ReconnectConfig | boolean;
+    /**
+     * Enables Fishjam SDK's debug logs in the console.
+     */
+    debug?: boolean;
+    /** Type of client used */
+    clientType?: ClientType;
+};

package/dist/ts-client/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ts-client/src/version.d.ts

@@ -0,0 +1 @@
+export declare const packageVersion: string;

package/dist/ts-client/src/version.js

@@ -0,0 +1,2 @@
+import { version } from '../package.json';
+export const packageVersion = version;