@fishjam-cloud/webrtc-client 0.25.2 → 0.25.3

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

@@ -1,340 +0,0 @@
-import type { MediaEvent_Track_SimulcastConfig } from '@fishjam-cloud/protobufs/server';
-import type { Variant } from '@fishjam-cloud/protobufs/shared';
-import type TypedEmitter from 'typed-emitter';
-import type { getLogger } from './logger';
-import type { SerializedMediaEvent } from './mediaEvent';
-export type LocalTrackId = string;
-export type MLineId = string;
-export type MediaStreamTrackId = string;
-export type RemoteTrackId = string;
-export type MetadataJson = string;
-export type TrackKind = 'audio' | 'video';
-/**
- * Type describing Voice Activity Detection statuses.
- *
- * - `speech` - voice activity has been detected
- * - `silence` - lack of voice activity has been detected
- */
-export type VadStatus = 'speech' | 'silence';
-/**
- * Type describing maximal bandwidth that can be used, in kbps. 0 is interpreted as unlimited bandwidth.
- */
-export type BandwidthLimit = number;
-/**
- * Type describing bandwidth limit for simulcast track.
- * It is a mapping (encoding => BandwidthLimit).
- * If encoding isn't present in this mapping, it will be assumed that this particular encoding shouldn't have any bandwidth limit
- */
-export type SimulcastBandwidthLimit = Map<Variant, BandwidthLimit>;
-/**
- * Type describing bandwidth limitation of a Track, including simulcast and non-simulcast tracks.
- * A sum type of `BandwidthLimit` and `SimulcastBandwidthLimit`
- */
-export type TrackBandwidthLimit = BandwidthLimit | SimulcastBandwidthLimit;
-/**
- * Type describing possible reasons for currently selected encoding.
- * - `other` - the exact reason couldn't be determined
- * - `encodingInactive` - previously selected encoding became inactive
- * - `lowBandwidth` - there is no longer enough bandwidth to maintain previously selected encoding
- */
-export type EncodingReason = 'other' | 'encodingInactive' | 'lowBandwidth';
-/**
- * Track's context i.e. all data that can be useful when operating on track.
- */
-interface TrackContextFields {
-    readonly track: MediaStreamTrack | null;
-    /**
-     * Stream this track belongs to.
-     */
-    readonly stream: MediaStream | null;
-    /**
-     * Endpoint this track comes from.
-     */
-    readonly endpoint: Endpoint;
-    /**
-     * Track id. It is generated by RTC engine and takes form `endpoint_id:<random_uuidv4>`.
-     * It is WebRTC agnostic i.e. it does not contain `mid` or `stream id`.
-     */
-    readonly trackId: string;
-    /**
-     * Simulcast configuration.
-     * Only present for local tracks.
-     */
-    readonly simulcastConfig?: MediaEvent_Track_SimulcastConfig;
-    /**
-     * Any info that was passed in {@link WebRTCEndpoint.addTrack}.
-     */
-    readonly metadata?: unknown;
-    readonly maxBandwidth?: TrackBandwidthLimit;
-    readonly vadStatus: VadStatus;
-    /**
-     * Encoding that is currently received.
-     * Only present for remote tracks.
-     */
-    readonly encoding?: Variant;
-    /**
-     * The reason of currently selected encoding.
-     * Only present for remote tracks.
-     */
-    readonly encodingReason?: EncodingReason;
-}
-export interface TrackContextEvents {
-    /**
-     * Emitted each time track encoding has changed.
-     *
-     * Track encoding can change in the following cases:
-     * - when user requested a change
-     * - when sender stopped sending some encoding (because of bandwidth change)
-     * - when receiver doesn't have enough bandwidth
-     *
-     * Some of those reasons are indicated in {@link TrackContext.encodingReason}.
-     */
-    encodingChanged: (context: TrackContext) => void;
-    /**
-     * Emitted every time an update about voice activity is received from the server.
-     */
-    voiceActivityChanged: (context: TrackContext) => void;
-}
-export interface TrackContext extends TrackContextFields, TypedEmitter<Required<TrackContextEvents>> {
-}
-export type TrackNegotiationStatus = 'awaiting' | 'offered' | 'done';
-/**
- * Events emitted by the {@link WebRTCEndpoint} instance.
- */
-export interface WebRTCEndpointEvents {
-    /**
-     * Emitted each time WebRTCEndpoint need to send some data to the server.
-     */
-    sendMediaEvent: (mediaEvent: SerializedMediaEvent) => void;
-    /**
-     * Emitted when endpoint of this {@link WebRTCEndpoint} instance is ready. Triggered by {@link WebRTCEndpoint.connect}
-     */
-    connected: (endpointId: string, otherEndpoints: Endpoint[]) => void;
-    /**
-     * Emitted when endpoint of this {@link WebRTCEndpoint} instance was removed.
-     */
-    disconnected: () => void;
-    /**
-     * Emitted when data in a new track arrives.
-     *
-     * This event is always emitted after {@link trackAdded}.
-     * It informs the user that data related to the given track arrives and can be played or displayed.
-     */
-    trackReady: (ctx: TrackContext) => void;
-    /**
-     * Emitted each time the endpoint 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 trackReady}
-     */
-    trackAdded: (ctx: TrackContext) => void;
-    /**
-     * Emitted when some track will no longer be sent.
-     *
-     * It will also be emitted before {@link endpointRemoved} for each track of this endpoint.
-     */
-    trackRemoved: (ctx: TrackContext) => void;
-    /**
-     * Emitted each time endpoint has its track metadata updated.
-     */
-    trackUpdated: (ctx: TrackContext) => void;
-    /**
-     * Emitted each time new endpoint is added to the room.
-     */
-    endpointAdded: (endpoint: Endpoint) => void;
-    /**
-     * Emitted each time endpoint is removed, emitted only for other endpoints.
-     */
-    endpointRemoved: (endpoint: Endpoint) => void;
-    /**
-     * Emitted each time endpoint has its metadata updated.
-     */
-    endpointUpdated: (endpoint: Endpoint) => void;
-    /**
-     * Emitted in case of errors related to multimedia session e.g. ICE connection.
-     */
-    connectionError: (error: {
-        message: string;
-        event: Event;
-    }) => void;
-    /**
-     * Emitted in case of errors related to multimedia session e.g. ICE connection.
-     */
-    signalingError: (error: {
-        message: string;
-    }) => void;
-    /**
-     * Currently, this event is only emitted when DisplayManager in RTC Engine is
-     * enabled and simulcast is disabled.
-     *
-     * Emitted 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[], disabledTracks: TrackContext[]) => void;
-    /**
-     * Emitted 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;
-    /**
-     * Emitted each time track encoding has been disabled.
-     */
-    trackEncodingDisabled: (context: TrackContext, encoding: Variant) => void;
-    /**
-     * Emitted each time track encoding has been enabled.
-     */
-    trackEncodingEnabled: (context: TrackContext, encoding: Variant) => void;
-    targetTrackEncodingRequested: (event: {
-        trackId: string;
-        variant: Variant;
-    }) => void;
-    disconnectRequested: (event: any) => void;
-    localTrackAdded: (event: {
-        trackId: string;
-        track: MediaStreamTrack;
-        stream: MediaStream;
-        trackMetadata?: unknown;
-        simulcastConfig: MediaEvent_Track_SimulcastConfig;
-        maxBandwidth: TrackBandwidthLimit;
-    }) => void;
-    localTrackRemoved: (event: {
-        trackId: string;
-    }) => void;
-    localTrackReplaced: (event: {
-        trackId: string;
-        track: MediaStreamTrack | null;
-    }) => void;
-    localTrackMuted: (event: {
-        trackId: string;
-    }) => void;
-    localTrackUnmuted: (event: {
-        trackId: string;
-    }) => void;
-    localTrackBandwidthSet: (event: {
-        trackId: string;
-        bandwidth: BandwidthLimit;
-    }) => void;
-    localTrackEncodingBandwidthSet: (event: {
-        trackId: string;
-        rid: Variant;
-        bandwidth: BandwidthLimit;
-    }) => void;
-    localTrackEncodingEnabled: (event: {
-        trackId: string;
-        encoding: Variant;
-    }) => void;
-    localTrackEncodingDisabled: (event: {
-        trackId: string;
-        encoding: Variant;
-    }) => void;
-    localEndpointMetadataChanged: (event: {
-        metadata: unknown;
-    }) => void;
-    localTrackMetadataChanged: (event: {
-        trackId: string;
-        metadata: unknown;
-    }) => void;
-    /**
-     * Emitted when data channels (for both reliable and lossy) are created and ready to send data.
-     * This event is fired after calling connectDataChannels().
-     */
-    dataChannelsReady: () => void;
-    /**
-     * Emitted when data is received on any data channel.
-     * The payload includes the channel type (reliable/lossy) and the binary data.
-     */
-    dataChannelPayload: (payload: DataChannelMessagePayload) => void;
-    /**
-     * Emitted when any data channel errors.
-     */
-    dataChannelsError: (error: Error) => void;
-}
-/**
- * Interface describing Endpoint.
- */
-export interface Endpoint {
-    /**
-     * Endpoint's id. It is assigned by user in custom logic that use backend API.
-     */
-    id: string;
-    /**
-     * Type of the endpoint, e.g. "webrtc", "hls" or "rtsp".
-     */
-    type: string;
-    /**
-     * Any information that was provided in {@link WebRTCEndpoint.connect}.
-     */
-    metadata?: unknown;
-    /**
-     * List of tracks that are sent by the endpoint.
-     */
-    tracks: Map<string, TrackContext>;
-}
-/**
- * Options for publishing or subscribing to data.
- */
-export interface DataChannelOptions {
-    /**
-     * If true, uses the reliable data channel (ordered, guaranteed delivery).
-     * If false, uses the lossy data channel (unordered, low latency).
-     */
-    reliable: boolean;
-}
-/**
- * Callback type for receiving data from a data channel.
- * @param data - The received data as a Uint8Array
- */
-export type DataCallback = (data: Uint8Array) => void;
-/**
- * Internal type for channel classification
- * @internal
- */
-export type DataChannelType = 'reliable' | 'lossy';
-/**
- * Internal status tracking for data channels
- * @internal
- */
-export type DataChannelStatus = 'init' | 'creating' | 'open' | 'closed';
-/**
- * Payload for data received events from data channels.
- */
-export interface DataChannelMessagePayload {
-    /**
-     * The type of channel the data was received on.
-     */
-    channelType: DataChannelType;
-    /**
-     * The binary payload data.
-     */
-    data: Uint8Array;
-}
-/**
- * Events emitted by the DataChannelManager.
- */
-export interface DataChannelManagerEvents {
-    /**
-     * Emitted when both reliable and lossy data channel publishers are ready to send data.
-     */
-    ready: () => void;
-    /**
-     * Emitted when a data channel is opened.
-     */
-    channelOpen: (type: DataChannelType) => void;
-    /**
-     * Emitted when a data channel errors.
-     */
-    error: (type: DataChannelType, error: Event) => void;
-    /**
-     * Emitted when data is received on any data channel.
-     */
-    data: (payload: DataChannelMessagePayload) => void;
-}
-export type WebRTCEndpointProps = {
-    /**
-     * Enables Fishjam SDK's debug logs in the console.
-     */
-    debug?: boolean;
-};
-export type Logger = ReturnType<typeof getLogger>;
-export {};

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

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

