@vindral/web-sdk 3.4.4 → 4.0.0-191-g9f7294ed

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

@@ -1,18 +1,3 @@
-type AudioCodec = "aac" | "opus" | "mp3";
-type VideoCodec = "h264" | "av1";
-/**
- * Represents a timed metadata event
- */
-export interface Metadata {
-	/**
-	 * The raw string content as it was ingested (if using JSON, it needs to be parsed on your end)
-	 */
-	content: string;
-	/**
-	 * Timestamp in ms
-	 */
-	timestamp: number;
-}
 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;
@@ -73,21 +58,81 @@ 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;
+	};
+};
 /**
- * The current reconnect state to use to decide whether to kep reconnecting or not
+ * Channel
  */
-export interface ReconnectState {
+export interface Channel {
 	/**
-	 * 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.
+	 * Channel ID for the channel
 	 */
-	reconnectRetries: number;
+	channelId: string;
+	/**
+	 * Display name
+	 */
+	name: string;
+	/**
+	 * Indicates whether there is an incoming source feed for the channel
+	 */
+	isLive: boolean;
+	/**
+	 * URLs to fetch thumbnail from
+	 */
+	thumbnailUrls: string[];
+}
+interface ClientOverrides {
+	maxVideoBitRate?: number;
+	minBufferTime?: number;
+	maxBufferTime?: number;
+	burstEnabled?: boolean;
+	sizeBasedResolutionCapEnabled?: boolean;
+	separateVideoSocketEnabled?: boolean;
+	videoCodecs?: string[];
+}
+type AudioCodec = "aac" | "opus" | "mp3";
+type VideoCodec = "h264" | "av1";
+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;
+}
+interface CatalogRoot {
+	version: number;
+	streamingFormat?: number;
+	streamingFormatVersion?: string;
+}
+interface TracksCatalog extends CatalogRoot {
+	namespace: Namespace;
+	tracks: Array<TrackObject>;
 }
 interface RenditionProps {
 	id: number;
@@ -119,6 +164,78 @@ type VideoRendition = VideoRenditionProps & RenditionProps;
 type AudioRendition = AudioRenditionProps & RenditionProps;
 type TextRendition = TextRenditionProps & RenditionProps;
 type Rendition = VideoRendition | AudioRendition | TextRendition;
+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;
+}
 interface Size {
 	width: number;
 	height: number;
@@ -141,6 +258,19 @@ export interface AdvancedOptions {
 	 */
 	wasmDecodingConstraint: Partial<VideoConstraint>;
 }
+/**
+ * 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 Media = "audio" | "video" | "audio+video";
 /**
  * Options for the Vindral instance
@@ -335,6 +465,10 @@ export interface Options {
 	advanced?: AdvancedOptions;
 	media?: Media;
 	videoCodecs?: VideoCodec[];
+	/**
+	 * DRM options to provide to the Vindral instance
+	 */
+	drm?: DrmOptions;
 }
 /**
  * Represents a rendition (quality level).
@@ -352,60 +486,95 @@ export interface RenditionLevelChanged {
 	to?: RenditionLevel;
 	reason: RenditionLevelChangedReason;
 }
+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 VindralErrorProps {
+	isFatal: boolean;
+	type?: ErrorType;
+	code: string;
+	source?: Error | MediaError;
+}
+export declare const CONNECTION_FAILED_CODE = "connection_failed";
+export declare const CONNECTION_FAILED_AFTER_RETRIES_CODE = "connection_failed_will_not_attempt_again";
+export declare const AUTHENTICATION_FAILED_CODE = "authentication_error";
+export declare const AUTHENTICATION_EXPIRED_CODE = "authentication_expired";
+export declare const CHANNEL_NOT_FOUND_CODE = "channel_not_found";
+export declare const NO_INCOMING_DATA = "no_incoming_data_error";
+export declare const INACTIVITY_CODE = "connection_inactivity";
+export declare const DISCONNECTED_BY_EDGE = "disconnected_by_edge";
+type ErrorType = "internal" | "external";
 /**
- * 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;
+type PlaybackState = "buffering" | "playing" | "paused";
+type BufferStateEvent = "filled" | "drained";
+interface PlaybackModuleStatistics {
+	/**
+	 * Current target buffer time if using dynamic buffer. Otherwise, this is the statically set buffer time from instantiation.
+	 */
+	bufferTime: number;
+	needsInputForAudioCount: number;
+	needsInputForVideoCount: number;
 }
