@simplito/privmx-webendpoint 2.6.4 → 2.7.1

package/dist/service/StreamApi.d.ts

@@ -0,0 +1,237 @@
+import { Types } from "../ServerTypes";
+import * as EndpointTypes from "../Types";
+import { AudioLevelsStats, WebRtcClient } from "../webStreams/WebRtcClient";
+import { DataChannelMeta } from "../webStreams/types/ApiTypes";
+import { BaseApi } from "./BaseApi";
+import { ContainerPolicy, PagingList, PagingQuery, StreamInfo, StreamEventSelectorType, StreamEventType, StreamRoom, UserWithPubKey, StreamHandle, StreamSubscription, StreamPublishResult, RemoteStreamListener } from "../Types";
+import { StreamApiNative } from "../api/StreamApiNative";
+import { Buffer } from "buffer";
+export interface StreamTrack {
+    id: Types.StreamTrackId;
+    streamId?: Types.StreamId;
+    streamHandle: StreamHandle;
+    track?: MediaStreamTrack;
+    dataChannelMeta?: DataChannelMeta;
+    published: Boolean;
+    markedToRemove?: boolean;
+}
+/**
+ * `StreamApi` is a class representing Endpoint's API for Stream Rooms.
+ */
+export declare class StreamApi extends BaseApi {
+    private native;
+    private client;
+    constructor(native: StreamApiNative, ptr: number, client: WebRtcClient);
+    private streams;
+    private streamTracks;
+    /**
+     * Creates a new Stream Room in given Context.
+     *
+     * @param {string} contextId ID of the Context to create the Stream Room in
+     * @param {UserWithPubKey[]} users array of UserWithPubKey structs which indicates who will have access to the created Stream Room
+     * @param {UserWithPubKey[]} managers array of UserWithPubKey structs which indicates who will have access (and management rights) to the created Stream Room
+     * @param {Uint8Array} publicMeta public (unencrypted) metadata
+     * @param {Uint8Array} privateMeta private (encrypted) metadata
+     * @param {ContainerPolicy} policies Stream Room's policies (pass `undefined` to use defaults)
+     * @returns {string} ID of the created Stream Room
+     */
+    createStreamRoom(contextId: string, users: UserWithPubKey[], managers: UserWithPubKey[], publicMeta: Uint8Array, privateMeta: Uint8Array, policies?: ContainerPolicy): Promise<Types.StreamRoomId>;
+    /**
+     * Updates an existing Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to update
+     * @param {UserWithPubKey[]} users array of UserWithPubKey structs which indicates who will have access to the Stream Room
+     * @param {UserWithPubKey[]} managers array of UserWithPubKey structs which indicates who will have access (and management rights) to the Stream Room
+     * @param {Uint8Array} publicMeta public (unencrypted) metadata
+     * @param {Uint8Array} privateMeta private (encrypted) metadata
+     * @param {number} version current version of the updated Stream Room
+     * @param {boolean} force force update (without checking version)
+     * @param {boolean} forceGenerateNewKey force to regenerate a key for the Stream Room
+     * @param {ContainerPolicy} policies Stream Room's policies (pass `undefined` to keep current/defaults)
+     */
+    updateStreamRoom(streamRoomId: Types.StreamRoomId, users: UserWithPubKey[], managers: UserWithPubKey[], publicMeta: Uint8Array, privateMeta: Uint8Array, version: number, force: boolean, forceGenerateNewKey: boolean, policies?: ContainerPolicy): Promise<void>;
+    /**
+     * Gets a list of Stream Rooms in given Context.
+     *
+     * @param {string} contextId ID of the Context to get the Stream Rooms from
+     * @param {PagingQuery} query struct with list query parameters
+     * @returns {PagingList<StreamRoom>} list of Stream Rooms
+     */
+    listStreamRooms(contextId: string, query: PagingQuery): Promise<PagingList<StreamRoom>>;
+    /**
+     * Joins a Stream Room.
+     *
+     * This is required before calling `createStream`/`publishStream` and before subscribing to remote streams
+     * in the room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to join
+     */
+    joinStreamRoom(streamRoomId: Types.StreamRoomId): Promise<void>;
+    /**
+     * Leaves a Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to leave
+     */
+    leaveStreamRoom(streamRoomId: Types.StreamRoomId): Promise<void>;
+    /**
+     * Enables server-side recording for the Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     */
+    enableStreamRoomRecording(streamRoomId: Types.StreamRoomId): Promise<void>;
+    /**
+     * Gets encryption keys used for Stream Room recordings.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     * @returns {EndpointTypes.RecordingEncKey[]} list of recording encryption keys
+     */
+    getStreamRoomRecordingKeys(streamRoomId: Types.StreamRoomId): Promise<EndpointTypes.RecordingEncKey[]>;
+    /**
+     * Gets a single Stream Room by given Stream Room ID.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to get
+     * @returns {StreamRoom} information about the Stream Room
+     */
+    getStreamRoom(streamRoomId: Types.StreamRoomId): Promise<StreamRoom>;
+    /**
+     * Deletes a Stream Room by given Stream Room ID.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to delete
+     */
+    deleteStreamRoom(streamRoomId: Types.StreamRoomId): Promise<void>;
+    /**
+     * Creates a local Stream handle for publishing media in given Stream Room.
+     *
+     * Call `addStreamTrack`/`removeStreamTrack` to stage tracks and `publishStream`/`updateStream` to send
+     * changes to the server.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to create the stream in
+     * @returns {StreamHandle} handle to a local Stream instance
+     */
+    createStream(streamRoomId: Types.StreamRoomId): Promise<StreamHandle>;
+    /**
+     * Gets a list of currently published streams in given Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to list streams from
+     * @returns {StreamInfo[]} list of StreamInfo structs describing currently published streams
+     */
+    listStreams(streamRoomId: Types.StreamRoomId): Promise<StreamInfo[]>;
+    /**
+     * Adds a local media track or a data channel definition to a Stream handle.
+     *
+     * The track is staged locally and becomes visible to others after `publishStream`/`updateStream`.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @param {Types.StreamTrackMeta} meta track/data channel metadata (track: `MediaStreamTrack`, dataChannel: `DataChannelMeta`)
+     * @returns {string} StreamTrackId assigned locally for this track
+     * @throws {Error} when the given `streamHandle` does not exist or the same browser track is already staged
+     */
+    addStreamTrack(streamHandle: StreamHandle, meta: Types.StreamTrackMeta): Promise<Types.StreamTrackId>;
+    /**
+     * Removes a previously added media track from a Stream handle.
+     *
+     * For already published streams the removal is applied on `updateStream`.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @param {Types.StreamTrackMeta} meta media track metadata previously passed to `addStreamTrack`
+     * @throws {Error} when the given `streamHandle` does not exist
+     */
+    removeStreamTrack(streamHandle: StreamHandle, meta: Types.StreamTrackMeta): Promise<void>;
+    /**
+     * Sends a data message over a stream data track.
+     *
+     * @param {string} _streamTrackId StreamTrackId returned by `addStreamTrack`
+     * @param {Buffer} _data data to send
+     * @throws {Error} not implemented
+     */
+    streamTrackSendData(_streamTrackId: Types.StreamTrackId, _data: Buffer): Promise<void>;
+    /**
+     * Registers a data receive callback for a stream data track.
+     *
+     * @param {string} _streamTrackId StreamTrackId returned by `addStreamTrack`
+     * @param {(data: Buffer) => void} _onData callback invoked when data is received
+     * @throws {Error} not implemented
+     */
+    streamTrackRecvData(_streamTrackId: Types.StreamTrackId, _onData: (data: Buffer) => void): Promise<void>;
+    /**
+     * Publishes the Stream (with currently staged tracks) to the server.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @param {(state: RTCPeerConnectionState) => void} onStreamState optional callback invoked on RTCPeerConnection state changes
+     * @returns {StreamPublishResult} result of the publish operation
+     * @throws {Error} when the given `streamHandle` does not exist
+     */
+    publishStream(streamHandle: StreamHandle, onStreamState?: (state: RTCPeerConnectionState) => void): Promise<StreamPublishResult>;
+    /**
+     * Updates a published Stream after adding/removing tracks.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @returns {StreamPublishResult} result of the update operation
+     * @throws {Error} when the given `streamHandle` does not exist
+     */
+    updateStream(streamHandle: StreamHandle): Promise<StreamPublishResult>;
+    private filterMapByValue;
+    /**
+     * Stops publishing the Stream.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @throws {Error} when the given `streamHandle` does not exist
+     */
+    unpublishStream(streamHandle: StreamHandle): Promise<void>;
+    /**
+     * Subscribes to selected remote streams (and optionally specific tracks) in the Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     * @param {EndpointTypes.StreamSubscription[]} subscriptions list of remote streams/tracks to subscribe to
+     */
+    subscribeToRemoteStreams(streamRoomId: Types.StreamRoomId, subscriptions: EndpointTypes.StreamSubscription[]): Promise<void>;
+    /**
+     * Modifies current remote streams subscriptions.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     * @param {EndpointTypes.StreamSubscription[]} subscriptionsToAdd list of subscriptions to add
+     * @param {StreamSubscription[]} subscriptionsToRemove list of subscriptions to remove
+     */
+    modifyRemoteStreamsSubscriptions(streamRoomId: Types.StreamRoomId, subscriptionsToAdd: EndpointTypes.StreamSubscription[], subscriptionsToRemove: StreamSubscription[]): Promise<void>;
+    /**
+     * Unsubscribes from selected remote streams (and optionally specific tracks) in the Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     * @param {StreamSubscription[]} subscriptions list of subscriptions to remove
+     */
+    unsubscribeFromRemoteStreams(streamRoomId: Types.StreamRoomId, subscriptions: StreamSubscription[]): Promise<void>;
+    /**
+     * Registers a listener for remote tracks in the Stream Room.
+     *
+     * @param {RemoteStreamListener} listener listener configuration
+     * @param {string} listener.streamRoomId ID of the Stream Room
+     * @param {number} [listener.streamId] optional remote Stream ID to filter events (omit for all streams)
+     * @param {(event: RTCTrackEvent) => void} listener.onRemoteStreamTrack callback invoked for incoming remote tracks
+     */
+    addRemoteStreamListener(listener: RemoteStreamListener): void;
+    /**
+     * Subscribe for the Stream Room events on the given subscription query.
+     *
+     * @param {string[]} subscriptionQueries list of queries
+     * @return list of subscriptionIds in maching order to subscriptionQueries
+     */
+    subscribeFor(subscriptionQueries: string[]): Promise<string[]>;
+    /**
+     * Unsubscribe from events for the given subscriptionId.
+     * @param {string[]} subscriptionIds list of subscriptionId
+     */
+    unsubscribeFrom(subscriptionIds: string[]): Promise<void>;
+    /**
+     * Generate subscription Query for the Stream Room events.
+     * @param {EventType} eventType type of event which you listen for
+     * @param {EventSelectorType} selectorType scope on which you listen for events
+     * @param {string} selectorId ID of the selector
+     */
+    buildSubscriptionQuery(eventType: StreamEventType, selectorType: StreamEventSelectorType, selectorId: string): Promise<string>;
+    /**
+     * Registers a callback for audio level statistics produced by the WebRTC client.
+     *
+     * @param {(stats: AudioLevelsStats) => void} onStats callback invoked with current audio levels stats
+     */
+    addAudioLevelStatsListener(onStats: (stats: AudioLevelsStats) => void): Promise<void>;
+}

