@vindral/web-sdk 4.0.0 → 4.1.0-2-gc61db412

package/core.d.ts

@@ -1,3 +1,47 @@
+interface Channel {
+	/**
+	 * Channel ID for the channel
+	 */
+	channelId: string;
+	/**
+	 * Display name
+	 */
+	name: string;
+	/**
+	 * Indicates whether there is an incoming source feed for the channel
+	 */
+	isLive: boolean;
+	/**
+	 * URLs to fetch thumbnail from
+	 */
+	thumbnailUrls: string[];
+}
+interface ClientOverrides {
+	maxVideoBitRate?: number;
+	minBufferTime?: number;
+	maxBufferTime?: number;
+	burstEnabled?: boolean;
+	sizeBasedResolutionCapEnabled?: boolean;
+	separateVideoSocketEnabled?: boolean;
+	videoCodecs?: string[];
+}
+export type AudioCodec = "aac" | "opus" | "mp3";
+export type VideoCodec = "h264" | "av1";
+interface MinMaxAverage {
+	last: number;
+	/**
+	 * Average value over a given interval.
+	 */
+	average: number;
+	/**
+	 * Maximum value over a given interval.
+	 */
+	max: number;
+	/**
+	 * Minimum value over a given interval.
+	 */
+	min: number;
+}
 type 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;
@@ -5,6 +49,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;
 	/**
@@ -23,10 +70,13 @@ 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 Levels: readonly [
+declare const LogLevels: readonly [
 	"off",
 	"error",
 	"warn",
@@ -34,8 +84,8 @@ declare const Levels: readonly [
 	"debug",
 	"trace"
 ];
-export type Level = (typeof Levels)[number];
-export declare const Level: {
+type LogLevel = (typeof LogLevels)[number];
+declare const LogLevel: {
 	ERROR: "error";
 	WARN: "warn";
 	INFO: "info";
@@ -43,71 +93,81 @@ export declare const Level: {
 	TRACE: "trace";
 	OFF: "off";
 };
-interface MinMaxAverage {
-	last: number;
-	/**
-	 * Average value over a given interval.
-	 */
-	average: number;
-	/**
-	 * Maximum value over a given interval.
-	 */
-	max: number;
-	/**
-	 * Minimum value over a given interval.
-	 */
-	min: number;
+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;
+	["com.vindral.drm"]?: string;
 }
-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;
+interface CatalogRoot {
+	version: number;
+	streamingFormat?: number;
+	streamingFormatVersion?: string;
 }
-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 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 {
@@ -115,19 +175,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[];
+}
+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;
 }
 /**
@@ -141,7 +292,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
  *
@@ -181,7 +348,7 @@ export interface Options {
 	/**
 	 * Sets the log level - defaults to info
 	 */
-	logLevel?: Level;
+	logLevel?: LogLevel;
 	/**
 	 * Sets the minimum and initial buffer time
 	 */
