@vindral/web-sdk 3.4.3 → 4.0.0-100-g47797f66

package/{index.d.ts → legacy.d.ts}

@@ -1,31 +1,35 @@
-type AudioCodec = "aac" | "opus" | "mp3";
-type VideoCodec = "h264" | "av1";
 /**
- * Log level
- * @enum
- */
-export declare const Level: {
-	readonly CRITICAL: "critical";
-	readonly ERROR: "error";
-	readonly WARN: "warn";
-	readonly INFO: "info";
-	readonly DEBUG: "debug";
-	readonly TRACE: "trace";
-};
-export type Level = (typeof Level)[keyof typeof Level];
-/**
- * Represents a timed metadata event
+ * Channel
  */
-export interface Metadata {
+export interface Channel {
 	/**
-	 * The raw string content as it was ingested (if using JSON, it needs to be parsed on your end)
+	 * Channel ID for the channel
 	 */
-	content: string;
+	channelId: string;
 	/**
-	 * Timestamp in ms
+	 * Display name
 	 */
-	timestamp: number;
+	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[];
 }
+export type AudioCodec = "aac" | "opus" | "mp3";
+export type VideoCodec = "h264" | "av1";
 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;
@@ -33,6 +37,9 @@ declare class Emitter<TEvents, TEmits = TEvents, ArgLessEvents extends VoidKeys<
 	private listeners;
 	emit<T extends ArgLessEmits>(eventName: T): void;
 	emit<T extends ArgEmits>(eventName: T, args: TEmits[T]): void;
+	/**
+	 * Remove an event listener from `eventName`
+	 */
 	off<T extends ArgLessEvents>(eventName: T, fn: () => EventListenerReturnType): void;
 	off<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => EventListenerReturnType): void;
 	/**
@@ -51,9 +58,29 @@ declare class Emitter<TEvents, TEmits = TEvents, ArgLessEvents extends VoidKeys<
 	 */
 	once<T extends ArgLessEvents>(eventName: T, fn: () => void): void;
 	once<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => void): void;
+	/**
+	 * Reset the event emitter
+	 */
 	reset(): void;
 	private add;
 }
+declare const LogLevels: readonly [
+	"off",
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace"
+];
+type LogLevel = (typeof LogLevels)[number];
+declare const LogLevel: {
+	ERROR: "error";
+	WARN: "warn";
+	INFO: "info";
+	DEBUG: "debug";
+	TRACE: "trace";
+	OFF: "off";
+};
 interface MinMaxAverage {
 	last: number;
 	/**
@@ -69,41 +96,80 @@ interface MinMaxAverage {
 	 */
 	min: number;
 }
