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[];
	/**
	 * Urls for timeshift if available
	 */
	timeshiftUrls?: string[];
}
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;
declare class Emitter<TEvents, TEmits = TEvents, ArgLessEvents extends VoidKeys<TEvents> = VoidKeys<TEvents>, ArgEvents extends Exclude<keyof TEvents, ArgLessEvents> = Exclude<keyof TEvents, ArgLessEvents>, ArgLessEmits extends VoidKeys<TEmits> = VoidKeys<TEmits>, ArgEmits extends Exclude<keyof TEmits, ArgLessEmits> = Exclude<keyof TEmits, ArgLessEmits>> {
	private listeners;
	emit<T extends ArgLessEmits>(eventName: T): void;
	emit<T extends ArgEmits>(eventName: T, args: TEmits[T]): void;
	/**
	 * 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;
	/**
	 * Add an event listener to `eventName`
	 *
	 * Event listeners may optionally return a "defer function" that will be called once all other listeners have been called.
	 * This is useful when one listener may want everone to have reacted to an event before calling something.
	 */
	on<T extends ArgLessEvents>(eventName: T, fn: () => void): void;
	on<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => void): void;
	/**
	 * Add an event listener to `eventName` that will be called once only
	 *
	 * Event listeners may optionally return a "defer function" that will be called once all other listeners have been called.
	 * This is useful when one listener may want everone to have reacted to an event before calling something.
	 */
	once<T extends ArgLessEvents>(eventName: T, fn: () => void): void;
	once<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => void): void;
	/**
	 * Check whether there are any listeners registered for the given event.
	 */
	hasListeners<T extends keyof TEvents | keyof TEmits>(eventName: T): boolean;
	/**
	 * 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";
};
declare const tags: unique symbol;
type Tagged<BaseType, Tag extends PropertyKey> = BaseType & {
	[tags]: {
		[K in Tag]: void;
	};
};
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;
	};
}
export type AudioCodec = "aac" | "opus" | "mp3";
export type VideoCodec = "h264" | "av1";
/**
 * 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;
}
/**
 * Advanced options to override default behaviour.
 */
export interface AdvancedOptions {
}
/**
 * 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>;
	/**
	 * Widevine options to override default behaviour
	 */
	widevine?: {
		videoRobustness?: string[];
		audioRobustness?: string[];
	};
	/**
	 * Playready options to override default behaviour
	 */
	playready?: {
		videoRobustness?: string[];
		audioRobustness?: string[];
	};
}
/**
 * Type of media.
 */
export type Media = "audio" | "video" | "audio+video";
type WebCodecsHardwareAccelerationPreference = "no-preference" | "prefer-hardware" | "prefer-software";
type DecoderType = "mse" | "webcodecs" | "wasm";
/**
 * Options for the Vindral instance
 *
 */
