@vindral/web-sdk 2.3.0 → 3.0.1

package/index.d.ts

@@ -1,83 +1,5 @@
-declare type Type = "audio" | "video";
-interface BaseCodedSample {
-	channelId: string;
-	isSync: boolean;
-	renditionId: number;
-	timestamp: number;
-	timescale: number;
-	duration: number;
-	data: ArrayBuffer;
-	compositionTimeOffset?: number;
-}
-interface CodedAudioSample extends BaseCodedSample {
-	type: "audio";
-	codec: AudioCodec;
-	channels: number;
-	sampleRate: number;
-	language?: string;
-}
-interface CodedVideoSample extends BaseCodedSample {
-	type: "video";
-	codec: VideoCodec;
-	width: number;
-	height: number;
-	buffer?: ArrayBuffer;
-}
-declare type CodedSample = CodedAudioSample | CodedVideoSample;
 declare type AudioCodec = "aac" | "opus" | "mp3";
 declare type VideoCodec = "h264" | "av1";
-declare type Codec = VideoCodec | AudioCodec;
-interface DecodedSampleStatistics {
-	decodeTime: number;
-	transportTimeFromWorker: number;
-	transportTimeToWorker: number;
-	samplesInBatch: number;
-}
-interface DecodedVideoSample {
-	type: "video";
-	colorPrimaries: "bt709";
-	channelId: string;
-	isSync: boolean;
-	renditionId: number;
-	timestamp: number;
-	timescale: number;
-	duration: number;
-	width: number;
-	height: number;
-	codedWidth: number;
-	codedHeight: number;
-	format: "yuv420";
-	data: [
-		Uint8Array,
-		Uint8Array,
-		Uint8Array
-	];
-	buffer: ArrayBuffer;
-	statistics?: DecodedSampleStatistics;
-}
-interface DecodedAudioSample {
-	type: "audio";
-	channels: number;
-	channelId: string;
-	isSync: boolean;
-	renditionId: number;
-	timestamp: number;
-	timescale: number;
-	duration: number;
-	sampleRate: number;
-	format: "f32";
-	data: Float32Array;
-	statistics?: DecodedSampleStatistics;
-}
-declare type DecodedSample = DecodedVideoSample | DecodedAudioSample;
-interface InitSegment {
-	type: Type;
-	codec: Codec;
-	channelId: string;
-	renditionId: number;
-	timescale: number;
-	data: ArrayBuffer;
-}
 declare type MatchingKeys<TRecord, TMatch, K extends keyof TRecord = keyof TRecord> = K extends (TRecord[K] extends TMatch ? K : never) ? K : never;
 declare type VoidKeys<Record> = MatchingKeys<Record, void>;
 declare type EventListenerReturnType = (() => void) | void;
@@ -87,63 +9,315 @@ declare class Emitter<TEvents, TEmits = TEvents, ArgLessEvents extends VoidKeys<
 	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 type FilterFunc<T> = (item: T) => boolean;
-declare class Fifo<T> {
-	readonly maxSize: number;
-	private values;
-	constructor(maxSize?: number);
-	push: (value: T) => void;
-	clear: () => void;
-	pop: () => T | undefined;
-	peekFirst: () => T | undefined;
-	peekLast: () => T | undefined;
-	isFull: () => boolean;
-	isEmpty: () => boolean;
-	items: () => ReadonlyArray<T>;
-	filterPop: (filter: FilterFunc<T>) => void;
-}
-declare type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<T>;
 interface MinMaxAverage {
 	average: number;
 	max: number;
 	min: number;
 }
-interface Regression {
-	slope: number;
-	intercept: number;
-	r2: number;
-	predict(x: number): 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;
+}
+declare type VideoRendition = VideoRenditionProps & RenditionProps;
+declare type AudioRendition = AudioRenditionProps & RenditionProps;
+declare type Rendition = VideoRendition | AudioRendition;
+interface Size {
+	width: number;
+	height: number;
 }
+interface VideoConstraint {
+	width: number;
+	height: number;
+	bitRate: number;
+	codec?: VideoCodec;
+	codecString?: string;
+}
+/**
+ * Channel
+ */
+export 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;
+}
+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;
+}
+export interface ConnectResponse {
+	logsUrl?: string;
+	statsUrl?: string;
+	telemetry?: Telemetry;
+	channels: ChannelWithRenditionsAndOverrides[];
+	edges: string[];
+}
+/**
+ * ApiClientOptions
+ */
+export 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;
+}
+/**
+ * Represents what authorization that will be requested.
+ */
+export interface AuthorizationContext {
+	/**
+	 * The channelGroupId that might need authorization.
+	 */
+	channelGroupId?: string;
+	/**
+	 * The channelId that might need authorization.
+	 */
+	channelId?: string;
+}
+/**
+ * AuthorizationTokenFactory
+ */
+export declare type AuthorizationTokenFactory = (context: AuthorizationContext) => string | undefined;
+/**
+ * Convenience class to call the public available endpoints of the Vindral Live CDN.
+ */
+export 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;
+}
+/**
+ * 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;
 }
+/**
+ * Available events to listen to
+ */
+export interface CastSenderEvents {
+	/**
+	 * When a connection has been established with a CastReceiver
+	 */
+	["connected"]: void;
+	/**
+	 * When a previous session has been resumed
+	 */
+	["resumed"]: void;
+	/**
+	 * When a CastReceiver has lost or stopped a connection
+	 */
+	["disconnected"]: void;
+	/**
+	 * When a connection attempt was initiated unsuccessfully
+	 */
+	["failed"]: void;
+	/**
+	 * When the remote connection emits a metadata event
+	 */
+	["metadata"]: Metadata;
+	/**
+	 * When the remote connection receives a server wallclock time event
+	 */
+	["server wallclock time"]: number;
+}
+/**
+ * Used for initializing the CastSender
+ */
+export interface CastConfig {
+	/**
+	 * The [Vindral Options](./Options) to use for the Cast Receiver
+	 */
+	options: Options;
+	/**
+	 * URL to a background image.
+	 * Example: "https://via.placeholder.com/256x144"
+	 */
+	background?: string;
+	/**
+	 * Override this if you have your own custom receiver
+	 */
+	receiverApplicationId?: string;
+}
+/**
+ * CastSender handles initiation of and communication with the Google Cast Receiver
+ */
+export declare class CastSender extends Emitter<CastSenderEvents> {
+	private state;
+	private config;
+	private unloaded;
+	constructor(config: CastConfig);
+	/**
+	 * True if the instance is casting right now
+	 */
+	get casting(): boolean;
+	/**
+	 * The current volume
+	 */
+	get volume(): number;
+	/**
+	 * Set the current volume. Setting this to zero is equivalent to muting the video
+	 */
+	set volume(volume: number);
+	/**
+	 * The current language
+	 */
+	get language(): string | undefined;
+	/**
+	 * Set the current language
+	 */
+	set language(language: string | undefined);
+	/**
+	 * The current channelId
+	 */
+	get channelId(): string;
+	/**
+	 * Set the current channelId
+	 */
+	set channelId(channelId: string);
+	/**
+	 * Update authentication token on an already established and authenticated connection
+	 */
+	updateAuthenticationToken: (token: string) => void;
+	/**
+	 * Fully unloads the instance. This disconnects the current listener but lets the
+	 * cast session continue on the receiving device
+	 */
+	unload: () => void;
+	/**
+	 * Initiates the CastSender.
+	 * Will reject if Cast is not available on the device or the network.
+	 */
+	init: () => Promise<void>;
+	/**
+	 * Requests a session. It will open the native cast receiver chooser dialog
+	 */
+	start: () => Promise<void>;
+	/**
+	 * Stops a session. It will stop playback on device as well.
+	 */
+	stop: () => void;
+	/**
+	 * Returns a string representing the name of the Cast receiver device or undefined if no receiver exists
+	 */
+	getReceiverName: () => string | undefined;
+	private onGCastApiAvailable;
+	private send;
+	private onMessage;
+	private onSessionStarted;
+	private onSessionStateChanged;
+	private getInstance;
+	private getSession;
+	private castLibrariesAdded;
+	private verifyCastLibraries;
+}
 export interface TimeRange {
 	start: number;
 	end: number;
 }
