@vindral/web-sdk 3.4.3 → 4.0.0

package/core.d.ts

@@ -0,0 +1,1364 @@
+type MatchingKeys<TRecord, TMatch, K extends keyof TRecord = keyof TRecord> = K extends (TRecord[K] extends TMatch ? K : never) ? K : never;
+type VoidKeys<Record> = MatchingKeys<Record, void>;
+type EventListenerReturnType = (() => void) | void;
+declare class Emitter<TEvents, TEmits = TEvents, ArgLessEvents extends VoidKeys<TEvents> = VoidKeys<TEvents>, ArgEvents extends Exclude<keyof TEvents, ArgLessEvents> = Exclude<keyof TEvents, ArgLessEvents>, ArgLessEmits extends VoidKeys<TEmits> = VoidKeys<TEmits>, ArgEmits extends Exclude<keyof TEmits, ArgLessEmits> = Exclude<keyof TEmits, ArgLessEmits>> {
+	private listeners;
+	emit<T extends ArgLessEmits>(eventName: T): void;
+	emit<T extends ArgEmits>(eventName: T, args: TEmits[T]): void;
+	off<T extends ArgLessEvents>(eventName: T, fn: () => EventListenerReturnType): void;
+	off<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => EventListenerReturnType): void;
+	/**
+	 * Add an event listener to `eventName`
+	 *
+	 * Event listeners may optionally return a "defer function" that will be called once all other listeners have been called.
+	 * This is useful when one listener may want everone to have reacted to an event before calling something.
+	 */
+	on<T extends ArgLessEvents>(eventName: T, fn: () => void): void;
+	on<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => void): void;
+	/**
+	 * Add an event listener to `eventName` that will be called once only
+	 *
+	 * Event listeners may optionally return a "defer function" that will be called once all other listeners have been called.
+	 * This is useful when one listener may want everone to have reacted to an event before calling something.
+	 */
+	once<T extends ArgLessEvents>(eventName: T, fn: () => void): void;
+	once<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => void): void;
+	reset(): void;
+	private add;
+}
+declare const Levels: readonly [
+	"off",
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace"
+];
+export type Level = (typeof Levels)[number];
+export declare const Level: {
+	ERROR: "error";
+	WARN: "warn";
+	INFO: "info";
+	DEBUG: "debug";
+	TRACE: "trace";
+	OFF: "off";
+};
+interface MinMaxAverage {
+	last: number;
+	/**
+	 * Average value over a given interval.
+	 */
+	average: number;
+	/**
+	 * Maximum value over a given interval.
+	 */
+	max: number;
+	/**
+	 * Minimum value over a given interval.
+	 */
+	min: number;
+}
+type AudioCodec = "aac" | "opus" | "mp3";
+type VideoCodec = "h264" | "av1";
+/**
+ * Represents a timed metadata event
+ */
+export interface Metadata {
+	/**
+	 * The raw string content as it was ingested (if using JSON, it needs to be parsed on your end)
+	 */
+	content: string;
+	/**
+	 * Timestamp in ms
+	 */
+	timestamp: number;
+}
+export interface TimeRange {
+	start: number;
+	end: number;
+}
+/**
+ * The current reconnect state to use to decide whether to kep reconnecting or not
+ */
+export interface ReconnectState {
+	/**
+	 * The number or retry attempts so far.
+	 * This gets reset on every successful connect, so it will start from zero every
+	 * time the client instance gets disconnected and will increment until the
+	 * client instance makes a connection attempt is successful.
+	 */
+	reconnectRetries: number;
+}
+interface RenditionProps {
+	id: number;
+	bitRate: number;
+	codecString?: string;
+	language?: string;
+	meta?: Record<string, string>;
+}
+interface VideoRenditionProps {
+	codec: VideoCodec;
+	frameRate: [
+		number,
+		number
+	];
+	width: number;
+	height: number;
+}
+interface AudioRenditionProps {
+	codec: AudioCodec;
+	channels: number;
+	sampleRate: number;
+}
+interface TextRenditionProps {
+	codec: "webvtt";
+	kind: "subtitles" | "captions";
+	label?: string;
+}
+type VideoRendition = VideoRenditionProps & RenditionProps;
+type AudioRendition = AudioRenditionProps & RenditionProps;
+type TextRendition = TextRenditionProps & RenditionProps;
+type Rendition = VideoRendition | AudioRendition | TextRendition;
+interface Size {
+	width: number;
+	height: number;
+}
+interface VideoConstraint {
+	width: number;
+	height: number;
+	bitRate: number;
+	codec?: VideoCodec;
+	codecString?: string;
+}
+/**
+ * Advanced options to override default behaviour.
+ */
+export interface AdvancedOptions {
+	/**
+	 * Constrains wasm decoding to this resolution.
+	 * By default it is set to 1280 in width and height.
+	 * This guarantees better performance on older devices and reduces battery drain in general.
+	 */
+	wasmDecodingConstraint: Partial<VideoConstraint>;
+}
+type Media = "audio" | "video" | "audio+video";
+/**
+ * Options for the Vindral instance
+ *
+ */
+export interface Options {
+	/**
+	 * URL to use when connecting to the stream
+	 */
+	url: string;
+	/**
+	 * Channel ID to connect to initially - can be changed later mid-stream when connected to a channel group.
+	 */
+	channelId: string;
+	/**
+	 * Channel group to connect to
+	 * Note: Only needed for fast channel switching
+	 */
+	channelGroupId?: string;
+	/**
+	 * A container to attach the video view in - can be provided later with .attach() on the vindral core instance
+	 */
+	container?: HTMLElement;
+	/**
+	 * An authentication token to provide to the server when connecting - only needed for channels with authentication enabled
+	 * Note: If not supplied when needed, an "Authentication Failed" error will be raised.
+	 */
+	authenticationToken?: string;
+	/**
+	 * Language to use initially - can be changed during during runtime on the vindral instance
+	 * Note: Only needed when multiple languages are provided - if no language is specified, one will be automatically selected.
+	 */
+	language?: string;
+	/**
+	 * TextTrack to use initially - can be changed during during runtime on the vindral instance
+	 */
+	textTrack?: string;
+	/**
+	 * Sets the log level - defaults to info
+	 */
+	logLevel?: Level;
+	/**
+	 * Sets the minimum and initial buffer time
+	 */
+	minBufferTime?: number;
+	/**
+	 * Sets the maximum buffer time allowed. The vindral instance will automatically slowly increase
+	 * the buffer time if the use experiences to much buffering with the initial buffer time.
+	 */
+	maxBufferTime?: number;
+	/**
+	 * Enables or disables user bandwidth savings by capping the video resolution to the size of the video element.
+	 *
+	 * Is enabled by default.
+	 *
+	 * Note: This is automatically set to false when abrEnabled is set to false.
+	 */
+	sizeBasedResolutionCapEnabled?: boolean;
+	/**
+	 * Enables or disables picture in picture support.
+	 */
+	pictureInPictureEnabled?: boolean;
+	/**
+	 * Enable bursting for initial connection and channel switches. This makes time to first frame faster at the
+	 * cost of stability (more demanding due to the sudden burst of live content)
+	 *
+	 * Is disabled by default.
+	 *
+	 */
+	burstEnabled?: boolean;
+	/**
+	 * Enable usage of the MediaSource API on supported browsers.
+	 *
+	 * Is enabled by default.
+	 *
+	 * Note: We recommend to keep this at the default value unless you have very specific needs.
+	 */
+	mseEnabled?: boolean;
+	/**
+	 * Enable Opus with the MediaSource API on supported browsers.
+	 *
+	 * Is enabled by default.
+	 *
+	 */
+	mseOpusEnabled?: boolean;
+	/**
+	 * Enable or disable support for playing audio in the background for iOS devices.
+	 *
+	 * Is false (disabled) by default.
+	 *
+	 * Note:  This may be enabled by default in a future (major) release
+	 */
+	iosBackgroundPlayEnabled?: boolean;
+	/**
+	 * Enable or disable Adaptive Bit Rate. This allows for automatically adapting the incoming bit rate based on
+	 * the viewers bandwidth and thus avoiding buffering events. This also disables the
+	 * sizeBasedResolutionCapEnabled option.
+	 *
+	 * Is enabled by default.
+	 *
+	 * Note:  It is strongly recommended to keep this enabled as user experience can greatly suffer without ABR.
+	 */
+	abrEnabled?: boolean;
+	/**
+	 * Enable or disable telemetry. This allows for telemetry and errors being collected.
+	 *
+	 * Is enabled by default.
+	 *
+	 * We appreciate you turning it off during development/staging to not bloat real telemetry data.
+	 *
+	 * Note: It is strongly recommended to keep this enabled in production as it is required for insights and KPIs.
+	 */
+	telemetryEnabled?: boolean;
+	/**
+	 * Set a cap on the maximum video size.
+	 * This can be used to provide user options to limit the video bandwidth usage.
+	 *
+	 * Note: This takes presedence over any size based resolution caps.
+	 */
+	maxSize?: Size;
+	/**
+	 * Maximum audio bit rate allowed.
+	 * This can be used to provide user options to limit the audio bandwidth usage.
+	 */
+	maxAudioBitRate?: number;
+	/**
+	 * Maximum video bit rate allowed.
+	 * This can be used to provide user options to limit the video bandwidth usage.
+	 */
+	maxVideoBitRate?: number;
+	/**
+	 * Controls video element background behaviour while loading.
+	 * - If `false`, a black background will be shown.
+	 * - If undefined or `true`, a live thumbnail will be shown.
+	 * - If set to a string containing a URL (https://urltoimage), use that.
+	 * Default `true` - meaning a live thumbnail is shown
+	 */
+	poster?: boolean | string;
+	/**
+	 * Whether to start the player muted or to try to start playing audio automatically.
+	 */
+	muted?: boolean;
+	/**
+	 * Provide a custom reconnect handler to control when the instance should stop trying to
+	 * reconnect. The reconnect handler should either return true to allow the reconnect or
+	 * false to stop reconnecting. It can also return a promise with true or false if it needs
+	 * to make any async calls before determining wether to reconnect.
+	 *
+	 * The default reconnect handler allows 30 reconnects before stopping.
+	 *
+	 * Note: the ReconnectState gets reset every time the client instance makes a successful connection.
+	 * This means the default reconnect handler will only stop reconnecting after 30 _consecutive_ failed connections.
+	 *
+	 * ```typescript
+	 * // An example reconnect handler that will reconnect forever
+	 * const reconnectHandler = (state: ReconnectState) => true
+	 *
+	 * // An example reconnect handler that will fetch an url and determine whether to reconnect
+	 * const reconnectHandler = async (state: ReconnectState) => {
+	 *   const result = await fetch("https://should-i-reconnect-now.com")
+	 *   return result.ok
+	 * },
+	 * ```
+	 */
+	reconnectHandler?: (state: ReconnectState) => Promise<boolean> | boolean;
+	tags?: string[];
+	ownerSessionId?: string;
+	edgeUrl?: string;
+	logShippingEnabled?: boolean;
+	statsShippingEnabled?: boolean;
+	/**
+	 * Enable wake lock for iOS devices.
+	 * The wake lock requires that the audio has been activated at least once for the instance, othwerwise it will not work.
+	 * Other devices already provide wake lock by default.
+	 *
+	 * This option is redundant and has no effect if iosMediaElementEnabled is enabled since that automatically enables wake lock.
+	 *
+	 * Disabled by default.
+	 */
+	iosWakeLockEnabled?: boolean;
+	/**
+	 * Disabling this will revert to legacy behaviour where Vindral will try to always keep the video element playing.
+	 */
+	pauseSupportEnabled?: boolean;
+	/**
+	 * Enables iOS devices to use a media element for playback. This enables fullscreen and picture in picture support on iOS.
+	 */
+	iosMediaElementEnabled?: boolean;
+	/**
+	 * Advanced options to override default behaviour.
+	 */
+	advanced?: AdvancedOptions;
+	media?: Media;
+	videoCodecs?: VideoCodec[];
+}
+/**
+ * Represents a rendition (quality level).
+ */
+export interface RenditionLevel {
+	audio?: AudioRendition;
+	video?: VideoRendition;
+}
+type RenditionLevelChangedReason = "abr" | "manual";
+/**
+ * Contextual information about the rendition level change.
+ */
+export interface RenditionLevelChanged {
+	from?: RenditionLevel;
+	to?: RenditionLevel;
+	reason: RenditionLevelChangedReason;
+}
+interface Channel {
+	/**
+	 * Channel ID for the channel
+	 */
+	channelId: string;
+	/**
+	 * Display name
+	 */
+	name: string;
+	/**
+	 * Indicates whether there is an incoming source feed for the channel
+	 */
+	isLive: boolean;
+	/**
+	 * URLs to fetch thumbnail from
+	 */
+	thumbnailUrls: string[];
+}
+interface ClientOverrides {
+	maxVideoBitRate?: number;
+	minBufferTime?: number;
+	maxBufferTime?: number;
+	burstEnabled?: boolean;
+	sizeBasedResolutionCapEnabled?: boolean;
+	separateVideoSocketEnabled?: boolean;
+	videoCodecs?: string[];
+}
+interface ChannelWithRenditionsAndOverrides extends Channel {
+	renditions: Rendition[];
+	overrides?: ClientOverrides;
+}
+interface ConnectOptions {
+	channelGroupId?: string;
+	channelId: string;
+}
+interface Telemetry {
+	url: string;
+	probability?: number;
+	includeErrors?: boolean;
+	includeEvents?: boolean;
+	includeStats?: boolean;
+	maxRetries?: number;
+	maxErrorReports?: number;
+	interval?: number;
+}
+interface ConnectResponse {
+	logsUrl?: string;
+	statsUrl?: string;
+	telemetry?: Telemetry;
+	channels: ChannelWithRenditionsAndOverrides[];
+	edges: string[];
+}
+interface ApiClientOptions {
+	/**
+	 * String representing the URL to the public CDN API.
+	 */
+	publicEndpoint: string;
+	/**
+	 * Function that should return a string containing a signed authentication token.
+	 */
+	tokenFactory?: AuthorizationTokenFactory;
+}
+interface AuthorizationContext {
+	/**
+	 * The channelGroupId that might need authorization.
+	 */
+	channelGroupId?: string;
+	/**
+	 * The channelId that might need authorization.
+	 */
+	channelId?: string;
+}
+type AuthorizationTokenFactory = (context: AuthorizationContext) => string | undefined;
+declare class ApiClient {
+	private baseUrl;
+	private tokenFactory?;
+	constructor(options: ApiClientOptions);
+	/**
+	 * Returns everything needed to setup the connection of Vindral instance.
+	 */
+	connect(options: ConnectOptions): Promise<ConnectResponse>;
+	/**
+	 * Fetches information regarding a single channel.
+	 *
+	 * @param channelId the channel to fetch
+	 * @returns a [[Channel]] containing information about the requested channel.
+	 */
+	getChannel(channelId: string): Promise<Channel>;
+	/**
+	 * Fetches channels within a channel group
+	 *
+	 * Note: The returned list includes inactive channels - check isLive to filter out only active channels
+	 *
+	 * @param channelGroup the channel group to fetch channels from
+	 * @returns an array of [[Channel]] that belong to the channel group
+	 */
+	getChannels(channelGroupId: string): Promise<Channel[]>;
+	private getHeaders;
+	private getAuthToken;
+	private toChannels;
+	private toChannel;
+}
+interface VindralErrorProps {
+	isFatal: boolean;
+	type?: ErrorType;
+	code: string;
+	source?: Error | MediaError;
+}
+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 const DISCONNECTED_BY_EDGE = "disconnected_by_edge";
+type ErrorType = "internal" | "external";
+/**
+ * Represents a vindral error - all errors emitted from the Vindral instance inherit from this class.
+ */
+export declare class VindralError extends Error {
+	private props;
+	private extra;
+	constructor(message: string, props: VindralErrorProps, extra?: {});
+	/**
+	 * The error code is a stable string that represents the error type - this should be treated as an
+	 * opaque string that can be used as a key for looking up localized strings for displaying error messages.
+	 * @returns the error code
+	 */
+	code: () => string;
+	/**
+	 * Indicates whether the error is fatal - if it is that means the Vindral instance will be unloaded because of this error.
+	 */
+	isFatal: () => boolean;
+	/**
+	 * The underlying error that caused the Vindral error
+	 * @returns the underlying error
+	 */
+	source: () => Error | MediaError | undefined;
+	type: () => ErrorType;
+	/**
+	 * @returns a stringifiable represenation of the error
+	 */
+	toStringifiable: () => Record<string, unknown>;
+}
+type PlaybackState = "buffering" | "playing" | "paused";
+type BufferStateEvent = "filled" | "drained";
+interface PlaybackModuleStatistics {
+	/**
+	 * Current target buffer time if using dynamic buffer. Otherwise, this is the statically set buffer time from instantiation.
+	 */
+	bufferTime: number;
+	needsInputForAudioCount: number;
+	needsInputForVideoCount: number;
+}
+interface NeedsUserInputContext {
+	/**
+	 * True if user input is needed for audio
+	 */
+	forAudio: boolean;
+	/**
+	 * True if user input is needed for video
+	 */
+	forVideo: boolean;
+}
+type State = "connected" | "disconnected" | "connecting";
+type ContextSwitchState = "completed" | "started";
+interface ConnectionStatistics {
+	/**
+	 * RTT (round trip time) between client and server(s).
+	 */
+	rtt: MinMaxAverage;
+	/**
+	 * A very rough initial estimation of minimum available bandwidth.
+	 */
+	estimatedBandwidth: number;
+	edgeUrl?: string;
+	/**
+	 * Total number of connections that have been established since instantiation.
+	 */
+	connectCount: number;
+	/**
+	 * Total number of connection attempts since instantiation.
+	 */
+	connectionAttemptCount: number;
+}
+/**
+ * Contextual information about the language switch
+ */
+export interface LanguageSwitchContext {
+	/**
+	 * The new language that was switched to
+	 */
+	language: string;
+}
+/**
+ * Contextual information about the channel switch
+ */
+export interface ChannelSwitchContext {
+	/**
+	 * The new channel id that was switched to
+	 */
+	channelId: string;
+}
+interface VolumeState {
+	/**
+	 * Wether the audio is muted
+	 */
+	isMuted: boolean;
+	/**
+	 * The volume level
+	 */
+	volume: number;
+}
+/**
+ * The events that can be emitted from the Vindral instance
+ */
+export interface PublicVindralEvents {
+	/**
+	 * When an error that requires action has occured
+	 *
+	 * Can be a fatal error that will unload the Vindral instance - this is indicated by `isFatal()` on the error object returning true.
+	 *
+	 * In case of a fatal error it is appropriate to indicate what the error was to the user, either by displaying the error.message or
+	 * by using the error.code() as a key to look up a localization string. To resume streaming it is required to create a new Vindral instance.
+	 */
+	["error"]: Readonly<VindralError>;
+	/**
+	 * When the instance needs user input to activate audio or sometimes video playback.
+	 * Is called with an object
+	 * ```javascript
+	 * {
+	 *   forAudio: boolean // true if user input is needed for audio playback
+	 *   forVideo: boolean // true if user input is needed for video playback
+	 * }
+	 * ```
+	 */
+	["needs user input"]: NeedsUserInputContext;
+	/**
+	 * When a timed metadata event has been triggered
+	 */
+	["metadata"]: Readonly<Metadata>;
+	/**
+	 * When the playback state changes
+	 */
+	["playback state"]: Readonly<PlaybackState>;
+	/**
+	 * When the connection state changes
+	 */
+	["connection state"]: Readonly<State>;
+	/**
+	 * When the available rendition levels is changed
+	 */
+	["rendition levels"]: ReadonlyArray<RenditionLevel>;
+	/**
+	 * When the rendition level is changed
+	 */
+	["rendition level"]: Readonly<RenditionLevel>;
+	/**
+	 * When the available languages is changed
+	 */
+	["languages"]: ReadonlyArray<string>;
+	/**
+	 * When the available text tracks are changed
+	 */
+	["text tracks"]: ReadonlyArray<string>;
+	/**
+	 * When the available channels is changed
+	 */
+	["channels"]: ReadonlyArray<Channel>;
+	/**
+	 * When a context switch state change has occured.
+	 * E.g. when a channel change has been requested, or quality is changed.
+	 */
+	["context switch"]: Readonly<ContextSwitchState>;
+	/**
+	 * Emitted when a wallclock time message has been received from the server.
+	 *
+	 * Note: This is the edge server wallclock time and thus may differ slightly
+	 * between two viewers if they are connected to different edge servers.
+	 */
+	["server wallclock time"]: Readonly<number>;
+	/**
+	 * Is emitted during connection whether the channel is live or not.
+	 *
+	 * If the channel is not live, the Vindral instance will try to reconnect until the `reconnectHandler`
+	 * determines that no more retries should be made.
+	 *
+	 * Note: If the web-sdk is instantiated at the same time as you are starting the stream it is possible
+	 * that this emits false until the started state has propagated through the system.
+	 */
+	["is live"]: boolean;
+	/**
+	 * Emitted when a channel switch has been completed and the first frame of the new channel is rendered.
+	 * A string containing the channel id of the new channel is provided as an argument.
+	 */
+	["channel switch"]: Readonly<ChannelSwitchContext>;
+	/**
+	 * Emitted when a language switch has been completed and the new language starts playing.
+	 */
+	["language switch"]: Readonly<LanguageSwitchContext>;
+	/**
+	 * Emitted when the volume state changes.
+	 *
+	 * This is triggered triggered both when the user changes the volume through the Vindral instance, but also
+	 * from external sources such as OS media shortcuts or other native UI outside of the browser.
+	 */
+	["volume state"]: Readonly<VolumeState>;
+	["buffer state event"]: Readonly<BufferStateEvent>;
+	["initialized media"]: void;
+}
+declare const defaultOptions: {
+	sizeBasedResolutionCapEnabled: boolean;
+	pictureInPictureEnabled: boolean;
+	abrEnabled: boolean;
+	burstEnabled: boolean;
+	mseEnabled: boolean;
+	mseOpusEnabled: boolean;
+	muted: boolean;
+	minBufferTime: number;
+	maxBufferTime: number;
+	logLevel: Level;
+	maxSize: Size;
+	maxVideoBitRate: number;
+	maxAudioBitRate: number;
+	tags: string[];
+	media: Media;
+	poster: string | boolean;
+	reconnectHandler: (state: ReconnectState) => Promise<boolean> | boolean;
+	iosWakeLockEnabled: boolean;
+	telemetryEnabled: boolean;
+	iosMediaElementEnabled: boolean;
+	pauseSupportEnabled: boolean;
+	advanced: {
+		wasmDecodingConstraint: Partial<VideoConstraint>;
+	};
+	videoCodecs: VideoCodec[];
+};
+interface AdaptivityStatistics {
+	/**
+	 * True if adaptive bitrate (ABR) is enabled.
+	 */
+	isAbrEnabled: boolean;
+}
+interface BufferTimeStatistics {
+	/**
+	 * Number of time buffer time has been adjusted. This will only happen when using dynamic buffer time
+	 * (different min/max values of bufferTime).
+	 */
+	bufferTimeAdjustmentCount: number;
+}
+interface RenditionsModuleStatistics {
+	/**
+	 * Id of current video rendition subscribed to.
+	 */
+	videoRenditionId?: number;
+	/**
+	 * Id of current audio rendition subscribed to.
+	 */
+	audioRenditionId?: number;
+	/**
+	 * Current video codec being used.
+	 */
+	videoCodec?: string;
+	/**
+	 * Current audio codec being used.
+	 */
+	audioCodec?: string;
+	/**
+	 * Width of current video rendition (if any).
+	 */
+	videoWidth?: number;
+	/**
+	 * Height of current video rendition (if any).
+	 */
+	videoHeight?: number;
+	/**
+	 * Currently expected video bit rate according to metadata in bits/s.
+	 */
+	expectedVideoBitRate?: number;
+	/**
+	 * Currently expected audio bit rate according to metadata in bits/s.
+	 */
+	expectedAudioBitRate?: number;
+	/**
+	 * Current language. For non-multi language streams, this will often be unset.
+	 */
+	language?: string;
+	/**
+	 * Frame rate. Example: `"frameRate": [24000, 1001]`.
+	 */
+	frameRate?: [
+		number,
+		number
+	];
+	/**
+	 * Total count of rendition level changes (quality downgrades/upgrades).
+	 */
+	renditionLevelChangeCount: number;
+}
+interface VideoConstraintCap {
+	width: number;
+	height: number;
+	bitRate: number;
+}
+interface AudioConstraintCap {
+	bitRate: number;
+}
+interface ConstraintCap {
+	video: VideoConstraintCap;
+	audio: AudioConstraintCap;
+}
+interface ConstraintCapStatistics {
+	constraintCap?: ConstraintCap;
+	windowInnerWidth: number;
+	windowInnerHeight: number;
+	elementWidth: number;
+	elementHeight: number;
+	pixelRatio: number;
+}
+interface DecoderStatistics {
+	videoDecodeRate: number;
+	videoDecodeTime: MinMaxAverage;
+	audioDecodeTime: MinMaxAverage;
+	videoTransportTime: MinMaxAverage;
+}
+interface DocumentStateModulesStatistics {
+	isVisible: boolean;
+	isOnline: boolean;
+	isVisibleCount: number;
+	isHiddenCount: number;
+	isOnlineCount: number;
+	isOfflineCount: number;
+	navigatorRtt?: number;
+	navigatorEffectiveType?: EffectiveConnectionType;
+	navigatorConnectionType?: ConnectionType;
+	navigatorSaveData?: boolean;
+	navigatorDownlink?: number;
+}
+interface IncomingDataModuleStatistics {
+	/**
+	 * Current video bitrate in bits/second.
+	 */
+	videoBitRate?: number;
+	/**
+	 * Current audio bitrate in bits/second.
+	 */
+	audioBitRate?: number;
+	/**
+	 * Counter of number of bytes received.
+	 */
+	bytesReceived: number;
+}
+interface MseModuleStatistics {
+	quotaErrorCount: number;
+	mediaSourceOpenTime: number;
+	totalVideoFrames?: number;
+	droppedVideoFrames?: number;
+	successfulVideoAppendCalls?: number;
+	successfulAudioAppendsCalls?: number;
+}
+interface QualityOfServiceModuleStatistics {
+	/**
+	 * Time in milliseconds spent in buffering state. Note that this value will increase while in background if
+	 * buffering when leaving foreground.
+	 */
+	timeSpentBuffering: number;
+	/**
+	 * Total number of buffering events since instantiation.
+	 */
+	bufferingEventsCount: number;
+	/**
+	 * Number of fatal quality of service events.
+	 */
+	fatalQosCount: number;
+	/**
+	 * Ratio of time being spent on different bitrates.
+	 * Example: `"timeSpentRatio": { "1160000": 0.2, "2260000": 0.8 }` shows 20% spent on 1.16 Mbps, 80% spent on 2.26 Mbps.
+	 */
+	timeSpentRatio: {
+		[bitRate: string]: number;
+	};
+}
+interface SyncModuleStatistics {
+	drift: number | undefined;
+	driftAdjustmentCount: number;
+	timeshiftDriftAdjustmentCount: number;
+	seekTime: number;
+}
+interface TelemetryModuleStatistics {
+	/**
+	 * The total amount of errors being spawned. Note that some media errors can trigger
+	 * thousands of errors for a single client in a few seconds before recovering. Therefore,
+	 * consider the number of viewers with errors, not just the total amount. Also, consider the median
+	 * instead of the mean for average calculation.
+	 */
+	errorCount: number;
+}
+interface VideoPlayerStatistics {
+	renderedFrameCount: number;
+	rendererDroppedFrameCount: number;
+	contextLostCount: number;
+	contextRestoredCount: number;
+}
+declare class UserAgentInformation {
+	private highEntropyValues?;
+	constructor();
+	getUserAgentInformation(): {
+		locationOrigin: string;
+		locationPath: string;
+		ancestorOrigins: string[] | undefined;
+		hardwareConcurrency: number;
+		deviceMemory: number | undefined;
+		userAgentLegacy: string;
+		ua: {
+			browser: {
+				brands: string[];
+				fullVersionBrands: string[];
+				majorVersions: string[];
+			};
+			device: string;
+			os: {
+				family: string;
+				version: string;
+				major_version: number;
+			};
+		};
+	} | {
+		locationOrigin: string;
+		locationPath: string;
+		ancestorOrigins: string[] | undefined;
+		hardwareConcurrency: number;
+		deviceMemory: number | undefined;
+		userAgent: string;
+	};
+}
+type ModuleStatistics = AdaptivityStatistics & BufferTimeStatistics & ConnectionStatistics & ConstraintCapStatistics & DecoderStatistics & DocumentStateModulesStatistics & IncomingDataModuleStatistics & MseModuleStatistics & PlaybackModuleStatistics & QualityOfServiceModuleStatistics & RenditionsModuleStatistics & SyncModuleStatistics & TelemetryModuleStatistics & VideoPlayerStatistics;
+/**
+ * Contains internal statistics.
+ *
+ * Note that this object will have some undocumented properties, used internally or temporarily,
+ * for monitoring and improving the performance of the service.
+ *
+ * @interface
+ */
+export type Statistics = ModuleStatistics & ReturnType<UserAgentInformation["getUserAgentInformation"]> & {
+	/**
+	 * Version of the @vindral/web-sdk being used.
+	 */
+	version: string;
+	/**
+	 * IP of the client.
+	 */
+	ip?: string;
+	/**
+	 * URL being used for connecting to the stream.
+	 */
+	url: string;
+	/**
+	 * A session is bound to a connection. If the client reconnects for any reason (e.g. coming back from inactivity
+	 * or a problem with network on client side), a new sessionId will be used.
+	 *
+	 */
+	sessionId?: string;
+	/**
+	 * Unlike `sessionId`, `clientId` will remain the same even after reconnections and represents this unique Vindral instance.
+	 */
+	clientId: string;
+	/**
+	 * How long in milliseconds since the instance was created.
+	 */
+	uptime: number;
+	/**
+	 * Current channel ID being subscribed to.
+	 */
+	channelId: string;
+	/**
+	 * Channel group being subscribed to.
+	 */
+	channelGroupId?: string;
+	/**
+	 * Time in milliseconds from instantiation to playback of video and audio being started.
+	 * Note that an actual frame render often happens much quicker, but that is not counted as TTFF.
+	 */
+	timeToFirstFrame?: number;
+	iosMediaElementEnabled?: boolean;
+};
+/**
+ * Represents a Vindral client instance
+ *
+ * The most most essential methods when using the Vindral class are:
+ *
+ * - connect() - this has to be called to actually start connecting
+ * - attach() - to attach the Vindral video view to the DOM so that users can see it
+ * - userInput() - to activate audio on browsers that require a user gesture to play audio
+ * - unload() - unloads the instance, its very important that this is called when cleaning up the Vindral instance, otherwise background timers may leak.
+ *
+ * The Vindral instance will emit a variety of events during its lifetime. Use .on("event-name", callback) to listen to these events.
+ * See [[PublicVindralEvents]] for the events types that can be emitted.
+ *
+ * ```typescript
+ * // minimal configuration of a Vindral client instance
+ * const instance = new Vindral({
+ *   url: "https://lb.cdn.vindral.com",
+ *   channelId: "vindral_demo1_ci_099ee1fa-80f3-455e-aa23-3d184e93e04f",
+ * })
+ *
+ * // Will be called when timed metadata is received
+ * instance.on("metadata", console.log)
+ *
+ * // Will be called when a user interaction is needed to activate audio
+ * instance.on("needs user input", console.log)
+ *
+ * // Start connecting to the cdn
+ * instance.connect()
+ *
+ * // Attach the video view to the DOM
+ * instance.attach(document.getElementById("root"))
+ *
+ * // When done with the instance
+ * instance.unload()
+ * ```
+ */
+export declare class Vindral extends Emitter<PublicVindralEvents> {
+	#private;
+	private static MAX_POOL_SIZE;
+	private static INITIAL_MAX_BIT_RATE;
+	private static PING_TIMEOUT;
+	private static DISCONNECT_TIMEOUT;
+	private static REMOVE_CUE_THRESHOLD;
+	/**
+	 * Picture in picture
+	 */
+	readonly pictureInPicture: {
+		/**
+		 * Enters picture in picture
+		 * @returns a promise that resolves if successful
+		 */
+		enter: () => Promise<void>;
+		/**
+		 * Exits picture in picture
+		 * @returns a promise that resolves if successful
+		 */
+		exit: () => Promise<void>;
+		/**
+		 * returns whether picture in picture is currently active
+		 */
+		isActive: () => boolean;
+		/**
+		 * returns whether picture in picture is supported
+		 */
+		isSupported: () => boolean;
+	};
+	private browser;
+	private options;
+	private element;
+	private playbackSource;
+	private emitter;
+	private logger;
+	private modules;
+	private clientIp?;
+	private sessionId?;
+	private clientId;
+	private _channels;
+	private createdAt;
+	private hasCalledConnect;
+	private apiClient;
+	private latestEmittedLanguages;
+	private wakeLock;
+	private cachedEdges;
+	private shiftedEdges;
+	private pool;
+	private userAgentInformation;
+	private sampleProcessingSesssions;
+	private sizes;
+	private isSuspended;
+	private disconnectTimeout;
+	constructor(options: Options);
+	/**
+	 * Attaches the video view to a DOM element. The Vindral video view will be sized to fill this element while
+	 * maintaining the correct aspect ratio.
+	 * @param container the container element to append the video view to. Often a div element.
+	 * @returns
+	 */
+	attach: (container: HTMLElement) => void;
+	/**
+	 * Set the current volume.
+	 * Setting this to 0 is not equivalent to muting the audio.
+	 * Setting this to >0 is not equivalent to unmuting the audio.
+	 *
+	 * Note that setting volume is not allowed on iPadOS and iOS devices.
+	 * This is an OS/browser limitation on the video element.
+	 *
+	 * [Read more about it on Apple docs](https://developer.apple.com/library/archive/documentation/AudioVideo/Conceptual/Using_HTML5_Audio_Video/Device-SpecificConsiderations/Device-SpecificConsiderations.html)
+	 * for iOS-Specific Considerations. The following section is the important part:
+	 * On iOS devices, the audio level is always under the user's physical control. The volume property is not settable in JavaScript. Reading the volume property always returns 1.
+	 */
+	set volume(volume: number);
+	/**
+	 * The current volume. Note that if the playback is muted volume can still be set.
+	 */
+	get volume(): number;
+	/**
+	 * Set playback to muted/unmuted
+	 */
+	set muted(muted: boolean);
+	/**
+	 * Whether the playback is muted or not
+	 */
+	get muted(): boolean;
+	/**
+	 * Media (audio | video | audio+video)
+	 */
+	get media(): Media;
+	/**
+	 * The current average video bit rate in bits/s
+	 */
+	get videoBitRate(): number;
+	/**
+	 * The current average audio bit rate in bits/s
+	 */
+	get audioBitRate(): number;
+	/**
+	 * The current connection state
+	 */
+	get connectionState(): Readonly<State>;
+	/**
+	 * The current playback state
+	 */
+	get playbackState(): Readonly<PlaybackState>;
+	/**
+	 * The current buffer fullness as a floating point value between 0-1, where 1 is full and 0 i empty.
+	 */
+	get bufferFullness(): number;
+	/**
+	 * Whether user bandwidth savings by capping the video resolution to the size of the video element is enabled
+	 */
+	get sizeBasedResolutionCapEnabled(): boolean;
+	/**
+	 * Enables or disables user bandwidth savings by capping the video resolution to the size of the video element.
+	 */
+	set sizeBasedResolutionCapEnabled(enabled: boolean);
+	/**
+	 * Whether ABR is currently enabled
+	 */
+	get abrEnabled(): boolean;
+	/**
+	 * Enable or disable ABR
+	 *
+	 * The client will immediatly stop changing renditon level based on QoS metrics
+	 *
+	 * Note: It is strongly recommended to keep this enabled as it can severly increase
+	 * the number of buffering events for viewers.
+	 */
+	set abrEnabled(enabled: boolean);
+	/**
+	 * Estimated live edge time for the current channel
+	 */
+	get serverEdgeTime(): number | undefined;
+	/**
+	 * @returns Estimated wallclock time on the edge server in milliseconds
+	 */
+	get serverWallclockTime(): number | undefined;
+	/**
+	 * Local current time normalized between all channels in the channel group
+	 */
+	get currentTime(): number;
+	/**
+	 * Current time for the channel. This is the actual stream time, passed on from your ingress.
+	 * Integer overflow could make this value differ from your encoder timestamps if it has been rolling for more
+	 * than 42 days with RTMP as target.
+	 *
+	 * Note: This is not normalized between channels, thus it can make jumps when switching channels
+	 */
+	get channelCurrentTime(): number;
+	/**
+	 * The current target buffer time in milliseconds
+	 */
+	get targetBufferTime(): number;
+	/**
+	 * Set the current target buffer time in milliseconds
+	 */
+	set targetBufferTime(bufferTimeMs: number);
+	/**
+	 * The estimated playback latency based on target buffer time, the connection rtt and local playback drift
+	 */
+	get playbackLatency(): number | undefined;
+	/**
+	 * The estimated utc timestamp (in ms) for the playhead.
+	 */
+	get playbackWallclockTime(): number | undefined;
+	/**
+	 * Channels that can be switched between
+	 */
+	get channels(): ReadonlyArray<Channel>;
+	/**
+	 * Languages available
+	 */
+	get languages(): ReadonlyArray<string>;
+	/**
+	 * The current language
+	 */
+	get language(): string | undefined;
+	/**
+	 * Set the current language
+	 */
+	set language(language: string | undefined);
+	/**
+	 * Set the active text track
+	 */
+	set textTrack(label: string | undefined);
+	/**
+	 * Get the available text tracks
+	 */
+	get textTracks(): string[];
+	/**
+	 * Get the active text track
+	 */
+	get textTrack(): string | undefined;
+	/**
+	 * The current channelId
+	 */
+	get channelId(): string;
+	/**
+	 * Set the current channelId
+	 *
+	 * Possible channels to set are available from [[channels]]
+	 *
+	 * Note that the following scenarios are not possible right now:
+	 * - switching channel from a channel with audio to a channel without audio (unless audio only mode is active)
+	 * - switching channel from a channel with video to a channel without video (unless video only mode is active)
+	 */
+	set channelId(channelId: string);
+	/**
+	 * Max size that will be subcribed to
+	 */
+	get maxSize(): Size;
+	/**
+	 * Set max size that will be subscribed to
+	 *
+	 * Note: If ABR is disabled, setting this will make the client instantly subscribe to this size
+	 */
+	set maxSize(size: Size);
+	/**
+	 * The max video bit rate that will be subscribed to
+	 *
+	 * Note: Returns Number.MAX_SAFE_INTEGER if no limits have been set
+	 */
+	get maxVideoBitRate(): number;
+	/**
+	 * Set max video bit rate that will be subscribed to
+	 *
+	 * Note: If ABR is disabled, setting this will make the client instantly subscribe to this bitrate
+	 */
+	set maxVideoBitRate(bitRate: number);
+	/**
+	 * The max audio bit rate that will be subscribed to
+	 *
+	 * Note: Returns Number.MAX_SAFE_INTEGER if no limits have been set
+	 */
+	get maxAudioBitRate(): number;
+	/**
+	 * Set max audio bit rate that will be subscribed to
+	 *
+	 * Note: If ABR is disabled, setting this will make the client instantly subscribe to this bit rate
+	 */
+	set maxAudioBitRate(bitRate: number);
+	/**
+	 * The rendition levels available.
+	 */
+	get renditionLevels(): ReadonlyArray<RenditionLevel>;
+	/**
+	 * The current rendition level
+	 */
+	get currentRenditionLevel(): Readonly<RenditionLevel> | undefined;
+	/**
+	 * The target rendition level that the client is currently switching to
+	 */
+	get targetRenditionLevel(): Readonly<RenditionLevel> | undefined;
+	/**
+	 * True if the client is currently switching from one rendition level to another
+	 */
+	get isSwitchingRenditionLevel(): boolean;
+	/**
+	 * The time ranges buffered for video.
+	 * The ranges are specified in milliseconds.
+	 */
+	get videoBufferedRanges(): ReadonlyArray<TimeRange>;
+	/**
+	 * The time ranges buffered for audio.
+	 * The ranges are specified in milliseconds.
+	 */
+	get audioBufferedRanges(): ReadonlyArray<TimeRange>;
+	/**
+	 * The API client for calls to the public available endpoints of the Vindral Live CDN.
+	 */
+	getApiClient(): ApiClient;
+	get lastBufferEvent(): Readonly<BufferStateEvent>;
+	get activeRatios(): Map<string, number>;
+	get bufferingRatios(): Map<string, number>;
+	get timeSpentBuffering(): number;
+	get timeActive(): number;
+	get mediaElement(): HTMLMediaElement | HTMLCanvasElement;
+	/**
+	 * Get active Vindral Options
+	 */
+	getOptions: () => Options & typeof defaultOptions;
+	/**
+	 * Get url for fetching thumbnail. Note that fetching thumbnails only works for an active channel.
+	 */
+	getThumbnailUrl: () => string;
+	/**
+	 * Update authentication token on an already established and authenticated connection
+	 */
+	updateAuthenticationToken: (token: string) => void;
+	/**
+	 * @deprecated since 3.0.0 Use play instead.
+	 * Connects to the configured channel and starts streaming
+	 */
+	connect: () => void;
+	private _connect;
+	/**
+	 * Get options that can be used for CastSender
+	 */
+	getCastOptions: () => Options;
+	private connectionInfo;
+	private estimateRTT;
+	private connectHandler;
+	private emitLanguagesIfChanged;
+	private updateTextTracks;
+	private cleanupTextTracks;
+	private filterRenditions;
+	/**
+	 * Patch the subscription with properties from the channel that isn't known until connection
+	 * @param channel Channel with the renditions to patch the subscription based on
+	 */
+	private patchSubscription;
+	private isSupportedVideoCodecProfile;
+	private supportedAudioCodecs;
+	private initializeDecodingModule;
+	/**
+	 * Fully unloads the instance. This disconnects the clients and stops any background tasks.
+	 * This client instance can not be used after this has been called.
+	 */
+	unload: () => Promise<void>;
+	/**
+	 * @deprecated since 3.0.0 Use play instead.
+	 *
+	 * Activates audio or video on web browsers that require a user gesture to enable media playback.
+	 * The Vindral instance will emit a "needs user input" event to indicate when this is needed.
+	 * But it is also safe to pre-emptively call this if it is more convenient - such as in cases where
+	 * the Vindral instance itself is created in a user input event.
+	 *
+	 * Requirements: This method needs to be called within an user-input event handler to function properly, such as
+	 * an onclick handler.
+	 *
+	 * Note: Even if you pre-emptively call this it is still recommended to listen to "needs user input"
+	 * and handle that event gracefully.
+	 */
+	userInput: () => void;
+	/**
+	 * Pauses the stream. Call .play() to resume playback again.
+	 */
+	pause: () => void;
+	private registerDebugInstance;
+	/**
+	 *
+	 * Start playing the stream.
+	 *
+	 * This method also activates audio or video on web browsers that require a user gesture to enable media playback.
+	 * The Vindral instance will emit a "needs user input" event to indicate when this is needed.
+	 * But it is also safe to pre-emptively call this if it is more convenient - such as in cases where
+	 * the Vindral instance itself is created in a user input event.
+	 *
+	 * Note: In most browsers this method needs to be called within an user-input event handler, such as
+	 * an onclick handler in order to activate audio. Most implementations call this directly after constructing the Vindral
+	 * instance once in order to start playing, and then listen to a user-event in order to allow audio to be activated.
+	 *
+	 * Note 2: Even if you pre-emptively call this it is still recommended to listen to "needs user input"
+	 * and handle that event gracefully.
+	 */
+	play: () => void;
+	/**
+	 * How long in milliseconds since the instance was created
+	 */
+	get uptime(): number;
+	/**
+	 * This method collects a statistics report from internal modules. While many of the report's properties are documented, the report may also contain undocumented
+	 * properties used internally or temporarily for monitoring and improving the performance of the service.
+	 *
+	 * Use undocumented properties at your own risk.
+	 */
+	getStatistics: () => Statistics;
+	private resetModules;
+	private suspend;
+	private unsuspend;
+	private getRuntimeInfo;
+	private onMediaElementState;
+	private onBufferEvent;
+	/**
+	 * Aligns size and bitrate to match a rendition level correctly
+	 */
+	private alignSizeAndBitRate;
+	private get currentSubscription();
+	private get targetSubscription();
+	private timeToFirstFrame;
+	private willUseMediaSource;
+}
+
+export {};