-export interface TimeRange {
-	start: number;
-	end: number;
+declare const tags: unique symbol;
+type Tagged<BaseType, Tag extends PropertyKey> = BaseType & {
+	[tags]: {
+		[K in Tag]: void;
+	};
+};
+type Namespace = Tagged<Array<string>, "Namespace">;
+interface TrackObject {
+	namespace?: Namespace;
+	name: string;
+	format: string;
+	label?: string;
+	renderGroup?: number;
+	altGroup?: number;
+	initData?: string;
+	initTrack?: string;
+	depends?: Array<string>;
+	temporalId?: number;
+	spatialId?: number;
+	codec?: string;
+	mimeType?: string;
+	framerate?: [
+		number,
+		number
+	];
+	bitrate?: number;
+	width?: number;
+	height?: number;
+	samplerate?: number;
+	channelConfig?: string;
+	displayWidth?: number;
+	displayHeight?: number;
+	language?: string;
+	["com.vindral.variant_uid"]?: string;
 }
-/**
- * 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 CatalogRoot {
+	version: number;
+	streamingFormat?: number;
+	streamingFormatVersion?: string;
+}
+interface TracksCatalog extends CatalogRoot {
+	namespace: Namespace;
+	tracks: Array<TrackObject>;
 }
 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 {
@@ -111,19 +177,110 @@ interface TextRenditionProps {
 	kind: "subtitles" | "captions";
 	label?: string;
 }
-type VideoRendition = VideoRenditionProps & RenditionProps;
-type AudioRendition = AudioRenditionProps & RenditionProps;
+/**
+ * @interface
+ */
+export type VideoRendition = VideoRenditionProps & RenditionProps;
+/**
+ * @interface
+ */
+export type AudioRendition = AudioRenditionProps & RenditionProps;
 type TextRendition = TextRenditionProps & RenditionProps;
 type Rendition = VideoRendition | AudioRendition | TextRendition;
-interface Size {
+interface Telemetry {
+	url: string;
+	probability?: number;
+	includeErrors?: boolean;
+	includeEvents?: boolean;
+	includeStats?: boolean;
+	maxRetries?: number;
+	maxErrorReports?: number;
+	interval?: number;
+}
+interface ChannelWithCatalog extends Channel {
+	catalog: TracksCatalog;
+	renditions: Rendition[];
+	overrides?: ClientOverrides;
+}
+interface ChannelWithRenditions extends Channel {
+	renditions: Rendition[];
+	overrides?: ClientOverrides;
+}
+interface ServerCertificateHash {
+	algorithm: string;
+	value: string;
+}
+interface Edge {
+	moqUrl?: string;
+	moqWsUrl: string;
+	serverCertificateHashes?: ServerCertificateHash[];
+}
+interface MoQConnectInfo {
+	logsUrl?: string;
+	statsUrl?: string;
+	telemetry?: Telemetry;
+	channels: ChannelWithCatalog[];
+	edges: Edge[];
+}
+interface VindralConnectInfo {
+	logsUrl?: string;
+	statsUrl?: string;
+	telemetry?: Telemetry;
+	channels: ChannelWithRenditions[];
+	edges: string[];
+}
+export type ConnectInfo = VindralConnectInfo | MoQConnectInfo;
+/**
+ * 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;
+}
+/**
+ * Represents a size with a width and height.
+ */
+export interface Size {
+	/** */
 	width: number;
+	/** */
 	height: number;
 }
-interface VideoConstraint {
+export interface VideoConstraint {
+	/** */
 	width: number;
+	/** */
 	height: number;
+	/** */
 	bitRate: number;
+	/** */
 	codec?: VideoCodec;
+	/** */
 	codecString?: string;
 }
 /**
@@ -137,7 +294,23 @@ export interface AdvancedOptions {
 	 */
 	wasmDecodingConstraint: Partial<VideoConstraint>;
 }
-type Media = "audio" | "video" | "audio+video";
+/**
+ * DRM options to provide to the Vindral instance
+ */
+export interface DrmOptions {
+	/**
+	 * Headers to be added to requests to license servers
+	 */
+	headers?: Record<string, string>;
+	/**
+	 * Query parameters to be added to requests to license servers
+	 */
+	queryParams?: Record<string, string>;
+}
+/**
+ * Type of media.
+ */
+export type Media = "audio" | "video" | "audio+video";
 /**
  * Options for the Vindral instance
  *
@@ -177,7 +350,7 @@ export interface Options {
 	/**
 	 * Sets the log level - defaults to info
 	 */
-	logLevel?: Level;
+	logLevel?: LogLevel;
 	/**
 	 * Sets the minimum and initial buffer time
 	 */
@@ -307,6 +480,7 @@ export interface Options {
 	edgeUrl?: string;
 	logShippingEnabled?: boolean;
 	statsShippingEnabled?: boolean;
+	webtransportEnabled?: 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.
@@ -331,77 +505,103 @@ export interface Options {
 	advanced?: AdvancedOptions;
 	media?: Media;
 	videoCodecs?: VideoCodec[];
+	/**
+	 * DRM options to provide to the Vindral instance
+	 */
+	drm?: DrmOptions;
 }
 /**
  * Represents a rendition (quality level).
  */
 export interface RenditionLevel {
+	/** */
 	audio?: AudioRendition;
+	/** */
 	video?: VideoRendition;
 }
-type RenditionLevelChangedReason = "abr" | "manual";
+/**
+ * Reason for the rendition level change.
+ */
+export type RenditionLevelChangedReason = "abr" | "manual";
 /**
  * Contextual information about the rendition level change.
  */
 export interface RenditionLevelChanged {
+	/** */
 	from?: RenditionLevel;
+	/** */
 	to?: RenditionLevel;
+	/** */
 	reason: RenditionLevelChangedReason;
 }
+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";
+export type ErrorType = "internal" | "external";
 /**
- * Channel
+ * Represents a vindral error - all errors emitted from the Vindral instance inherit from this class.
  */
-export interface Channel {
+export declare class VindralError extends Error {
+	private props;
+	private extra;
+	constructor(message: string, props: VindralErrorProps, extra?: {});
 	/**
-	 * Channel ID for the channel
+	 * 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
 	 */
-	channelId: string;
+	code: () => string;
 	/**
-	 * Display name
+	 * Indicates whether the error is fatal - if it is that means the Vindral instance will be unloaded because of this error.
 	 */
-	name: string;
+	isFatal: () => boolean;
 	/**
-	 * Indicates whether there is an incoming source feed for the channel
+	 * The underlying error that caused the Vindral error
+	 * @returns the underlying error
 	 */
-	isLive: boolean;
+	source: () => Error | MediaError | undefined;
+	type: () => ErrorType;
 	/**
-	 * URLs to fetch thumbnail from
+	 * @returns a stringifiable represenation of the error
 	 */
-	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;
+	toStringifiable: () => Record<string, unknown>;
 }
-interface Telemetry {
-	url: string;
-	probability?: number;
-	includeErrors?: boolean;
-	includeEvents?: boolean;
-	includeStats?: boolean;
-	maxRetries?: number;
-	maxErrorReports?: number;
-	interval?: number;
+/**
+ * Represents a playback state.
+ */
+export type PlaybackState = "buffering" | "playing" | "paused";
+export 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;
 }
-export interface ConnectResponse {
-	logsUrl?: string;
-	statsUrl?: string;
-	telemetry?: Telemetry;
-	channels: ChannelWithRenditionsAndOverrides[];
-	edges: string[];
+/**
+ * Shows for what context the browser needs a user input event.
+ */
+export interface NeedsUserInputContext {
+	/**
+	 * True if user input is needed for audio
+	 */
+	forAudio: boolean;
+	/**
+	 * True if user input is needed for video
+	 */
+	forVideo: boolean;
 }
 /**
  * ApiClientOptions
@@ -429,6 +629,10 @@ export interface AuthorizationContext {
 	 */
 	channelId?: string;
 }
+interface ConnectOptions {
+	channelGroupId?: string;
+	channelId: string;
+}
 /**
  * AuthorizationTokenFactory
  */
@@ -441,9 +645,10 @@ export declare class ApiClient {
 	private tokenFactory?;
 	constructor(options: ApiClientOptions);
 	/**
+	 * @ignore
 	 * Returns everything needed to setup the connection of Vindral instance.
 	 */
-	connect(options: ConnectOptions): Promise<ConnectResponse>;
+	connect(options: ConnectOptions): Promise<ConnectInfo>;
 	/**
 	 * Fetches information regarding a single channel.
 	 *
@@ -456,7 +661,7 @@ export declare class ApiClient {
 	 *
 	 * Note: The returned list includes inactive channels - check isLive to filter out only active channels
 	 *
-	 * @param channelGroup the channel group to fetch channels from
+	 * @param channelGroupId the channel group to fetch channels from
 	 * @returns an array of [[Channel]] that belong to the channel group
 	 */
 	getChannels(channelGroupId: string): Promise<Channel[]>;
@@ -465,580 +670,678 @@ export declare class ApiClient {
 	private toChannels;
 	private toChannel;
 }
-/**
- * Available events to listen to
- */
-export interface CastSenderEvents {
+interface AdaptivityStatistics {
 	/**
-	 * When a connection has been established with a CastReceiver
+	 * True if adaptive bitrate (ABR) is enabled.
 	 */
-	["connected"]: void;
+	isAbrEnabled: boolean;
+}
+interface BufferTimeStatistics {
 	/**
-	 * When a previous session has been resumed
+	 * Number of time buffer time has been adjusted. This will only happen when using dynamic buffer time
+	 * (different min/max values of bufferTime).
 	 */
-	["resumed"]: void;
+	bufferTimeAdjustmentCount: number;
+}
+interface RenditionsModuleStatistics {
 	/**
-	 * When a CastReceiver has lost or stopped a connection
+	 * Id of current video rendition subscribed to.
 	 */
-	["disconnected"]: void;
+	videoRenditionId?: number;
 	/**
-	 * When a connection attempt was initiated unsuccessfully
+	 * Id of current audio rendition subscribed to.
 	 */
-	["failed"]: void;
+	audioRenditionId?: number;
 	/**
-	 * 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
+	 * Current video codec being used.
 	 */
-	options: Options;
+	videoCodec?: string;
 	/**
-	 * URL to a background image.
-	 * Example: "https://via.placeholder.com/256x144"
+	 * Current audio codec being used.
 	 */
-	background?: string;
+	audioCodec?: string;
 	/**
-	 * Override this if you have your own custom receiver
+	 * Width of current video rendition (if any).
 	 */
-	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);
+	videoWidth?: number;
 	/**
-	 * True if the instance is casting right now
+	 * Height of current video rendition (if any).
 	 */
-	get casting(): boolean;
+	videoHeight?: number;
 	/**
-	 * The current volume
+	 * Currently expected video bit rate according to metadata in bits/s.
 	 */
-	get volume(): number;
+	expectedVideoBitRate?: number;
 	/**
-	 * Set the current volume. Setting this to zero is equivalent to muting the video
+	 * Currently expected audio bit rate according to metadata in bits/s.
 	 */
-	set volume(volume: number);
+	expectedAudioBitRate?: number;
 	/**
-	 * The current language
+	 * Current language. For non-multi language streams, this will often be unset.
 	 */
-	get language(): string | undefined;
+	language?: string;
 	/**
-	 * Set the current language
+	 * Frame rate. Example: `"frameRate": [24000, 1001]`.
 	 */
-	set language(language: string | undefined);
+	frameRate?: [
+		number,
+		number
+	];
 	/**
-	 * The current channelId
+	 * Total count of rendition level changes (quality downgrades/upgrades).
 	 */
-	get channelId(): string;
+	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 {
 	/**
-	 * Set the current channelId
+	 * Current video bitrate in bits/second.
 	 */
-	set channelId(channelId: string);
+	videoBitRate?: number;
 	/**
-	 * Update authentication token on an already established and authenticated connection
+	 * Current audio bitrate in bits/second.
 	 */
-	updateAuthenticationToken: (token: string) => void;
+	audioBitRate?: number;
 	/**
-	 * Fully unloads the instance. This disconnects the current listener but lets the
-	 * cast session continue on the receiving device
+	 * Counter of number of bytes received.
 	 */
-	unload: () => void;
+	bytesReceived: number;
+}
+interface MseModuleStatistics {
+	quotaErrorCount: number;
+	mediaSourceOpenTime: number;
+	totalVideoFrames?: number;
+	droppedVideoFrames?: number;
+	successfulVideoAppendCalls?: number;
+	successfulAudioAppendsCalls?: number;
+}
+interface QualityOfServiceModuleStatistics {
 	/**
-	 * Initiates the CastSender.
-	 * Will reject if Cast is not available on the device or the network.
+	 * Time in milliseconds spent in buffering state. Note that this value will increase while in background if
+	 * buffering when leaving foreground.
 	 */
-	init: () => Promise<void>;
+	timeSpentBuffering: number;
 	/**
-	 * Requests a session. It will open the native cast receiver chooser dialog
+	 * Total number of buffering events since instantiation.
 	 */
-	start: () => Promise<void>;
+	bufferingEventsCount: number;
 	/**
-	 * Stops a session. It will stop playback on device as well.
+	 * Number of fatal quality of service events.
 	 */
-	stop: () => void;
+	fatalQosCount: number;
 	/**
-	 * Returns a string representing the name of the Cast receiver device or undefined if no receiver exists
+	 * 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.
 	 */
-	getReceiverName: () => string | undefined;
-	private onGCastApiAvailable;
-	private send;
-	private onMessage;
-	private onSessionStarted;
-	private onSessionStateChanged;
-	private getInstance;
-	private getSession;
-	private castLibrariesAdded;
-	private verifyCastLibraries;
+	timeSpentRatio: {
+		[bitRate: string]: number;
+	};
 }
-interface VindralErrorProps {
-	isFatal: boolean;
-	type?: ErrorType;
-	code: string;
-	source?: Error | MediaError;
+interface SyncModuleStatistics {
+	drift: number | undefined;
+	driftAdjustmentCount: number;
+	timeshiftDriftAdjustmentCount: number;
+	seekTime: number;
 }
-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";
+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;
 /**
- * Represents a vindral error - all errors emitted from the Vindral instance inherit from this class.
+ * 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 declare class VindralError extends Error {
-	private props;
-	private extra;
-	constructor(message: string, props: VindralErrorProps, extra?: {});
+export type Statistics = ModuleStatistics & ReturnType<UserAgentInformation["getUserAgentInformation"]> & {
 	/**
-	 * 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
+	 * Version of the @vindral/web-sdk being used.
 	 */
-	code: () => string;
+	version: string;
 	/**
-	 * Indicates whether the error is fatal - if it is that means the Vindral instance will be unloaded because of this error.
+	 * IP of the client.
 	 */
-	isFatal: () => boolean;
+	ip?: string;
 	/**
-	 * The underlying error that caused the Vindral error
-	 * @returns the underlying error
+	 * URL being used for connecting to the stream.
 	 */
-	source: () => Error | MediaError | undefined;
-	type: () => ErrorType;
+	url: string;
 	/**
-	 * @returns a stringifiable represenation of the error
+	 * 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.
+	 *
 	 */
-	toStringifiable: () => Record<string, unknown>;
-}
-interface AirPlaySenderEvents {
+	sessionId?: string;
 	/**
-	 * When airplay targets are available.
+	 * Unlike `sessionId`, `clientId` will remain the same even after reconnections and represents this unique Vindral instance.
 	 */
-	["available"]: void;
+	clientId: string;
 	/**
-	 * When a connection has been established with an airplay target.
+	 * How long in milliseconds since the instance was created.
 	 */
-	["connected"]: void;
+	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 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 latestEmittedLanguages;
+	private wakeLock;
+	private pool;
+	private userAgentInformation;
+	private encryptedMediaExtensions;
+	private sampleProcessingSesssions;
+	private sizes;
+	private isSuspended;
+	private disconnectTimeout;
+	constructor(options: Options);
 	/**
-	 * When the airplay target has lost or stopped a connection.
+	 * 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
 	 */
-	["disconnected"]: void;
-}
-interface AirPlayConfig {
+	attach: (container: HTMLElement) => void;
 	/**
-	 * URL to use when connecting to the stream.
+	 * 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.
+	 *
+	 * @param volume The volume to set. A floating point value between 0-1.
+	 *
 	 */
-	url: string;
+	set volume(volume: number);
 	/**
-	 * Channel ID to connect to.
+	 * The current volume. Note that if the playback is muted volume can still be set.
 	 */
-	channelId: string;
+	get volume(): number;
 	/**
-	 * A container to attach the video element in. This should be the same container that the vindral video element is attached to.
+	 * Set playback to muted/unmuted
 	 */
-	container: HTMLElement;
+	set muted(muted: boolean);
 	/**
-	 * 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.
+	 * Whether the playback is muted or not
 	 */
-	authenticationToken?: string;
-}
-declare class AirPlaySender extends Emitter<AirPlaySenderEvents> {
-	private config;
-	private hlsUrl;
-	private element;
-	private connectingTimeout?;
-	private browser;
-	constructor(config: AirPlayConfig);
+	get muted(): boolean;
 	/**
-	 * True if the instance is casting right now.
+	 * Which media type is currently being played
 	 */
-	get casting(): boolean;
+	get media(): Media;
 	/**
-	 * Set the current channelId.
+	 * The current average video bit rate in bits/s
 	 */
-	set channelId(channelId: string);
+	get videoBitRate(): number;
 	/**
-	 * Update authentication token on an already established and authenticated connection.
+	 * The current average audio bit rate in bits/s
 	 */
-	updateAuthenticationToken: (_token: string) => void;
+	get audioBitRate(): number;
 	/**
-	 * Fully unloads the instance. This disconnects the current listeners.
+	 * The current connection state
 	 */
-	unload: () => void;
+	get connectionState(): Readonly<ConnectionState>;
 	/**
-	 * Show the AirPlay picker.
+	 * The current playback state
 	 */
-	showPlaybackTargetPicker(): void;
+	get playbackState(): Readonly<PlaybackState>;
 	/**
-	 * Returns if AirPlay is supported.
+	 * The current buffer fullness as a floating point value between 0-1, where 1 is full and 0 i empty.
 	 */
-	static isAirPlaySupported(): boolean;
-	private onAirPlayAvailable;
-	private onAirPlayPlaybackChanged;
-}
-type PlaybackState = "buffering" | "playing" | "paused";
-type BufferStateEvent = "filled" | "drained";
-interface PlaybackModuleStatistics {
+	get bufferFullness(): number;
 	/**
-	 * Current target buffer time if using dynamic buffer. Otherwise, this is the statically set buffer time from instantiation.
+	 * Whether user bandwidth savings by capping the video resolution to the size of the video element is enabled
 	 */
-	bufferTime: number;
-	needsInputForAudioCount: number;
-	needsInputForVideoCount: number;
-}
-interface NeedsUserInputContext {
+	get sizeBasedResolutionCapEnabled(): boolean;
 	/**
-	 * True if user input is needed for audio
+	 * Enables or disables user bandwidth savings by capping the video resolution to the size of the video element.
 	 */
-	forAudio: boolean;
+	set sizeBasedResolutionCapEnabled(enabled: boolean);
 	/**
-	 * True if user input is needed for video
+	 * Whether ABR is currently enabled
 	 */
-	forVideo: boolean;
-}
-type State = "connected" | "disconnected" | "connecting";
-type ContextSwitchState = "completed" | "started";
-interface ConnectionStatistics {
+	get abrEnabled(): boolean;
 	/**
-	 * RTT (round trip time) between client and server(s).
+	 * 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.
 	 */
-	rtt: MinMaxAverage;
+	set abrEnabled(enabled: boolean);
 	/**
-	 * A very rough initial estimation of minimum available bandwidth.
+	 * Estimated live edge time for the current channel
 	 */
-	estimatedBandwidth: number;
-	edgeUrl?: string;
+	get serverEdgeTime(): number | undefined;
 	/**
-	 * Total number of connections that have been established since instantiation.
+	 * @returns Estimated wallclock time on the edge server in milliseconds
 	 */
-	connectCount: number;
+	get serverWallclockTime(): number | undefined;
 	/**
-	 * Total number of connection attempts since instantiation.
+	 * Local current time normalized between all channels in the channel group
 	 */
-	connectionAttemptCount: number;
-}
-/**
- * Contextual information about the language switch
- */
-export interface LanguageSwitchContext {
+	get currentTime(): number;
 	/**
-	 * The new language that was switched to
+	 * 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
 	 */
-	language: string;
-}
-/**
- * Contextual information about the channel switch
- */
-export interface ChannelSwitchContext {
+	get channelCurrentTime(): number;
 	/**
-	 * The new channel id that was switched to
+	 * The current target buffer time in milliseconds
 	 */
-	channelId: string;
-}
-interface VolumeState {
+	get targetBufferTime(): number;
 	/**
-	 * Wether the audio is muted
+	 * Set the current target buffer time in milliseconds
 	 */
-	isMuted: boolean;
+	set targetBufferTime(bufferTimeMs: number);
 	/**
-	 * The volume level
+	 * The estimated playback latency based on target buffer time, the connection rtt and local playback drift
 	 */
-	volume: number;
-}
-/**
- * The events that can be emitted from the Vindral instance
- */
-export interface PublicVindralEvents {
+	get playbackLatency(): number | undefined;
 	/**
-	 * 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.
+	 * The estimated utc timestamp (in ms) for the playhead.
 	 */
-	["error"]: Readonly<VindralError>;
+	get playbackWallclockTime(): number | undefined;
 	/**
-	 * 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
-	 * }
-	 * ```
+	 * Channels that can be switched between
 	 */
-	["needs user input"]: NeedsUserInputContext;
+	get channels(): ReadonlyArray<Channel>;
 	/**
-	 * When a timed metadata event has been triggered
+	 * Languages available
 	 */
-	["metadata"]: Readonly<Metadata>;
+	get languages(): ReadonlyArray<string>;
 	/**
-	 * When the playback state changes
+	 * The current language
 	 */
-	["playback state"]: Readonly<PlaybackState>;
+	get language(): string | undefined;
 	/**
-	 * When the connection state changes
+	 * Set the current language
 	 */
-	["connection state"]: Readonly<State>;
+	set language(language: string | undefined);
 	/**
-	 * When the available rendition levels is changed
+	 * Set the active text track
 	 */
-	["rendition levels"]: ReadonlyArray<RenditionLevel>;
+	set textTrack(label: string | undefined);
 	/**
-	 * When the rendition level is changed
+	 * Get the available text tracks
 	 */
-	["rendition level"]: Readonly<RenditionLevel>;
+	get textTracks(): string[];
 	/**
-	 * When the available languages is changed
+	 * Get the active text track
 	 */
-	["languages"]: ReadonlyArray<string>;
+	get textTrack(): string | undefined;
 	/**
-	 * When the available text tracks are changed
+	 * The current channelId
 	 */
-	["text tracks"]: ReadonlyArray<string>;
+	get channelId(): string;
 	/**
-	 * When the available channels is changed
+	 * 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)
 	 */
-	["channels"]: ReadonlyArray<Channel>;
+	set channelId(channelId: string);
 	/**
-	 * When a context switch state change has occured.
-	 * E.g. when a channel change has been requested, or quality is changed.
+	 * Max size that will be subscribed to
 	 */
-	["context switch"]: Readonly<ContextSwitchState>;
+	get maxSize(): Size;
 	/**
-	 * Emitted when a wallclock time message has been received from the server.
+	 * Set max size that will be subscribed to
 	 *
-	 * Note: This is the edge server wallclock time and thus may differ slightly
-	 * between two viewers if they are connected to different edge servers.
+	 * Note: If ABR is disabled, setting this will make the client instantly subscribe to this size
 	 */
-	["server wallclock time"]: Readonly<number>;
+	set maxSize(size: Size);
 	/**
-	 * 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.
+	 * The max video bit rate that will be subscribed to
 	 *
-	 * 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.
+	 * Note: Returns Number.MAX_SAFE_INTEGER if no limits have been set
 	 */
-	["is live"]: boolean;
+	get maxVideoBitRate(): number;
 	/**
-	 * 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.
+	 * 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
 	 */
-	["channel switch"]: Readonly<ChannelSwitchContext>;
+	set maxVideoBitRate(bitRate: number);
 	/**
-	 * Emitted when a language switch has been completed and the new language starts playing.
+	 * The max audio bit rate that will be subscribed to
+	 *
+	 * Note: Returns Number.MAX_SAFE_INTEGER if no limits have been set
 	 */
-	["language switch"]: Readonly<LanguageSwitchContext>;
+	get maxAudioBitRate(): number;
 	/**
-	 * Emitted when the volume state changes.
+	 * Set max audio bit rate that will be subscribed to
 	 *
-	 * 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.
+	 * Note: If ABR is disabled, setting this will make the client instantly subscribe to this bit rate
 	 */
-	["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 {
+	set maxAudioBitRate(bitRate: number);
 	/**
-	 * True if adaptive bitrate (ABR) is enabled.
+	 * The rendition levels available.
 	 */
-	isAbrEnabled: boolean;
-}
-interface BufferTimeStatistics {
+	get renditionLevels(): ReadonlyArray<RenditionLevel>;
 	/**
-	 * Number of time buffer time has been adjusted. This will only happen when using dynamic buffer time
-	 * (different min/max values of bufferTime).
+	 * The current rendition level
 	 */
-	bufferTimeAdjustmentCount: number;
-}
-interface RenditionsModuleStatistics {
+	get currentRenditionLevel(): Readonly<RenditionLevel> | undefined;
 	/**
-	 * Id of current video rendition subscribed to.
+	 * The target rendition level that the client is currently switching to
 	 */
-	videoRenditionId?: number;
+	get targetRenditionLevel(): Readonly<RenditionLevel> | undefined;
 	/**
-	 * Id of current audio rendition subscribed to.
+	 * True if the client is currently switching from one rendition level to another
 	 */
-	audioRenditionId?: number;
+	get isSwitchingRenditionLevel(): boolean;
 	/**
-	 * Current video codec being used.
+	 * The time ranges buffered for video.
+	 * The ranges are specified in milliseconds.
 	 */
-	videoCodec?: string;
+	get videoBufferedRanges(): ReadonlyArray<TimeRange>;
 	/**
-	 * Current audio codec being used.
+	 * The time ranges buffered for audio.
+	 * The ranges are specified in milliseconds.
 	 */
-	audioCodec?: string;
+	get audioBufferedRanges(): ReadonlyArray<TimeRange>;
 	/**
-	 * Width of current video rendition (if any).
+	 * The API client for calls to the public available endpoints of the Vindral Live CDN.
 	 */
-	videoWidth?: number;
+	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 audioNode(): AudioNode | undefined;
+	get drmStatistics(): {
+		keySystem?: string | undefined;
+		licenseServerUrl?: string | undefined;
+		mediaKeySystemConfiguration?: MediaKeySystemConfiguration | undefined;
+		provider?: string | undefined;
+		clearkeys?: Record<string, string>;
+		playreadyLicenseUrl?: string;
+		widevineLicenseUrl?: string;
+		fairplayLicenseUrl?: string;
+		fairplayCertificate?: ArrayBuffer;
+		videoCodec?: string;
+		audioCodec?: string;
+	} | null;
 	/**
-	 * Height of current video rendition (if any).
+	 * Get active Vindral Options
 	 */
-	videoHeight?: number;
+	getOptions: () => Options;
 	/**
-	 * Currently expected video bit rate according to metadata in bits/s.
+	 * Get url for fetching thumbnail. Note that fetching thumbnails only works for an active channel.
 	 */
-	expectedVideoBitRate?: number;
+	getThumbnailUrl: () => string;
 	/**
-	 * Currently expected audio bit rate according to metadata in bits/s.
+	 * Update authentication token on an already established and authenticated connection
 	 */
-	expectedAudioBitRate?: number;
+	updateAuthenticationToken: (token: string) => void;
 	/**
-	 * Current language. For non-multi language streams, this will often be unset.
+	 * @deprecated since 3.0.0 Use play instead.
+	 * Connects to the configured channel and starts streaming
 	 */
-	language?: string;
+	connect: () => void;
+	private _connect;
 	/**
-	 * Frame rate. Example: `"frameRate": [24000, 1001]`.
+	 * Get options that can be used for CastSender
 	 */
-	frameRate?: [
-		number,
-		number
-	];
+	getCastOptions: () => Options;
+	private onConnectInfo;
+	private emitLanguagesIfChanged;
+	private updateTextTracks;
+	private cleanupTextTracks;
+	private filterRenditions;
 	/**
-	 * Total count of rendition level changes (quality downgrades/upgrades).
+	 * 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
 	 */
-	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;
-}
-type ConnectionType = "bluetooth" | "cellular" | "ethernet" | "mixed" | "none" | "other" | "unknown" | "wifi" | "wimax";
-type EffectiveConnectionType = "2g" | "3g" | "4g" | "slow-2g";
-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 {
+	private patchSubscription;
+	private isSupportedVideoCodecProfile;
+	private supportedAudioCodecs;
+	private initializeDecodingModule;
 	/**
-	 * Current video bitrate in bits/second.
+	 * 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.
 	 */
-	videoBitRate?: number;
+	unload: () => Promise<void>;
 	/**
-	 * Current audio bitrate in bits/second.
+	 * @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.
 	 */
-	audioBitRate?: number;
+	userInput: () => void;
 	/**
-	 * Counter of number of bytes received.
+	 * Pauses the stream. Call .play() to resume playback again.
 	 */
-	bytesReceived: number;
-}
-interface MseModuleStatistics {
-	quotaErrorCount: number;
-	mediaSourceOpenTime: number;
-	totalVideoFrames?: number;
-	droppedVideoFrames?: number;
-	successfulVideoAppendCalls?: number;
-	successfulAudioAppendsCalls?: number;
-}
-interface QualityOfServiceModuleStatistics {
+	pause: () => void;
+	private registerDebugInstance;
 	/**
-	 * Time in milliseconds spent in buffering state. Note that this value will increase while in background if
-	 * buffering when leaving foreground.
+	 *
+	 * 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.
 	 */
-	timeSpentBuffering: number;
+	play: () => void;
 	/**
-	 * Total number of buffering events since instantiation.
+	 * How long in milliseconds since the instance was created
 	 */
-	bufferingEventsCount: number;
+	get uptime(): number;
 	/**
-	 * Number of fatal quality of service events.
+	 * 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.
 	 */
-	fatalQosCount: number;
+	getStatistics: () => Statistics;
+	private resetModules;
+	private suspend;
+	private unsuspend;
+	private getRuntimeInfo;
+	private onMediaElementState;
+	private onBufferEvent;
 	/**
-	 * 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.
+	 * Aligns size and bitrate to match a rendition level correctly
 	 */
-	timeSpentRatio: {
-		[bitRate: string]: number;
-	};
-}
-interface SyncModuleStatistics {
-	drift: number | undefined;
-	driftAdjustmentCount: number;
-	timeshiftDriftAdjustmentCount: number;
-	seekTime: number;
+	private alignSizeAndBitRate;
+	private get currentSubscription();
+	private get targetSubscription();
+	private timeToFirstFrame;
+	private willUseMediaSource;
 }
 interface TelemetryModuleStatistics {
 	/**
@@ -1049,511 +1352,353 @@ interface TelemetryModuleStatistics {
 	 */
 	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;
+ * Represents a connection state.
+ */
+export type ConnectionState = "connected" | "disconnected" | "connecting";
+/**
+ * Represents state of a context switch. The state change starts when connection starts receiving a new
+ * channel or quality and is completed when the new quality/channel has received its init segments and key frames.
+ */
+export type ContextSwitchState = "completed" | "started";
+interface ConnectionStatistics {
 	/**
-	 * 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.
-	 *
+	 * RTT (round trip time) between client and server(s).
 	 */
-	sessionId?: string;
+	rtt: MinMaxAverage;
 	/**
-	 * Unlike `sessionId`, `clientId` will remain the same even after reconnections and represents this unique Vindral instance.
+	 * A very rough initial estimation of minimum available bandwidth.
 	 */
-	clientId: string;
+	estimatedBandwidth: number;
+	edgeUrl?: string;
 	/**
-	 * How long in milliseconds since the instance was created.
+	 * Total number of connections that have been established since instantiation.
 	 */
-	uptime: number;
+	connectCount: number;
 	/**
-	 * Current channel ID being subscribed to.
+	 * Total number of connection attempts since instantiation.
 	 */
-	channelId: string;
+	connectionAttemptCount: number;
+	connectionProtocol: "vindral_ws" | "moq" | undefined;
+}
+/**
+ * Contextual information about the language switch
+ */
+export interface LanguageSwitchContext {
 	/**
-	 * Channel group being subscribed to.
+	 * The new language that was switched to
 	 */
-	channelGroupId?: string;
+	language: string;
+}
+/**
+ * Contextual information about the channel switch
+ */
+export interface ChannelSwitchContext {
 	/**
-	 * 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.
+	 * The new channel id that was switched to
 	 */
-	timeToFirstFrame?: number;
-	iosMediaElementEnabled?: boolean;
-};
+	channelId: string;
+}
 /**
- * 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()
- * ```
+ * Volume state changes
  */
-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;
+export interface VolumeState {
 	/**
-	 * Picture in picture
+	 * Wether the audio is muted
 	 */
-	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);
+	isMuted: boolean;
 	/**
-	 * 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
+	 * The volume level
 	 */
-	attach: (container: HTMLElement) => void;
+	volume: number;
+}
+/**
+ * The events that can be emitted from the Vindral instance
+ */
+export interface PublicVindralEvents {
 	/**
-	 * 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.
+	 * When an error that requires action has occured
 	 *
-	 * Note that setting volume is not allowed on iPadOS and iOS devices.
-	 * This is an OS/browser limitation on the video element.
+	 * Can be a fatal error that will unload the Vindral instance - this is indicated by `isFatal()` on the error object returning true.
 	 *
-	 * [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.
+	 * 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.
 	 */
-	get volume(): number;
+	["error"]: Readonly<VindralError>;
 	/**
-	 * Set playback to muted/unmuted
+	 * 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
+	 * }
+	 * ```
 	 */
-	set muted(muted: boolean);
+	["needs user input"]: NeedsUserInputContext;
 	/**
-	 * Whether the playback is muted or not
+	 * When a timed metadata event has been triggered
 	 */
-	get muted(): boolean;
+	["metadata"]: Readonly<Metadata>;
 	/**
-	 * Media (audio | video | audio+video)
+	 * When the playback state changes
 	 */
-	get media(): Media;
+	["playback state"]: Readonly<PlaybackState>;
 	/**
-	 * The current average video bit rate in bits/s
+	 * When the connection state changes
 	 */
-	get videoBitRate(): number;
+	["connection state"]: Readonly<ConnectionState>;
 	/**
-	 * The current average audio bit rate in bits/s
+	 * When the available rendition levels is changed
 	 */
-	get audioBitRate(): number;
+	["rendition levels"]: ReadonlyArray<RenditionLevel>;
 	/**
-	 * The current connection state
+	 * When the rendition level is changed
 	 */
-	get connectionState(): Readonly<State>;
+	["rendition level"]: Readonly<RenditionLevel>;
 	/**
-	 * The current playback state
+	 * When the available languages is changed
 	 */
-	get playbackState(): Readonly<PlaybackState>;
+	["languages"]: ReadonlyArray<string>;
 	/**
-	 * The current buffer fullness as a floating point value between 0-1, where 1 is full and 0 i empty.
+	 * When the available text tracks are changed
 	 */
-	get bufferFullness(): number;
+	["text tracks"]: ReadonlyArray<string>;
 	/**
-	 * Whether user bandwidth savings by capping the video resolution to the size of the video element is enabled
+	 * When the available channels is changed
 	 */
-	get sizeBasedResolutionCapEnabled(): boolean;
+	["channels"]: ReadonlyArray<Channel>;
 	/**
-	 * Enables or disables user bandwidth savings by capping the video resolution to the size of the video element.
+	 * When a context switch state change has occured.
+	 * E.g. when a channel change has been requested, or quality is changed.
 	 */
-	set sizeBasedResolutionCapEnabled(enabled: boolean);
+	["context switch"]: Readonly<ContextSwitchState>;
 	/**
-	 * Whether ABR is currently enabled
+	 * 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.
 	 */
-	get abrEnabled(): boolean;
+	["server wallclock time"]: Readonly<number>;
 	/**
-	 * Enable or disable ABR
+	 * Is emitted during connection whether the channel is live or not.
 	 *
-	 * The client will immediatly stop changing renditon level based on QoS metrics
+	 * 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: It is strongly recommended to keep this enabled as it can severly increase
-	 * the number of buffering events for viewers.
+	 * 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.
 	 */
-	set abrEnabled(enabled: boolean);
+	["is live"]: boolean;
 	/**
-	 * Estimated live edge time for the current channel
+	 * 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.
 	 */
-	get serverEdgeTime(): number | undefined;
+	["channel switch"]: Readonly<ChannelSwitchContext>;
 	/**
-	 * @returns Estimated wallclock time on the edge server in milliseconds
+	 * Emmitted when a channel switch fails.
+	 * A string containing the channel id of the current channel is provided as an argument.
 	 */
-	get serverWallclockTime(): number | undefined;
+	["channel switch failed"]: Readonly<ChannelSwitchContext>;
 	/**
-	 * Local current time normalized between all channels in the channel group
+	 * Emitted when a language switch has been completed and the new language starts playing.
 	 */
-	get currentTime(): number;
+	["language switch"]: Readonly<LanguageSwitchContext>;
 	/**
-	 * 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.
+	 * Emitted when the volume state changes.
 	 *
-	 * 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
+	 * 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.
 	 */
-	get playbackLatency(): number | undefined;
+	["volume state"]: Readonly<VolumeState>;
+	["buffer state event"]: Readonly<BufferStateEvent>;
+	["initialized media"]: void;
+}
+/**
+ * Available events to listen to
+ */
+export interface CastSenderEvents {
 	/**
-	 * The estimated utc timestamp (in ms) for the playhead.
+	 * When a connection has been established with a CastReceiver
 	 */
-	get playbackWallclockTime(): number | undefined;
+	["connected"]: void;
 	/**
-	 * Channels that can be switched between
+	 * When a previous session has been resumed
 	 */
-	get channels(): ReadonlyArray<Channel>;
+	["resumed"]: void;
 	/**
-	 * Languages available
+	 * When a CastReceiver has lost or stopped a connection
 	 */
-	get languages(): ReadonlyArray<string>;
+	["disconnected"]: void;
 	/**
-	 * The current language
+	 * When a connection attempt was initiated unsuccessfully
 	 */
-	get language(): string | undefined;
+	["failed"]: void;
 	/**
-	 * Set the current language
+	 * When the remote connection emits a metadata event
 	 */
-	set language(language: string | undefined);
+	["metadata"]: Metadata;
 	/**
-	 * Set the active text track
+	 * When the remote connection receives a server wallclock time event
 	 */
-	set textTrack(label: string | undefined);
+	["server wallclock time"]: number;
+}
+/**
+ * Used for initializing the CastSender
+ */
+export interface CastConfig {
 	/**
-	 * Get the available text tracks
+	 * The Vindral Options to use for the Cast Receiver
 	 */
-	get textTracks(): string[];
+	options: Options;
 	/**
-	 * Get the active text track
+	 * URL to a background image.
+	 * Example: "https://via.placeholder.com/256x144"
 	 */
-	get textTrack(): string | undefined;
+	background?: string;
 	/**
-	 * The current channelId
+	 * Override this if you have your own custom receiver
 	 */
-	get channelId(): string;
+	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);
 	/**
-	 * 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)
+	 * True if the instance is casting right now
 	 */
-	set channelId(channelId: string);
+	get casting(): boolean;
 	/**
-	 * Max size that will be subcribed to
+	 * The current volume
 	 */
-	get maxSize(): Size;
+	get volume(): number;
 	/**
-	 * 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 the current volume. Setting this to zero is equivalent to muting the video
 	 */
-	set maxSize(size: Size);
+	set volume(volume: number);
 	/**
-	 * The max video bit rate that will be subscribed to
-	 *
-	 * Note: Returns Number.MAX_SAFE_INTEGER if no limits have been set
+	 * The current language
 	 */
-	get maxVideoBitRate(): number;
+	get language(): string | undefined;
 	/**
-	 * 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 the current language
 	 */
-	set maxVideoBitRate(bitRate: number);
+	set language(language: string | undefined);
 	/**
-	 * The max audio bit rate that will be subscribed to
-	 *
-	 * Note: Returns Number.MAX_SAFE_INTEGER if no limits have been set
+	 * The current channelId
 	 */
-	get maxAudioBitRate(): number;
+	get channelId(): string;
 	/**
-	 * 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 the current channelId
 	 */
-	set maxAudioBitRate(bitRate: number);
+	set channelId(channelId: string);
 	/**
-	 * The rendition levels available.
+	 * Update authentication token on an already established and authenticated connection
 	 */
-	get renditionLevels(): ReadonlyArray<RenditionLevel>;
+	updateAuthenticationToken: (token: string) => void;
 	/**
-	 * The current rendition level
+	 * Fully unloads the instance. This disconnects the current listener but lets the
+	 * cast session continue on the receiving device
 	 */
-	get currentRenditionLevel(): Readonly<RenditionLevel> | undefined;
+	unload: () => void;
 	/**
-	 * The target rendition level that the client is currently switching to
+	 * Initiates the CastSender.
+	 * Will reject if Cast is not available on the device or the network.
 	 */
-	get targetRenditionLevel(): Readonly<RenditionLevel> | undefined;
+	init: () => Promise<void>;
 	/**
-	 * True if the client is currently switching from one rendition level to another
+	 * Requests a session. It will open the native cast receiver chooser dialog
 	 */
-	get isSwitchingRenditionLevel(): boolean;
+	start: () => Promise<void>;
 	/**
-	 * The time ranges buffered for video.
-	 * The ranges are specified in milliseconds.
+	 * Stops a session. It will stop playback on device as well.
 	 */
-	get videoBufferedRanges(): ReadonlyArray<TimeRange>;
+	stop: () => void;
 	/**
-	 * The time ranges buffered for audio.
-	 * The ranges are specified in milliseconds.
+	 * Returns a string representing the name of the Cast receiver device or undefined if no receiver exists
 	 */
-	get audioBufferedRanges(): ReadonlyArray<TimeRange>;
-	get lastBufferEvent(): Readonly<BufferStateEvent>;
-	get activeRatios(): Map<string, number>;
-	get bufferingRatios(): Map<string, number>;
-	get timeSpentBuffering(): number;
-	get timeActive(): number;
-	get mediaElement(): HTMLMediaElement | HTMLCanvasElement;
+	getReceiverName: () => string | undefined;
+	private onGCastApiAvailable;
+	private send;
+	private onMessage;
+	private onSessionStarted;
+	private onSessionStateChanged;
+	private getInstance;
+	private getSession;
+	private castLibrariesAdded;
+	private verifyCastLibraries;
+}
+interface AirPlaySenderEvents {
 	/**
-	 * Get active Vindral Options
+	 * When airplay targets are available.
 	 */
-	getOptions: () => Options & typeof defaultOptions;
+	["available"]: void;
 	/**
-	 * Get url for fetching thumbnail. Note that fetching thumbnails only works for an active channel.
+	 * When a connection has been established with an airplay target.
 	 */
-	getThumbnailUrl: () => string;
+	["connected"]: void;
 	/**
-	 * Update authentication token on an already established and authenticated connection
+	 * When the airplay target has lost or stopped a connection.
 	 */
-	updateAuthenticationToken: (token: string) => void;
+	["disconnected"]: void;
+}
+interface AirPlayConfig {
 	/**
-	 * @deprecated since 3.0.0 Use play instead.
-	 * Connects to the configured channel and starts streaming
+	 * URL to use when connecting to the stream.
 	 */
-	connect: () => void;
-	private _connect;
+	url: string;
 	/**
-	 * Get options that can be used for CastSender
+	 * Channel ID to connect to.
 	 */
-	getCastOptions: () => Options;
-	private connectionInfo;
-	private estimateRTT;
-	private connectHandler;
-	private emitLanguagesIfChanged;
-	private updateTextTracks;
-	private cleanupTextTracks;
-	private filterRenditions;
+	channelId: string;
 	/**
-	 * 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
+	 * A container to attach the video element in. This should be the same container that the vindral video element is attached to.
 	 */
-	private patchSubscription;
-	private isSupportedVideoCodecProfile;
-	private supportedAudioCodecs;
-	private initializeDecodingModule;
+	container: HTMLElement;
 	/**
-	 * 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.
+	 * 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.
 	 */
-	unload: () => Promise<void>;
+	authenticationToken?: string;
+}
+declare class AirPlaySender extends Emitter<AirPlaySenderEvents> {
+	private config;
+	private hlsUrl;
+	private element;
+	private connectingTimeout?;
+	constructor(config: AirPlayConfig);
 	/**
-	 * @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.
+	 * True if the instance is casting right now.
 	 */
-	userInput: () => void;
+	get casting(): boolean;
 	/**
-	 * Pauses the stream. Call .play() to resume playback again.
+	 * Set the current channelId.
 	 */
-	pause: () => void;
-	private registerDebugInstance;
+	set channelId(channelId: string);
 	/**
-	 *
-	 * 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.
+	 * Update authentication token on an already established and authenticated connection.
 	 */
-	play: () => void;
+	updateAuthenticationToken: (_token: string) => void;
 	/**
-	 * How long in milliseconds since the instance was created
+	 * Fully unloads the instance. This disconnects the current listeners.
 	 */
-	get uptime(): number;
+	unload: () => void;
 	/**
-	 * 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.
+	 * Show the AirPlay picker.
 	 */
-	getStatistics: () => Statistics;
-	private resetModules;
-	private suspend;
-	private unsuspend;
-	private getRuntimeInfo;
-	private onMediaElementState;
-	private onBufferEvent;
+	showPlaybackTargetPicker(): void;
 	/**
-	 * Aligns size and bitrate to match a rendition level correctly
+	 * Returns if AirPlay is supported.
 	 */
-	private alignSizeAndBitRate;
-	private get currentSubscription();
-	private get targetSubscription();
-	private timeToFirstFrame;
-	private willUseMediaSource;
+	static isAirPlaySupported(): boolean;
+	private onAirPlayAvailable;
+	private onAirPlayPlaybackChanged;
+	private checkHlsUrl;
 }
 /**
  * Available options when initializing the Player. Used for enabling/disabling features