@@ -311,6 +478,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.
@@ -335,125 +503,35 @@ 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 Channel {
-	/**
-	 * Channel ID for the channel
-	 */
-	channelId: string;
-	/**
-	 * Display name
-	 */
-	name: string;
-	/**
-	 * Indicates whether there is an incoming source feed for the channel
-	 */
-	isLive: boolean;
-	/**
-	 * URLs to fetch thumbnail from
-	 */
-	thumbnailUrls: string[];
-}
-interface ClientOverrides {
-	maxVideoBitRate?: number;
-	minBufferTime?: number;
-	maxBufferTime?: number;
-	burstEnabled?: boolean;
-	sizeBasedResolutionCapEnabled?: boolean;
-	separateVideoSocketEnabled?: boolean;
-	videoCodecs?: string[];
-}
-interface ChannelWithRenditionsAndOverrides extends Channel {
-	renditions: Rendition[];
-	overrides?: ClientOverrides;
-}
-interface ConnectOptions {
-	channelGroupId?: string;
-	channelId: string;
-}
-interface Telemetry {
-	url: string;
-	probability?: number;
-	includeErrors?: boolean;
-	includeEvents?: boolean;
-	includeStats?: boolean;
-	maxRetries?: number;
-	maxErrorReports?: number;
-	interval?: number;
-}
-interface ConnectResponse {
-	logsUrl?: string;
-	statsUrl?: string;
-	telemetry?: Telemetry;
-	channels: ChannelWithRenditionsAndOverrides[];
-	edges: string[];
-}
-interface ApiClientOptions {
-	/**
-	 * String representing the URL to the public CDN API.
-	 */
-	publicEndpoint: string;
-	/**
-	 * Function that should return a string containing a signed authentication token.
-	 */
-	tokenFactory?: AuthorizationTokenFactory;
-}
-interface AuthorizationContext {
-	/**
-	 * The channelGroupId that might need authorization.
-	 */
-	channelGroupId?: string;
-	/**
-	 * The channelId that might need authorization.
-	 */
-	channelId?: string;
-}
-type AuthorizationTokenFactory = (context: AuthorizationContext) => string | undefined;
-declare class ApiClient {
-	private baseUrl;
-	private tokenFactory?;
-	constructor(options: ApiClientOptions);
-	/**
-	 * Returns everything needed to setup the connection of Vindral instance.
-	 */
-	connect(options: ConnectOptions): Promise<ConnectResponse>;
-	/**
-	 * Fetches information regarding a single channel.
-	 *
-	 * @param channelId the channel to fetch
-	 * @returns a [[Channel]] containing information about the requested channel.
-	 */
-	getChannel(channelId: string): Promise<Channel>;
-	/**
-	 * Fetches channels within a channel group
-	 *
-	 * Note: The returned list includes inactive channels - check isLive to filter out only active channels
-	 *
-	 * @param channelGroup the channel group to fetch channels from
-	 * @returns an array of [[Channel]] that belong to the channel group
-	 */
-	getChannels(channelGroupId: string): Promise<Channel[]>;
-	private getHeaders;
-	private getAuthToken;
-	private toChannels;
-	private toChannel;
-}
 interface VindralErrorProps {
 	isFatal: boolean;
 	type?: ErrorType;
@@ -468,7 +546,7 @@ 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";
+export type ErrorType = "internal" | "external";
 /**
  * Represents a vindral error - all errors emitted from the Vindral instance inherit from this class.
  */
@@ -497,199 +575,87 @@ export declare class VindralError extends Error {
 	 */
 	toStringifiable: () => Record<string, unknown>;
 }
-type PlaybackState = "buffering" | "playing" | "paused";
-type BufferStateEvent = "filled" | "drained";
-interface PlaybackModuleStatistics {
-	/**
-	 * Current target buffer time if using dynamic buffer. Otherwise, this is the statically set buffer time from instantiation.
-	 */
-	bufferTime: number;
-	needsInputForAudioCount: number;
-	needsInputForVideoCount: number;
-}
-interface NeedsUserInputContext {
-	/**
-	 * True if user input is needed for audio
-	 */
-	forAudio: boolean;
-	/**
-	 * True if user input is needed for video
-	 */
-	forVideo: boolean;
-}
-type State = "connected" | "disconnected" | "connecting";
-type ContextSwitchState = "completed" | "started";
-interface ConnectionStatistics {
-	/**
-	 * RTT (round trip time) between client and server(s).
-	 */
-	rtt: MinMaxAverage;
-	/**
-	 * A very rough initial estimation of minimum available bandwidth.
-	 */
-	estimatedBandwidth: number;
-	edgeUrl?: string;
-	/**
-	 * Total number of connections that have been established since instantiation.
-	 */
-	connectCount: number;
-	/**
-	 * Total number of connection attempts since instantiation.
-	 */
-	connectionAttemptCount: number;
-}
-/**
- * Contextual information about the language switch
- */
-export interface LanguageSwitchContext {
-	/**
-	 * The new language that was switched to
-	 */
-	language: string;
-}
-/**
- * Contextual information about the channel switch
- */
-export interface ChannelSwitchContext {
-	/**
-	 * The new channel id that was switched to
-	 */
-	channelId: string;
-}
-interface VolumeState {
-	/**
-	 * Wether the audio is muted
-	 */
-	isMuted: boolean;
-	/**
-	 * The volume level
-	 */
-	volume: number;
-}
 /**
- * The events that can be emitted from the Vindral instance
+ * Represents a playback state.
  */
-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>;
+export type PlaybackState = "buffering" | "playing" | "paused";
+export type BufferStateEvent = "filled" | "drained";
+interface PlaybackModuleStatistics {
 	/**
-	 * When the rendition level is changed
+	 * Current target buffer time if using dynamic buffer. Otherwise, this is the statically set buffer time from instantiation.
 	 */
-	["rendition level"]: Readonly<RenditionLevel>;
+	bufferTime: number;
+	needsInputForAudioCount: number;
+	needsInputForVideoCount: number;
+}
+/**
+ * Shows for what context the browser needs a user input event.
+ */
+export interface NeedsUserInputContext {
 	/**
-	 * When the available languages is changed
+	 * True if user input is needed for audio
 	 */
-	["languages"]: ReadonlyArray<string>;
+	forAudio: boolean;
 	/**
-	 * When the available text tracks are changed
+	 * True if user input is needed for video
 	 */
-	["text tracks"]: ReadonlyArray<string>;
+	forVideo: boolean;
+}
+interface ApiClientOptions {
 	/**
-	 * When the available channels is changed
+	 * String representing the URL to the public CDN API.
 	 */
-	["channels"]: ReadonlyArray<Channel>;
+	publicEndpoint: string;
 	/**
-	 * When a context switch state change has occured.
-	 * E.g. when a channel change has been requested, or quality is changed.
+	 * Function that should return a string containing a signed authentication token.
 	 */
-	["context switch"]: Readonly<ContextSwitchState>;
+	tokenFactory?: AuthorizationTokenFactory;
+}
+interface AuthorizationContext {
 	/**
-	 * 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.
+	 * The channelGroupId that might need authorization.
 	 */
-	["server wallclock time"]: Readonly<number>;
+	channelGroupId?: string;
 	/**
-	 * 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.
+	 * The channelId that might need authorization.
 	 */
-	["is live"]: boolean;
+	channelId?: string;
+}
+interface ConnectOptions {
+	channelGroupId?: string;
+	channelId: string;
+}
+type AuthorizationTokenFactory = (context: AuthorizationContext) => string | undefined;
+declare class ApiClient {
+	private baseUrl;
+	private tokenFactory?;
+	constructor(options: ApiClientOptions);
 	/**
-	 * 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.
+	 * @ignore
+	 * Returns everything needed to setup the connection of Vindral instance.
 	 */
-	["channel switch"]: Readonly<ChannelSwitchContext>;
+	connect(options: ConnectOptions): Promise<ConnectInfo>;
 	/**
-	 * Emitted when a language switch has been completed and the new language starts playing.
+	 * Fetches information regarding a single channel.
+	 *
+	 * @param channelId the channel to fetch
+	 * @returns a [[Channel]] containing information about the requested channel.
 	 */
-	["language switch"]: Readonly<LanguageSwitchContext>;
+	getChannel(channelId: string): Promise<Channel>;
 	/**
-	 * Emitted when the volume state changes.
+	 * Fetches channels within a channel group
 	 *
-	 * 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: The returned list includes inactive channels - check isLive to filter out only active channels
+	 *
+	 * @param channelGroupId the channel group to fetch channels from
+	 * @returns an array of [[Channel]] that belong to the channel group
 	 */
-	["volume state"]: Readonly<VolumeState>;
-	["buffer state event"]: Readonly<BufferStateEvent>;
-	["initialized media"]: void;
+	getChannels(channelGroupId: string): Promise<Channel[]>;
+	private getHeaders;
+	private getAuthToken;
+	private toChannels;
+	private toChannel;
 }
-declare const defaultOptions: {
-	sizeBasedResolutionCapEnabled: boolean;
-	pictureInPictureEnabled: boolean;
-	abrEnabled: boolean;
-	burstEnabled: boolean;
-	mseEnabled: boolean;
-	mseOpusEnabled: boolean;
-	muted: boolean;
-	minBufferTime: number;
-	maxBufferTime: number;
-	logLevel: Level;
-	maxSize: Size;
-	maxVideoBitRate: number;
-	maxAudioBitRate: number;
-	tags: string[];
-	media: Media;
-	poster: string | boolean;
-	reconnectHandler: (state: ReconnectState) => Promise<boolean> | boolean;
-	iosWakeLockEnabled: boolean;
-	telemetryEnabled: boolean;
-	iosMediaElementEnabled: boolean;
-	pauseSupportEnabled: boolean;
-	advanced: {
-		wasmDecodingConstraint: Partial<VideoConstraint>;
-	};
-	videoCodecs: VideoCodec[];
-};
 interface AdaptivityStatistics {
 	/**
 	 * True if adaptive bitrate (ABR) is enabled.
@@ -841,15 +807,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;
@@ -979,7 +936,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;
 	/**
@@ -1005,6 +961,10 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 		 */
 		isSupported: () => boolean;
 	};
+	readonly drm: {
+		setHeaders: (headers: Record<string, string>) => void;
+		setQueryParams: (queryParams: Record<string, string>) => void;
+	};
 	private browser;
 	private options;
 	private element;
@@ -1018,13 +978,11 @@ 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;
@@ -1048,6 +1006,9 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	 * [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.
+	 *
 	 */
 	set volume(volume: number);
 	/**
@@ -1063,7 +1024,7 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	 */
 	get muted(): boolean;
 	/**
-	 * Media (audio | video | audio+video)
+	 * Which media type is currently being played
 	 */
 	get media(): Media;
 	/**
@@ -1077,7 +1038,7 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	/**
 	 * The current connection state
 	 */
-	get connectionState(): Readonly<State>;
+	get connectionState(): Readonly<ConnectionState>;
 	/**
 	 * The current playback state
 	 */
@@ -1186,7 +1147,7 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	 */
 	set channelId(channelId: string);
 	/**
-	 * Max size that will be subcribed to
+	 * Max size that will be subscribed to
 	 */
 	get maxSize(): Size;
 	/**
@@ -1255,10 +1216,24 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	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;
 	/**
 	 * Get active Vindral Options
 	 */
-	getOptions: () => Options & typeof defaultOptions;
+	getOptions: () => Options;
 	/**
 	 * Get url for fetching thumbnail. Note that fetching thumbnails only works for an active channel.
 	 */
@@ -1277,9 +1252,7 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	 * Get options that can be used for CastSender
 	 */
 	getCastOptions: () => Options;
-	private connectionInfo;
-	private estimateRTT;
-	private connectHandler;
+	private onConnectInfo;
 	private emitLanguagesIfChanged;
 	private updateTextTracks;
 	private cleanupTextTracks;
@@ -1360,5 +1333,176 @@ export declare class Vindral extends Emitter<PublicVindralEvents> {
 	private timeToFirstFrame;
 	private willUseMediaSource;
 }
+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;
+}
+/**
+ * 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 {
+	/**
+	 * 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;
+	connectionProtocol: "vindral_ws" | "moq" | undefined;
+}
+/**
+ * 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;
+}
+/**
+ * Volume state changes
+ */
+export 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<ConnectionState>;
+	/**
+	 * 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>;
+	/**
+	 * Emmitted when a channel switch fails.
+	 * A string containing the channel id of the current channel is provided as an argument.
+	 */
+	["channel switch failed"]: Readonly<ChannelSwitchContext>;
+	/**
+	 * Emitted when a language switch has been completed and the new language starts playing.
+	 */
+	["language switch"]: Readonly<LanguageSwitchContext>;
+	/**
+	 * Emitted when the volume state changes.
+	 *
+	 * This is triggered triggered both when the user changes the volume through the Vindral instance, but also
+	 * from external sources such as OS media shortcuts or other native UI outside of the browser.
+	 */
+	["volume state"]: Readonly<VolumeState>;
+	["buffer state event"]: Readonly<BufferStateEvent>;
+	["initialized media"]: void;
+}
 
 export {};