@vindral/web-sdk 1.2.1 → 2.0.2

package/LICENSES

@@ -0,0 +1,66 @@
+libopus license
+---------------
+
+Copyright 2001-2011 Xiph.Org, Skype Limited, Octasic,
+                    Jean-Marc Valin, Timothy B. Terriberry,
+                    CSIRO, Gregory Maxwell, Mark Borgerding,
+                    Erik de Castro Lopo
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of Internet Society, IETF or IETF Trust, nor the
+names of specific contributors, may be used to endorse or promote
+products derived from this software without specific prior written
+permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Opus is subject to the royalty-free patent licenses which are
+specified at:
+
+Xiph.Org Foundation:
+https://datatracker.ietf.org/ipr/1524/
+
+Microsoft Corporation:
+https://datatracker.ietf.org/ipr/1914/
+
+Broadcom Corporation:
+https://datatracker.ietf.org/ipr/1526/
+
+
+
+h264 license
+------------
+
+Copyright (C) 2009 The Android Open Source Project
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -2,41 +2,55 @@
 
 **Ultra low latency streaming on all modern web browsers.**
 
-This package contains the web SDK for Vindral - the ultra low latency streaming platform for synchronized live experiences.
+This package contains the Web SDK for Vindral - the ultra low latency streaming platform for synchronized live experiences.
 