package/dist/service/StreamApi.js

@@ -0,0 +1,442 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamApi = void 0;
+const Utils_1 = require("../webStreams/Utils");
+const BaseApi_1 = require("./BaseApi");
+/**
+ * `StreamApi` is a class representing Endpoint's API for Stream Rooms.
+ */
+class StreamApi extends BaseApi_1.BaseApi {
+    native;
+    client;
+    constructor(native, ptr, client) {
+        super(ptr);
+        this.native = native;
+        this.client = client;
+    }
+    // local data
+    streams = new Map();
+    streamTracks = new Map();
+    /**
+     * Creates a new Stream Room in given Context.
+     *
+     * @param {string} contextId ID of the Context to create the Stream Room in
+     * @param {UserWithPubKey[]} users array of UserWithPubKey structs which indicates who will have access to the created Stream Room
+     * @param {UserWithPubKey[]} managers array of UserWithPubKey structs which indicates who will have access (and management rights) to the created Stream Room
+     * @param {Uint8Array} publicMeta public (unencrypted) metadata
+     * @param {Uint8Array} privateMeta private (encrypted) metadata
+     * @param {ContainerPolicy} policies Stream Room's policies (pass `undefined` to use defaults)
+     * @returns {string} ID of the created Stream Room
+     */
+    async createStreamRoom(contextId, users, managers, publicMeta, privateMeta, policies) {
+        const res = await this.native.createStreamRoom(this.servicePtr, [
+            contextId,
+            users,
+            managers,
+            publicMeta,
+            privateMeta,
+            policies,
+        ]);
+        return res;
+    }
+    /**
+     * Updates an existing Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to update
+     * @param {UserWithPubKey[]} users array of UserWithPubKey structs which indicates who will have access to the Stream Room
+     * @param {UserWithPubKey[]} managers array of UserWithPubKey structs which indicates who will have access (and management rights) to the Stream Room
+     * @param {Uint8Array} publicMeta public (unencrypted) metadata
+     * @param {Uint8Array} privateMeta private (encrypted) metadata
+     * @param {number} version current version of the updated Stream Room
+     * @param {boolean} force force update (without checking version)
+     * @param {boolean} forceGenerateNewKey force to regenerate a key for the Stream Room
+     * @param {ContainerPolicy} policies Stream Room's policies (pass `undefined` to keep current/defaults)
+     */
+    async updateStreamRoom(streamRoomId, users, managers, publicMeta, privateMeta, version, force, forceGenerateNewKey, policies) {
+        return this.native.updateStreamRoom(this.servicePtr, [
+            streamRoomId,
+            users,
+            managers,
+            publicMeta,
+            privateMeta,
+            version,
+            force,
+            forceGenerateNewKey,
+            policies,
+        ]);
+    }
+    /**
+     * Gets a list of Stream Rooms in given Context.
+     *
+     * @param {string} contextId ID of the Context to get the Stream Rooms from
+     * @param {PagingQuery} query struct with list query parameters
+     * @returns {PagingList<StreamRoom>} list of Stream Rooms
+     */
+    async listStreamRooms(contextId, query) {
+        return this.native.listStreamRooms(this.servicePtr, [contextId, query]);
+    }
+    /**
+     * Joins a Stream Room.
+     *
+     * This is required before calling `createStream`/`publishStream` and before subscribing to remote streams
+     * in the room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to join
+     */
+    async joinStreamRoom(streamRoomId) {
+        return this.native.joinStreamRoom(this.servicePtr, [streamRoomId]);
+    }
+    /**
+     * Leaves a Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to leave
+     */
+    async leaveStreamRoom(streamRoomId) {
+        return this.native.leaveStreamRoom(this.servicePtr, [streamRoomId]);
+    }
+    /**
+     * Enables server-side recording for the Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     */
+    async enableStreamRoomRecording(streamRoomId) {
+        return this.native.enableStreamRoomRecording(this.servicePtr, [streamRoomId]);
+    }
+    /**
+     * Gets encryption keys used for Stream Room recordings.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     * @returns {EndpointTypes.RecordingEncKey[]} list of recording encryption keys
+     */
+    async getStreamRoomRecordingKeys(streamRoomId) {
+        return this.native.getStreamRoomRecordingKeys(this.servicePtr, [streamRoomId]);
+    }
+    /**
+     * Gets a single Stream Room by given Stream Room ID.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to get
+     * @returns {StreamRoom} information about the Stream Room
+     */
+    async getStreamRoom(streamRoomId) {
+        return this.native.getStreamRoom(this.servicePtr, [streamRoomId]);
+    }
+    /**
+     * Deletes a Stream Room by given Stream Room ID.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to delete
+     */
+    async deleteStreamRoom(streamRoomId) {
+        return this.native.deleteStreamRoom(this.servicePtr, [streamRoomId]);
+    }
+    /**
+     * Creates a local Stream handle for publishing media in given Stream Room.
+     *
+     * Call `addStreamTrack`/`removeStreamTrack` to stage tracks and `publishStream`/`updateStream` to send
+     * changes to the server.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to create the stream in
+     * @returns {StreamHandle} handle to a local Stream instance
+     */
+    async createStream(streamRoomId) {
+        const meta = {};
+        // tutaj uzupelniajac opcjonalne pola obiektu meta mozemy ustawiac w Janusie dodatkowe rzeczy
+        const handle = await this.native.createStream(this.servicePtr, [streamRoomId]);
+        this.streams.set(handle, { handle, streamRoomId, createStreamMeta: meta, remote: false });
+        return handle;
+    }
+    /**
+     * Gets a list of currently published streams in given Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room to list streams from
+     * @returns {StreamInfo[]} list of StreamInfo structs describing currently published streams
+     */
+    async listStreams(streamRoomId) {
+        const remoteStreams = await this.native.listStreams(this.servicePtr, [streamRoomId]);
+        return remoteStreams;
+    }
+    /**
+     * Adds a local media track or a data channel definition to a Stream handle.
+     *
+     * The track is staged locally and becomes visible to others after `publishStream`/`updateStream`.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @param {Types.StreamTrackMeta} meta track/data channel metadata (track: `MediaStreamTrack`, dataChannel: `DataChannelMeta`)
+     * @returns {string} StreamTrackId assigned locally for this track
+     * @throws {Error} when the given `streamHandle` does not exist or the same browser track is already staged
+     */
+    async addStreamTrack(streamHandle, meta) {
+        // if (streamTrack.dataChannelMeta) {
+        //     await this.client.provideSession();
+        //     const request: StreamDataTrackAddRequest = {
+        //         kind: "streams.streamDataTrackAdd",
+        //         data: {
+        //             streamRoomId: stream.streamRoomId,
+        //             streamId: streamTrack.streamId,
+        //             streamTrackId: streamTrack.id,
+        //             meta: streamTrack.dataChannelMeta
+        //         }
+        //     };
+        //     await this.serverChannel.call<StreamsApi.StreamDataTrackAddRequest, void>(request);
+        // }
+        if (!this.streams.has(streamHandle)) {
+            throw new Error("[addStreamTrack]: there is no Stream with given Id: " + streamHandle);
+        }
+        let alreadyAddedId = "";
+        const tracksByHandle = Array.from(this.streamTracks.values()).filter((x) => x.streamHandle === streamHandle);
+        for (const streamTrack of tracksByHandle) {
+            if (streamTrack.track && streamTrack.track?.id === meta.track?.id) {
+                if (streamTrack.markedToRemove === true) {
+                    streamTrack.markedToRemove === undefined;
+                    alreadyAddedId = streamTrack.id;
+                    break;
+                }
+                else {
+                    throw new Error("[addStreamTrack] StreamTrack with given browser's track already added.");
+                }
+            }
+        }
+        if (alreadyAddedId.length > 0) {
+            return alreadyAddedId;
+        }
+        const stream = this.streams.get(streamHandle);
+        if (!stream) {
+            throw new Error("Cannot find stream by id");
+        }
+        const streamTrackId = Utils_1.Utils.getRandomString(16);
+        const streamTrack = {
+            id: streamTrackId,
+            streamHandle: streamHandle,
+            track: meta.track,
+            dataChannelMeta: meta.dataChannel,
+            published: false,
+        };
+        this.streamTracks.set(streamTrackId, streamTrack);
+        return streamTrackId;
+    }
+    /**
+     * Removes a previously added media track from a Stream handle.
+     *
+     * For already published streams the removal is applied on `updateStream`.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @param {Types.StreamTrackMeta} meta media track metadata previously passed to `addStreamTrack`
+     * @throws {Error} when the given `streamHandle` does not exist
+     */
+    async removeStreamTrack(streamHandle, meta) {
+        if (!this.streams.has(streamHandle)) {
+            throw new Error("[removeStreamTrack]: there is no Stream with given Id: " + streamHandle);
+        }
+        for (const [key, streamTrack] of this.streamTracks.entries()) {
+            if (streamTrack.track &&
+                streamTrack.track?.id === meta.track?.id &&
+                streamTrack.streamHandle === streamHandle) {
+                streamTrack.markedToRemove = true;
+            }
+        }
+    }
+    /**
+     * Sends a data message over a stream data track.
+     *
+     * @param {string} _streamTrackId StreamTrackId returned by `addStreamTrack`
+     * @param {Buffer} _data data to send
+     * @throws {Error} not implemented
+     */
+    async streamTrackSendData(_streamTrackId, _data) {
+        throw new Error("not implemented");
+    }
+    /**
+     * Registers a data receive callback for a stream data track.
+     *
+     * @param {string} _streamTrackId StreamTrackId returned by `addStreamTrack`
+     * @param {(data: Buffer) => void} _onData callback invoked when data is received
+     * @throws {Error} not implemented
+     */
+    async streamTrackRecvData(_streamTrackId, _onData) {
+        throw new Error("not implemented");
+    }
+    /**
+     * Publishes the Stream (with currently staged tracks) to the server.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @param {(state: RTCPeerConnectionState) => void} onStreamState optional callback invoked on RTCPeerConnection state changes
+     * @returns {StreamPublishResult} result of the publish operation
+     * @throws {Error} when the given `streamHandle` does not exist
+     */
+    async publishStream(streamHandle, onStreamState) {
+        const mediaTracks = [];
+        for (const value of this.streamTracks.values()) {
+            if (value.streamHandle === streamHandle &&
+                value.track &&
+                !value.markedToRemove &&
+                value.published === false) {
+                mediaTracks.push(value.track);
+                value.published = true;
+            }
+        }
+        const _stream = this.streams.get(streamHandle);
+        if (!_stream) {
+            throw new Error("No stream defined to publish");
+        }
+        const mediaStream = new MediaStream(mediaTracks);
+        _stream.localMediaStream = mediaStream;
+        const turnCredentials = await this.native.getTurnCredentials(this.servicePtr, []);
+        await this.client.setTurnCredentials(turnCredentials);
+        await this.client.createPeerConnectionWithLocalStream(streamHandle, _stream.streamRoomId, mediaStream);
+        if (onStreamState && typeof onStreamState === "function") {
+            this.client
+                .getStreamStateChangeDispatcher()
+                .addOnStateChangeListener({ streamHandle: streamHandle }, (event) => onStreamState(event.state));
+        }
+        const res = await this.native.publishStream(this.servicePtr, [streamHandle]);
+        return res;
+    }
+    /**
+     * Updates a published Stream after adding/removing tracks.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @returns {StreamPublishResult} result of the update operation
+     * @throws {Error} when the given `streamHandle` does not exist
+     */
+    async updateStream(streamHandle) {
+        // configure client
+        const tracksToAdd = [];
+        const tracksToRemove = [];
+        for (const value of this.streamTracks.values()) {
+            if (value.streamHandle === streamHandle && value.track) {
+                if (!value.published && !value.markedToRemove) {
+                    tracksToAdd.push(value.track);
+                }
+                if (value.markedToRemove) {
+                    tracksToRemove.push(value.track);
+                }
+            }
+        }
+        const _stream = this.streams.get(streamHandle);
+        if (!_stream) {
+            throw new Error("No stream defined to publish");
+        }
+        const turnCredentials = await this.native.getTurnCredentials(this.servicePtr, []);
+        await this.client.setTurnCredentials(turnCredentials);
+        await this.client.updatePeerConnectionWithLocalStream(_stream.streamRoomId, _stream.localMediaStream, tracksToAdd, tracksToRemove);
+        const res = await this.native.updateStream(this.servicePtr, [streamHandle]);
+        return res;
+    }
+    filterMapByValue(map, predicate) {
+        const result = new Map();
+        for (const [key, value] of map) {
+            if (predicate(value, key)) {
+                result.set(key, value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Stops publishing the Stream.
+     *
+     * @param {StreamHandle} streamHandle handle returned by `createStream`
+     * @throws {Error} when the given `streamHandle` does not exist
+     */
+    async unpublishStream(streamHandle) {
+        if (!this.streams.has(streamHandle)) {
+            throw new Error("No local stream with given id to unpublish");
+        }
+        const _stream = this.streams.get(streamHandle);
+        const filteredTracks = this.filterMapByValue(this.streamTracks, (x) => x.streamHandle !== streamHandle);
+        this.streamTracks = filteredTracks;
+        await this.native.unpublishStream(this.servicePtr, [streamHandle]);
+        this.client.removeSenderPeerConnectionOnUnpublish(_stream.streamRoomId, _stream.localMediaStream);
+        this.streams.delete(streamHandle);
+        this.client.getStreamStateChangeDispatcher().removeOnStateChangeListener({ streamHandle });
+    }
+    /**
+     * Subscribes to selected remote streams (and optionally specific tracks) in the Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     * @param {EndpointTypes.StreamSubscription[]} subscriptions list of remote streams/tracks to subscribe to
+     */
+    async subscribeToRemoteStreams(streamRoomId, subscriptions) {
+        // native part
+        const peerCredentials = await this.native.getTurnCredentials(this.servicePtr, []);
+        await this.client.setTurnCredentials(peerCredentials);
+        // server / core part
+        await this.native.subscribeToRemoteStreams(this.servicePtr, [streamRoomId, subscriptions]);
+        this.client.getConnectionManager().initialize(streamRoomId, "subscriber");
+    }
+    /**
+     * Modifies current remote streams subscriptions.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     * @param {EndpointTypes.StreamSubscription[]} subscriptionsToAdd list of subscriptions to add
+     * @param {StreamSubscription[]} subscriptionsToRemove list of subscriptions to remove
+     */
+    async modifyRemoteStreamsSubscriptions(streamRoomId, subscriptionsToAdd, subscriptionsToRemove) {
+        await this.native.modifyRemoteStreamsSubscriptions(this.servicePtr, [
+            streamRoomId,
+            subscriptionsToAdd,
+            subscriptionsToRemove,
+        ]);
+    }
+    /**
+     * Unsubscribes from selected remote streams (and optionally specific tracks) in the Stream Room.
+     *
+     * @param {string} streamRoomId ID of the Stream Room
+     * @param {StreamSubscription[]} subscriptions list of subscriptions to remove
+     */
+    async unsubscribeFromRemoteStreams(streamRoomId, subscriptions) {
+        await this.native.unsubscribeFromRemoteStreams(this.servicePtr, [
+            streamRoomId,
+            subscriptions,
+        ]);
+    }
+    /**
+     * Registers a listener for remote tracks in the Stream Room.
+     *
+     * @param {RemoteStreamListener} listener listener configuration
+     * @param {string} listener.streamRoomId ID of the Stream Room
+     * @param {number} [listener.streamId] optional remote Stream ID to filter events (omit for all streams)
+     * @param {(event: RTCTrackEvent) => void} listener.onRemoteStreamTrack callback invoked for incoming remote tracks
+     */
+    addRemoteStreamListener(listener) {
+        this.client.addRemoteStreamListener(listener);
+    }
+    /**
+     * Subscribe for the Stream Room events on the given subscription query.
+     *
+     * @param {string[]} subscriptionQueries list of queries
+     * @return list of subscriptionIds in maching order to subscriptionQueries
+     */
+    async subscribeFor(subscriptionQueries) {
+        return this.native.subscribeFor(this.servicePtr, [subscriptionQueries]);
+    }
+    /**
+     * Unsubscribe from events for the given subscriptionId.
+     * @param {string[]} subscriptionIds list of subscriptionId
+     */
+    async unsubscribeFrom(subscriptionIds) {
+        return this.native.unsubscribeFrom(this.servicePtr, [subscriptionIds]);
+    }
+    /**
+     * Generate subscription Query for the Stream Room events.
+     * @param {EventType} eventType type of event which you listen for
+     * @param {EventSelectorType} selectorType scope on which you listen for events
+     * @param {string} selectorId ID of the selector
+     */
+    async buildSubscriptionQuery(eventType, selectorType, selectorId) {
+        return this.native.buildSubscriptionQuery(this.servicePtr, [
+            eventType,
+            selectorType,
+            selectorId,
+        ]);
+    }
+    /**
+     * Registers a callback for audio level statistics produced by the WebRTC client.
+     *
+     * @param {(stats: AudioLevelsStats) => void} onStats callback invoked with current audio levels stats
+     */
+    async addAudioLevelStatsListener(onStats) {
+        if (onStats && typeof onStats === "function") {
+            this.client.setAudioLevelCallback(onStats);
+        }
+    }
+}
+exports.StreamApi = StreamApi;