export interface Options {
	/**
	 * URL to use when connecting to the stream
	 */
	url: string;
	/**
	 * Channel ID to connect to initially - can be changed later mid-stream when connected to a channel group.
	 */
	channelId: string;
	/**
	 * Channel group to connect to
	 * Note: Only needed for fast channel switching
	 */
	channelGroupId?: string;
	/**
	 * A container to attach the video view in - can be provided later with .attach() on the vindral core instance
	 */
	container?: HTMLElement;
	/**
	 * An authentication token to provide to the server when connecting - only needed for channels with authentication enabled
	 * Note: If not supplied when needed, an "Authentication Failed" error will be raised.
	 */
	authenticationToken?: string;
	/**
	 * Language to use initially - can be changed during during runtime on the vindral instance
	 * Note: Only needed when multiple languages are provided - if no language is specified, one will be automatically selected.
	 */
	language?: string;
	/**
	 * TextTrack to use initially - can be changed during during runtime on the vindral instance
	 */
	textTrack?: string;
	/**
	 * Sets the log level - defaults to info
	 */
	logLevel?: LogLevel;
	/**
	 * Sets the minimum and initial buffer time
	 */
	minBufferTime?: number;
	/**
	 * Sets the maximum buffer time allowed. The vindral instance will automatically slowly increase
	 * the buffer time if the use experiences to much buffering with the initial buffer time.
	 */
	maxBufferTime?: number;
	/**
	 * Enables or disables user bandwidth savings by capping the video resolution to the size of the video element.
	 *
	 * Is enabled by default.
	 *
	 * Note: This is automatically set to false when abrEnabled is set to false.
	 */
	sizeBasedResolutionCapEnabled?: boolean;
	/**
	 * Enables or disables picture in picture support.
	 */
	pictureInPictureEnabled?: boolean;
	/**
	 * Enable bursting for initial connection and channel switches. This makes time to first frame faster at the
	 * cost of stability (more demanding due to the sudden burst of live content)
	 *
	 * Is disabled by default.
	 *
	 */
	burstEnabled?: boolean;
	/**
	 * @deprecated Use `decoders` instead.
	 * Setting `mseEnabled: false` is equivalent to `decoders: ["wasm"]`.
	 * When both `mseEnabled` and `decoders` are provided, `decoders` takes precedence.
	 */
	mseEnabled?: boolean;
	/**
	 * Enable Opus with the MediaSource API on supported browsers.
	 *
	 * Is enabled by default.
	 *
	 */
	mseOpusEnabled?: boolean;
	/**
	 * Enable or disable support for playing audio in the background for iOS devices.
	 *
	 * Is false (disabled) by default.
	 *
	 * Note:  This may be enabled by default in a future (major) release
	 */
	iosBackgroundPlayEnabled?: boolean;
	/**
	 * Enable or disable Adaptive Bit Rate. This allows for automatically adapting the incoming bit rate based on
	 * the viewers bandwidth and thus avoiding buffering events. This also disables the
	 * sizeBasedResolutionCapEnabled option.
	 *
	 * Is enabled by default.
	 *
	 * Note:  It is strongly recommended to keep this enabled as user experience can greatly suffer without ABR.
	 */
	abrEnabled?: boolean;
	/**
	 * Enable or disable telemetry. This allows for telemetry and errors being collected.
	 *
	 * Is enabled by default.
	 *
	 * We appreciate you turning it off during development/staging to not bloat real telemetry data.
	 *
	 * Note: It is strongly recommended to keep this enabled in production as it is required for insights and KPIs.
	 */
	telemetryEnabled?: boolean;
	/**
	 * Set a cap on the maximum video size.
	 * This can be used to provide user options to limit the video bandwidth usage.
	 *
	 * Note: This takes presedence over any size based resolution caps.
	 */
	maxSize?: Size;
	/**
	 * Maximum audio bit rate allowed.
	 * This can be used to provide user options to limit the audio bandwidth usage.
	 */
	maxAudioBitRate?: number;
	/**
	 * Maximum video bit rate allowed.
	 * This can be used to provide user options to limit the video bandwidth usage.
	 */
	maxVideoBitRate?: number;
	/**
	 * Initial maximum bit rate cap applied when first connecting to a channel.
	 * This helps prevent buffering on initial connection by starting at a conservative bitrate.
	 * The client will adapt to higher bitrates as bandwidth allows if ABR is enabled.
	 *
	 * Default is 2.5 Mbps (2500000 bits per second).
	 */
	maxInitialBitRate?: number;
	/**
	 * Controls video element background behaviour while loading.
	 * - If `false`, a black background will be shown.
	 * - If undefined or `true`, a live thumbnail will be shown.
	 * - If set to a string containing a URL (https://urltoimage), use that.
	 * Default `true` - meaning a live thumbnail is shown
	 */
	poster?: boolean | string;
	/**
	 * Whether to start the player muted or to try to start playing audio automatically.
	 */
	muted?: boolean;
	/**
	 * Initial volume level for the player. A floating point value between 0-1.
	 * Default is 1 (100% volume).
	 *
	 * Note: Volume cannot be set on iOS devices due to system restrictions.
	 * The volume property is not settable in JavaScript on iOS, and reading it always returns 1.
	 */
	volume?: number;
	/**
	 * Provide a custom reconnect handler to control when the instance should stop trying to
	 * reconnect. The reconnect handler should either return true to allow the reconnect or
	 * false to stop reconnecting. It can also return a promise with true or false if it needs
	 * to make any async calls before determining wether to reconnect.
	 *
	 * The default reconnect handler allows 30 reconnects before stopping.
	 *
	 * Note: the ReconnectState gets reset every time the client instance makes a successful connection.
	 * This means the default reconnect handler will only stop reconnecting after 30 _consecutive_ failed connections.
	 *
	 * ```typescript
	 * // An example reconnect handler that will reconnect forever
	 * const reconnectHandler = (state: ReconnectState) => true
	 *
	 * // An example reconnect handler that will fetch an url and determine whether to reconnect
	 * const reconnectHandler = async (state: ReconnectState) => {
	 *   const result = await fetch("https://should-i-reconnect-now.com")
	 *   return result.ok
	 * },
	 * ```
	 */
	reconnectHandler?: (state: ReconnectState) => Promise<boolean> | boolean;
	tags?: string[];
	ownerSessionId?: string;
	edgeUrl?: string;
	logShippingEnabled?: boolean;
	statsShippingEnabled?: boolean;
	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.
	 * Other devices already provide wake lock by default.
	 *
	 * This option is redundant and has no effect if streamToMediaElementEnabled is enabled since that automatically enables wake lock.
	 *
	 * Disabled by default.
	 */
	iosWakeLockEnabled?: boolean;
	/**
	 * Disabling this will revert to legacy behaviour where Vindral will try to always keep the video element playing.
	 */
	pauseSupportEnabled?: boolean;
	/**
	 * Stream canvas-rendered video/audio to a media element via captureStream.
	 *
	 * This enables platform media features such as fullscreen and picture-in-picture
	 * for non-MSE playback by routing the canvas output through a `<video>` element.
	 *
	 * Disabled by default.
	 */
	streamToMediaElementEnabled?: boolean;
	/**
	 * @deprecated Use `streamToMediaElementEnabled` instead.
	 *
	 * Legacy alias kept for backwards compatibility.
	 */
	iosMediaElementEnabled?: boolean;
	/**
	 * Hardware acceleration preference for WebCodecs video decoding.
	 *
	 * Defaults to `"no-preference"`.
	 */
	webcodecsHardwareAcceleration?: WebCodecsHardwareAccelerationPreference;
	/**
	 * Enable OffscreenCanvas rendering in worker thread.
	 *
	 * When enabled, video rendering happens in the worker thread using OffscreenCanvas.
	 * Automatically enabled when `decoders` resolves to WebCodecs. Set to `false`
	 * to explicitly disable even when WebCodecs is active.
	 *
	 * Requires browser support for OffscreenCanvas and WebCodecs.
	 * Works with `streamToMediaElementEnabled` for fullscreen/PiP support.
	 */
	offscreenCanvasEnabled?: boolean;
	/**
	 * Ordered list of decoders to try.
	 *
	 * The runtime walks the list and uses the first decoder that is available on the
	 * current platform. When DRM is active, MSE is forced regardless of order.
	 *
	 * When omitted, the platform default order is used (`["mse", "wasm"]`).
	 *
	 * @example
	 * // Prefer WebCodecs over MSE
	 * decoders: ["webcodecs", "mse", "wasm"]
	 */
	decoders?: DecoderType[];
	/**
	 * Advanced options to override default behaviour.
	 */
	advanced?: AdvancedOptions;
	media?: Media;
	videoCodecs?: VideoCodec[];
	/**
	 * DRM options to provide to the Vindral instance
	 */
	drm?: DrmOptions;
}
interface ClientOverrides {
	maxVideoBitRate?: number;
	minBufferTime?: number;
	maxBufferTime?: number;
	burstEnabled?: boolean;
	sizeBasedResolutionCapEnabled?: boolean;
	separateVideoSocketEnabled?: boolean;
	webcodecsHardwareAcceleration?: WebCodecsHardwareAccelerationPreference;
	offscreenCanvasEnabled?: boolean;
	videoCodecs?: string[];
}
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;
}
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 {
	codec: "webvtt";
	kind: "subtitles" | "captions";
	label?: string;
}
/**
 * @interface
 */