-export interface ConnectResponse {
-	logsUrl?: string;
-	statsUrl?: string;
-	telemetry?: Telemetry;
-	channels: ChannelWithRenditionsAndOverrides[];
-	edges: string[];
+interface NeedsUserInputContext {
+	/**
+	 * True if user input is needed for audio
+	 */
+	forAudio: boolean;
+	/**
+	 * True if user input is needed for video
+	 */
+	forVideo: boolean;
 }
 /**
  * ApiClientOptions
@@ -433,6 +602,10 @@ export interface AuthorizationContext {
 	 */
 	channelId?: string;
 }
+interface ConnectOptions {
+	channelGroupId?: string;
+	channelId: string;
+}
 /**
  * AuthorizationTokenFactory
  */
@@ -447,7 +620,7 @@ export declare class ApiClient {
 	/**
 	 * 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.
 	 *
@@ -469,431 +642,9 @@ 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
-	 */
-	["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;
-}
-interface VindralErrorProps {
-	isFatal: boolean;
-	type?: ErrorType;
-	code: string;
-	source?: Error | MediaError;
-}
-export declare const CONNECTION_FAILED_CODE = "connection_failed";
-export declare const CONNECTION_FAILED_AFTER_RETRIES_CODE = "connection_failed_will_not_attempt_again";
-export declare const AUTHENTICATION_FAILED_CODE = "authentication_error";
-export declare const AUTHENTICATION_EXPIRED_CODE = "authentication_expired";
-export declare const CHANNEL_NOT_FOUND_CODE = "channel_not_found";
-export declare const NO_INCOMING_DATA = "no_incoming_data_error";
-export declare const INACTIVITY_CODE = "connection_inactivity";
-export declare const DISCONNECTED_BY_EDGE = "disconnected_by_edge";
-type ErrorType = "internal" | "external";
-/**
- * Represents a vindral error - all errors emitted from the Vindral instance inherit from this class.
- */
-export declare class VindralError extends Error {
-	private props;
-	private extra;
-	constructor(message: string, props: VindralErrorProps, extra?: {});
-	/**
-	 * The error code is a stable string that represents the error type - this should be treated as an
-	 * opaque string that can be used as a key for looking up localized strings for displaying error messages.
-	 * @returns the error code
-	 */
-	code: () => string;
-	/**
-	 * Indicates whether the error is fatal - if it is that means the Vindral instance will be unloaded because of this error.
-	 */
-	isFatal: () => boolean;
-	/**
-	 * The underlying error that caused the Vindral error
-	 * @returns the underlying error
-	 */
-	source: () => Error | MediaError | undefined;
-	type: () => ErrorType;
-	/**
-	 * @returns a stringifiable represenation of the error
-	 */
-	toStringifiable: () => Record<string, unknown>;
-}
-interface AirPlaySenderEvents {
-	/**
-	 * When airplay targets are available.
-	 */
-	["available"]: void;
-	/**
-	 * When a connection has been established with an airplay target.
-	 */
-	["connected"]: void;
-	/**
-	 * When the airplay target has lost or stopped a connection.
-	 */
-	["disconnected"]: void;
-}
-interface AirPlayConfig {
-	/**
-	 * URL to use when connecting to the stream.
-	 */
-	url: string;
-	/**
-	 * Channel ID to connect to.
-	 */
-	channelId: string;
-	/**
-	 * A container to attach the video element in. This should be the same container that the vindral video element is attached to.
-	 */
-	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;
-}
-declare class AirPlaySender extends Emitter<AirPlaySenderEvents> {
-	private config;
-	private hlsUrl;
-	private element;
-	private connectingTimeout?;
-	constructor(config: AirPlayConfig);
-	/**
-	 * True if the instance is casting right now.
-	 */
-	get casting(): boolean;
-	/**
-	 * 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 listeners.
-	 */
-	unload: () => void;
-	/**
-	 * Show the AirPlay picker.
-	 */
-	showPlaybackTargetPicker(): void;
-	/**
-	 * Returns if AirPlay is supported.
-	 */
-	static isAirPlaySupported(): boolean;
-	private onAirPlayAvailable;
-	private onAirPlayPlaybackChanged;
-	private checkHlsUrl;
-}
-type PlaybackState = "buffering" | "playing" | "paused";
-type BufferStateEvent = "filled" | "drained";
-interface PlaybackModuleStatistics {
-	/**
-	 * Current target buffer time if using dynamic buffer. Otherwise, this is the statically set buffer time from instantiation.
-	 */
-	bufferTime: number;
-	needsInputForAudioCount: number;
-	needsInputForVideoCount: number;
-}
-interface NeedsUserInputContext {
-	/**
-	 * True if user input is needed for audio
-	 */
-	forAudio: boolean;
-	/**
-	 * True if user input is needed for video
-	 */
-	forVideo: boolean;
-}
-type State = "connected" | "disconnected" | "connecting";
-type ContextSwitchState = "completed" | "started";
-interface ConnectionStatistics {
-	/**
-	 * RTT (round trip time) between client and server(s).
-	 */
-	rtt: MinMaxAverage;
-	/**
-	 * A very rough initial estimation of minimum available bandwidth.
-	 */
-	estimatedBandwidth: number;
-	edgeUrl?: string;
-	/**
-	 * Total number of connections that have been established since instantiation.
-	 */
-	connectCount: number;
-	/**
-	 * Total number of connection attempts since instantiation.
-	 */
-	connectionAttemptCount: number;
-}
-/**
- * Contextual information about the language switch
- */
-export interface LanguageSwitchContext {
-	/**
-	 * The new language that was switched to
-	 */
-	language: string;
-}
-/**
- * Contextual information about the channel switch
- */
-export interface ChannelSwitchContext {
-	/**
-	 * The new channel id that was switched to
-	 */
-	channelId: string;
-}
-interface VolumeState {
-	/**
-	 * Wether the audio is muted
-	 */
-	isMuted: boolean;
-	/**
-	 * The volume level
-	 */
-	volume: number;
-}
-/**
- * The events that can be emitted from the Vindral instance
- */
-export interface PublicVindralEvents {
-	/**
-	 * When an error that requires action has occured
-	 *
-	 * Can be a fatal error that will unload the Vindral instance - this is indicated by `isFatal()` on the error object returning true.
-	 *
-	 * In case of a fatal error it is appropriate to indicate what the error was to the user, either by displaying the error.message or
-	 * by using the error.code() as a key to look up a localization string. To resume streaming it is required to create a new Vindral instance.
-	 */
-	["error"]: Readonly<VindralError>;
-	/**
-	 * When the instance needs user input to activate audio or sometimes video playback.
-	 * Is called with an object
-	 * ```javascript
-	 * {
-	 *   forAudio: boolean // true if user input is needed for audio playback
-	 *   forVideo: boolean // true if user input is needed for video playback
-	 * }
-	 * ```
-	 */
-	["needs user input"]: NeedsUserInputContext;
-	/**
-	 * When a timed metadata event has been triggered
-	 */
-	["metadata"]: Readonly<Metadata>;
-	/**
-	 * When the playback state changes
-	 */
-	["playback state"]: Readonly<PlaybackState>;
-	/**
-	 * When the connection state changes
-	 */
-	["connection state"]: Readonly<State>;
-	/**
-	 * When the available rendition levels is changed
-	 */
-	["rendition levels"]: ReadonlyArray<RenditionLevel>;
-	/**
-	 * When the rendition level is changed
-	 */
-	["rendition level"]: Readonly<RenditionLevel>;
-	/**
-	 * When the available languages is changed
-	 */
-	["languages"]: ReadonlyArray<string>;
-	/**
-	 * When the available text tracks are changed
-	 */
-	["text tracks"]: ReadonlyArray<string>;
-	/**
-	 * When the available channels is changed
-	 */
-	["channels"]: ReadonlyArray<Channel>;
-	/**
-	 * When a context switch state change has occured.
-	 * E.g. when a channel change has been requested, or quality is changed.
-	 */
-	["context switch"]: Readonly<ContextSwitchState>;
-	/**
-	 * Emitted when a wallclock time message has been received from the server.
-	 *
-	 * Note: This is the edge server wallclock time and thus may differ slightly
-	 * between two viewers if they are connected to different edge servers.
-	 */
-	["server wallclock time"]: Readonly<number>;
-	/**
-	 * Is emitted during connection whether the channel is live or not.
-	 *
-	 * If the channel is not live, the Vindral instance will try to reconnect until the `reconnectHandler`
-	 * determines that no more retries should be made.
-	 *
-	 * Note: If the web-sdk is instantiated at the same time as you are starting the stream it is possible
-	 * that this emits false until the started state has propagated through the system.
-	 */
-	["is live"]: boolean;
-	/**
-	 * Emitted when a channel switch has been completed and the first frame of the new channel is rendered.
-	 * A string containing the channel id of the new channel is provided as an argument.
-	 */
-	["channel switch"]: Readonly<ChannelSwitchContext>;
-	/**
-	 * Emitted when a language switch has been completed and the new language starts playing.
-	 */
-	["language switch"]: Readonly<LanguageSwitchContext>;
-	/**
-	 * Emitted when the volume state changes.
-	 *
-	 * This is triggered triggered both when the user changes the volume through the Vindral instance, but also
-	 * from external sources such as OS media shortcuts or other native UI outside of the browser.
-	 */
-	["volume state"]: Readonly<VolumeState>;
-	["buffer state event"]: Readonly<BufferStateEvent>;
-	["initialized media"]: void;
-}
-declare const defaultOptions: {
-	sizeBasedResolutionCapEnabled: boolean;
-	pictureInPictureEnabled: boolean;
-	abrEnabled: boolean;
-	burstEnabled: boolean;
-	mseEnabled: boolean;
-	mseOpusEnabled: boolean;
-	muted: boolean;
-	minBufferTime: number;
-	maxBufferTime: number;
-	logLevel: "off" | "error" | "warn" | "info" | "debug" | "trace";
-	maxSize: Size;
-	maxVideoBitRate: number;
-	maxAudioBitRate: number;
-	tags: string[];
-	media: Media;
-	poster: string | boolean;
-	reconnectHandler: (state: ReconnectState) => Promise<boolean> | boolean;
-	iosWakeLockEnabled: boolean;
-	telemetryEnabled: boolean;
-	iosMediaElementEnabled: boolean;
-	pauseSupportEnabled: boolean;
-	advanced: {
-		wasmDecodingConstraint: Partial<VideoConstraint>;
-	};
-	videoCodecs: VideoCodec[];
-};
-interface AdaptivityStatistics {
-	/**
-	 * True if adaptive bitrate (ABR) is enabled.
+	 * True if adaptive bitrate (ABR) is enabled.
 	 */
 	isAbrEnabled: boolean;
 }
@@ -979,8 +730,6 @@ interface DecoderStatistics {
 	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;
@@ -1044,15 +793,6 @@ interface SyncModuleStatistics {
 	timeshiftDriftAdjustmentCount: number;
 	seekTime: number;
 }
-interface TelemetryModuleStatistics {
-	/**
-	 * The total amount of errors being spawned. Note that some media errors can trigger
-	 * thousands of errors for a single client in a few seconds before recovering. Therefore,
-	 * consider the number of viewers with errors, not just the total amount. Also, consider the median
-	 * instead of the mean for average calculation.
-	 */
-	errorCount: number;
-}
 interface VideoPlayerStatistics {
 	renderedFrameCount: number;
 	rendererDroppedFrameCount: number;
@@ -1182,7 +922,6 @@ 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;
 	/**
@@ -1221,347 +960,686 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	private _channels;
 	private createdAt;
 	private hasCalledConnect;
-	private apiClient;
 	private latestEmittedLanguages;
 	private wakeLock;
-	private cachedEdges;
-	private shiftedEdges;
 	private pool;
 	private userAgentInformation;
+	private encryptedMediaExtensions;
 	private sampleProcessingSesssions;
 	private sizes;
 	private isSuspended;
 	private disconnectTimeout;
 	constructor(options: Options);
 	/**
-	 * Attaches the video view to a DOM element. The Vindral video view will be sized to fill this element while
-	 * maintaining the correct aspect ratio.
-	 * @param container the container element to append the video view to. Often a div element.
-	 * @returns
+	 * Attaches the video view to a DOM element. The Vindral video view will be sized to fill this element while
+	 * maintaining the correct aspect ratio.
+	 * @param container the container element to append the video view to. Often a div element.
+	 * @returns
+	 */
+	attach: (container: HTMLElement) => void;
+	/**
+	 * Set the current volume.
+	 * Setting this to 0 is not equivalent to muting the audio.
+	 * Setting this to >0 is not equivalent to unmuting the audio.
+	 *
+	 * Note that setting volume is not allowed on iPadOS and iOS devices.
+	 * This is an OS/browser limitation on the video element.
+	 *
+	 * [Read more about it on Apple docs](https://developer.apple.com/library/archive/documentation/AudioVideo/Conceptual/Using_HTML5_Audio_Video/Device-SpecificConsiderations/Device-SpecificConsiderations.html)
+	 * for iOS-Specific Considerations. The following section is the important part:
+	 * On iOS devices, the audio level is always under the user's physical control. The volume property is not settable in JavaScript. Reading the volume property always returns 1.
+	 */
+	set volume(volume: number);
+	/**
+	 * The current volume. Note that if the playback is muted volume can still be set.
+	 */
+	get volume(): number;
+	/**
+	 * Set playback to muted/unmuted
+	 */
+	set muted(muted: boolean);
+	/**
+	 * Whether the playback is muted or not
+	 */
+	get muted(): boolean;
+	/**
+	 * Media (audio | video | audio+video)
+	 */
+	get media(): Media;
+	/**
+	 * The current average video bit rate in bits/s
+	 */
+	get videoBitRate(): number;
+	/**
+	 * The current average audio bit rate in bits/s
+	 */
+	get audioBitRate(): number;
+	/**
+	 * The current connection state
+	 */
+	get connectionState(): Readonly<State>;
+	/**
+	 * The current playback state
+	 */
+	get playbackState(): Readonly<PlaybackState>;
+	/**
+	 * The current buffer fullness as a floating point value between 0-1, where 1 is full and 0 i empty.
+	 */
+	get bufferFullness(): number;
+	/**
+	 * Whether user bandwidth savings by capping the video resolution to the size of the video element is enabled
+	 */
+	get sizeBasedResolutionCapEnabled(): boolean;
+	/**
+	 * Enables or disables user bandwidth savings by capping the video resolution to the size of the video element.
+	 */
+	set sizeBasedResolutionCapEnabled(enabled: boolean);
+	/**
+	 * Whether ABR is currently enabled
+	 */
+	get abrEnabled(): boolean;
+	/**
+	 * Enable or disable ABR
+	 *
+	 * The client will immediatly stop changing renditon level based on QoS metrics
+	 *
+	 * Note: It is strongly recommended to keep this enabled as it can severly increase
+	 * the number of buffering events for viewers.
+	 */
+	set abrEnabled(enabled: boolean);
+	/**
+	 * Estimated live edge time for the current channel
+	 */
+	get serverEdgeTime(): number | undefined;
+	/**
+	 * @returns Estimated wallclock time on the edge server in milliseconds
+	 */
+	get serverWallclockTime(): number | undefined;
+	/**
+	 * Local current time normalized between all channels in the channel group
+	 */
+	get currentTime(): number;
+	/**
+	 * Current time for the channel. This is the actual stream time, passed on from your ingress.
+	 * Integer overflow could make this value differ from your encoder timestamps if it has been rolling for more
+	 * than 42 days with RTMP as target.
+	 *
+	 * Note: This is not normalized between channels, thus it can make jumps when switching channels
+	 */
+	get channelCurrentTime(): number;
+	/**
+	 * The current target buffer time in milliseconds
+	 */
+	get targetBufferTime(): number;
+	/**
+	 * Set the current target buffer time in milliseconds
+	 */
+	set targetBufferTime(bufferTimeMs: number);
+	/**
+	 * The estimated playback latency based on target buffer time, the connection rtt and local playback drift
+	 */
+	get playbackLatency(): number | undefined;
+	/**
+	 * The estimated utc timestamp (in ms) for the playhead.
+	 */
+	get playbackWallclockTime(): number | undefined;
+	/**
+	 * Channels that can be switched between
+	 */
+	get channels(): ReadonlyArray<Channel>;
+	/**
+	 * Languages available
+	 */
+	get languages(): ReadonlyArray<string>;
+	/**
+	 * The current language
+	 */
+	get language(): string | undefined;
+	/**
+	 * Set the current language
+	 */
+	set language(language: string | undefined);
+	/**
+	 * Set the active text track
+	 */
+	set textTrack(label: string | undefined);
+	/**
+	 * Get the available text tracks
+	 */
+	get textTracks(): string[];
+	/**
+	 * Get the active text track
+	 */
+	get textTrack(): string | undefined;
+	/**
+	 * The current channelId
+	 */
+	get channelId(): string;
+	/**
+	 * Set the current channelId
+	 *
+	 * Possible channels to set are available from [[channels]]
+	 *
+	 * Note that the following scenarios are not possible right now:
+	 * - switching channel from a channel with audio to a channel without audio (unless audio only mode is active)
+	 * - switching channel from a channel with video to a channel without video (unless video only mode is active)
+	 */
+	set channelId(channelId: string);
+	/**
+	 * Max size that will be subcribed to
+	 */
+	get maxSize(): Size;
+	/**
+	 * Set max size that will be subscribed to
+	 *
+	 * Note: If ABR is disabled, setting this will make the client instantly subscribe to this size
+	 */
+	set maxSize(size: Size);
+	/**
+	 * The max video bit rate that will be subscribed to
+	 *
+	 * Note: Returns Number.MAX_SAFE_INTEGER if no limits have been set
+	 */
+	get maxVideoBitRate(): number;
+	/**
+	 * Set max video bit rate that will be subscribed to
+	 *
+	 * Note: If ABR is disabled, setting this will make the client instantly subscribe to this bitrate
+	 */
+	set maxVideoBitRate(bitRate: number);
+	/**
+	 * The max audio bit rate that will be subscribed to
+	 *
+	 * Note: Returns Number.MAX_SAFE_INTEGER if no limits have been set
+	 */
+	get maxAudioBitRate(): number;
+	/**
+	 * Set max audio bit rate that will be subscribed to
+	 *
+	 * Note: If ABR is disabled, setting this will make the client instantly subscribe to this bit rate
+	 */
+	set maxAudioBitRate(bitRate: number);
+	/**
+	 * The rendition levels available.
+	 */
+	get renditionLevels(): ReadonlyArray<RenditionLevel>;
+	/**
+	 * The current rendition level
+	 */
+	get currentRenditionLevel(): Readonly<RenditionLevel> | undefined;
+	/**
+	 * The target rendition level that the client is currently switching to
+	 */
+	get targetRenditionLevel(): Readonly<RenditionLevel> | undefined;
+	/**
+	 * True if the client is currently switching from one rendition level to another
+	 */
+	get isSwitchingRenditionLevel(): boolean;
+	/**
+	 * The time ranges buffered for video.
+	 * The ranges are specified in milliseconds.
+	 */
+	get videoBufferedRanges(): ReadonlyArray<TimeRange>;
+	/**
+	 * The time ranges buffered for audio.
+	 * The ranges are specified in milliseconds.
+	 */
+	get audioBufferedRanges(): ReadonlyArray<TimeRange>;
+	/**
+	 * The API client for calls to the public available endpoints of the Vindral Live CDN.
+	 */
+	getApiClient(): ApiClient;
+	get lastBufferEvent(): Readonly<BufferStateEvent>;
+	get activeRatios(): Map<string, number>;
+	get bufferingRatios(): Map<string, number>;
+	get timeSpentBuffering(): number;
+	get timeActive(): number;
+	get mediaElement(): HTMLMediaElement | HTMLCanvasElement;
+	get audioNode(): AudioNode | undefined;
+	/**
+	 * 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
 	 */
-	attach: (container: HTMLElement) => void;
+	getCastOptions: () => Options;
+	private onConnectInfo;
+	private emitLanguagesIfChanged;
+	private updateTextTracks;
+	private cleanupTextTracks;
+	private filterRenditions;
 	/**
-	 * 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.
+	 * 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.
 	 *
-	 * Note that setting volume is not allowed on iPadOS and iOS devices.
-	 * This is an OS/browser limitation on the video element.
+	 * 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.
 	 *
-	 * [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.
+	 * 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.
 	 */
-	set volume(volume: number);
+	userInput: () => void;
 	/**
-	 * The current volume. Note that if the playback is muted volume can still be set.
+	 * Pauses the stream. Call .play() to resume playback again.
 	 */
-	get volume(): number;
+	pause: () => void;
+	private registerDebugInstance;
 	/**
-	 * Set playback to muted/unmuted
+	 *
+	 * 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.
 	 */
-	set muted(muted: boolean);
+	play: () => void;
 	/**
-	 * Whether the playback is muted or not
+	 * How long in milliseconds since the instance was created
 	 */
-	get muted(): boolean;
+	get uptime(): number;
 	/**
-	 * Media (audio | video | audio+video)
+	 * 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.
 	 */
-	get media(): Media;
+	getStatistics: () => Statistics;
+	private resetModules;
+	private suspend;
+	private unsuspend;
+	private getRuntimeInfo;
+	private onMediaElementState;
+	private onBufferEvent;
 	/**
-	 * The current average video bit rate in bits/s
+	 * Aligns size and bitrate to match a rendition level correctly
 	 */
-	get videoBitRate(): number;
+	private alignSizeAndBitRate;
+	private get currentSubscription();
+	private get targetSubscription();
+	private timeToFirstFrame;
+	private willUseMediaSource;
+}
+interface TelemetryModuleStatistics {
 	/**
-	 * The current average audio bit rate in bits/s
+	 * The total amount of errors being spawned. Note that some media errors can trigger
+	 * thousands of errors for a single client in a few seconds before recovering. Therefore,
+	 * consider the number of viewers with errors, not just the total amount. Also, consider the median
+	 * instead of the mean for average calculation.
 	 */
-	get audioBitRate(): number;
+	errorCount: number;
+}
+type State = "connected" | "disconnected" | "connecting";
+type ContextSwitchState = "completed" | "started";
+interface ConnectionStatistics {
 	/**
-	 * The current connection state
+	 * RTT (round trip time) between client and server(s).
 	 */
-	get connectionState(): Readonly<State>;
+	rtt: MinMaxAverage;
 	/**
-	 * The current playback state
+	 * A very rough initial estimation of minimum available bandwidth.
 	 */
-	get playbackState(): Readonly<PlaybackState>;
+	estimatedBandwidth: number;
+	edgeUrl?: string;
 	/**
-	 * The current buffer fullness as a floating point value between 0-1, where 1 is full and 0 i empty.
+	 * Total number of connections that have been established since instantiation.
 	 */
-	get bufferFullness(): number;
+	connectCount: number;
 	/**
-	 * Whether user bandwidth savings by capping the video resolution to the size of the video element is enabled
+	 * Total number of connection attempts since instantiation.
 	 */
-	get sizeBasedResolutionCapEnabled(): boolean;
+	connectionAttemptCount: number;
+	connectionProtocol: "vindral_ws" | "moq" | undefined;
+}
+/**
+ * Contextual information about the language switch
+ */
+export interface LanguageSwitchContext {
 	/**
-	 * Enables or disables user bandwidth savings by capping the video resolution to the size of the video element.
+	 * The new language that was switched to
 	 */
-	set sizeBasedResolutionCapEnabled(enabled: boolean);
+	language: string;
+}
+/**
+ * Contextual information about the channel switch
+ */
+export interface ChannelSwitchContext {
 	/**
-	 * Whether ABR is currently enabled
+	 * The new channel id that was switched to
 	 */
-	get abrEnabled(): boolean;
+	channelId: string;
+}
+interface VolumeState {
 	/**
-	 * Enable or disable ABR
+	 * 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
 	 *
-	 * The client will immediatly stop changing renditon level based on QoS metrics
+	 * Can be a fatal error that will unload the Vindral instance - this is indicated by `isFatal()` on the error object returning true.
 	 *
-	 * Note: It is strongly recommended to keep this enabled as it can severly increase
-	 * the number of buffering events for viewers.
+	 * 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.
 	 */
-	set abrEnabled(enabled: boolean);
+	["error"]: Readonly<VindralError>;
 	/**
-	 * Estimated live edge time for the current channel
+	 * 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
+	 * }
+	 * ```
 	 */
-	get serverEdgeTime(): number | undefined;
+	["needs user input"]: NeedsUserInputContext;
 	/**
-	 * @returns Estimated wallclock time on the edge server in milliseconds
+	 * When a timed metadata event has been triggered
 	 */
-	get serverWallclockTime(): number | undefined;
+	["metadata"]: Readonly<Metadata>;
 	/**
-	 * Local current time normalized between all channels in the channel group
+	 * When the playback state changes
 	 */
-	get currentTime(): number;
+	["playback state"]: Readonly<PlaybackState>;
 	/**
-	 * 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.
+	 * When the connection state changes
+	 */
+	["connection state"]: Readonly<State>;
+	/**
+	 * When the available rendition levels is changed
+	 */
+	["rendition levels"]: ReadonlyArray<RenditionLevel>;
+	/**
+	 * When the rendition level is changed
+	 */
+	["rendition level"]: Readonly<RenditionLevel>;
+	/**
+	 * When the available languages is changed
+	 */
+	["languages"]: ReadonlyArray<string>;
+	/**
+	 * When the available text tracks are changed
+	 */
+	["text tracks"]: ReadonlyArray<string>;
+	/**
+	 * When the available channels is changed
+	 */
+	["channels"]: ReadonlyArray<Channel>;
+	/**
+	 * When a context switch state change has occured.
+	 * E.g. when a channel change has been requested, or quality is changed.
+	 */
+	["context switch"]: Readonly<ContextSwitchState>;
+	/**
+	 * Emitted when a wallclock time message has been received from the server.
 	 *
-	 * Note: This is not normalized between channels, thus it can make jumps when switching channels
+	 * 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 channelCurrentTime(): number;
+	["server wallclock time"]: Readonly<number>;
 	/**
-	 * The current target buffer time in milliseconds
+	 * 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.
 	 */
-	get targetBufferTime(): number;
+	["is live"]: boolean;
 	/**
-	 * Set the current target buffer time in milliseconds
+	 * 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 targetBufferTime(bufferTimeMs: number);
+	["channel switch"]: Readonly<ChannelSwitchContext>;
 	/**
-	 * The estimated playback latency based on target buffer time, the connection rtt and local playback drift
+	 * Emitted when a language switch has been completed and the new language starts playing.
 	 */
-	get playbackLatency(): number | undefined;
+	["language switch"]: Readonly<LanguageSwitchContext>;
 	/**
-	 * The estimated utc timestamp (in ms) for the playhead.
+	 * 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.
 	 */
-	get playbackWallclockTime(): number | undefined;
+	["volume state"]: Readonly<VolumeState>;
+	["buffer state event"]: Readonly<BufferStateEvent>;
+	["initialized media"]: void;
+}
+/**
+ * Available events to listen to
+ */
+export interface CastSenderEvents {
 	/**
-	 * Channels that can be switched between
+	 * When a connection has been established with a CastReceiver
 	 */
-	get channels(): ReadonlyArray<Channel>;
+	["connected"]: void;
 	/**
-	 * Languages available
+	 * When a previous session has been resumed
 	 */
-	get languages(): ReadonlyArray<string>;
+	["resumed"]: void;
 	/**
-	 * The current language
+	 * When a CastReceiver has lost or stopped a connection
 	 */
-	get language(): string | undefined;
+	["disconnected"]: void;
 	/**
-	 * Set the current language
+	 * When a connection attempt was initiated unsuccessfully
 	 */
-	set language(language: string | undefined);
+	["failed"]: void;
 	/**
-	 * Set the active text track
+	 * When the remote connection emits a metadata event
 	 */
-	set textTrack(label: string | undefined);
+	["metadata"]: Metadata;
 	/**
-	 * Get the available text tracks
+	 * When the remote connection receives a server wallclock time event
 	 */
-	get textTracks(): string[];
+	["server wallclock time"]: number;
+}
+/**
+ * Used for initializing the CastSender
+ */
+export interface CastConfig {
 	/**
-	 * Get the active text track
+	 * The [Vindral Options](./Options) to use for the Cast Receiver
 	 */
-	get textTrack(): string | undefined;
+	options: Options;
 	/**
-	 * The current channelId
+	 * URL to a background image.
+	 * Example: "https://via.placeholder.com/256x144"
 	 */
-	get channelId(): string;
+	background?: string;
 	/**
-	 * Set the current channelId
-	 *
-	 * Possible channels to set are available from [[channels]]
-	 *
-	 * Note that the following scenarios are not possible right now:
-	 * - switching channel from a channel with audio to a channel without audio (unless audio only mode is active)
-	 * - switching channel from a channel with video to a channel without video (unless video only mode is active)
+	 * Override this if you have your own custom receiver
 	 */
-	set channelId(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);
 	/**
-	 * Max size that will be subcribed to
+	 * True if the instance is casting right now
 	 */
-	get maxSize(): Size;
+	get casting(): boolean;
 	/**
-	 * Set max size that will be subscribed to
-	 *
-	 * Note: If ABR is disabled, setting this will make the client instantly subscribe to this size
+	 * The current volume
 	 */
-	set maxSize(size: Size);
+	get volume(): number;
 	/**
-	 * The max video bit rate that will be subscribed to
-	 *
-	 * Note: Returns Number.MAX_SAFE_INTEGER if no limits have been set
+	 * Set the current volume. Setting this to zero is equivalent to muting the video
 	 */
-	get maxVideoBitRate(): number;
+	set volume(volume: 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
+	 * The current language
 	 */
-	set maxVideoBitRate(bitRate: number);
+	get 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
+	 * Set the current language
 	 */
-	get maxAudioBitRate(): number;
+	set language(language: string | undefined);
 	/**
-	 * 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
+	 * The current channelId
 	 */
-	set maxAudioBitRate(bitRate: number);
+	get channelId(): string;
 	/**
-	 * The rendition levels available.
+	 * Set the current channelId
 	 */
-	get renditionLevels(): ReadonlyArray<RenditionLevel>;
+	set channelId(channelId: string);
 	/**
-	 * The current rendition level
+	 * Update authentication token on an already established and authenticated connection
 	 */
-	get currentRenditionLevel(): Readonly<RenditionLevel> | undefined;
+	updateAuthenticationToken: (token: string) => void;
 	/**
-	 * The target rendition level that the client is currently switching to
+	 * Fully unloads the instance. This disconnects the current listener but lets the
+	 * cast session continue on the receiving device
 	 */
-	get targetRenditionLevel(): Readonly<RenditionLevel> | undefined;
+	unload: () => void;
 	/**
-	 * True if the client is currently switching from one rendition level to another
+	 * Initiates the CastSender.
+	 * Will reject if Cast is not available on the device or the network.
 	 */
-	get isSwitchingRenditionLevel(): boolean;
+	init: () => Promise<void>;
 	/**
-	 * The time ranges buffered for video.
-	 * The ranges are specified in milliseconds.
+	 * Requests a session. It will open the native cast receiver chooser dialog
 	 */
-	get videoBufferedRanges(): ReadonlyArray<TimeRange>;
+	start: () => Promise<void>;
 	/**
-	 * The time ranges buffered for audio.
-	 * The ranges are specified in milliseconds.
+	 * Stops a session. It will stop playback on device as well.
 	 */
-	get audioBufferedRanges(): ReadonlyArray<TimeRange>;
+	stop: () => void;
 	/**
-	 * The API client for calls to the public available endpoints of the Vindral Live CDN.
+	 * Returns a string representing the name of the Cast receiver device or undefined if no receiver exists
 	 */
-	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;
+	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