-Check out our [demo](https://demo.vindral.com/).
+For information about the Vindral product family and how the Web SDK fits into the system, [make sure to read the System Overview](https://docs.vindral.com/docs/overview/system-overview).
+
+Make sure to check out the full [Web SDK Documentation](https://docs.vindral.com/web-sdk/) as well.
+
+[Check out our demo](https://demo.vindral.com/) to see some of Vindral's features.
 
 ## Getting Started
 
 There are multiple ways to integrate the Web SDK, depending on use-case.
 
-The simplest way to get started is to use the [Iframe Embed Player](#embed). This requires the least amount of code, and will automatically be updated when new releases are available.
+The most simple way to get started is to use the iframe-based [Embed Player](#embed-player). This requires the least amount of code, and will automatically be updated when new releases are available.
 
 The two other alternatives are [Player SDK](#player-sdk) and [Core SDK](#core-sdk) - these are the recommended options if the integration requires access to the APIs, such as timed metadata or other controls. The two SDKs have very similar APIs, but the Player SDK provides controls and buffering indication built in - the Core SDK is the most strippped down implementation for use-cases where all UI components are customized.
 
-### Embed
+If you are going for one of the SDK alternatives, follow the steps at [Installation](#installation) to get started:
+
+## Embed Player
 
 This is the simplest way to integrate. It allows you to add a fully functional video player to your site in no time. It will also be automatically updated when improvements are released.
 
-Add the following html snippet, replace `channel-id` and `cdn-entry-url` with your stream credentials, done!
+Add the following html snippet, set `channelId` to channel id credential, done!
 
-```
-<iframe src="https://embed.vindral.com/?core.channelId=<channel-id>&core.url=<cdn-entry-url>" frameborder="0" allowfullscreen></iframe>
+```html
+<iframe
+  src="https://embed.vindral.com/?channelId=vindral_demo1_ci_099ee1fa-80f3-455e-aa23-3d184e93e04f"
+  frameborder="0"
+  allowfullscreen
+></iframe>
 ```
 
-### SDK
+[See the player in action](https://embed.vindral.com/?channelId=vindral_demo1_ci_099ee1fa-80f3-455e-aa23-3d184e93e04f) or [read more about Embed Player here](https://docs.vindral.com/docs/guides/using-the-embed-player).
 
-**Installation**
+## Installation
 
-The SDK is available as a package on NPM for use with a module bundler:
+Install @vindral/web-sdk using `npm`:
 
 ```
-npm install @vindral/web-sdk
+npm install --save @vindral/web-sdk
 ```
 
-For usage, see [Player Example](#example) and [Core Example](#example-1) and the API references.
+or `yarn`:
 
-#### Player SDK
+```
+yarn add @vindral/web-sdk
+```
+
+### Player SDK
 
 The Player SDK provides a ready-to-go player with controls - perfect for use-cases where the embed solution is not enough, such as when access to the javascript API is needed.
 
@@ -52,21 +66,18 @@ import { Player } from "@vindral/web-sdk"
 const root = document.querySelector<HTMLElement>("#root")
 
 const player = new Player({
-  url: "<cdn-entry-url>",
-  channelId: "<channel-id>",
+  url: "https://lb.cdn.vindral.com",
+  channelId: "vindral_demo1_ci_099ee1fa-80f3-455e-aa23-3d184e93e04f",
 })
 
 // Starts connecting to the channel
 player.core.connect()
 
-// This event is emitted when timed metadata events occur
-player.core.on("metadata", (metadata) => console.log("metadata: ", metadata.content))
-
 // Attaches the player view to the DOM
 player.attach(root)
 ```
 
-#### Core SDK
+### Core SDK
 
 The Core SDK is the lowest level method to integrate that provides only a video view and audio playback - this allows for full customization of the look of buffering indication, controls, etc.
 
@@ -75,7 +86,7 @@ The Core SDK is the lowest level method to integrate that provides only a video
 The example assumes that there is a html page that loads this script that has at least a div with `id="#root"`, `id="#playback-state"` and a button with `id="#activate-audio-button"`.
 
 ```typescript
-import { Vindral } from "@vindrl/web-sdk"
+import { Vindral } from "@vindral/web-sdk"
 
 const root = document.querySelector<HTMLElement>("#root")!
 const button = document.querySelector<HTMLElement>("#activate-audio-button")!
@@ -84,8 +95,8 @@ const playbackState = document.querySelector<HTMLElement>("#playback-state")!
 button.style.display = "none"
 
 const instance = new Vindral({
-  url: "<cdn-entry-url>",
-  channelId: "<channel-id>",
+  url: "https://lb.cdn.vindral.com",
+  channelId: "vindral_demo1_ci_099ee1fa-80f3-455e-aa23-3d184e93e04f",
 })
 
 // Errors are emitted when they can not be handled internally
@@ -122,6 +133,6 @@ button.addEventListener("click", () => {
 
 #### License and support
 
-Vindral is a commercial product and requires an active, paid license to access and use. To obtain such a license, or in case you have any questions, get in touch on vindral.com/inquiries
+Vindral is a commercial product and requires an active, paid license to access and use. To obtain such a license, or in case you have any questions, do not hesitate to [get in touch](https://vindral.com/inquiries)!
 
-Copyright Realsprint AB
+Copyright RealSprint AB

package/index.d.ts

@@ -317,8 +317,12 @@ interface VindralErrorProps {
 	source?: Error;
 }
 export declare const CONNECTION_FAILED_CODE = "connection_failed";
+export declare const CONNECTION_FAILED_AFTER_RETRIES_CODE = "connection_failed_will_not_attempt_again";
 export declare const AUTHENTICATION_FAILED_CODE = "authentication_error";
+export declare const AUTHENTICATION_EXPIRED_CODE = "authentication_expired";
+export declare const CHANNEL_NOT_FOUND_CODE = "channel_not_found";
 export declare const NO_INCOMING_DATA = "no_incoming_data_error";
+export declare const INACTIVITY_CODE = "connection_inactivity";
 export declare class VindralError extends Error {
 	private props;
 	private extra;
@@ -331,7 +335,12 @@ export declare class VindralError extends Error {
 export declare const mediaElementError: (isFatal: boolean, mediaError: MediaError) => VindralError;
 export declare const audioContextTimeoutError: () => VindralError;
 export declare const authenticationError: () => VindralError;
+export declare const authenticationExpiredError: () => VindralError;
+export declare const inactivityError: () => VindralError;
+export declare const channelNotFoundError: () => VindralError;
 export declare const noIncomingDataError: () => VindralError;
+export declare const unableToConnectError: () => VindralError;
+export declare const unableToConnectAfterRetriesError: () => VindralError;
 export declare const isValidOptions: (options: unknown) => options is Options;
 export declare const validateOptions: (options: Options) => Options;
 declare type State = "connected" | "disconnected" | "connecting";
@@ -369,7 +378,9 @@ declare class ConnectionModule {
 	private lastPingSentTime?;
 	private connectCount;
 	private _firstConnectionTime?;
+	private _lastConnectionTime?;
 	private contextSwitchesInProgress;
+	private contextSwitchesCompleted;
 	private buffer;
 	private constructor();
 	static create: (emitter: Emitter<ConnectionModuleListeners, ConnectionModuleEvents>, logger: Logger, options: ConnectOptions) => ConnectionModule;
@@ -380,12 +391,13 @@ declare class ConnectionModule {
 	get estimatedBandwidth(): number | undefined;
 	get connectTime(): number | undefined;
 	get firstConnectionTime(): number | undefined;
+	get lastConnectionTime(): number | undefined;
 	getState: () => State;
 	sendSignal: (signal: Readonly<string>) => void;
 	getStatistics: () => ConnectionStatistics;
 	private onMessage;
 	private handleMessage;
-	connect: () => void;
+	connect: (connectionsCount: 1 | 2) => void;
 	private onTransportChange;
 	disconnect: (reason?: string) => void;
 	reconnect: (reason: string) => void;
@@ -451,8 +463,8 @@ declare class RenditionsModule {
 	constructor(emitter: Emitter<RenditionsModuleListeners, RenditionsModuleEvents>, subscriptionSource: SubscriptionSource);
 	unload: () => void;
 	static create: (emitter: Emitter<RenditionsModuleListeners, RenditionsModuleEvents>, subscriptionSource: SubscriptionSource) => RenditionsModule;
-	getRenditionLevels: () => ReadonlyArray<RenditionLevel>;
-	getRenditionLevel: (constraint?: Constraint) => RenditionLevel | undefined;
+	getRenditionLevels: (subscription?: Readonly<Subscription> | undefined) => ReadonlyArray<RenditionLevel>;
+	getRenditionLevel: (subscription?: Readonly<Subscription> | undefined) => RenditionLevel | undefined;
 	setRenditions: (channelId: ChannelId, renditions: Rendition[]) => void;
 	getLanguages: () => ReadonlyArray<string>;
 	getVideoRendition: (renditionId: number, channelId?: string) => Readonly<VideoRendition> | undefined;
@@ -462,6 +474,7 @@ declare class RenditionsModule {
 	private onRenditions;
 	private onSubscriptionChanged;
 	private updateRenditionLevels;
+	private createRenditionLevels;
 	private getCurrentSubscription;
 }
 interface Size {
@@ -485,8 +498,11 @@ declare class SubscriptionModule {
 	isSwitchingSubscription: () => boolean;
 	getTargetSubscription: () => Subscription;
 	getCurrentSubscription: () => Subscription;
-	setMaxSize: (size: Readonly<Size>) => void;
-	setMaxBitRate: (bitRate: number) => void;
+	setSize: (size: Readonly<Size>) => void;
+	setVideoConstraint: (constraint: VideoConstraint) => void;
+	setAudioConstraint: (constraint: AudioConstraint) => void;
+	setVideoBitRate: (bitRate: number) => void;
+	setAudioBitRate: (bitRate: number) => void;
 	setChannelId: (channelId: string) => void;
 	setLanguage: (language: string | undefined) => void;
 	setVideoCodec: (videoCodec: VideoCodec | undefined) => void;
@@ -545,6 +561,7 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	private _channels;
 	private createdAt;
 	private hasCalledConnect;
+	private apiClient;
 	private durationSessions;
 	constructor(options: Options);
 	attach: (container: HTMLElement) => void;
@@ -573,6 +590,10 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	set maxSize(size: Size);
 	get maxBitRate(): number;
 	set maxBitRate(bitRate: number);
+	get maxVideoBitrate(): number;
+	set maxVideoBitrate(bitRate: number);
+	get maxAudioBitrate(): number;
+	set maxAudioBitrate(bitRate: number);
 	get renditionLevels(): ReadonlyArray<RenditionLevel>;
 	get currentRenditionLevel(): Readonly<RenditionLevel> | undefined;
 	get targetRenditionLevel(): Readonly<RenditionLevel> | undefined;
@@ -584,10 +605,13 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	get bufferingRatios(): Map<string, number>;
 	get timeSpentBuffering(): number;
 	get timeActive(): number;
+	updateAuthenticationToken: (token: string) => void;
 	connect: () => void;
+	private connectionInfo;
 	private connectHandler;
 	private filterRenditions;
 	private patchSubscription;
+	private isSupportedVideoCodecProfile;
 	private supportedAudioCodecs;
 	private initializeDecodingModule;
 	unload: () => Promise<void>;
@@ -596,6 +620,7 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	get uptime(): number;
 	getStatistics: () => Statistics;
 	private onBufferEvent;
+	private alignSizeAndBitRate;
 	private get currentSubscription();
 	private get targetSubscription();
 	private timeToFirstFrame;
@@ -637,15 +662,30 @@ interface Size {
 interface PictureInPictureSizeSource {
 	getPictureInPictureSize(): Size | undefined;
 }
+declare type DeepPartial<T> = {
+	[P in keyof T]?: DeepPartial<T[P]>;
+};
 interface ConstraintCapModuleEvents {
-	["constraint cap changed"]: Readonly<Constraint>;
+	["constraint cap changed"]: Readonly<ConstraintCap>;
 }
 interface ConstraintCapModuleListeners {
 	["enter picture in picture"]: Readonly<PictureInPictureSizeSource>;
 	["exit picture in picture"]: void;
 }
+interface VideoConstraintCap {
+	width: number;
+	height: number;
+	bitRate: number;
+}
+interface AudioConstraintCap {
+	bitRate: number;
+}
+interface ConstraintCap {
+	video: VideoConstraintCap;
+	audio: AudioConstraintCap;
+}
 interface ConstraintCapStatistics {
-	constraintCap?: Constraint;
+	constraintCap?: ConstraintCap;
 	windowInnerWidth: number;
 	windowInnerHeight: number;
 	elementWidth: number;
@@ -666,17 +706,20 @@ declare class ConstraintCapModule {
 	private renditionLevelSource;
 	private resizeObserver?;
 	private elementSize;
-	private sizeBasedResolutionCapEnabled;
+	private _sizeBasedResolutionCapEnabled;
 	constructor(emitter: Emitter<ConstraintCapModuleListeners, ConstraintCapModuleEvents>, element: HTMLElement, renditionLevelSource: RenditionLevelSource, sizeBasedResolutionCapEnabled: boolean);
 	unload: () => void;
 	load: () => void;
 	static create: (emitter: Emitter<ConstraintCapModuleListeners, ConstraintCapModuleEvents>, element: HTMLElement, renditionLevelSource: RenditionLevelSource, sizeBasedResolutionCapEnabled: boolean) => ConstraintCapModule;
 	unsuspend: () => void;
 	suspend: () => void;
-	setUserSpecifiedCap: (cap: Partial<Constraint>) => void;
-	getUserSpecifiedCap: () => Constraint | undefined;
-	getCurrentConstraintCap: () => Constraint | undefined;
+	get sizeBasedResolutionCapEnabled(): boolean;
+	set sizeBasedResolutionCapEnabled(enabled: boolean);
+	setUserSpecifiedCap: (cap: DeepPartial<ConstraintCap>) => void;
+	getUserSpecifiedCap: () => ConstraintCap | undefined;
+	getCurrentConstraintCap: () => ConstraintCap | undefined;
 	getStatistics: () => ConstraintCapStatistics;
+	constrainSubscription: (subscription: Subscription) => Subscription;
 	private onResize;
 	private evaluateConstraintCap;
 	private enterPictureInPicture;
@@ -906,6 +949,7 @@ interface QualityOfServiceModuleEvents {
 interface QualityOfServiceModuleStatistics {
 	timeSpentBuffering: number;
 	bufferingEventsCount: number;
+	fatalQosCount: number;
 	timeSpentRatio: {
 		[bitRate: string]: number;
 	};
@@ -919,6 +963,7 @@ declare class QualityOfServiceModule {
 	private bufferFullnessRegression?;
 	private currentLevel?;
 	private isSuspended;
+	private _fatalQosCount;
 	private hasAsserted;
 	constructor(emitter: Emitter<QualityOfServiceModuleEvents>, logger: Logger);
 	static create: (emitter: Emitter<QualityOfServiceModuleEvents>, logger: Logger) => QualityOfServiceModule;
@@ -926,6 +971,9 @@ declare class QualityOfServiceModule {
 	unload: () => void;
 	suspend: () => void;
 	unsuspend: () => void;
+	fatalQosGraceTime: () => number;
+	get fatalQosCount(): number;
+	incrementFatalQosCount: () => void;
 	getMetrics: () => Metrics;
 	getLevelStats: (renditionLevel: RenditionLevel) => PerLevelStats | undefined;
 	getBufferFullnessRegression: () => Regression | undefined;
@@ -974,20 +1022,25 @@ interface SyncModuleStatistics {
 	discardedTimeInfoCount: number;
 }
 declare class SyncModule {
-	private static INCREASE_MAX_BEHIND_EVERY;
 	private emitter;
 	private logger;
 	private playbackSource;
 	private bufferSource;
 	private lastSeekTime;
 	readonly seekCooldownTime = 5000;
-	readonly catchupRate = 1.05;
-	readonly slowdownRate = 0.95;
-	syncMaxBehind: number;
+	readonly syncMaxBehind: number;
+	readonly syncMaxBehindMultiplierStep = 1;
+	readonly syncMaxBehindIncreaseEvery = 5;
+	readonly syncMaxBehindMaximumAllowed = 1000;
 	syncMaxBehindMultiplier: number;
-	readonly playbackRateMaxBehind = 1000;
 	readonly syncMaxAhead = 150;
-	readonly maxExpectedTimeSyncDifference = 150;
+	readonly playbackRateSyncConstants: {
+		readonly enabled: true;
+		readonly maxBehind: 1000;
+		readonly catchupRate: 1.05;
+		readonly slowdownRate: 0.95;
+	};
+	readonly maxTimeSyncDifferenceTolerance = 150;
 	private timers;
 	private rtt;
 	private channelSyncInfo;
@@ -1029,12 +1082,12 @@ declare class SyncModule {
 }
 interface TelemetryModuleOptions {
 	url: string;
-	interval: number;
-	includeErrors: boolean;
-	includeEvents: boolean;
-	includeStats: boolean;
-	maxRetries: number;
-	maxErrorReports: number;
+	interval?: number;
+	includeErrors?: boolean;
+	includeEvents?: boolean;
+	includeStats?: boolean;
+	maxRetries?: number;
+	maxErrorReports?: number;
 }
 interface FlushOptions {
 	isFinal?: boolean;
@@ -1139,8 +1192,9 @@ export interface ReconnectState {
 	reconnectRetries: number;
 }
 export interface AdvancedOptions {
-	wasmDecodingConstraint: Partial<Constraint>;
+	wasmDecodingConstraint: Partial<VideoConstraint>;
 }
+export declare type Media = "audio" | "video" | "audio+video";
 export interface Options {
 	url: string;
 	channelId: string;
@@ -1157,7 +1211,8 @@ export interface Options {
 	mseOpusEnabled?: boolean;
 	abrEnabled?: boolean;
 	maxSize?: Size;
-	maxBitRate?: number;
+	maxAudioBitRate?: number;
+	maxVideoBitRate?: number;
 	muted?: boolean;
 	reconnectHandler?: (state: ReconnectState) => Promise<boolean> | boolean;
 	tags?: string[];
@@ -1166,6 +1221,7 @@ export interface Options {
 	logShippingEnabled?: boolean;
 	statsShippingEnabled?: boolean;
 	advanced?: AdvancedOptions;
+	media?: Media;
 }
 export interface PlaybackSource {
 	volume: number;
@@ -1185,6 +1241,7 @@ export interface PublicVindralEvents {
 	["rendition levels"]: ReadonlyArray<RenditionLevel>;
 	["rendition level"]: Readonly<RenditionLevel>;
 	["languages"]: ReadonlyArray<string>;
+	["channels"]: ReadonlyArray<Channel>;
 	["server wallclock time"]: Readonly<number>;
 	["buffer state event"]: Readonly<BufferStateEvent>;
 	["initialized media"]: void;
@@ -1230,24 +1287,33 @@ export declare type Rendition = VideoRendition | AudioRendition;
 export declare const isVideoRendition: (rendition: Readonly<Rendition>) => rendition is VideoRendition;
 export declare const isAudioRendition: (rendition: Readonly<Rendition>) => rendition is AudioRendition;
 export declare const getMimeType: (rendition: Readonly<Rendition>) => string;
-interface Constraint {
+interface AudioConstraint {
+	bitRate: number;
+	codec?: AudioCodec;
+	codecString?: string;
+	language?: string;
+}
+interface VideoConstraint {
 	width: number;
 	height: number;
 	bitRate: number;
+	codec?: VideoCodec;
+	codecString?: string;
 }
 declare type SubscriptionInitiator = "manual" | "edge";
 interface Subscription {
 	channelId: string;
-	videoCodec?: VideoCodec;
-	audioCodec?: AudioCodec;
-	language?: string;
+	video: VideoConstraint;
+	audio: AudioConstraint;
 	meta?: Record<string, string>;
-	constraint: Constraint;
 	initiator?: SubscriptionInitiator;
 }
 interface ContextSwitch {
 	type: "context switch";
 }
+interface ContextSwitchComplete {
+	type: "context switch complete";
+}
 interface RenditionsSignal {
 	type: "renditions";
 	renditions: Rendition[];
@@ -1278,35 +1344,33 @@ interface PingSignal {
 interface PongSignal {
 	type: "pong";
 }
-declare type Signal = RenditionsSignal | SubscribeSignal | SubscriptionChangedSignal | TimingInfoSignal | PingSignal | PongSignal | ClientIpSignal | ContextSwitch;
+interface RefreshAuthSignal {
+	type: "refresh auth";
+	token: string;
+}
+declare type Signal = RenditionsSignal | SubscribeSignal | SubscriptionChangedSignal | TimingInfoSignal | PingSignal | PongSignal | ClientIpSignal | ContextSwitch | ContextSwitchComplete | RefreshAuthSignal;
 export interface Channel {
-	id: string;
+	channelId: string;
 	name: string;
 	isLive: boolean;
-	thumbnailUrl: string;
+	thumbnailUrls: string[];
 }
-declare type ChannelWithRenditions = {
+interface ChannelWithRenditions extends Channel {
 	renditions: Rendition[];
-} & Channel;
-export interface ChannelsApi {
-	getChannelGroup: (channelGroupId: string) => Promise<Channel[]>;
 }
-interface ConnectInfo {
+interface ConnectOptions {
 	channelGroupId?: string;
 	channelId: string;
 }
-interface ConnectApi {
-	get: (connectInfo: ConnectInfo) => Promise<ConnectResponse>;
-}
 interface Telemetry {
-	probability: number;
 	url: string;
-	includeErrors: boolean;
-	includeEvents: boolean;
-	includeStats: boolean;
-	maxRetries: number;
-	maxErrorReports: number;
-	interval: number;
+	probability?: number;
+	includeErrors?: boolean;
+	includeEvents?: boolean;
+	includeStats?: boolean;
+	maxRetries?: number;
+	maxErrorReports?: number;
+	interval?: number;
 }
 export interface ConnectResponse {
 	logsUrl?: string;
@@ -1315,10 +1379,26 @@ export interface ConnectResponse {
 	channels: ChannelWithRenditions[];
 	edges: string[];
 }
-export declare const apiClient: (url: string) => {
-	readonly channels: ChannelsApi;
-	readonly connect: ConnectApi;
-};
+export interface ApiClientOptions {
+	publicEndpoint: string;
+	tokenFactory?: AuthorizationTokenFactory;
+}
+export interface AuthorizationContext {
+	channelGroupId?: string;
+	channelId?: string;
+}
+export declare type AuthorizationTokenFactory = (context: AuthorizationContext) => string | undefined;
+export declare class ApiClient {
+	private baseUrl;
+	private tokenFactory?;
+	constructor(options: ApiClientOptions);
+	connect(options: ConnectOptions): Promise<ConnectResponse>;
+	getChannel(channelId: string): Promise<Channel>;
+	getChannels(channelGroupId: string): Promise<Channel[]>;
+	private getAuthToken;
+	private toChannels;
+	private toChannel;
+}
 interface FullscreenEvents {
 	["on fullscreen change"]: boolean;
 }
@@ -1336,6 +1416,12 @@ declare class Fullscreen extends Emitter<FullscreenEvents> {
 }
 export interface PlayerOptions {
 	controlsEnabled?: boolean;
+	fullscreenButtonEnabled?: boolean;
+	pipButtonEnabled?: boolean;
+	channelSelectionEnabled?: boolean;
+	renditionLevelsEnabled?: boolean;
+	languagesButtonEnabled?: boolean;
+	oneToOneButtonEnabled?: boolean;
 	hideTimeout?: number;
 }
 export interface PlayerState {

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@vindral/web-sdk",
-  "version": "1.2.1",
+  "version": "2.0.2",
   "homepage": "https://vindral.com",
   "description": "Web SDK for viewing Vindral streams",
   "license": "SEE LICENSE IN https://www.vindral.com/terms-conditions",
   "author": "RealSprint",
   "files": [
     "README.md",
+    "LICENSES",
     "web-sdk.esm.js",
     "web-sdk.umd.js",
     "index.d.ts"