export type VideoRendition = VideoRenditionProps & RenditionProps;
/**
 * @interface
 */
export 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[];
	timeshift: {
		urls: string[];
		duration: string;
	};
}
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;
}
/**
 * Represents a rendition (quality level).
 */
export interface RenditionLevel {
	/** */
	audio?: AudioRendition;
	/** */
	video?: VideoRendition;
}
/**
 * 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;
}
export interface VideoConstraint {
	/** */
	width: number;
	/** */
	height: number;
	/** */
	bitRate: number;
	/** */
	codec?: VideoCodec;
	/** */
	codecString?: string;
}
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";
/**
 * 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>;
}
/**
 * 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;
}
/**
 * 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;
}
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;
}
interface ConnectOptions {
	channelGroupId?: string;
	channelId: string;
}
type AuthorizationTokenFactory = (context: AuthorizationContext) => string | undefined;
declare class ApiClient {
	private baseUrl;
	private tokenFactory?;
	constructor(options: ApiClientOptions);
	/**
	 * @ignore
	 * Returns everything needed to setup the connection of Vindral instance.
	 */
	connect(options: ConnectOptions): Promise<ConnectInfo>;
	/**
	 * 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 channelGroupId 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 AdaptivityStatistics {
	/**
	 * True if adaptive bitrate (ABR) is enabled.
	 */
	isAbrEnabled: boolean;
}
interface BufferTimeStatistics {
	/**
	 * Number of time buffer time has been adjusted. This will only happen when using dynamic buffer time
	 * (different min/max values of bufferTime).
	 */
	bufferTimeAdjustmentCount: number;
}
interface RenditionsModuleStatistics {
	/**
	 * Id of current video rendition subscribed to.
	 */
	videoRenditionId?: number;
	/**
	 * Id of current audio rendition subscribed to.
	 */
	audioRenditionId?: number;
	/**
	 * Current video codec being used.
	 */
	videoCodec?: string;
	/**
	 * Current audio codec being used.
	 */
	audioCodec?: string;
	/**
	 * Width of current video rendition (if any).
	 */
	videoWidth?: number;
	/**
	 * Height of current video rendition (if any).
	 */
	videoHeight?: number;
	/**
	 * Currently expected video bit rate according to metadata in bits/s.
	 */
	expectedVideoBitRate?: number;
	/**
	 * Currently expected audio bit rate according to metadata in bits/s.
	 */
	expectedAudioBitRate?: number;
	/**
	 * Current language. For non-multi language streams, this will often be unset.
	 */
	language?: string;
	/**
	 * Frame rate. Example: `"frameRate": [24000, 1001]`.
	 */
	frameRate?: [
		number,
		number
	];
	/**
	 * Total count of rendition level changes (quality downgrades/upgrades).
	 */
	renditionLevelChangeCount: number;
}
interface VideoConstraintCap {
	width: number;
	height: number;
	bitRate: number;
}
interface AudioConstraintCap {
	bitRate: number;
}
interface ConstraintCap {
	video: VideoConstraintCap;
	audio: AudioConstraintCap;
}
interface ConstraintCapStatistics {
	constraintCap?: ConstraintCap;
	windowInnerWidth: number;
	windowInnerHeight: number;
	elementWidth: number;
	elementHeight: number;
	pixelRatio: number;
}
interface DecoderStatistics {
	videoDecodeRate: number;
	videoDecodeTime: MinMaxAverage;
	audioDecodeTime: MinMaxAverage;
	videoTransportTime: MinMaxAverage;
	videoKeyframeIntervalMs?: number;
	renderedFrameCount?: number;
	rendererDroppedFrameCount?: number;
	videoRenderer?: "OffscreenCanvas" | "Canvas" | "MSE";
	videoDecoder?: "WebCodecs" | "WASM" | "MSE";
	audioRenderer?: "AudioContext" | "MSE";
	audioDecoder?: "WebCodecs" | "WASM" | "MSE";
}
interface DocumentStateModulesStatistics {
	isVisible: boolean;
	isOnline: boolean;
	isVisibleCount: number;
	isHiddenCount: number;
	isOnlineCount: number;
	isOfflineCount: number;
	navigatorRtt?: number;
	navigatorEffectiveType?: EffectiveConnectionType;
	navigatorConnectionType?: ConnectionType;
	navigatorSaveData?: boolean;
	navigatorDownlink?: number;
}
interface IncomingDataModuleStatistics {
	/**
	 * Current video bitrate in bits/second.
	 */
	videoBitRate?: number;
	/**
	 * Current audio bitrate in bits/second.
	 */
	audioBitRate?: number;
	/**
	 * Counter of number of bytes received.
	 */
	bytesReceived: number;
}
interface JitterStatistics {
	/** Minimum jitter in the recent window */
	min: number;
	/** Maximum jitter in the recent window for spike detection */
	max: number;
	/** Latest average jitter in ms (recent window) */
	last: number;
	/** Average jitter in ms (RFC 3550 style, smoothed with /16) */
	average: number;
}
interface JitterModuleStatistics {
	audioJitter: JitterStatistics | undefined;
	videoJitter: JitterStatistics | undefined;
}
interface MseModuleStatistics {
	quotaErrorCount: number;
	mediaSourceOpenTime: number;
	totalVideoFrames?: number;
	droppedVideoFrames?: number;
	successfulVideoAppendCalls?: number;
	successfulAudioAppendsCalls?: number;
	videoKeyframeIntervalMs?: number;
	videoRenderer?: "OffscreenCanvas" | "Canvas" | "MSE";
	videoDecoder?: "WebCodecs" | "WASM" | "MSE";
	audioRenderer?: "AudioContext" | "MSE";
	audioDecoder?: "WebCodecs" | "WASM" | "MSE";
}
interface QualityOfServiceModuleStatistics {
	/**
	 * Time in milliseconds spent in buffering state. Note that this value will increase while in background if
	 * buffering when leaving foreground.
	 */
	timeSpentBuffering: number;
	/**
	 * Total number of buffering events since instantiation.
	 */
	bufferingEventsCount: number;
	/**
	 * Number of fatal quality of service events.
	 */
	fatalQosCount: number;
	/**
	 * Ratio of time being spent on different quality indexes. Index 0 is always the highest quality.
	 * Example: `"timeSpentRatio": { "0": 0.8, "1": 0.2 }` shows 80% spent on the best level, 20% on the next one.
	 */
	timeSpentRatio: {
		[qualityIndex: string]: number;
	};
	/**
	 * Ratio of time spent buffering to total active time (0-1).
	 * Provides a normalized buffering quality metric regardless of session length.
	 * A value of 0.05 means 5% of the active session was spent buffering.
	 */
	bufferingRatio: number;
	/**
	 * Number of buffering events per minute of active playback.
	 * Normalizes buffering event count for comparison across sessions of different durations.
	 */
	bufferingEventsPerMinute: number;
	/**
	 * Weighted average rendition index based on time spent at each level.
	 * Lower values indicate higher quality (index 0 is the highest quality).
	 * Example: 0.3 means mostly on the best quality with some time on lower qualities.
	 */
	averageRenditionIndex: number;
	/**
	 * Buffering ratio for the last minute of playback (0-1).
	 * Useful for detecting recent degradation vs overall session quality.
	 */
	bufferingRatioPerMinute: number;
	/**
	 * Number of rendition level changes (upgrades + downgrades) per minute.
	 * Measures ABR stability - lower values indicate a more stable experience.
	 */
	renditionChangesPerMinute: number;
	/**
	 * Average time in milliseconds spent buffering per buffering event.
	 * Helps distinguish many short buffering events from fewer long ones.
	 */
	timePerBufferingEvent: number;
}
interface SyncModuleStatistics {
	drift: number | undefined;
	seekAdjustmentCount: number;
	timeshiftAdjustmentCount: number;
	seekTime: number;
	/**
	 * Total time spent seeking in milliseconds for the entire session.
	 * High values indicate frequent or slow seeks, which may impact user experience.
	 */
	totalSeekTime: number;
	seekToleranceMultiplier: number;
	currentSeekToleranceMs: number;
	currentAheadToleranceMs: number;
	isPlaybackRateAdjustmentEnabled: boolean;
	playbackRate: number;
	playbackRateAdjustmentCount: number;
	/**
	 * Average absolute drift in milliseconds over a rolling window.
	 * Measures how far off sync the playback typically is, regardless of direction.
	 */
	averageDrift: number;
}
interface VideoPlayerStatistics {
	renderedFrameCount: number;
	rendererDroppedFrameCount: number;
}
type ModuleStatistics = AdaptivityStatistics & BufferTimeStatistics & ConnectionStatistics & ConstraintCapStatistics & DecoderStatistics & DocumentStateModulesStatistics & IncomingDataModuleStatistics & JitterModuleStatistics & MseModuleStatistics & PlaybackModuleStatistics & QualityOfServiceModuleStatistics & RenditionsModuleStatistics & SyncModuleStatistics & TelemetryModuleStatistics & VideoPlayerStatistics;
/**
 * Contains internal statistics.
 *
 * Note that this object will have some undocumented properties, used internally or temporarily,
 * for monitoring and improving the performance of the service.
 *
 * @interface
 */
