sinch-rtc 1.4.11 → 2.42.6

package/README.md

@@ -1,189 +1,103 @@
-Sinch Javascript SDK 1.4.8
-==========================
-Welcome to Sinch JS SDK, http://www.sinch.com
+# Sinch RTC SDK - JavaScript
 
-For REST API helper libraries see node modules sinch-rest-api or sinch-request (signing only).
+## Setting Up the Development Environment
 
-Copyright 2014-2017, Sinch AB (reg. no 556969-5397)
+Build tools are installed using [Nix](https://nixos.org/download.html) package manager.
+Before running any `make` commands, ensure your Nix environment is configured to use the correct channel for dependencies.
 
+1. **Add the NixOS 25.05 channel**
 
-Features
-========
-- Sinch SDK for web
-- PSTN Calling
- - Make calls using WebRTC
-- Web/app calling 
- - Make and receive calls using WebRTC
- - Call both web clients and native (iOS and Android)
-- SIP calling
- - Make calls connected to SIP clients
-- Conference calling
-- Instant messaging
- - Cross platform, using native SDK's for iOS and Android
- - Conversations with up to 10 participants
- - Delivery receipts
-- Video calling (beta)
- - Web clients only
-- Group p2p calling
- - Web clients only
-- Phone number verification 
-  - SMS verification
-  - Callout verification
-- Partner user management
- - Authentication ticket for session creation
- - Allows full user management for partner
- - Sample python (tornado) backend in samples folder (SinchAUTHsample)
- - NOTE: Review your app setting for "JS Auth" in the Sinch portal
-- Sinch user management
- - Create user, update password and basic profile
- - Authenticate as user
- - Generate authentication tickets when running as backend
-
-Should you encounter any bugs, glitches, lack of functionality or other problems
-using our SDK, please send us an email to dev@sinch.com. 
-Your help in this regard is greatly appreciated.
-
-
-Quick start
-===========
+   Open your `.nix-channels` file (usually in your home directory) and add the following line:
 
-- Include Sinch JS SDK with:
+   ```bash
+   https://nixos.org/channels/nixos-25.05 nixpkgs-25
+   ```
 
-		<script src="//cdn.sinch.com/latest/sinch.min.js"></script>
+2. **Update Nix channels**
 
-- Read the user-guide for introduction and the reference docs for details
+   Run the following commands to update your channels:
 
-- Look at the sample apps for inspiration
-
-
-Install using Bower
-===================
-
-You can install Sinch RTC SDK in your project using Bower;
-
-	bower install sinch
-
-Import the Sinch SDK in your website using
-
-	<script src="PATH_TO_BOWER_MODULES/sinch-rtc/sinch.min.js"></script>
+   ```bash
+   nix-channel --update
+   nix-channel --list
+   ```
 
+   You should see something like:
 
-Install using Node JS
-=====================
-
-Sinch is also available as a node package. Install Sinch RTC SDK using;
-
-	npm install sinch-rtc
-
-Import Sinch SDK in your javascript using
-
-	var SinchClient = require('sinch-rtc');
-
-	var sinchClient = new SinchClient({
-		applicationKey: 'YOUR KEY',
-		capabilities: {messaging: true},
-		onLogMessage: function(message) {
-			console.log(message);
-		}
-		});
+   ```bash
+   nixpkgs-25 https://nixos.org/channels/nixos-25.05
+   ```
 
-	sinchClient.start(CREDENTIALS).then(function() {
-			console.log('Success!');
-		})
+   You can now safely run `make` commands
 
-Applications developed with node package does not quite yet support Browserify,
-without some minor modifications.
+To install a local devenv, run:
 
+    make devenv
 
-Getting Started
-===============
-Familiarise yourself with the user guide (documentation folder or online).
+In the root of this repository run:
 
-Have a look at the Sample App in the samples/ folder, where you'll find:
-- SinchIMsample, our Instant Messaging sample app
-- SinchPSTNsample, our PSTN calling sample app
-- SinchWEBsample, our Web to Web calling sample app
-- SinchAUTHsample, our sample for demonstrating integrating a custom backend
-  for user authentication (useful for native app compatability)
-- python-backend-sample, a sample backend for Sinch written in Python 
-  (see README.md for more information on getting started)
-- SinchVIDEOsample, sample for person to person video calling
-- SinchGROUPVIDEOsample, sample for group video conferencing
-- SinchVERsample, sample for SMS number verification
-- SinchCALLOUTsample, sample for Callout number verification
+    make sync
 
-These sample apps demonstrate user management, session handling and more. 
-The interesting stuff can be found in the .js files.
+This will
 
-In order to get started follow these steps: 
+- Sync git submodules.
+- Set up npm environment [https://www.npmjs.com/]
 
-1. Try open SinchIMsample/index.html in a web-browser (Chrome or Firefox). 
-   Open the developer console. 
-2. In the browser window you should see a web form where you can either create 
-   a new user or login as a user. 
-3. Try creating a user
-4. An error message "Illegal Authorization Header" error is shown. This is 
-   because the sample app don't use your app key yet. 
-5. Go to www.sinch.com, create an account and a new application (or use an 
-   already existing app)
-6. Replace MY_APPLICATION_KEY in IMsample.js with your application key. 
-7. Try creating a user, now it should work! 
-   Note: Only if "JS Auth" is enabled in portal for your app
-8. Open the same page in a separate window and create another user
-9. You can now try sending messages between these two users.
+When the script finishes, it should be possible to run.
 
-Have a look at the source code in IMsample.js, enable the onLogMessage callback 
-if you're curious about the activity under the hood. It's a good way to have 
-logging enabled during development for easy error tracking.
+    make serve
 
-You can also activate session loading by enabling the if-statement on line 45, 
-by removing "false" from the if-statement. The PSTN and AUTH sample application 
-has this activated by default, please see the PSTNsample.js file for reference.
+this will build the sdk and start a local http server on port 5050 if everything works you should be able to load [http://localhost:5050/reference-apps/javascript/samples/]
 
-As for the PSTN sample app, you may have to load the application from a web 
-server (can be local), depending on the security settings for WebRTC in your 
-browser. Also, when trying PSTN calls please ensure you replace 
-"MY_APPLICATION_KEY" with your actual key. 
+## Build and Test Sdk
 
+### Build
 
-Documentation
-=============
-The user-guide is available in the docs/ folder. 
-Open index.html and read about:
+    make build
 
-- Instructions for first-time developers
-- Using Sinch in your app for sending and receiving messages
-- Using Sinch in your app for making PSTN calls
-- Using Sinch in your app for making data calls
-- Learn about sinch authentication 
-- Session Management 
-- Other information about Sinch, such as creating your app, note on export 
-  regulations and more.
+### Generate ocra api from ocra design
 
-Reference documentation is available in docs/ folder. Read about: 
+    make ocra
 
-- SinchClient (starting point)
-- MessageClient
-- CallClient
+### Build and start local http server
 
+    make serve
 
-Known issues
-============
-- There is an issue running too many instances at the same time. No more than 
-  5-6 instances can be run at the same time in the same browser. 
-  (if problem experienced, restart browser and only run one instance and try 
-  again with fewer instances)
-- After three failed login attempts on one user accounts, that account is 
-  locked for a while with no ability to unlock (when using Sinch auth).
-- Restore messages missed since last login is currently disabled. 
-- When browser close, any ongoing PSTN calls are not terminated properly but 
-  relies on B-side doing a time-out. (~ 1 minute)
-- Browserify is not yet supported for Node JS distribution. 
+### Tests
 
+    make test
 
+### Create the jssdk package
 
+    make dist
 
+## E2E Smoke test
 
+### Build Sdk for E2E smoke test
 
+    make bidiro
 
+### Build and start local host for running test host app
 
+    make bidiro-serve
+
+This will start a local webserver at port 1080 and a WebSocket proxy listening on port 3000. To run the test host app use <http://localhost:1080/sinch/{channel}/?sdk={sdk}>
+
+{channel} is an identifier for the channel and can be any string. WebSocket message to this app should be sent to http://{host}:3000/bidiro/{channel}
+
+{sdk} is the folder where the sdk is located. By defaulr {sdk} is "sdk" which is the folder where the local built (make bidiro) sdk is located.
+
+### Running E2E Tests inside docker locally
+
+`npm run e2e`
+
+## Prerequisites
+
+1. Make sure you have cloned the [E2E repository](https://gitlab.com/sinch/sinch-projects/voice/rtc-sdk-e2e-test) in your home directory
+2. The JS sdk and E2E respository are in the same parent directory
+3. Docker or [Docker Desktop](https://www.docker.com/products/docker-desktop/) is installed on your machine
+4. Replace `localhost` with `bidirohost` for `sinch.device.1` and `sinch.device.1` in `parameters-js-v2.xml`.
+
+### Design
+
+For design document, see [design/README.md](design/README.md)

package/npm/src/ClientRegistration.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Callback object to be used to proceed in user registration/setup when
+ * registration credentials for the user in question have been obtained.
+ */
+export declare class ClientRegistration {
+    register: (jwtSignature: string) => Promise<void>;
+    registerFailed: () => void;
+    /**
+     * Methods to call when registration credentials for the user have been
+     * obtained.
+     *
+     * @param register - Callback to call with a signed JWT token for this user.
+     * @param registerFailed - Callback to call when registration for the user has failed
+     */
+    constructor(register: (jwtSignature: string) => Promise<void>, registerFailed: () => void);
+}

package/npm/src/ClientRegistration.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientRegistration = void 0;
+/**
+ * Callback object to be used to proceed in user registration/setup when
+ * registration credentials for the user in question have been obtained.
+ */
+class ClientRegistration {
+    /**
+     * Methods to call when registration credentials for the user have been
+     * obtained.
+     *
+     * @param register - Callback to call with a signed JWT token for this user.
+     * @param registerFailed - Callback to call when registration for the user has failed
+     */
+    constructor(register, registerFailed) {
+        this.register = register;
+        this.registerFailed = registerFailed;
+    }
+}
+exports.ClientRegistration = ClientRegistration;
+//# sourceMappingURL=ClientRegistration.js.map

package/npm/src/DefaultSinchClient.d.ts

@@ -0,0 +1,59 @@
+import { CallInitiator, CallClient } from "./calling";
+import { SinchConfig } from "./models";
+import { SinchClientListener } from "./SinchClientListener";
+import { CallInitiationResponse, Config, InitiateCallRequest } from "./ocra/api";
+import { SinchClient } from "./SinchClient";
+import { NotificationResult } from "./push/NotificationResult";
+export declare class DefaultSinchClient implements CallInitiator, SinchClient {
+    private static readonly OCRA_PATH;
+    private readonly ServiceWorkerName;
+    applicationKey: string;
+    userId: string;
+    private callerIdentifier?;
+    private defaultCallClient;
+    private clientEvent;
+    private instanceController;
+    private isClientStarted;
+    private apiClient;
+    private onStartedAction;
+    private pushWorker?;
+    private pushService;
+    private features;
+    private useRelayIceCandidatesOnly;
+    private addTurnListener;
+    private isUsingManagedPush;
+    private instanceConfigJson?;
+    private instanceConfigUpdateInterval?;
+    /**
+     * @param config -
+     * config.applicationKey - application unique key from Sinch portal
+     * config.userId - userId for whom instance is created
+     * [config.ttl] TODO: TTL param for setting lifetime of Ocra instance
+     */
+    constructor(config: SinchConfig);
+    set pushNotificationDisplayName(displayName: string | undefined);
+    get pushNotificationDisplayName(): string | undefined;
+    setUseRelayIceCandidatesOnly(useRelayIceCandidatesOnly: boolean): void;
+    private processExternalPushNotification;
+    private getBaseUrl;
+    private isUrl;
+    start(instanceConfig?: Config): Promise<void>;
+    setSupportManagedPush(serviceWorker?: string): Promise<void>;
+    disableManagedPushSupport(): Promise<void>;
+    private failed;
+    private setupPush;
+    private createAndSetUpCallReporter;
+    private started;
+    private setupConfigCheck;
+    private clearInstanceConfigUpdateInterval;
+    addListener(listener: SinchClientListener): void;
+    removeListener(listener: SinchClientListener): void;
+    initiateCall(request: InitiateCallRequest): Promise<CallInitiationResponse>;
+    onPush: (message: any) => void;
+    get callClient(): CallClient;
+    terminate(): void;
+    get localUserId(): string;
+    isStarted(): boolean;
+    relayRemotePushNotification(payload: Record<string, string>): NotificationResult;
+    showPushNotification(title: string, options: NotificationOptions): void;
+}

package/npm/src/DefaultSinchClient.js

@@ -0,0 +1,253 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSinchClient = void 0;
+const calling_1 = require("./calling");
+const models_1 = require("./models");
+const api_1 = require("./ocra/api");
+const InstanceController_1 = require("./instance/InstanceController");
+const fsm_1 = require("./session/fsm");
+const push_1 = require("./push");
+const ClientEventFanout_1 = require("./calling/listeners/ClientEventFanout");
+const CallReporter_1 = require("./calling/reporting/CallReporter");
+const ApiClient_1 = require("./ocra/ApiClient");
+const utils_1 = require("./utils");
+const Features_1 = require("./features/Features");
+const StorageFactory_1 = require("./storage/StorageFactory");
+const IceServer_1 = require("./rtc/IceServer");
+class DefaultSinchClient {
+    /**
+     * @param config -
+     * config.applicationKey - application unique key from Sinch portal
+     * config.userId - userId for whom instance is created
+     * [config.ttl] TODO: TTL param for setting lifetime of Ocra instance
+     */
+    constructor(config) {
+        this.ServiceWorkerName = "sw.js";
+        this.isClientStarted = false;
+        this.useRelayIceCandidatesOnly = false;
+        this.isUsingManagedPush = false;
+        this.processExternalPushNotification = (json) => {
+            const payload = {
+                sinch: json,
+                name: "ForSmokeTests",
+            };
+            this.relayRemotePushNotification(payload);
+        };
+        this.onPush = (message) => {
+            this.relayRemotePushNotification(message.data);
+        };
+        this.clientEvent = new ClientEventFanout_1.ClientEventFanout(this);
+        this.features = Features_1.FeaturesFactory.create(StorageFactory_1.StorageFactory.createFeatureStorage());
+        if (!config || !config.applicationKey) {
+            throw new Error("Parameter appKey is required");
+        }
+        this.applicationKey = config.applicationKey;
+        this.userId = config.userId;
+        this.callerIdentifier = config.callerIdentifier;
+        this.apiClient = ApiClient_1.ApiClientFactory.create(new api_1.Configuration({
+            basePath: this.getBaseUrl(config.baseUrl),
+            fetchApi: config.fetchApi,
+        }));
+        this.instanceController = new InstanceController_1.InstanceController(this.applicationKey, this.userId, this.clientEvent, this.apiClient);
+        this.pushService = push_1.PushFactory.createPushService(this.userId, this.apiClient);
+        this.defaultCallClient = calling_1.CallClientFactory.create(this.userId, this.applicationKey, config.mediaManager);
+        this.onStartedAction = new Array();
+        this.addTurnListener = (0, utils_1.pipe)(IceServer_1.onTurnFeatureFlagChanged, this.features.addListener.bind(this.features));
+    }
+    set pushNotificationDisplayName(displayName) {
+        if (displayName && displayName.length > 255)
+            throw new fsm_1.ArgumentError("displayName must not exceed 255 bytes", (0, utils_1.nameof)(displayName));
+        this.pushService.pushNotificationDisplayName = displayName;
+    }
+    get pushNotificationDisplayName() {
+        return this.pushService.pushNotificationDisplayName;
+    }
+    setUseRelayIceCandidatesOnly(useRelayIceCandidatesOnly) {
+        this.useRelayIceCandidatesOnly = useRelayIceCandidatesOnly;
+    }
+    getBaseUrl(url) {
+        return ((!this.isUrl(url) ? "https://" : "") + url + DefaultSinchClient.OCRA_PATH);
+    }
+    isUrl(urlOrHost) {
+        return urlOrHost.startsWith("http://") || urlOrHost.startsWith("https://");
+    }
+    start(instanceConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.started(yield this.instanceController.start(), instanceConfig);
+            }
+            catch (ex) {
+                this.isClientStarted = false;
+                console.error(ex);
+                this.failed("Unable to create instance!");
+            }
+        });
+    }
+    setSupportManagedPush(serviceWorker) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.instanceController.toggleCapability(models_1.Capability.Push, true);
+            this.isUsingManagedPush = true;
+            this.pushWorker = push_1.PushFactory.createPushWorker(serviceWorker !== null && serviceWorker !== void 0 ? serviceWorker : this.ServiceWorkerName, this.pushService);
+            yield this.pushWorker.register();
+            this.pushWorker.addEventListener(this.onPush);
+        });
+    }
+    disableManagedPushSupport() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.instanceController.toggleCapability(models_1.Capability.Push, false);
+            this.isUsingManagedPush = false;
+            yield ((_a = this.pushWorker) === null || _a === void 0 ? void 0 : _a.unregister());
+            this.pushWorker = undefined;
+        });
+    }
+    failed(reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clientEvent.onEvent({ eventType: "failed", context: reason });
+        });
+    }
+    setupPush(instance, applicationServerKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!applicationServerKey)
+                throw new fsm_1.InvalidOperationError("Missing public VAPID key");
+            if (this.pushWorker) {
+                // todo: this key should be populated from the instanceConfig once the push backend is ready, for now fallback on hardcoded.
+                yield this.pushWorker.start(applicationServerKey, instance);
+            }
+        });
+    }
+    createAndSetUpCallReporter(instance) {
+        return new CallReporter_1.CallReporter(this.userId, instance, this.apiClient);
+    }
+    started(instance, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                if (this.instanceController.authentication) {
+                    const instanceConfig = config !== null && config !== void 0 ? config : (yield this.apiClient.getConfig({
+                        instanceId: instance.id,
+                        userId: this.userId,
+                    }));
+                    this.instanceConfigJson = JSON.stringify(instanceConfig);
+                    this.setupConfigCheck(instance, instanceConfig);
+                    this.instanceController.setUpdateInstanceTtlWindow(instanceConfig.updateInstanceTtlWindowDays);
+                    this.apiClient.setUpdateInstanceTtlWindow(instanceConfig.updateInstanceTtlWindowDays);
+                    yield this.instanceController.prolongInstanceIfNeeded();
+                    this.addTurnListener(this.instanceController);
+                    const fetchIceServers = (0, IceServer_1.createIceServerFetcher)(this.apiClient, this.userId, instance.id);
+                    this.features.setUserInstance(this.userId, instance.id, this.applicationKey);
+                    const callReporter = this.createAndSetUpCallReporter(instance);
+                    if (this.features.shouldRefresh()) {
+                        yield this.features.refresh(this.apiClient);
+                    }
+                    if (this.isUsingManagedPush) {
+                        yield this.setupPush(instance, (_a = instanceConfig.pushConfig) === null || _a === void 0 ? void 0 : _a.w3cApplicationServerKey);
+                    }
+                    this.defaultCallClient.init(this, instanceConfig.rtcProfile, instanceConfig.rtcConfig, fetchIceServers, callReporter, this.pushService, this.useRelayIceCandidatesOnly, this.features, instance.id, this.callerIdentifier);
+                    this.isClientStarted = true;
+                    this.onStartedAction.splice(0).forEach((a) => a());
+                    this.clientEvent.onEvent({ eventType: "started" });
+                }
+            }
+            catch (error) {
+                this.failed(error).catch(() => {
+                    console.error(error);
+                });
+            }
+        });
+    }
+    setupConfigCheck(instance, instanceConfig) {
+        var _a, _b;
+        const configUpdater = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const newInstanceConfig = yield this.apiClient.getConfig({
+                instanceId: instance.id,
+                userId: this.userId,
+            });
+            const newInstanceConfigJson = JSON.stringify(newInstanceConfig);
+            if (this.instanceConfigJson !== newInstanceConfigJson) {
+                this.clearInstanceConfigUpdateInterval();
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    if (!((_a = this.defaultCallClient.getInstance()) === null || _a === void 0 ? void 0 : _a.hasActiveCall())) {
+                        console.log("New instance config - restarting client");
+                        this.terminate();
+                        this.start(newInstanceConfig);
+                        break;
+                    }
+                    yield utils_1.PromiseHelper.sleep(1000);
+                }
+            }
+        });
+        const interval = setInterval(configUpdater, instanceConfig.configRefreshIntervalMs);
+        this.instanceConfigUpdateInterval = (_b = (_a = interval.unref) === null || _a === void 0 ? void 0 : _a.call(interval)) !== null && _b !== void 0 ? _b : interval;
+    }
+    clearInstanceConfigUpdateInterval() {
+        if (this.instanceConfigUpdateInterval != null) {
+            clearInterval(this.instanceConfigUpdateInterval);
+            this.instanceConfigUpdateInterval = undefined;
+        }
+    }
+    addListener(listener) {
+        this.clientEvent.addListener(listener);
+    }
+    removeListener(listener) {
+        this.clientEvent.removeListener(listener);
+    }
+    initiateCall(request) {
+        if (this.isClientStarted) {
+            return this.apiClient.initiateCall(request);
+        }
+        else {
+            throw new fsm_1.InvalidOperationError("Can not initiate a call before authentication");
+        }
+    }
+    get callClient() {
+        return this.defaultCallClient;
+    }
+    terminate() {
+        this.isClientStarted = false;
+        this.instanceController.terminate();
+        this.clearInstanceConfigUpdateInterval();
+        this.features.resetListeners();
+        this.clientEvent.onEvent({ eventType: "terminated" });
+    }
+    get localUserId() {
+        return this.userId;
+    }
+    isStarted() {
+        return this.isClientStarted;
+    }
+    relayRemotePushNotification(payload) {
+        const result = new push_1.DefaultNotificationResult(payload.sinch, payload.name);
+        if (result.isValid()) {
+            if (this.isStarted()) {
+                this.defaultCallClient.handleCallPushPayload(result);
+            }
+            else {
+                this.onStartedAction.push(() => this.defaultCallClient.handleCallPushPayload(result));
+                this.start();
+            }
+        }
+        return result;
+    }
+    showPushNotification(title, options) {
+        var _a;
+        (_a = this.pushWorker) === null || _a === void 0 ? void 0 : _a.showNotification(title, options);
+    }
+}
+exports.DefaultSinchClient = DefaultSinchClient;
+DefaultSinchClient.OCRA_PATH = "/ocra";
+// Export as standalone to global scope
+if (typeof window !== "undefined")
+    window.SinchClient = DefaultSinchClient;
+//# sourceMappingURL=DefaultSinchClient.js.map