package/dist/webrtc-client/src/webRTCEndpoint.d.ts

@@ -1,350 +0,0 @@
-import type { MediaEvent_Track_SimulcastConfig } from '@fishjam-cloud/protobufs/server';
-import type { Variant } from '@fishjam-cloud/protobufs/shared';
-import type TypedEmitter from 'typed-emitter';
-import { ConnectionManager } from './ConnectionManager';
-import type { EndpointWithTrackContext } from './internal';
-import type { SerializedMediaEvent } from './mediaEvent';
-import type { BandwidthLimit, DataChannelOptions, TrackBandwidthLimit, TrackContext, WebRTCEndpointEvents, WebRTCEndpointProps } from './types';
-declare const WebRTCEndpoint_base: new () => TypedEmitter<Required<WebRTCEndpointEvents>>;
-/**
- * Main class that is responsible for connecting to the RTC Engine, sending and receiving media.
- */
-export declare class WebRTCEndpoint extends WebRTCEndpoint_base {
-    private readonly localTrackManager;
-    private readonly remote;
-    private readonly local;
-    private readonly commandsQueue;
-    private readonly dataChannelManager;
-    private proposedIceServers;
-    private logger;
-    bandwidthEstimation: bigint;
-    connectionManager?: ConnectionManager;
-    private clearConnectionCallbacks;
-    constructor(props?: WebRTCEndpointProps);
-    /**
-     * Tries to connect to the RTC Engine. If user is successfully connected then {@link WebRTCEndpointEvents.connected}
-     * will be emitted.
-     *
-     * @param metadata - Any information that other endpoints will receive in {@link WebRTCEndpointEvents.endpointAdded}
-     * after accepting this endpoint
-     *
-     * @example
-     * ```ts
-     * let webrtc = new WebRTCEndpoint();
-     * webrtc.connect({displayName: "Bob"});
-     * ```
-     */
-    connect: (metadata: unknown) => void;
-    /**
-     * Feeds media event received from RTC Engine to {@link WebRTCEndpoint}.
-     * This function should be called whenever some media event from RTC Engine
-     * was received and can result in {@link WebRTCEndpoint} generating some other
-     * media events.
-     *
-     * @param mediaEvent - String data received over custom signalling layer.
-     *
-     * @example
-     * This example assumes phoenix channels as signalling layer.
-     * As phoenix channels require objects, RTC Engine encapsulates binary data into
-     * map with one field that is converted to object with one field on the TS side.
-     * ```ts
-     * webrtcChannel.on("mediaEvent", (event) => webrtc.receiveMediaEvent(event.data));
-     * ```
-     */
-    receiveMediaEvent: (mediaEvent: SerializedMediaEvent) => Promise<void>;
-    private getEndpointId;
-    private onTrackReady;
-    /**
-     * Retrieves statistics related to the RTCPeerConnection.
-     * These statistics provide insights into the performance and status of the connection.
-     *
-     * @return {Promise<RTCStatsReport>}
-     *
-     * @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 (webRTCEndpoint.getRemoteTracks()[trackId]?.simulcastConfig?.enabled) {
-     *   webRTCEndpoint.setTargetTrackEncoding(trackId, encoding);
-     * }
-     */
-    getRemoteTracks(): Record<string, TrackContext>;
-    /**
-     * Returns a snapshot of currently received remote endpoints.
-     */
-    getRemoteEndpoints(): Record<string, EndpointWithTrackContext>;
-    getLocalEndpoint(): EndpointWithTrackContext;
-    getBandwidthEstimation(): bigint;
-    getDataChannelsReadiness(): boolean;
-    private handleMediaEvent;
-    private onSdpAnswer;
-    /**
-     * Adds track that will be sent to the RTC Engine.
-     * @param track - Audio or video track e.g. from your microphone or camera.
-     * @param trackMetadata - Any information about this track that other endpoints will
-     * receive in {@link WebRTCEndpointEvents.endpointAdded}. E.g. this can source of the track - whether it's
-     * screensharing, webcam or some other media device.
-     * @param _simulcastConfig - Simulcast configuration parameter. **Currently ignored** - simulcast is disabled
-     * regardless of the value passed. This is a temporary change until bandwidth estimation is implemented or
-     * manual track selection support is added. For more information refer to {@link SimulcastConfig}.
-     * @param _maxBandwidth - maximal bandwidth this track can use. **Currently processed with a threshold check**:
-     * if the value is a positive number, it will be used; otherwise, it defaults to 0 (unlimited).
-     * This option has no effect for simulcast and audio tracks.
-     * For simulcast tracks use `{@link WebRTCEndpoint.setTrackBandwidth}.
-     * @returns {string} Returns id of added track
-     * @example
-     * ```ts
-     * let localStream: MediaStream = new MediaStream();
-     * try {
-     *   localAudioStream = await navigator.mediaDevices.getUserMedia(
-     *     AUDIO_CONSTRAINTS
-     *   );
-     *   localAudioStream
-     *     .getTracks()
-     *     .forEach((track) => localStream.addTrack(track));
-     * } catch (error) {
-     *   this.logger.error("Couldn't get microphone permission:", error);
-     * }
-     *
-     * try {
-     *   localVideoStream = await navigator.mediaDevices.getUserMedia(
-     *     VIDEO_CONSTRAINTS
-     *   );
-     *   localVideoStream
-     *     .getTracks()
-     *     .forEach((track) => localStream.addTrack(track));
-     * } catch (error) {
-     *  this.logger.error("Couldn't get camera permission:", error);
-     * }
-     *
-     * localStream
-     *  .getTracks()
-     *  .forEach((track) => webrtc.addTrack(track, localStream));
-     * ```
-     */
-    addTrack(track: MediaStreamTrack, trackMetadata?: unknown, _simulcastConfig?: MediaEvent_Track_SimulcastConfig, _maxBandwidth?: TrackBandwidthLimit): Promise<string>;
-    /**
-     * Replaces a track that is being sent to the RTC Engine.
-     * @param trackId - Audio or video track.
-     * @param {string} trackId - Id of audio or video track to replace.
-     * @param {MediaStreamTrack} newTrack
-     * @returns {Promise<boolean>} success
-     * @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) {
-     *   this.logger.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) => {
-     *     this.logger.error('Error switching camera', error);
-     *   })
-     * ```
-     */
-    replaceTrack(trackId: string, newTrack: MediaStreamTrack | null): 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<void>;
-    /**
-     * 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: Variant, bandwidth: BandwidthLimit): Promise<void>;
-    /**
-     * Removes a track from connection that was sent to the RTC Engine.
-     * @param {string} trackId - Id of audio or video track to remove.
-     * @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) {
-     *   this.logger.error("Couldn't get camera permission:", error);
-     * }
-     *
-     * let trackId
-     * localStream
-     *  .getTracks()
-     *  .forEach((track) => trackId = webrtc.addTrack(track, localStream));
-     *
-     * // remove track
-     * webrtc.removeTrack(trackId)
-     * ```
-     */
-    removeTrack(trackId: string): Promise<void>;
-    /**
-     * Sets track variant that server should send to the client library.
-     *
-     * The variant will be sent whenever it is available.
-     * If chosen variant is temporarily unavailable, some other variant
-     * will be sent until the chosen variant becomes active again.
-     *
-     * @param {string} trackId - id of track
-     * @param {Encoding} variant - variant to receive
-     * @example
-     * ```ts
-     * webrtc.setTargetTrackEncoding(incomingTrackCtx.trackId, "l")
-     * ```
-     */
-    setTargetTrackEncoding(trackId: string, variant: Variant): void;
-    /**
-     * Enables track encoding so that it will be sent to the server.
-     * @param {string} trackId - id of track
-     * @param {Encoding} encoding - encoding that will be enabled
-     * @example
-     * ```ts
-     * const trackId = webrtc.addTrack(track, stream, {}, {enabled: true, activeEncodings: ["l", "m", "h"]});
-     * webrtc.disableTrackEncoding(trackId, "l");
-     * // wait some time
-     * webrtc.enableTrackEncoding(trackId, "l");
-     * ```
-     */
-    enableTrackEncoding: (trackId: string, encoding: Variant) => Promise<void>;
-    /**
-     * Disables track encoding so that it will be no longer sent to the server.
-     * @param {string} trackId - id of track
-     * @param {Encoding} encoding - encoding that will be disabled
-     * @example
-     * ```ts
-     * const trackId = webrtc.addTrack(track, stream, {}, {enabled: true, activeEncodings: ["l", "m", "h"]});
-     * webrtc.disableTrackEncoding(trackId, "l");
-     * ```
-     */
-    disableTrackEncoding: (trackId: string, encoding: Variant) => Promise<void>;
-    /**
-     * Updates the metadata for the current endpoint.
-     * @param metadata - Data about this endpoint that other endpoints will receive upon being added.
-     *
-     * If the metadata is different from what is already tracked in the room, the optional
-     * event `endpointUpdated` will be emitted for other endpoint in the room.
-     */
-    updateEndpointMetadata: (metadata: any) => 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 endpoint will receive upon being added.
-     *
-     * If the metadata is different from what is already tracked in the room, the optional
-     * event `trackUpdated` will be emitted for other endpoints in the room.
-     */
-    updateTrackMetadata: (trackId: string, trackMetadata: any) => void;
-    /**
-     * Disconnects from the room. This function should be called when user disconnects from 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 endpoint will be notified
-     * that endpoint was removed in {@link WebRTCEndpointEvents.endpointRemoved},
-     */
-    disconnect: () => void;
-    /**
-     * Create both reliable and lossy data channel.
-     * This method must be called before publishData() can be used.
-     * Emits the 'dataChannelsReady' event when both channels are open and ready.
-     *
-     * @example
-     * ```ts
-     * const webrtc = new WebRTCEndpoint();
-     *
-     * webrtc.on('dataChannelsReady', () => {
-     *   console.log('Data channels ready, can now send data');
-     *   webrtc.publishData(new TextEncoder().encode('Hello'), { reliable: true });
-     * });
-     *
-     * webrtc.connectDataChannels();
-     * ```
-     */
-    connectDataChannels: () => Promise<void>;
-    /**
-     * Publish data through a data channel.
-     * The data channels must be created first by calling connectDataChannels() or enabling negotiateOnConnect.
-     * Throws an error if the channel doesn't exist or isn't ready yet.
-     *
-     * @param data - The data to send as Uint8Array
-     * @param options - Options specifying which channel to use (reliable or lossy)
-     * @throws Error if the channel doesn't exist or isn't ready
-     *
-     * @example
-     * ```ts
-     * // Subscribe to incoming data
-     * webrtc.on('dataReceived', ({ channelType, data }) => {
-     *   console.log(`Received on ${channelType}:`, new TextDecoder().decode(data));
-     * });
-     *
-     * webrtc.on('dataChannelsReady', () => {
-     *   // Send reliable data
-     *   const data = new TextEncoder().encode('Hello World');
-     *   webrtc.publishData(data, { reliable: true });
-     *
-     *   // Send lossy data for low-latency updates
-     *   const gameState = new Uint8Array([1, 2, 3, 4, 5]);
-     *   webrtc.publishData(gameState, { reliable: false });
-     * });
-     *
-     * webrtc.connectDataChannels();
-     * ```
-     */
-    publishData: (data: Uint8Array, options: DataChannelOptions) => void;
-    /**
-     * Cleans up {@link WebRTCEndpoint} instance.
-     */
-    cleanUp: () => void;
-    private getTrackId;
-    private sendMediaEvent;
-    private createAndSendOffer;
-    private onOfferData;
-    private setupConnectionListeners;
-    private createNewConnection;
-    private onRemoteCandidate;
-    private onLocalCandidate;
-    private onIceCandidateError;
-    private onConnectionStateChange;
-    private onIceConnectionStateChange;
-}
-export {};