export type Statistics = ModuleStatistics & ReturnType<UserAgentInformation["getUserAgentInformation"]> & {
	/**
	 * Version of the @vindral/web-sdk being used.
	 */
	version: string;
	/**
	 * IP of the client.
	 */
	ip?: string;
	/**
	 * URL being used for connecting to the stream.
	 */
	url: string;
	/**
	 * A session is bound to a connection. If the client reconnects for any reason (e.g. coming back from inactivity
	 * or a problem with network on client side), a new sessionId will be used.
	 *
	 */
	sessionId?: string;
	/**
	 * Unlike `sessionId`, `clientId` will remain the same even after reconnections and represents this unique Vindral instance.
	 */
	clientId: string;
	/**
	 * How long in milliseconds since the instance was created.
	 */
	uptime: number;
	/**
	 * Current channel ID being subscribed to.
	 */
	channelId: string;
	/**
	 * Channel group being subscribed to.
	 */
	channelGroupId?: string;
	/**
	 * Time in milliseconds from instantiation to playback of video and audio being started.
	 * Note that an actual frame render often happens much quicker, but that is not counted as TTFF.
	 */
	timeToFirstFrame?: number;
	streamToMediaElementEnabled?: boolean;
	/** @deprecated */
	iosMediaElementEnabled?: boolean;
	/**
	 * Average bitrate for the entire session in bits/second.
	 */
	averageBitRate?: number;
	/**
	 * Number of reconnections per hour of uptime.
	 * Measures connection stability over time. Lower is better.
	 * Excludes the initial connection, so a stable session will have a value of 0.
	 */
	reconnectsPerHour: number;
	/**
	 * Number of seek adjustments (seeks to catch up) per minute of active playback.
	 * High values indicate sync issues or network instability.
	 */
	seekAdjustmentsPerMinute: number;
	/**
	 * Number of timeshift adjustments per minute of active playback.
	 * Relevant for timeshift-enabled streams.
	 */
	timeshiftAdjustmentsPerMinute: number;
};
/**
 * 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 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;
	};
	readonly drm: {
		setHeaders: (headers: Record<string, string>) => void;
		setQueryParams: (queryParams: Record<string, string>) => void;
	};
	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 offscreenCanvasElement?;
	private webCodecsRenditionSupport;
	private hasCalledConnect;
	private latestEmittedLanguages;
	private wakeLock;
	private pool;
	private userAgentInformation;
	private encryptedMediaExtensions;
	private sampleProcessingSesssions;
	private sizes;
	private isSuspended;
	private disconnectTimeout;
	private offscreenSubtitleInterval?;
	constructor(options: Options);
	/**
	 * Attaches the video view to a DOM element. The Vindral video view will be sized to fill this element while
	 * maintaining the correct aspect ratio.
	 * @param container the container element to append the video view to. Often a div element.
	 * @returns
	 */
	attach: (container: HTMLElement) => void;
	private setElement;
	/**
	 * 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.
	 *
	 */
	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;
	/**
	 * Which media type is currently being played
	 */
	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<ConnectionState>;
	/**
	 * 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.
	 *
	 * Initially, this will always be equal to `minBufferTime`.
	 * Only when using a separate `maxBufferTime`, the `targetBufferTime` will be able to vary between min and max.
	 *
	 */
	get targetBufferTime(): number;
	/**
	 * Set the current target buffer time in milliseconds.
	 *
	 * Note that setting this will not respect min/max buffer time values.
	 * For instance with `{ minBufferTime: 500, maxBufferTime: 3000 }, you can still set `targetBufferTime` to 100 ms.`
	 * The dynamic buffer will still work in respect to the originally set values when needed. Therefore we recommend
	 * setting targetBufferTime within that range for consistancy if using both min/max.
	 */
	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 subscribed 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 timestamps (in milliseconds) of video keyframes currently in the buffer.
	 */
	get videoKeyframeTimestamps(): ReadonlyArray<number>;
	/**
	 * 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 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;
	/**
	 * Get url for fetching thumbnail. Note that fetching thumbnails only works for an active channel.
	 */
	getThumbnailUrl: () => string;
	/**
	 * Update authentication token on an already established and authenticated connection
	 */
	updateAuthenticationToken: (token: string) => void;
	/**
	 * @deprecated since 3.0.0 Use play instead.
	 * Connects to the configured channel and starts streaming
	 */
	connect: () => void;
	private _connect;
	/**
	 * Get options that can be used for CastSender
	 */
	getCastOptions: () => Options;
	private onConnectInfo;
	private emitLanguagesIfChanged;
	private updateTextTracks;
	private cleanupTextTracks;
	private filterRenditions;
	/**
	 * Patch the subscription with properties from the channel that isn't known until connection
	 * @param channel Channel with the renditions to patch the subscription based on
	 */
	private patchSubscription;
	private isSupportedVideoCodecProfile;
	private supportedAudioCodecs;
	private initializeDecodingModule;
	/**
	 * Set up a polling interval that forwards subtitle cues to the decoder worker
	 * when OffscreenCanvas rendering is active. This is needed because the canvas modules'
	 * own subtitle intervals either get killed (LegacyCanvasModule) or don't have the
	 * OffscreenCanvas reference at construction time (ModernCanvasModule).
	 */
	private setupOffscreenSubtitleRouting;
	/**
	 * Fully unloads the instance. This disconnects the clients and stops any background tasks.
	 * This client instance cannot be used after this has been called.
	 */
	unload: () => Promise<void>;
	/**
	 * @deprecated since 3.0.0 Use play instead.
	 *
	 * Activates audio or video on web browsers that require a user gesture to enable media playback.
	 * The Vindral instance will emit a "needs user input" event to indicate when this is needed.
	 * But it is also safe to pre-emptively call this if it is more convenient - such as in cases where
	 * the Vindral instance itself is created in a user input event.
	 *
	 * Requirements: This method needs to be called within an user-input event handler to function properly, such as
	 * an onclick handler.
	 *
	 * Note: Even if you pre-emptively call this it is still recommended to listen to "needs user input"
	 * and handle that event gracefully.
	 */
	userInput: () => void;
	/**
	 * Pauses the stream. Call .play() to resume playback again.
	 */
	pause: () => void;
	private registerDebugInstance;
	/**
	 *
	 * Start playing the stream.
	 *
	 * This method also activates audio or video on web browsers that require a user gesture to enable media playback.
	 * The Vindral instance will emit a "needs user input" event to indicate when this is needed.
	 * But it is also safe to pre-emptively call this if it is more convenient - such as in cases where
	 * the Vindral instance itself is created in a user input event.
	 *
	 * Note: In most browsers this method needs to be called within an user-input event handler, such as
	 * an onclick handler in order to activate audio. Most implementations call this directly after constructing the Vindral
	 * instance once in order to start playing, and then listen to a user-event in order to allow audio to be activated.
	 *
	 * Note 2: Even if you pre-emptively call this it is still recommended to listen to "needs user input"
	 * and handle that event gracefully.
	 */
	play: () => void;
	/**
	 * How long in milliseconds since the instance was created
	 */
	get uptime(): number;
	/**
	 * This method collects a statistics report from internal modules. While many of the report's properties are documented, the report may also contain undocumented
	 * properties used internally or temporarily for monitoring and improving the performance of the service.
	 *
	 * Use undocumented properties at your own risk.
	 */
	getStatistics: () => Statistics;
	private resetModules;
	private suspend;
	private unsuspend;
	private getRuntimeInfo;
	private onMediaElementState;
	private onBufferEvent;
	/**
	 * Aligns size and bitrate to match a rendition level correctly
	 */
	private alignSizeAndBitRate;
	private get currentSubscription();
	private get targetSubscription();
	private timeToFirstFrame;
	private resolvedDecoder;
	private willUseMediaSource;
	private shouldUseWebCodecs;
	private isWebCodecsVideoAvailable;
	private isWebCodecsAudioAvailable;
	/**
	 * Returns true if OffscreenCanvas should be used.
	 * Implicitly enabled when the resolved decoder is WebCodecs, since OffscreenCanvas
	 * is the optimal rendering path for WebCodecs (worker renders VideoFrames directly).
	 */
	private shouldUseOffscreenCanvas;
}
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;
	/**
	 * Ratio of successful connections to total connection attempts (0-1).
	 * A value of 1.0 means every connection attempt succeeded.
	 */
	connectionSuccessRatio: number;
	connectionProtocol: "vindral_ws" | "moq" | "moq_ws" | 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;
}
interface TimeShiftInfo {
	urls: string[];
	duration: string;
}
interface CmafFragmentEvent {
	mediaType: "video" | "audio";
	initSegment: Readonly<Uint8Array<ArrayBuffer>>;
	fragment: Readonly<Uint8Array<ArrayBuffer>>;
	isKeyframe: boolean;
}
/**
 * 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>;
	/**
	 * Emitted when the timeshift URLs are updated.
	 */
	["timeshift info"]: Readonly<TimeShiftInfo>;
	/**
	 * Emitted for each CMAF fragment received via the MoQ/VoQ path.
	 * Contains raw fMP4 bytes suitable for recording.
	 *
	 * @internal Not part of the public API — may change without notice.
	 */
	["cmaf fragment"]: Readonly<CmafFragmentEvent>;
	["buffer state event"]: Readonly<BufferStateEvent>;
	["initialized media"]: void;
}

export {};