package/npm/src/DefaultSinchClientBuilder.d.ts

@@ -0,0 +1,22 @@
+import { MediaStreamFactory } from "./rtc/MediaStreamFactory";
+import { SinchClient } from "./SinchClient";
+import { SinchClientBuilder } from "./SinchClientBuilder";
+export declare class DefaultSinchClientBuilder implements SinchClientBuilder {
+    private clientUserId?;
+    private clientApplicationKey?;
+    private clientEnvironmentHost?;
+    private clientCallerIdentifier?;
+    private clientVideoConstraints?;
+    private clientFetchApi?;
+    private clientMediaStreamFactory?;
+    userId(userId: string): SinchClientBuilder;
+    applicationKey(applicationKey: string): SinchClientBuilder;
+    environmentHost(environmentHost: string): SinchClientBuilder;
+    callerIdentifier(callerIdentifier: string): SinchClientBuilder;
+    fetchApi(fetchApi: (input: RequestInfo, init?: RequestInit) => Promise<Response>): SinchClientBuilder;
+    mediaStreamFactory(mediaStreamFactory: MediaStreamFactory): SinchClientBuilder;
+    videoConfiguration(videoConstraints: MediaTrackConstraints): SinchClientBuilder;
+    silentMediaStream(): SinchClientBuilder;
+    private getDefaultMediaStreamFactory;
+    build(): SinchClient;
+}