-declare type Timestamp = number;
-export interface PerLevelStats {
-	upgradesFromLevel: Timestamp[];
-	downgradesFromLevel: Timestamp[];
-	bufferingRanges: PartialBy<TimeRange, "end">[];
-	activeRanges: PartialBy<TimeRange, "end">[];
-	decodeRate: number;
-}
-export interface Metrics {
-	levels: {
-		[key: string]: PerLevelStats;
-	};
-	general: PerLevelStats;
-	bufferFullness: number;
-}
 export declare enum Level {
 	TRACE = "trace",
 	DEBUG = "debug",
@@ -152,204 +326,28 @@ export declare enum Level {
 	ERROR = "error",
 	CRITICAL = "critical"
 }
-declare type Meta = Record<string, unknown>;
-interface Logger {
-	getLogger(category: string): Logger;
-	getFullCategory(): string[];
-	category(): string;
-	trace(message: string, meta?: Meta): void;
-	debug(message: string, meta?: Meta): void;
-	info(message: string, meta?: Meta): void;
-	warn(message: string, meta?: Meta): void;
-	error(message: string, meta?: Meta): void;
-	critical(message: string, meta?: Meta): void;
-}
-interface LoggerOptions {
-	category: string;
-	onLog: (instance: LoggerInstance, level: Level, message: string, meta?: Meta) => void;
-	parent?: Logger;
-}
-declare class LoggerInstance implements Logger {
-	private options;
-	constructor(options: LoggerOptions);
-	getLogger: (category: string) => Logger;
-	getFullCategory: () => string[];
-	category: () => string;
-	trace: (message: string, meta?: Meta | undefined) => void;
-	debug: (message: string, meta?: Meta | undefined) => void;
-	info: (message: string, meta?: Meta | undefined) => void;
-	warn: (message: string, meta?: Meta | undefined) => void;
-	error: (message: string, meta?: Meta | undefined) => void;
-	critical: (message: string, meta?: Meta | undefined) => void;
-}
-export declare type PlayInitiator = "user input" | "programatically";
-export interface PlaybackSource {
-	volume: number;
-	muted: boolean;
-	currentTime: number;
-	playbackRate?: number;
-	isActivated: boolean;
-	readonly seekTime: number;
-	readonly paused: boolean;
-	readonly isSeeking: boolean;
-	play(initiator: PlayInitiator): Promise<void>;
-	load?: () => void;
-	unload?: () => void;
-}
-interface MediaElementOptions {
-	autoplay: boolean;
-	muted: boolean;
-	type: "audio" | "video";
-	logger: Logger;
-	poster?: string;
-}
 interface NeedsUserInputContext {
+	/**
+	 * True if user input is needed for audio
+	 */
 	forAudio: boolean;
+	/**
+	 * True if user input is needed for video
+	 */
 	forVideo: boolean;
 }
-interface MediaElementEvents {
-	["needs user input"]: NeedsUserInputContext;
-	["buffer state"]: Readonly<BufferState>;
-}
-declare class MediaElement extends Emitter<MediaElementEvents> {
-	readonly element: HTMLMediaElement;
-	private logger;
-	private seekTimes;
-	private seekStartTime?;
-	private _userProvidedMuted;
-	private timers;
-	private _userHasProvidedInput;
-	isActivated: boolean;
-	constructor({ type, autoplay, muted, logger, poster }: MediaElementOptions);
-	attach: (container: HTMLElement) => void;
-	get seekTime(): number;
-	get isSeeking(): boolean;
-	get currentTime(): number;
-	set currentTime(value: number);
-	get playbackRate(): number;
-	set playbackRate(rate: number);
-	get volume(): number;
-	set volume(volume: number);
-	get muted(): boolean;
-	set muted(muted: boolean);
-	get userHasProvidedInput(): boolean;
-	get paused(): boolean;
-	load: () => void;
-	unload: () => void;
-	getPlaybackRate: () => number;
-	getPlaybackState: () => PlaybackState;
-	setPlaybackRate: (rate: number) => void;
-	getBuffer: () => TimeRange[];
-	play: (initiator: PlayInitiator) => Promise<void>;
-	private _play;
-	private onEvent;
-	private onBufferStateChange;
-	private onSeekStart;
-	private onSeekEnd;
-}
-declare type PlaybackState = "buffering" | "playing";
+declare type PlaybackState = "buffering" | "playing" | "paused";
 declare type BufferStateEvent = "filled" | "drained";
-declare type BufferState = {
-	buffered: ReadonlyArray<TimeRange>;
-	currentTime: number;
-	playbackState: PlaybackState;
-};
-interface PlaybackModuleListeners {
-	["buffer state"]: Readonly<BufferState>;
-	["needs user input"]: NeedsUserInputContext;
-}
-interface PlaybackModuleEvents {
-	["buffer state event"]: Readonly<BufferStateEvent>;
-	["playback state"]: Readonly<PlaybackState>;
-	["buffer fullness"]: number;
-}
-interface ClockSource {
-	readonly currentTime: number;
-}
 interface PlaybackModuleStatistics {
 	bufferTime: number;
 	needsInputForAudioCount: number;
 	needsInputForVideoCount: number;
 }
-declare class PlaybackModule {
-	private emitter;
-	private logger;
-	private clockSource;
-	private state;
-	private bufferFullness;
-	private targetBufferTime;
-	private lastBufferStateEvent;
-	private firstFrameTime?;
-	private needsInputForAudioCount;
-	private needsInputForVideoCount;
-	constructor(emitter: Emitter<PlaybackModuleListeners, PlaybackModuleEvents>, logger: Logger, clockSource: ClockSource, targetBufferTime: number);
-	static create: (emitter: Emitter<PlaybackModuleListeners, PlaybackModuleEvents>, logger: Logger, clockSource: ClockSource, targetBufferTime: number) => PlaybackModule;
-	unload: () => void;
-	setTargetBufferTime: (bufferTime: number) => void;
-	getTargetBufferTime: () => number;
-	getBufferFullness: () => number;
-	getLastBufferStateEvent: () => BufferStateEvent;
-	getState: () => PlaybackState;
-	getFirstFrameTime: () => number | undefined;
-	getStatistics: () => PlaybackModuleStatistics;
-	private onBufferedStateChanged;
-	private onNeedsUserInput;
-}
-declare type Direction = "upgrade" | "downgrade" | "double downgrade" | "reconnect";
-interface QualityOfServiceConfig {
-	cooldownTime: number;
-	maxBufferingEvents: {
-		last10Seconds: number;
-	};
-	maxBufferingRatio: {
-		last10Seconds: number;
-	};
-	maxRecentDowngradesCount: number;
-	maxDowngradeLookbackMs: number;
-	minTimeSpentPlaying: {
-		factor: number;
-		ratio: number;
-	};
-	maxCooldownRatio: number;
-}
-interface AdaptivityEvents {
-	["adapt level"]: Readonly<Direction>;
-}
 interface AdaptivityStatistics {
 	isAbrEnabled: boolean;
 }
-interface QualityOfServiceSource {
-	getMetrics(): Metrics;
-	getLevelStats(level: RenditionLevel): PerLevelStats | undefined;
-	getBufferFullnessRegression(): Regression | undefined;
-	timeSpentBuffering(): number;
-	timeActive(): number;
-	timeSpentBufferingLast(last: number): number;
-	timeSpentActiveLast(last: number): number;
-	timeSpentPlayingInAtLeastLevelRatio(level: RenditionLevel): number;
-}
-declare class AdaptivityModule {
-	private qualityOfServiceSource;
-	private config;
-	private emitter;
-	private logger;
-	private isSuspended;
-	private lastAdaptTime;
-	isEnabled: boolean;
-	constructor(emitter: Emitter<AdaptivityEvents>, logger: Logger, qualityOfServiceSource: QualityOfServiceSource, config: Partial<QualityOfServiceConfig>);
-	static create: (emitter: Emitter<AdaptivityEvents>, logger: Logger, qualityOfServiceSource: QualityOfServiceSource, config?: Partial<QualityOfServiceConfig>) => AdaptivityModule;
-	load: () => void;
-	unload: () => void;
-	suspend: () => void;
-	unsuspend: () => void;
-	reset: (extraGraceTimeMs?: number) => void;
-	getStatistics: () => AdaptivityStatistics;
-	isQoSOk: (renditionLevel: RenditionLevel) => boolean;
-	private onBufferState;
-	private onAdaptedLevel;
-	private adaptLevel;
-	private tooMuchTimeBuffering;
-	private tooManyBufferingEvents;
+interface BufferTimeStatistics {
+	bufferTimeAdjustmentCount: number;
 }
 interface VindralErrorProps {
 	isFatal: boolean;
@@ -364,158 +362,38 @@ 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 MISSING_INIT_SEGMENT = "missing_init_segment";
-export declare const NO_TRACK_CONTEXT = "no_track_context";
 export declare const DISCONNECTED_BY_EDGE = "disconnected_by_edge";
-export declare const DECODER_ERROR = "decoder_error";
-export declare const AUDIO_PLAYER_ERROR = "audio_player_error";
-export declare const MEDIA_SOURCE_ERROR = "media_source_error";
-export declare const WEBGL_CONTEXT_LOST_ERROR = "webgl_context_lost_error";
-export declare type ErrorType = "internal" | "external";
+declare 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>;
 }
-export declare const mediaElementError: (isFatal: boolean, source: MediaError) => VindralError;
-export declare const decoderError: (isFatal: boolean, source: Error) => VindralError;
-export declare const audioPlayerError: (isFatal: boolean, source: Error) => VindralError;
-export declare const missingInitSegmentError: (renditionId: number, channelId: string) => VindralError;
-export declare const mediaSourceError: (isFatal: boolean, source: Error) => VindralError;
-export declare const noTrackContextError: (type: "audio" | "video", renditionId: number, channelId: string) => VindralError;
-export declare const audioContextTimeoutError: () => VindralError;
-export declare const disconnectedFromEdgeServerError: (source?: VindralError | undefined) => VindralError;
-export declare const authenticationError: (source?: Error | undefined) => VindralError;
-export declare const authenticationExpiredError: (source?: Error | undefined) => VindralError;
-export declare const inactivityError: (type: ErrorType, source?: Error | undefined) => VindralError;
-export declare const channelNotFoundError: (type: ErrorType, source?: Error | undefined) => VindralError;
-export declare const noIncomingDataError: (source?: Error | undefined) => VindralError;
-export declare const unableToConnectError: (source?: Error | undefined) => VindralError;
-export declare const unableToConnectAfterRetriesError: () => VindralError;
-export declare const webglContextError: (source: Error) => VindralError;
-interface AudioPlayerModuleListeners {
-	["decoded frame"]: Readonly<DecodedSample>;
-}
-interface AudioPlayerModuleEvents {
-	["needs user input"]: NeedsUserInputContext;
-	["error"]: VindralError;
-}
-interface ClockSource {
-	readonly currentTime: number;
-}
-declare class AudioPlayerModule {
-	private logger;
-	private emitter;
-	private unmuter;
-	private audio?;
-	private gainNode?;
-	private _volume;
-	private _userProvidedMuted;
-	private _muted;
-	private startTime;
-	private samples;
-	private preInitSampleQueue;
-	private sampleRate;
-	private channels;
-	private index;
-	private clockSource;
-	private clockDelta?;
-	private startTimeIsInvalidated;
-	private lastSampleTimestamp;
-	isActivated: boolean;
-	get volume(): number;
-	set volume(volume: number);
-	get seekTime(): number;
-	get isSeeking(): boolean;
-	get muted(): boolean;
-	set muted(muted: boolean);
-	get paused(): boolean;
-	get currentTime(): number;
-	set currentTime(currentTime: number);
-	constructor(emitter: Emitter<AudioPlayerModuleListeners, AudioPlayerModuleEvents>, logger: Logger, clockSource: ClockSource, muted: boolean);
-	unload: () => Promise<void>;
-	suspend: () => void;
-	unsuspend: () => void;
-	static create: (emitter: Emitter<AudioPlayerModuleListeners, AudioPlayerModuleEvents>, logger: Logger, clockSource: ClockSource, muted: boolean) => AudioPlayerModule;
-	private flush;
-	private onDecodedFrame;
-	play: () => Promise<void>;
-	private resume;
-	private getAudioContext;
-	private setupContext;
-	private setGain;
-}
-interface BufferTimeConfig {
-	minBufferTime: number;
-	maxBufferTime: number;
-	cooldownTime: number;
-	maxBufferingEvents: {
-		last30Seconds: number;
-	};
-	maxBufferingRatio: {
-		last30Seconds: number;
-	};
-}
-interface BufferTimeListeners {
-	["buffer state"]: Readonly<BufferState>;
-}
-interface BufferTimeStatistics {
-	bufferTimeAdjustmentCount: number;
-}
-interface TargetBufferTimeTarget {
-	targetBufferTime: number;
-}
-interface QualityOfServiceSource {
-	bufferingEventsLast(last: number): number;
-	timeSpentBufferingLast(last: number): number;
-	timeSpentActiveLast(last: number): number;
-}
-declare class BufferTimeModule {
-	private static BUFFER_TIME_STEP_SIZE;
-	private qualityOfServiceSource;
-	private targetBufferTimeTarget;
-	private config;
-	private emitter;
-	private logger;
-	private isSuspended;
-	private lastIncreaseTime;
-	private bufferTimeAdjustmentCount;
-	constructor(emitter: Emitter<BufferTimeListeners, unknown>, logger: Logger, qualityOfServiceSource: QualityOfServiceSource, targetBufferTimeTarget: TargetBufferTimeTarget, config: Partial<BufferTimeConfig>);
-	static create: (emitter: Emitter<BufferTimeListeners, unknown>, logger: Logger, qualityOfServiceSource: QualityOfServiceSource, targetBufferTimeTarget: TargetBufferTimeTarget, config?: Partial<BufferTimeConfig>) => BufferTimeModule;
-	updateConfig(config: Partial<BufferTimeConfig>): void;
-	load: () => void;
-	unload: () => void;
-	suspend: () => void;
-	unsuspend: () => void;
-	reset: () => void;
-	getStatistics: () => BufferTimeStatistics;
-	private onBufferState;
-}
 declare type State = "connected" | "disconnected" | "connecting";
 declare type ContextSwitchState = "completed" | "started";
-interface ConnectionModuleListeners {
-	["send signal"]: Readonly<string>;
-	["disconnect"]: void;
-	["reconnect"]: string;
-}
-interface ConnectionModuleEvents {
-	["received signal"]: Readonly<Signal>;
-	["received data"]: Readonly<ArrayBuffer>;
-	["connection state"]: Readonly<State>;
-	["rtt"]: number;
-	["error"]: Readonly<VindralError>;
-	["context switch complete"]: Readonly<void>;
-	["context switch started"]: Readonly<void>;
-}
-interface ConnectOptions {
-	connectHandler: () => Promise<string>;
-	reconnectHandler: (state: ReconnectState) => Promise<boolean> | boolean;
-}
 interface ConnectionStatistics {
 	rtt: MinMaxAverage;
 	estimatedBandwidth: number;
@@ -523,55 +401,6 @@ interface ConnectionStatistics {
 	connectCount: number;
 	connectionAttemptCount: number;
 }
-declare class ConnectionModule {
-	private static PING_INTERVAL;
-	private static MAX_MISSED_PINGS;
-	private static TLS_ROUNDTRIPS;
-	private timers;
-	private emitter;
-	private transport?;
-	private logger;
-	private options;
-	private rtts;
-	private lastPingSentTime;
-	private isPingInFlight;
-	private connectCount;
-	private _firstConnectionTime?;
-	private _lastConnectionTime?;
-	private missedPings;
-	private contextSwitchesInProgress;
-	private contextSwitchesCompleted;
-	private buffer;
-	private constructor();
-	static create: (emitter: Emitter<ConnectionModuleListeners, ConnectionModuleEvents>, logger: Logger, options: ConnectOptions) => ConnectionModule;
-	unload: () => void;
-	suspend: () => void;
-	unsuspend: () => void;
-	get rtt(): number;
-	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: (connectionsCount: 1 | 2) => void;
-	private onTransportChange;
-	disconnect: (reason?: string) => void;
-	reconnect: (reason: string) => void;
-	private resetPingState;
-	private pingCooldownExpired;
-	private sendPing;
-}
-interface Size {
-	width: number;
-	height: number;
-}
-interface PictureInPictureSizeSource {
-	getPictureInPictureSize(): Size | undefined;
-}
 export interface RenditionLevel {
 	audio?: AudioRendition;
 	video?: VideoRendition;
@@ -582,29 +411,10 @@ export interface RenditionLevelChanged {
 	to?: RenditionLevel;
 	reason: RenditionLevelChangedReason;
 }
-export interface SubscriptionChange {
-	readonly to: Readonly<Subscription>;
-	readonly from: Readonly<Subscription>;
-}
-interface RenditionsModuleEvents {
-	["rendition level changed"]: Readonly<RenditionLevelChanged>;
-}
-interface RenditionsModuleListeners {
-	["subscription changed"]: Readonly<SubscriptionChange>;
-	["renditions"]: Readonly<RenditionsArgs>;
-}
-interface RenditionsArgs {
-	renditions: ReadonlyArray<Rendition>;
-	channelId: string;
-}
 interface RenditionLevel {
 	audio?: AudioRendition;
 	video?: VideoRendition;
 }
-interface SubscriptionSource {
-	getTargetSubscription(): Readonly<Subscription>;
-	getCurrentSubscription(): Readonly<Subscription>;
-}
 interface RenditionsModuleStatistics {
 	videoRenditionId?: number;
 	audioRenditionId?: number;
@@ -621,42 +431,6 @@ interface RenditionsModuleStatistics {
 	];
 	renditionLevelChangeCount: number;
 }
-declare type ChannelId = string;
-declare class RenditionsModule {
-	private renditions;
-	private renditionLevels;
-	private languages;
-	private emitter;
-	private subscriptionSource;
-	private renditionLevelChangeCount;
-	constructor(emitter: Emitter<RenditionsModuleListeners, RenditionsModuleEvents>, subscriptionSource: SubscriptionSource);
-	unload: () => void;
-	static create: (emitter: Emitter<RenditionsModuleListeners, RenditionsModuleEvents>, subscriptionSource: SubscriptionSource) => RenditionsModule;
-	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;
-	getAudioRenditions: (channelId: ChannelId) => Readonly<AudioRendition[]> | undefined;
-	getAudioRendition: (renditionId: number, channelId?: string) => Readonly<AudioRendition> | undefined;
-	getRendition: (renditionId: number, channelId?: string) => Readonly<Rendition> | undefined;
-	getStatistics: () => RenditionsModuleStatistics;
-	private onRenditions;
-	private onSubscriptionChanged;
-	private updateRenditionLevels;
-	private createRenditionLevels;
-	private getCurrentSubscription;
-}
-declare type DeepPartial<T> = {
-	[P in keyof T]?: DeepPartial<T[P]>;
-};
-interface ConstraintCapModuleEvents {
-	["constraint cap changed"]: Readonly<ConstraintCap>;
-}
-interface ConstraintCapModuleListeners {
-	["enter picture in picture"]: Readonly<PictureInPictureSizeSource>;
-	["exit picture in picture"]: void;
-}
 interface VideoConstraintCap {
 	width: number;
 	height: number;
@@ -677,120 +451,13 @@ interface ConstraintCapStatistics {
 	elementHeight: number;
 	pixelRatio: number;
 }
-interface RenditionLevelSource {
-	getRenditionLevels(): ReadonlyArray<RenditionLevel>;
-}
-declare class ConstraintCapModule {
-	private static CHECK_SIZE_INTERVAL;
-	private emitter;
-	private timers;
-	private pictureInPictureSource?;
-	private element;
-	private currentCap?;
-	private userSpecifiedCap?;
-	private renditionLevelSource;
-	private resizeObserver?;
-	private elementSize;
-	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;
-	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;
-	private exitPictureInPicture;
-}
-declare class ArrayBufferPool {
-	private maxSize;
-	private size;
-	private buffers;
-	private _borrowedBuffers;
-	constructor(maxSize: number);
-	get bufferSize(): number;
-	get poolSize(): number;
-	get borrowedBuffers(): number;
-	get: (size: number) => ArrayBuffer;
-	reclaim: (buffer: ArrayBuffer) => void;
-}
-declare type DecoderParamType<Type extends "audio" | "video"> = Type extends "video" ? CodedVideoSample : CodedAudioSample;
-declare type DecoderReturnType<Type extends "audio" | "video"> = Type extends "video" ? DecodedVideoSample : DecodedAudioSample;
-interface DecoderContext<Type extends "audio" | "video"> {
-	unload(): void;
-	initSegment(initSegment: Readonly<InitSegment>): void;
-	enqueue(sample: Readonly<DecoderParamType<Type>>): void;
-	take(): DecoderReturnType<Type> | undefined;
-	error?: () => Error | undefined;
-}
-interface DecoderModuleEvents {
-	["video decode rate"]: number;
-	["decoded frame"]: Readonly<DecodedSample>;
-	["buffer state"]: Readonly<BufferState>;
-	["error"]: Readonly<VindralError>;
-}
-interface DecoderModuleListeners {
-	["init segment"]: Readonly<InitSegment>;
-	["coded sample"]: Readonly<CodedSample>;
-}
 interface DecoderStatistics {
 	videoDecodeRate: number;
 	videoDecodeTime: MinMaxAverage;
 	audioDecodeTime: MinMaxAverage;
 	videoTransportTime: MinMaxAverage;
 }
-interface ClockSource {
-	readonly currentTime: number;
-}
-interface TrackContext {
-	buffer: TimeRange[];
-	decoderContext: DecoderContext<Type>;
-	decodeTime: Fifo<number>;
-	transportTime: Fifo<number>;
-	sampleDuration: number;
-}
-declare class DecoderModule {
-	private static BUFFER_GAP_THRESHOLD;
-	private static DECODED_FRAMES_CHECK_INTERVAL;
-	private static DECODE_RATE_INTERVAL;
-	private timers;
-	private logger;
-	private emitter;
-	private trackContexts;
-	private clockSource;
-	private isSuspended;
-	constructor(emitter: Emitter<DecoderModuleListeners, DecoderModuleEvents>, logger: Logger, trackContexts: Map<Type, TrackContext>, clockSource: ClockSource);
-	load: () => void;
-	unload: () => void;
-	suspend: () => void;
-	unsuspend: () => void;
-	static create: (emitter: Emitter<DecoderModuleListeners, DecoderModuleEvents>, logger: Logger, tracks: Track[], clockSource: ClockSource, pool: ArrayBufferPool) => Promise<DecoderModule>;
-	getBuffer: (type: Type) => TimeRange[] | undefined;
-	videoDecodeRate: () => number;
-	getStatistics: () => DecoderStatistics;
-	private onInitSegment;
-	private decode;
-	private emitDecodedFrames;
-	private emitDecodeRate;
-	private updateBufferState;
-}
 type EffectiveConnectionType = "2g" | "3g" | "4g" | "slow-2g";
-interface DocumentState {
-	readonly isVisible: boolean;
-	readonly isOnline: boolean;
-}
-interface DocumentStateEvents {
-	["page active"]: boolean;
-	["pagehide"]: PageTransitionEvent;
-}
 interface DocumentStateModulesStatistics {
 	isVisible: boolean;
 	isOnline: boolean;
@@ -804,407 +471,45 @@ interface DocumentStateModulesStatistics {
 	navigatorSaveData?: boolean;
 	navigatorDownlink?: number;
 }
-declare class DocumentStateModule implements DocumentState {
-	private emitter;
-	private isVisibleCount;
-	private isHiddenCount;
-	private isOnlineCount;
-	private isOfflineCount;
-	private isActive;
-	constructor(emitter: Emitter<unknown, DocumentStateEvents>);
-	static create: (emitter: Emitter<unknown, DocumentStateEvents>) => DocumentStateModule;
-	unload: () => void;
-	load: () => void;
-	unsuspend: () => void;
-	getStatistics: () => DocumentStateModulesStatistics;
-	get isOnline(): boolean;
-	get isVisible(): boolean;
-	private onOnline;
-	private onOffline;
-	private onPageHide;
-	private onVisibilityChanged;
-	private setIsActive;
-}
-interface EventModuleEvents {
-	["event"]: Readonly<StoredEvent>;
-}
-interface TimeSource {
-	readonly drift: number | undefined;
-	readonly serverCurrentTime: number;
-}
-interface BaseEvent {
-	timestamp: number;
-}
-declare type TimestampAdded = {
-	timestampAdded: number;
-};
-interface Metadata extends BaseEvent {
-	type: "metadata";
-	content: string;
-}
-interface ChannelSwitch extends BaseEvent {
-	type: "channel switch";
-	channelId: string;
-}
-interface LanguageSwitch extends BaseEvent {
-	type: "language switch";
-	language: string;
-}
-declare type Event = Metadata | ChannelSwitch | LanguageSwitch;
-declare type StoredEvent = TimestampAdded & Event;
-declare class EventModule {
-	private static EVENT_TIMEOUT;
-	private static EVENT_CHECK_INTERVAL;
-	private logger;
-	private emitter;
-	private waitingEvents;
-	private isTriggered;
-	private timeSource;
-	private timers;
-	constructor(emitter: Emitter<unknown, EventModuleEvents>, logger: Logger, timeSource: TimeSource);
-	load: () => void;
-	unload: () => void;
-	static create: (emitter: Emitter<unknown, EventModuleEvents>, logger: Logger, timeSource: TimeSource) => EventModule;
-	addEvent: (event: Event) => void;
-	extractEvent: (previousSample: CodedSample, sample: CodedSample) => void;
-	private onBufferedStateChanged;
-}
-interface IncomingDataModuleListeners {
-	["connection state"]: Readonly<State>;
-}
-interface IncomingDataModuleEvents {
-	["no data timeout"]: number;
-	["reconnect"]: string;
-	["error"]: Readonly<VindralError>;
-}
-interface IncomingDataModuleStatistics {
-	videoBitRate: number;
-	audioBitRate: number;
-	bytesReceived: number;
-}
-declare class IncomingDataModule {
-	static NO_DATA_ERROR_TIMEOUT: number;
-	static NO_DATA_TIMEOUT: number;
-	static UPDATE_RECEIVED_BYTES_INTERVAL: number;
-	private emitter;
-	private timers;
-	private bytesReceived;
-	private timeoutInterval?;
-	private lastBytesUpdated;
-	constructor(emitter: Emitter<IncomingDataModuleListeners, IncomingDataModuleEvents>);
-	static create: (emitter: Emitter<IncomingDataModuleListeners, IncomingDataModuleEvents>) => IncomingDataModule;
-	load: () => void;
-	unload: () => void;
-	averageBitRate: (type: Type) => number;
-	totalBytesReceived: () => number;
-	add: (type: Type, bytes: number) => void;
-	getStatistics: () => IncomingDataModuleStatistics;
-	private onConnectionState;
-	private checkTimeout;
-	private clearTimeoutInterval;
-}
-declare class LoggerModule {
-	private level;
-	private categoryLevels;
-	static create: () => LoggerModule;
-	getLogger: (category: string) => LoggerInstance;
-	setLevel: (level: Level, category?: string | undefined) => void;
-	unload: () => void;
-	private onLog;
-}
-interface RecoveredContext {
-	error: Error;
-	count: number;
-}
-interface MseModuleEvents {
-	["error"]: Readonly<VindralError>;
-	["recovered from media error"]: Readonly<RecoveredContext>;
-}
-interface MseModuleListeners {
-	["init segment"]: Readonly<InitSegment>;
-	["coded sample"]: Readonly<CodedSample>;
-}
-interface MseModuleStatistics {
-	quotaErrorCount: number;
-	totalVideoFrames?: number;
-	droppedVideoFrames?: number;
-}
-declare class MseModule {
-	private readonly maxChunkSize;
-	private logger;
-	private timers;
-	private emitter;
-	private mediaElement;
-	private tracks;
-	private mediaSource;
-	private trackContexts;
-	private autoRecoverFromMediaErrors;
-	private quotaErrorCount;
-	private recoveredFromErrorCount;
-	constructor(logger: Logger, emitter: Emitter<MseModuleListeners, MseModuleEvents>, mediaElement: HTMLMediaElement, tracks: Track[]);
-	static create: (logger: Logger, emitter: Emitter<MseModuleListeners, MseModuleEvents>, mediaElement: HTMLMediaElement, tracks: Track[]) => Promise<MseModule>;
-	load: () => void;
-	unload: () => void;
-	getStatistics: () => MseModuleStatistics;
-	private open;
-	getBuffer: (type: Type) => TimeRange[];
-	init: (initSegment: Readonly<InitSegment>) => void;
-	append: (samples: Readonly<CodedSample>[], needsInitSegment: boolean) => Promise<void>;
-	private onCodedSample;
-	private onSourceEnded;
-}
-interface PictureInPictureListeners {
-	["add picture in picture listener"]: {
-		element: Readonly<HTMLMediaElement>;
-	};
-}
-interface PictureInPictureEvents {
-	["enter picture in picture"]: Readonly<PictureInPictureSizeSource>;
-	["exit picture in picture"]: void;
-}
-declare class PictureInPictureModule {
-	private logger;
-	private emitter;
-	private element?;
-	private pictureInPictureWindow?;
-	private constructor();
-	static create: (emitter: Emitter<PictureInPictureListeners, PictureInPictureEvents>, logger: Logger) => PictureInPictureModule;
-	unload: () => void;
-	onEnablePictureInPicture: (params: PictureInPictureListeners["add picture in picture listener"]) => void;
-	getPictureInPictureSize: () => Size | undefined;
-	isPictureInPictureActive: () => boolean;
-	isPictureInPictureSupported: () => boolean;
-	requestPictureInPicture: () => Promise<void>;
-	exitPictureInPicture: () => Promise<void>;
-	private requestStandardPictureInPicture;
-	private exitStandardPictureInPicture;
-	private isStandardPictureInPictureSupported;
-	private isStandardPictureInPictureActive;
-	private isWebkitPresentationModeActive;
-	private requestWebkitPresentationMode;
-	private isWebkitPresentationModeSupported;
-}
-interface QualityOfServiceModuleEvents {
-	["fatal quality of service"]: void;
-}
-interface QualityOfServiceModuleStatistics {
-	timeSpentBuffering: number;
-	bufferingEventsCount: number;
-	fatalQosCount: number;
-	timeSpentRatio: {
-		[bitRate: string]: number;
-	};
-}
-declare class QualityOfServiceModule {
-	private readonly minBufferFullnessLengthForRegression;
-	private logger;
-	private emitter;
-	private timers;
-	private metrics;
-	private bufferFullness;
-	private bufferFullnessRegression?;
-	private currentLevel?;
-	private isSuspended;
-	private _fatalQosCount;
-	private hasAsserted;
-	constructor(emitter: Emitter<QualityOfServiceModuleEvents>, logger: Logger);
-	static create: (emitter: Emitter<QualityOfServiceModuleEvents>, logger: Logger) => QualityOfServiceModule;
-	load: () => void;
-	unload: () => void;
-	suspend: () => void;
-	unsuspend: () => void;
-	fatalQosGraceTime: () => number;
-	get fatalQosCount(): number;
-	incrementFatalQosCount: () => void;
-	getMetrics: () => Metrics;
-	getLevelStats: (renditionLevel: RenditionLevel) => PerLevelStats | undefined;
-	getBufferFullnessRegression: () => Regression | undefined;
-	activeRatios: () => Map<string, number>;
-	bufferingRatios: () => Map<string, number>;
-	bufferingEventsLast: (last: number) => number;
-	timeSpentBufferingLast: (last: number) => number;
-	timeSpentActiveLast: (last: number) => number;
-	timeSpentPlayingInAtLeastLevelRatio: (renditionLevel: RenditionLevel) => number;
-	timeSpentBuffering: () => number;
-	timeActive: () => number;
-	getStatistics: () => QualityOfServiceModuleStatistics;
-	private onRenditionLevelChanged;
-	private onBufferFullness;
-	private onPlaybackState;
-	private onVideoDecodeRate;
-	private calculateLinearRegression;
-	private stopBuffering;
-	private startBuffering;
-	private setActive;
-	private unsetActive;
-}
-interface SubscriptionModuleListeners {
-	["subscription changed"]: Readonly<SubscriptionChange>;
-}
-declare class SubscriptionModule {
-	private logger;
-	private timers;
-	private emitter;
-	private targetSubscription;
-	private currentSubscription;
-	private _isSwitchingSubscription;
-	private pendingSubscriptionTimeoutId?;
-	private burstMs;
-	private constructor();
-	unload: () => void;
-	static create: (logger: Logger, emitter: Emitter<SubscriptionModuleListeners>, subscription: Subscription) => SubscriptionModule;
-	isSwitchingSubscription: () => boolean;
-	getTargetSubscription: () => Subscription;
-	getCurrentSubscription: () => Subscription;
-	enableBurst: (bufferTimeMs: 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;
-	setAudioCodec: (audioCodec: AudioCodec | undefined) => void;
-	private setBurst;
-	private isNewSubscription;
-	private onSubscriptionChanged;
-	private scheduleSubscriptionChange;
-}
-interface SyncSample {
-	type: Type;
-	isSync: boolean;
-	channelId: string;
-	timestamp: number;
-	timescale: number;
-}
-interface SyncModuleListeners {
-	["rtt"]: number;
-}
-interface SyncModuleEvents {
-	["channel reset"]: void;
-}
-interface SyncInfo {
-	wallclockTime: number;
-	timestamp: number;
-}
-interface BufferSource {
-	getTargetBufferTime(): number;
-}
-interface SyncModuleStatistics {
-	drift: number | undefined;
-	driftAdjustmentCount: number;
-	timeshiftDriftAdjustmentCount: number;
-	discardedTimeInfoCount: number;
-	seekTime: number;
-}
-declare class SyncModule {
-	private emitter;
-	private logger;
-	private playbackSource;
-	private bufferSource;
-	private lastSeekTime;
-	readonly seekCooldownTime = 1000;
-	readonly seekTimeoutTime = 5000;
-	readonly syncMaxBehind: number;
-	readonly syncMaxBehindMultiplierStep = 1;
-	readonly syncMaxBehindIncreaseEvery = 3;
-	readonly syncMaxBehindMaximumAllowed = 2000;
-	syncMaxBehindMultiplier: number;
-	timeshiftOnAudio: boolean;
-	readonly syncMaxAhead = 150;
-	timeshiftSync: {
-		enabled: boolean;
-		maxBehind: number;
-		multiplier: number;
-		maxBehindAllowed: number;
-		overshoot: number;
-		minOvershootAllowed: number;
-		maxOvershootAllowed: number;
-	};
-	readonly maxTimeSyncDifferenceTolerance = 150;
-	private timers;
-	private rtt;
-	private channelSyncInfo;
-	private driftAdjustmentsCount;
-	private timeshiftDriftAdjustmentCount;
-	private timestampOffset?;
-	private currentChannelId?;
-	private highestSeenTimestamps;
-	private discardedTimeInfoCount;
-	private isSuspended;
-	private isSyncAdjustmentActivated;
-	private constructor();
-	load: () => void;
-	unload: () => void;
-	suspend: () => void;
-	unsuspend: () => void;
-	activateSyncAdjustments: () => void;
-	static create: (emitter: Emitter<SyncModuleListeners, SyncModuleEvents>, logger: Logger, playbackSource: PlaybackSource, bufferSource: BufferSource, isTimeshiftSyncEnabled: boolean) => SyncModule;
-	reset: () => void;
-	getTimeshiftOffset: () => number;
-	getCurrentChannelId: () => string | undefined;
-	updateChannelSyncInfo(channelId: string, syncInfo: SyncInfo): void;
-	private tryApplySyncInfo;
-	getLiveEdgeTime: (channelId: string) => number | undefined;
-	getLiveEdgeTimeLatencyAdjusted: (channelId: string) => number | undefined;
-	getWallclockTime: (channelId: string) => number | undefined;
-	getWallclockTimeLatencyAdjusted: (channelId: string) => number | undefined;
-	get serverCurrentTime(): number;
-	get channelCurrentTime(): number;
-	processSample: <T extends SyncSample>(sample: T) => T;
-	getStatistics: () => SyncModuleStatistics;
-	get drift(): number | undefined;
-	private updateRtt;
-	isPlaybackSourceReadyToSeek: () => boolean;
-	private isSeeking;
-	private isAllowedToSync;
-	private isSeekCooldownExpired;
-	private isSeekTimeoutExpired;
-	private currentTimeshiftMaxBehind;
-	private currentSyncMaxBehind;
-	private currentSyncMaxAhead;
-	private tryTimeshiftSync;
-	private onSync;
-}
-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;
-	advanced: {
-		wasmDecodingConstraint: Partial<VideoConstraint>;
+interface IncomingDataModuleStatistics {
+	videoBitRate: number;
+	audioBitRate: number;
+	bytesReceived: number;
+}
+interface VideoPlayerStatistics {
+	renderedFrameCount: number;
+	rendererDroppedFrameCount: number;
+	contextLostCount: number;
+	contextRestoredCount: number;
+}
+interface MseModuleStatistics {
+	quotaErrorCount: number;
+	mediaSourceOpenTime: number;
+	totalVideoFrames?: number;
+	droppedVideoFrames?: number;
+}
+interface QualityOfServiceModuleStatistics {
+	timeSpentBuffering: number;
+	bufferingEventsCount: number;
+	fatalQosCount: number;
+	timeSpentRatio: {
+		[bitRate: string]: number;
 	};
-};
+}
+interface SyncModuleStatistics {
+	drift: number | undefined;
+	driftAdjustmentCount: number;
+	timeshiftDriftAdjustmentCount: number;
+	seekTime: number;
+}
 interface UserAgentInformation {
 	userAgent: string;
 	locationOrigin: string;
 	locationPath: string;
 	ancestorOrigins?: string[];
 }
-declare type StatisticsType<K> = K extends {
-	getStatistics: () => unknown;
-} ? ReturnType<K["getStatistics"]> : never;
-declare type StatisticsTypes = {
-	[Property in keyof Modules]: StatisticsType<Modules[Property]>;
-};
-export declare type ModuleStatistics = Flatten<StatisticsTypes>;
-export declare type Statistics = ModuleStatistics & UserAgentInformation & {
+declare type ModuleStatistics = AdaptivityStatistics & BufferTimeStatistics & ConnectionStatistics & ConstraintCapStatistics & DecoderStatistics & DocumentStateModulesStatistics & IncomingDataModuleStatistics & MseModuleStatistics & PlaybackModuleStatistics & QualityOfServiceModuleStatistics & RenditionsModuleStatistics & SyncModuleStatistics & TelemetryModuleStatistics & VideoPlayerStatistics;
+declare type Statistics = ModuleStatistics & UserAgentInformation & {
 	version: string;
 	ip?: string;
 	url: string;
@@ -1217,15 +522,70 @@ export declare type Statistics = ModuleStatistics & UserAgentInformation & {
 	channelId: string;
 	channelGroupId?: string;
 	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 static MAX_POOL_SIZE;
 	private static INITIAL_MAX_BIT_RATE;
 	private static PING_TIMEOUT;
+	private static DISCONNECT_TIMEOUT;
+	/**
+	 * 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;
@@ -1249,47 +609,200 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	private pool;
 	private durationSessions;
 	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.
+	 */
 	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);
+	/**
+	 * The current channelId
+	 */
 	get channelId(): string;
+	/**
+	 * Set the current channelId
+	 *
+	 * Possible channels to set are available from [[channels]]
+	 */
 	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>;
 	get lastBufferEvent(): Readonly<BufferStateEvent>;
 	get activeRatios(): Map<string, number>;
@@ -1297,482 +810,498 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	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 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;
-	private play;
+	pause: () => void;
+	/**
+	 *
+	 * 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: () => Promise<void>;
+	/**
+	 * How long in milliseconds since the instance was created
+	 */
 	get uptime(): number;
 	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;
 }
-interface TelemetryModuleOptions {
-	url: string;
-	enabled?: boolean;
-	interval?: number;
-	includeErrors?: boolean;
-	includeEvents?: boolean;
-	includeStats?: boolean;
-	maxRetries?: number;
-	maxErrorReports?: number;
-	maxEvents?: number;
-}
-interface ShiftedEdgeEvent {
-	code: "shifted_edge";
-	edgeUrl: string;
-}
-declare type TelemetryEvent = ShiftedEdgeEvent;
-interface FlushOptions {
-	isFinal?: boolean;
-	initiator: StatsInitiator;
-}
-interface ParentContext {
-	getStatistics(): Statistics;
-	readonly connectionState: Readonly<State>;
-}
-interface TelemetryModuleListeners {
-	["visibilitystate"]: VisibilityState;
-	["pagehide"]: PageTransitionEvent;
-	["error"]: Readonly<VindralError>;
-}
-interface TelemetryModuleEvents {
-	["send signal"]: Readonly<string>;
-}
 interface TelemetryModuleStatistics {
 	errorCount: number;
 }
-declare type StatsInitiator = "interval" | "visibilitychange" | "pagehide" | "unload";
-declare class TelemetryModule {
-	private logger;
-	private timers;
-	private emitter;
-	private options;
-	private parentContext;
-	private unsentLines;
-	private retries;
-	private errorCount;
-	private eventCount;
-	private statsCount;
-	private constructor();
-	unload: () => void;
-	static create: (logger: Logger, emitter: Emitter<TelemetryModuleListeners, TelemetryModuleEvents>, options: TelemetryModuleOptions, parentContext: ParentContext) => TelemetryModule;
-	load: () => void;
-	addStats: ({ isFinal, initiator }?: FlushOptions, extra?: Record<string, unknown>) => void;
-	addEvent: (event: TelemetryEvent) => void;
-	getStatistics: () => TelemetryModuleStatistics;
-	private send;
-	private onVisibilityChange;
-	private onPageHide;
-	private onRejection;
-	private onError;
-	private addError;
-}
-declare class TimerModule {
-	private pendingTimeouts;
-	private pendingIntervals;
-	static create: () => TimerModule;
-	clearTimeout: (handle: number) => void;
-	clearInterval: (handle: number) => void;
-	setTimeout: (callback: (...args: unknown[]) => void, timeout: number, ...args: unknown[]) => number;
-	setInterval: (callback: (...args: unknown[]) => void, interval: number, ...args: unknown[]) => number;
-	unload: () => void;
-}
-declare class UnpauseModule {
-	private logger;
-	private element;
-	private documentState;
-	private timers;
-	private constructor();
-	static create: (logger: Logger, element: MediaElement, documentState: DocumentState) => UnpauseModule;
-	unload: () => void;
-	private unpause;
-}
-interface VideoPlayerModuleListeners {
-	["decoded frame"]: Readonly<DecodedSample>;
-	["error"]: Readonly<VindralError>;
-}
-interface ClockSource {
-	readonly currentTime: number;
-}
-interface VideoPlayerStatistics {
-	renderedFrameCount: number;
-	rendererDroppedFrameCount: number;
-	contextLostCount: number;
-	contextRestoredCount: number;
-}
-declare class VideoPlayerModule {
-	private readonly oldTimestampLimit;
-	private pool;
-	private logger;
-	private emitter;
-	private videoRenderer;
-	private renderQueue;
-	private clockSource;
-	private isFirstFrame;
-	private animationFrameRequest?;
-	private renderedFrameCount;
-	private rendererDroppedFrameCount;
-	constructor(emitter: Emitter<VideoPlayerModuleListeners, unknown>, logger: Logger, clockSource: ClockSource, pool: ArrayBufferPool);
-	load: () => void;
-	unload: () => Promise<void>;
-	suspend: () => void;
-	unsuspend: () => void;
-	element: () => HTMLCanvasElement;
-	getStatistics: () => VideoPlayerStatistics;
-	static create: (emitter: Emitter<VideoPlayerModuleListeners, unknown>, logger: Logger, clockSource: ClockSource, pool: ArrayBufferPool) => VideoPlayerModule;
-	private onDecodedFrame;
-	private render;
-	private renderSample;
-	private stopRender;
-}
-export interface Modules {
-	audioPlayer?: AudioPlayerModule;
-	videoPlayer?: VideoPlayerModule;
-	decoder?: DecoderModule;
-	mseModule?: MseModule;
-	constraintCap: ConstraintCapModule;
-	adaptivity: AdaptivityModule;
-	connection: ConnectionModule;
-	playback: PlaybackModule;
-	pictureInPicture: PictureInPictureModule;
-	logger: LoggerModule;
-	timer: TimerModule;
-	subscription: SubscriptionModule;
-	renditions: RenditionsModule;
-	qualityOfService: QualityOfServiceModule;
-	event: EventModule;
-	sync: SyncModule;
-	telemetry?: TelemetryModule;
-	documentState: DocumentStateModule;
-	incomingData: IncomingDataModule;
-	bufferTime: BufferTimeModule;
-	unpause?: UnpauseModule;
-}
+/**
+ * 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;
 }
+/**
+ * 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>;
 }
-export declare type Media = "audio" | "video" | "audio+video";
+declare 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;
+	/**
+	 * 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.
+	 *
+	 * Note: This is not yet implemented
+	 */
 	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.
+	 *
+	 * Note: Opus generally provides better audio quality and is therefore recommended to keep enabled.
+	 */
 	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;
 }
+/**
+ * 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
+	 * ```
+	 * {
+	 *   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 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;
 }
-export interface Track {
-	type: Type;
-	mimeType: string;
-}
-declare type ValuesOf<T> = T[keyof T];
-declare type UndefinedKeys<T> = {
-	[K in keyof T]: undefined extends T[K] ? K : never;
-}[keyof T];
-declare type ExtractOptional<T> = Pick<T, Exclude<UndefinedKeys<T>, undefined>>;
-declare type ExtractRequired<T> = Omit<T, Exclude<UndefinedKeys<T>, undefined>>;
-declare type NullableObjectValuesOf<T> = Exclude<Partial<Extract<ValuesOf<ExtractOptional<T>>, object>>, Array<unknown>>;
-declare type ObjectValuesOf<T> = Exclude<Extract<ValuesOf<ExtractRequired<T>>, object>, Array<unknown>>;
-declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-declare type Flatten<T> = UnionToIntersection<ObjectValuesOf<T> | NullableObjectValuesOf<T>>;
-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 CodecProps {
-	codec: Codec;
-	codecString?: string;
-}
-export declare type VideoRendition = VideoRenditionProps & RenditionProps;
-export declare type AudioRendition = AudioRenditionProps & RenditionProps;
-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<CodecProps>) => string;
-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;
-	video: VideoConstraint;
-	audio: AudioConstraint;
-	burstMs?: number;
-	meta?: Record<string, string>;
-	initiator?: SubscriptionInitiator;
-}
-interface ContextSwitch {
-	type: "context switch";
-}
-interface ContextSwitchComplete {
-	type: "context switch complete";
-}
-interface RenditionsSignal {
-	type: "renditions";
-	renditions: Rendition[];
-}
-interface SubscribeSignal {
-	type: "subscribe";
-	subscription: Subscription;
-}
-interface ClientIpSignal {
-	type: "client ip";
-	ip: string;
-}
-interface SubscriptionChangedSignal {
-	type: "subscription changed";
-	subscription: Subscription;
-}
-interface TimingInfoSignal {
-	type: "timing info";
-	timingInfo: {
-		channelId: string;
-		timestamp: number;
-		wallclockTime: number;
+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>;
 	};
-}
-interface PingSignal {
-	type: "ping";
-}
-interface PongSignal {
-	type: "pong";
-}
-interface RefreshAuthSignal {
-	type: "refresh auth";
-	token: string;
-}
-declare type Signal = RenditionsSignal | SubscribeSignal | SubscriptionChangedSignal | TimingInfoSignal | PingSignal | PongSignal | ClientIpSignal | ContextSwitch | ContextSwitchComplete | RefreshAuthSignal;
-export interface Channel {
-	channelId: string;
-	name: string;
-	isLive: boolean;
-	thumbnailUrls: string[];
-}
-interface ClientOverrides {
-	maxVideoBitRate?: number;
-	minBufferTime?: number;
-	maxBufferTime?: number;
-	burstEnabled?: boolean;
-}
-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;
-}
-export interface ConnectResponse {
-	logsUrl?: string;
-	statsUrl?: string;
-	telemetry?: Telemetry;
-	channels: ChannelWithRenditionsAndOverrides[];
-	edges: string[];
-}
-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 getHeaders;
-	private getAuthToken;
-	private toChannels;
-	private toChannel;
-}
-export declare type CastState = "casting" | "not casting";
-export interface CastSenderEvents {
-	["connected"]: void;
-	["resumed"]: void;
-	["disconnected"]: void;
-	["failed"]: void;
-	["metadata"]: Metadata;
-	["server wallclock time"]: number;
-}
-export interface CastConfig {
-	options: Options;
-	background?: string;
-	receiverApplicationId?: string;
-}
-export declare type CustomCastMessageType = "stop" | "start" | "updateAuthToken" | "serverWallclockTime" | "metadata" | "setChannelId" | "setLanguage";
-export interface CastCustomMessage {
-	type: CustomCastMessageType;
-	channelId?: string;
-	language?: string;
-	config?: CastConfig;
-	token?: string;
-	serverWallclockTime?: number;
-	metadata?: Metadata;
-}
-export declare class CastSender extends Emitter<CastSenderEvents> {
-	private state;
-	private config;
-	private unloaded;
-	constructor(config: CastConfig);
-	get casting(): boolean;
-	get volume(): number;
-	set volume(volume: number);
-	get language(): string | undefined;
-	set language(language: string | undefined);
-	get channelId(): string;
-	set channelId(channelId: string);
-	updateAuthenticationToken: (token: string) => void;
-	unload: () => void;
-	init: () => Promise<void>;
-	start: () => Promise<void>;
-	stop: () => void;
-	getReceiverName: () => string | undefined;
-	private onGCastApiAvailable;
-	private send;
-	private onMessage;
-	private onSessionStarted;
-	private onSessionStateChanged;
-	private getInstance;
-	private getSession;
-	private castLibrariesAdded;
-	private verifyCastLibraries;
-}
-export declare const isValidOptions: (options: unknown) => options is Options;
-export declare const validateOptions: (options: Options) => Options;
-interface FullscreenEvents {
-	["on fullscreen change"]: boolean;
-}
-declare class Fullscreen extends Emitter<FullscreenEvents> {
-	private container;
-	constructor(container: HTMLElement);
-	unload: () => void;
-	request: () => Promise<void>;
-	exit: () => Promise<void>;
-	private onChange;
-	isFullscreen: () => boolean;
-	isSupported: () => boolean;
-	private isFullscreenApiSupported;
-	private isInIframe;
-	private get requestFn();
-	private get exitFn();
-}
+};
+/**
+ * Available options when initializing the Player. Used for enabling/disabling features
+ * and hiding/showing buttons in the control pane
+ */
 export interface PlayerOptions {
+	/**
+	 * Enable or disable controls
+	 */
 	controlsEnabled?: boolean;
+	/**
+	 * Enable or disable Google Cast (button and functionality). Will be disabled if
+	 * device is unable to use Cast Framework
+	 */
 	castEnabled?: boolean;
+	/**
+	 * Enable or disable fullscreen button
+	 */
 	fullscreenButtonEnabled?: boolean;
+	/**
+	 * Enable or disable Picture-in-picture button. Will be disabled if
+	 * device is unable to manually enter PiP
+	 */
 	pipButtonEnabled?: boolean;
+	/**
+	 @deprecated since 2.0.10. Use channelSelectionOptions.
+  
+	 Enable or disable channel selector (only available for channel groups with more than one channel)
+	 */
 	channelSelectionEnabled?: boolean;
+	/**
+	 * Customize and enable channel selection interfaces.
+	 * Will be disabled if not using a channel group with more than one channel.
+	 */
 	channelSelectionOptions?: {
 		barButton?: {
 			enabled?: boolean;
@@ -1782,21 +1311,58 @@ export interface PlayerOptions {
 			enabled?: boolean;
 		};
 	};
+	/**
+	 * Enable or disable rendition (bitrate) selector
+	 */
 	renditionLevelsEnabled?: boolean;
+	/**
+	 * Enable or disable language selector
+	 */
 	languagesButtonEnabled?: boolean;
+	/**
+	 * Enable or disable one-to-one (real size, not filling the entire container)
+	 */
 	oneToOneButtonEnabled?: boolean;
+	/**
+	 * Hide controls after this time in ms
+	 */
 	hideTimeout?: number;
+	/**
+	 * Background image for Cast Receiver
+	 */
 	castBackground?: string;
+	/**
+	 * For custom Cast Receivers, enter your Application Id here
+	 */
 	castReceiverApplicationId?: string;
+	/**
+	 * How often we should refresh thumbnails if used in MS. Default is 60000.
+	 */
 	thumbnailUpdateInterval?: number;
-}
-export interface PlayerState {
-	isBuffering: boolean;
-	fullscreen: Fullscreen;
-	lastInteractionTime: number;
-}
+	/**
+	 * Enable or disable the pause and play button
+	 */
+	pauseButtonEnabled?: boolean;
+}
+/**
+ * Represents a Vindral player
+ *
+ * ```typescript
+ * // minimal configuration of a Vindral web player
+ * const instance = new Player({
+ *   url: "https://lb.cdn.vindral.com",
+ *   channelId: "vindral_demo1_ci_099ee1fa-80f3-455e-aa23-3d184e93e04f",
+ * })
+ * ```
+ */
 export declare class Player {
+	/**
+	 * The Vindral instance
+	 */
 	readonly core: Vindral;
+	/**
+	 * The CastSender instance
+	 */
 	readonly castSender: CastSender;
 	private options;
 	private state;
@@ -1806,16 +1372,31 @@ export declare class Player {
 	private channelSelectionList?;
 	private bar;
 	private stateInterval?;
-	private showBufferingTimeout?;
 	private thumbnailModule?;
+	private browser;
 	constructor(optionsOrInstance: Options | Vindral, playerOptions?: PlayerOptions);
+	/**
+	 * Fully unloads the Player and the Vindral instance.
+	 */
 	unload: () => void;
+	/**
+	 * Attaches the Player root node to a container
+	 */
 	attach: (container: HTMLElement) => void;
 	private setupCastSender;
 	private onMouseMove;
 	private onClick;
 	private togglePip;
 	private toggleFullscreen;
+	/**
+	 * This method is used to trigger play permissions without activating audio.
+	 * Setting muted to false will implicitly activate play permissions, and then we instantly revert the mute state to whatever it is.
+	 * The reason we need this method to begin with is because there are edge cases on iOS where users can enter fullscreen and then try to activate audio
+	 * from there. But that click (through a native ui control) to activate the audio only gives the media element permissions to play audio, but not the audio context.
+	 * By triggering this on any button that can lead to fullscreen mode we can ensure that the audio context already has permissions to play before the user might decide
+	 * to activate it through the native ui.
+	 */
+	private triggerUserInput;
 	private toggleOneToOne;
 	private enterFullscreen;
 	private exitFullscreen;