@hanifhan1f/vidstack 1.12.13

package/types/providers/google-cast/events.d.ts

@@ -0,0 +1,36 @@
+import type { DOMEvent } from 'maverick.js/std';
+import type { MediaPlayer } from '../../components/player';
+export interface GoogleCastEvents {
+    'google-cast-load-start': GoogleCastLoadStartEvent;
+    'google-cast-loaded': GoogleCastLoadedEvent;
+    'google-cast-prompt-open': GoogleCastPromptEvent;
+    'google-cast-prompt-close': GoogleCastPromptEvent;
+    'google-cast-prompt-error': GoogleCastPromptErrorEvent;
+}
+export interface GoogleCastEvent<DetailType = unknown> extends DOMEvent<DetailType> {
+    target: MediaPlayer;
+}
+/**
+ * Fired when the Google Cast framework starts loading.
+ */
+export interface GoogleCastLoadStartEvent extends GoogleCastEvent<void> {
+}
+/**
+ * Fired when the Google Cast framework has loaded.
+ */
+export interface GoogleCastLoadedEvent extends GoogleCastEvent<void> {
+}
+/**
+ * Fired when the Google Cast prompt is opened/closed.
+ */
+export interface GoogleCastPromptEvent extends GoogleCastEvent<void> {
+}
+export interface GoogleCastPromptError extends Error {
+    code: GoogleCastPromptErrorCode;
+}
+export type GoogleCastPromptErrorCode = 'CAST_NOT_AVAILABLE' | 'CANCEL' | 'TIMEOUT' | 'API_NOT_INITIALIZED' | 'INVALID_PARAMETER' | 'EXTENSION_NOT_COMPATIBLE' | 'EXTENSION_MISSING' | 'RECEIVER_UNAVAILABLE' | 'SESSION_ERROR' | 'CHANNEL_ERROR' | 'NO_DEVICES_AVAILABLE' | 'LOAD_MEDIA_FAILED';
+/**
+ * Fired when requesting Google Cast has failed.
+ */
+export interface GoogleCastPromptErrorEvent extends GoogleCastEvent<GoogleCastPromptError> {
+}

package/types/providers/google-cast/loader.d.ts

@@ -0,0 +1,18 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { Src } from '../../core/api/src-types';
+import type { MediaType } from '../../core/api/types';
+import type { MediaProviderLoader } from '../types';
+import type { GoogleCastProvider } from './provider';
+export declare class GoogleCastLoader implements MediaProviderLoader<GoogleCastProvider> {
+    #private;
+    readonly name = "google-cast";
+    target: HTMLElement;
+    /**
+     * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastContext}
+     */
+    get cast(): cast.framework.CastContext;
+    mediaType(): MediaType;
+    canPlay(src: Src): boolean;
+    prompt(ctx: MediaContext): Promise<void>;
+    load(ctx: MediaContext): Promise<GoogleCastProvider>;
+}

package/types/providers/google-cast/media-info.d.ts

@@ -0,0 +1,11 @@
+import type { Src } from '../../core/api/src-types';
+import type { MediaStreamType } from '../../core/api/types';
+import type { TextTrack } from '../../core/tracks/text/text-track';
+export declare class GoogleCastMediaInfoBuilder {
+    #private;
+    constructor(src: Src<string>);
+    build(): chrome.cast.media.MediaInfo;
+    setStreamType(streamType: MediaStreamType): this;
+    setTracks(tracks: TextTrack[]): this;
+    setMetadata(title: string, poster: string): this;
+}

package/types/providers/google-cast/provider.d.ts

@@ -0,0 +1,48 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { Src } from '../../core/api/src-types';
+import type { MediaProviderAdapter } from '../types';
+/**
+ * The Google Cast provider adds support for casting/streaming videos to Cast Receiver.
+ *
+ * @see {@link https://developers.google.com/cast/docs/overview}
+ * @docs {@link https://www.vidstack.io/docs/player/providers/google-cast}
+ */
+export declare class GoogleCastProvider implements MediaProviderAdapter {
+    #private;
+    protected $$PROVIDER_TYPE: string;
+    readonly scope: import("maverick.js").Scope;
+    constructor(player: cast.framework.RemotePlayer, ctx: MediaContext);
+    get type(): string;
+    get currentSrc(): Src<string> | null;
+    /**
+     * The Google Cast remote player.
+     *
+     * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.RemotePlayer}
+     */
+    get player(): cast.framework.RemotePlayer;
+    /**
+     * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastContext}
+     */
+    get cast(): cast.framework.CastContext;
+    /**
+     * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastSession}
+     */
+    get session(): cast.framework.CastSession | null;
+    /**
+     * @see {@link https://developers.google.com/cast/docs/reference/web_sender/chrome.cast.media.Media}
+     */
+    get media(): chrome.cast.media.Media | undefined;
+    /**
+     * Whether the current Google Cast session belongs to this provider.
+     */
+    get hasActiveSession(): boolean;
+    setup(): void;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    getMediaStatus(request: chrome.cast.media.GetStatusRequest): Promise<unknown>;
+    setMuted(muted: boolean): void;
+    setCurrentTime(time: number): void;
+    setVolume(volume: number): void;
+    loadSource(src: Src): Promise<void>;
+    destroy(): void;
+}

package/types/providers/google-cast/tracks.d.ts

@@ -0,0 +1,10 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { TextTrack } from '../../core/tracks/text/text-track';
+export declare class GoogleCastTracksManager {
+    #private;
+    constructor(cast: cast.framework.RemotePlayer, ctx: MediaContext, onNewLocalTracks?: () => void);
+    setup(): void;
+    getLocalTextTracks(): TextTrack[];
+    syncRemoteTracks(event?: Event): void;
+    syncRemoteActiveIds(event?: Event): void;
+}

package/types/providers/google-cast/types.d.ts

@@ -0,0 +1,3 @@
+export interface GoogleCastOptions extends Partial<cast.framework.CastOptions> {
+}
+export type { GoogleCastEvents } from './events';

package/types/providers/google-cast/utils.d.ts

@@ -0,0 +1,34 @@
+import type { Src } from '../../core/api/src-types';
+export declare function getCastFrameworkURL(): string;
+/**
+ * Whether the Google Cast framework has loaded.
+ */
+export declare function hasLoadedCastFramework(): boolean;
+/**
+ * Whether Google Cast is available on this platform.
+ */
+export declare function isCastAvailable(): boolean;
+/**
+ * Whether the cast sender is connected.
+ */
+export declare function isCastConnected(): boolean;
+/**
+ * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastContext}
+ */
+export declare function getCastContext(): cast.framework.CastContext;
+/**
+ * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastSession}
+ */
+export declare function getCastSession(): cast.framework.CastSession | null;
+/**
+ * @see {@link https://developers.google.com/cast/docs/reference/web_sender/chrome.cast.media.Media}
+ */
+export declare function getCastSessionMedia(): chrome.cast.media.Media | undefined;
+export declare function hasActiveCastSession(src: Src | undefined | null): boolean;
+/**
+ * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastOptions}
+ */
+export declare function getDefaultCastOptions(): cast.framework.CastOptions;
+export declare function getCastErrorMessage(code: chrome.cast.ErrorCode): string;
+export declare function listenCastContextEvent<T extends keyof cast.framework.CastContextEvents>(type: T, handler: (event: cast.framework.CastContextEvents[T]) => void): import("maverick.js").Dispose;
+export declare function listenCastSessionEvent<T extends keyof cast.framework.CastSessionEvents>(type: T, handler: (event: cast.framework.CastSessionEvents[T]) => void): import("maverick.js").Dispose;

package/types/providers/hls/events.d.ts

@@ -0,0 +1,463 @@
+import type * as HLS from 'hls.js';
+import type { DOMEvent } from 'maverick.js/std';
+import type { MediaPlayer } from '../../components/player';
+export interface HLSProviderEvents {
+    'hls-lib-load-start': HLSLibLoadStartEvent;
+    'hls-lib-loaded': HLSLibLoadedEvent;
+    'hls-lib-load-error': HLSLibLoadErrorEvent;
+    'hls-instance': HLSInstanceEvent;
+    'hls-unsupported': HLSUnsupportedEvent;
+    'hls-media-attaching': HLSMediaAttachingEvent;
+    'hls-media-attached': HLSMediaAttachedEvent;
+    'hls-media-detaching': HLSMediaDetachingEvent;
+    'hls-media-detached': HLSMediaDetachedEvent;
+    'hls-buffer-reset': HLSBufferResetEvent;
+    'hls-buffer-codecs': HLSBufferCodecsEvent;
+    'hls-buffer-created': HLSBufferCreatedEvent;
+    'hls-buffer-appending': HLSBufferAppendingEvent;
+    'hls-buffer-appended': HLSBufferAppendedEvent;
+    'hls-buffer-eos': HLSBufferEosEvent;
+    'hls-buffer-flushing': HLSBufferFlushingEvent;
+    'hls-buffer-flushed': HLSBufferFlushedEvent;
+    'hls-manifest-loading': HLSManifestLoadingEvent;
+    'hls-manifest-loaded': HLSManifestLoadedEvent;
+    'hls-manifest-parsed': HLSManifestParsedEvent;
+    'hls-level-switching': HLSLevelSwitchingEvent;
+    'hls-level-switched': HLSLevelSwitchedEvent;
+    'hls-level-loading': HLSLevelLoadingEvent;
+    'hls-level-loaded': HLSLevelLoadedEvent;
+    'hls-level-updated': HLSLevelUpdatedEvent;
+    'hls-level-pts-updated': HLSLevelPtsUpdatedEvent;
+    'hls-levels-updated': HLSLevelsUpdatedEvent;
+    'hls-audio-tracks-updated': HLSAudioTracksUpdatedEvent;
+    'hls-audio-track-switching': HLSAudioTrackSwitchingEvent;
+    'hls-audio-track-switched': HLSAudioTrackSwitchedEvent;
+    'hls-audio-track-loading': HLSAudioTrackLoadingEvent;
+    'hls-audio-track-loaded': HLSAudioTrackLoadedEvent;
+    'hls-subtitle-tracks-updated': HLSSubtitleTracksUpdatedEvent;
+    'hls-subtitle-tracks-cleared': HLSSubtitleTracksClearedEvent;
+    'hls-subtitle-track-switch': HLSSubtitleTrackSwitchEvent;
+    'hls-subtitle-track-loading': HLSSubtitleTrackLoadingEvent;
+    'hls-subtitle-track-loaded': HLSSubtitleTrackLoadedEvent;
+    'hls-subtitle-frag-processed': HLSSubtitleFragProcessedEvent;
+    'hls-cues-parsed': HLSCuesParsedEvent;
+    'hls-non-native-text-tracks-found': HLSNonNativeTextTracksFoundEvent;
+    'hls-init-pts-found': HLSInitPtsFoundEvent;
+    'hls-frag-loading': HLSFragLoadingEvent;
+    'hls-frag-load-emergency-aborted': HLSFragLoadEmergencyAbortedEvent;
+    'hls-frag-loaded': HLSFragLoadedEvent;
+    'hls-frag-decrypted': HLSFragDecryptedEvent;
+    'hls-frag-parsing-init-segment': HLSFragParsingInitSegmentEvent;
+    'hls-frag-parsing-userdata': HLSFragParsingUserdataEvent;
+    'hls-frag-parsing-metadata': HLSFragParsingMetadataEvent;
+    'hls-frag-parsed': HLSFragParsedEvent;
+    'hls-frag-buffered-data': HLSFragBufferedDataEvent;
+    'hls-frag-changed': HLSFragChangedEvent;
+    'hls-fps-drop': HLSFpsDropEvent;
+    'hls-fps-drop-level-capping': HLSFpsDropLevelCappingEvent;
+    'hls-error': HLSErrorEvent;
+    'hls-destroying': HLSDestroyingEvent;
+    'hls-key-loading': HLSKeyLoadingEvent;
+    'hls-key-loaded': HLSKeyLoadedEvent;
+    'hls-back-buffer-reached': HLSBackBufferReachedEvent;
+}
+export interface HLSMediaEvent<DetailType = unknown> extends DOMEvent<DetailType> {
+    target: MediaPlayer;
+}
+/**
+ * Fired when the browser begins downloading the `hls.js` library.
+ */
+export interface HLSLibLoadStartEvent extends HLSMediaEvent<void> {
+}
+/**
+ * Fired when the `hls.js` library has been loaded.
+ *
+ * @detail constructor
+ */
+export interface HLSLibLoadedEvent extends HLSMediaEvent<typeof HLS.default> {
+}
+/**
+ * Fired when the `hls.js` library fails during the download process.
+ *
+ * @detail error
+ */
+export interface HLSLibLoadErrorEvent extends HLSMediaEvent<Error> {
+}
+/**
+ * Fired when the `hls.js` instance is built. This will not fire if the browser does not
+ * support `hls.js`.
+ *
+ * @detail instance
+ */
+export interface HLSInstanceEvent extends HLSMediaEvent<HLS.default> {
+}
+/**
+ * Fired when the browser doesn't support HLS natively, _and_ `hls.js` doesn't support
+ * this environment either, most likely due to missing Media Extensions or video codecs.
+ */
+export interface HLSUnsupportedEvent extends HLSMediaEvent<void> {
+}
+/**
+ * Fired before `MediaSource` begins attaching to the media element.
+ *
+ * @detail data
+ */
+export interface HLSMediaAttachingEvent extends HLSMediaEvent<HLS.MediaAttachingData> {
+}
+/**
+ * Fired when `MediaSource` has been successfully attached to the media element.
+ *
+ * @detail data
+ */
+export interface HLSMediaAttachedEvent extends HLSMediaEvent<HLS.MediaAttachedData> {
+}
+/**
+ * Fired before detaching `MediaSource` from the media element.
+ */
+export interface HLSMediaDetachingEvent extends HLSMediaEvent<void> {
+}
+/**
+ * Fired when `MediaSource` has been detached from media element.
+ */
+export interface HLSMediaDetachedEvent extends HLSMediaEvent<void> {
+}
+/**
+ * Fired when we buffer is going to be reset.
+ */
+export interface HLSBufferResetEvent extends HLSMediaEvent<void> {
+}
+/**
+ * Fired when we know about the codecs that we need buffers for to push into.
+ *
+ * @detail data
+ */
+export interface HLSBufferCodecsEvent extends HLSMediaEvent<HLS.BufferCodecsData> {
+}
+/**
+ * Fired when `SourceBuffer`'s have been created.
+ *
+ * @detail data
+ */
+export interface HLSBufferCreatedEvent extends HLSMediaEvent<HLS.BufferCreatedData> {
+}
+/**
+ * Fired when we begin appending a media segment to the buffer.
+ *
+ * @detail data
+ */
+export interface HLSBufferAppendingEvent extends HLSMediaEvent<HLS.BufferAppendingData> {
+}
+/**
+ * Fired when we are done with appending a media segment to the buffer.
+ *
+ * @detail data
+ */
+export interface HLSBufferAppendedEvent extends HLSMediaEvent<HLS.BufferAppendedData> {
+}
+/**
+ * Fired when the stream is finished and we want to notify the media buffer that there will be no
+ * more data.
+ *
+ * @detail data
+ */
+export interface HLSBufferEosEvent extends HLSMediaEvent<HLS.BufferEOSData> {
+}
+/**
+ * Fired when the media buffer should be flushed.
+ *
+ * @detail data
+ */
+export interface HLSBufferFlushingEvent extends HLSMediaEvent<HLS.BufferFlushingData> {
+}
+/**
+ * Fired when the media buffer has been flushed.
+ *
+ * @detail data
+ */
+export interface HLSBufferFlushedEvent extends HLSMediaEvent<HLS.BufferFlushedData> {
+}
+/**
+ * Fired to signal that manifest loading is starting.
+ *
+ * @detail data
+ */
+export interface HLSManifestLoadingEvent extends HLSMediaEvent<HLS.ManifestLoadingData> {
+}
+/**
+ * Fired after the manifest has been loaded.
+ *
+ * @detail data
+ */
+export interface HLSManifestLoadedEvent extends HLSMediaEvent<HLS.ManifestLoadedData> {
+}
+/**
+ * Fired after manifest has been parsed.
+ *
+ * @detail data
+ */
+export interface HLSManifestParsedEvent extends HLSMediaEvent<HLS.ManifestParsedData> {
+}
+/**
+ * Fired when a level switch is requested.
+ *
+ * @detail data
+ */
+export interface HLSLevelSwitchingEvent extends HLSMediaEvent<HLS.LevelSwitchingData> {
+}
+/**
+ * Fired when a level switch is effective.
+ *
+ * @detail data
+ */
+export interface HLSLevelSwitchedEvent extends HLSMediaEvent<HLS.LevelSwitchedData> {
+}
+/**
+ * Fired when a level playlist loading starts.
+ *
+ * @detail data
+ */
+export interface HLSLevelLoadingEvent extends HLSMediaEvent<HLS.LevelLoadingData> {
+}
+/**
+ * Fired when a level playlist loading finishes.
+ *
+ * @detail data
+ */
+export interface HLSLevelLoadedEvent extends HLSMediaEvent<HLS.LevelLoadedData> {
+}
+/**
+ * Fired when a level's details have been updated based on previous details, after it has been
+ * loaded.
+ *
+ * @detail data
+ */
+export interface HLSLevelUpdatedEvent extends HLSMediaEvent<HLS.LevelUpdatedData> {
+}
+/**
+ * Fired when a level's PTS information has been updated after parsing a fragment.
+ *
+ * @detail data
+ */
+export interface HLSLevelPtsUpdatedEvent extends HLSMediaEvent<HLS.LevelPTSUpdatedData> {
+}
+/**
+ * Fired when a level is removed after calling `removeLevel()`.
+ *
+ * @detail data
+ */
+export interface HLSLevelsUpdatedEvent extends HLSMediaEvent<HLS.LevelsUpdatedData> {
+}
+/**
+ * Fired to notify that the audio track list has been updated.
+ *
+ * @detail data
+ */
+export interface HLSAudioTracksUpdatedEvent extends HLSMediaEvent<HLS.AudioTracksUpdatedData> {
+}
+/**
+ * Fired when an audio track switching is requested.
+ *
+ * @detail data
+ */
+export interface HLSAudioTrackSwitchingEvent extends HLSMediaEvent<HLS.AudioTrackSwitchingData> {
+}
+/**
+ * Fired when an audio track switch actually occurs.
+ *
+ * @detail data
+ */
+export interface HLSAudioTrackSwitchedEvent extends HLSMediaEvent<HLS.AudioTrackSwitchedData> {
+}
+/**
+ * Fired when loading an audio track starts.
+ *
+ * @detail data
+ */
+export interface HLSAudioTrackLoadingEvent extends HLSMediaEvent<HLS.TrackLoadingData> {
+}
+/**
+ * Fired when loading an audio track finishes.
+ *
+ * @detail data
+ */
+export interface HLSAudioTrackLoadedEvent extends HLSMediaEvent<HLS.AudioTrackLoadedData> {
+}
+/**
+ * Fired to notify that the subtitle track list has been updated.
+ *
+ * @detail data
+ */
+export interface HLSSubtitleTracksUpdatedEvent extends HLSMediaEvent<HLS.SubtitleTracksUpdatedData> {
+}
+/**
+ * Fired to notify that subtitle tracks were cleared as a result of stopping the media.
+ */
+export interface HLSSubtitleTracksClearedEvent extends HLSMediaEvent<void> {
+}
+/**
+ * Fired when a subtitle track switch occurs.
+ *
+ * @detail data
+ */
+export interface HLSSubtitleTrackSwitchEvent extends HLSMediaEvent<HLS.SubtitleTrackSwitchData> {
+}
+/**
+ * Fired when loading a subtitle track starts.
+ *
+ * @detail data
+ */
+export interface HLSSubtitleTrackLoadingEvent extends HLSMediaEvent<HLS.TrackLoadingData> {
+}
+/**
+ * Fired when loading a subtitle track finishes.
+ *
+ * @detail data
+ */
+export interface HLSSubtitleTrackLoadedEvent extends HLSMediaEvent<HLS.SubtitleTrackLoadedData> {
+}
+/**
+ * Fired when a subtitle fragment has been processed.
+ *
+ * @detail data
+ */
+export interface HLSSubtitleFragProcessedEvent extends HLSMediaEvent<HLS.SubtitleFragProcessedData> {
+}
+/**
+ * Fired when a set of `VTTCue`'s to be managed externally has been parsed.
+ *
+ * @detail data
+ */
+export interface HLSCuesParsedEvent extends HLSMediaEvent<HLS.CuesParsedData> {
+}
+/**
+ * Fired when a text track to be managed externally is found.
+ *
+ * @detail data
+ */
+export interface HLSNonNativeTextTracksFoundEvent extends HLSMediaEvent<HLS.NonNativeTextTracksData> {
+}
+/**
+ * Fired when the first timestamp is found.
+ *
+ * @detail data
+ */
+export interface HLSInitPtsFoundEvent extends HLSMediaEvent<HLS.InitPTSFoundData> {
+}
+/**
+ * Fired when loading a fragment starts.
+ *
+ * @detail data
+ */
+export interface HLSFragLoadingEvent extends HLSMediaEvent<HLS.FragLoadingData> {
+}
+/**
+ * Fired when fragment loading is aborted for emergency switch down.
+ *
+ * @detail data
+ */
+export interface HLSFragLoadEmergencyAbortedEvent extends HLSMediaEvent<HLS.FragLoadEmergencyAbortedData> {
+}
+/**
+ * Fired when fragment loading is completed.
+ *
+ * @detail data
+ */
+export interface HLSFragLoadedEvent extends HLSMediaEvent<HLS.FragLoadedData> {
+}
+/**
+ * Fired when a fragment has finished decrypting.
+ *
+ * @detail data
+ */
+export interface HLSFragDecryptedEvent extends HLSMediaEvent<HLS.FragDecryptedData> {
+}
+/**
+ * Fired when `InitSegment` has been extracted from a fragment.
+ *
+ * @detail data
+ */
+export interface HLSFragParsingInitSegmentEvent extends HLSMediaEvent<HLS.FragParsingInitSegmentData> {
+}
+/**
+ * Fired when parsing sei text is completed.
+ *
+ * @detail data
+ */
+export interface HLSFragParsingUserdataEvent extends HLSMediaEvent<HLS.FragParsingUserdataData> {
+}
+/**
+ * Fired when parsing id3 is completed.
+ *
+ * @detail data
+ */
+export interface HLSFragParsingMetadataEvent extends HLSMediaEvent<HLS.FragParsingMetadataData> {
+}
+/**
+ * Fired when fragment parsing is completed.
+ *
+ * @detail data
+ */
+export interface HLSFragParsedEvent extends HLSMediaEvent<HLS.FragParsedData> {
+}
+/**
+ * Fired when fragment remuxed MP4 boxes have all been appended into `SourceBuffer`.
+ *
+ * @detail data
+ */
+export interface HLSFragBufferedDataEvent extends HLSMediaEvent<HLS.FragBufferedData> {
+}
+/**
+ * Fired when fragment matching with current media position is changing.
+ *
+ * @detail data
+ */
+export interface HLSFragChangedEvent extends HLSMediaEvent<HLS.FragChangedData> {
+}
+/**
+ * Fired when a FPS drop is identified.
+ *
+ * @detail data
+ */
+export interface HLSFpsDropEvent extends HLSMediaEvent<HLS.FPSDropData> {
+}
+/**
+ * Fired when FPS drop triggers auto level capping.
+ *
+ * @detail data
+ */
+export interface HLSFpsDropLevelCappingEvent extends HLSMediaEvent<HLS.FPSDropLevelCappingData> {
+}
+/**
+ * Fired when an error has occurred during loading or playback.
+ *
+ * @detail data
+ */
+export interface HLSErrorEvent extends HLSMediaEvent<HLS.ErrorData> {
+}
+/**
+ * Fired when the `hls.js` instance is being destroyed. Different from `hls-media-detached` as
+ * one could want to detach, and reattach media to the `hls.js` instance to handle mid-rolls.
+ */
+export interface HLSDestroyingEvent extends HLSMediaEvent<void> {
+}
+/**
+ * Fired when a decrypt key loading starts.
+ *
+ * @detail data
+ */
+export interface HLSKeyLoadingEvent extends HLSMediaEvent<HLS.KeyLoadingData> {
+}
+/**
+ * Fired when a decrypt key has been loaded.
+ *
+ * @detail data
+ */
+export interface HLSKeyLoadedEvent extends HLSMediaEvent<HLS.KeyLoadedData> {
+}
+/**
+ * Fired when the back buffer is reached as defined by the `backBufferLength` config option.
+ *
+ * @detail data
+ */
+export interface HLSBackBufferReachedEvent extends HLSMediaEvent<HLS.BackBufferData> {
+}

package/types/providers/hls/hls.d.ts

@@ -0,0 +1,14 @@
+import type * as HLS from 'hls.js';
+import type { MediaContext } from '../../core/api/media-context';
+import type { Src } from '../../core/api/src-types';
+import type { HLSConstructor, HLSInstanceCallback } from './types';
+export declare class HLSController {
+    #private;
+    config: Partial<HLS.HlsConfig>;
+    get instance(): import("hls.js").default | null;
+    constructor(video: HTMLVideoElement, ctx: MediaContext);
+    setup(ctor: HLSConstructor): void;
+    onInstance(callback: HLSInstanceCallback): () => boolean;
+    loadSource(src: Src): void;
+    destroy(): void;
+}

package/types/providers/hls/lib-loader.d.ts

@@ -0,0 +1,6 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { HLSConstructor, HLSLibrary } from './types';
+export declare class HLSLibLoader {
+    #private;
+    constructor(lib: HLSLibrary, ctx: MediaContext, callback: (ctor: HLSConstructor) => void);
+}

package/types/providers/hls/loader.d.ts

@@ -0,0 +1,10 @@
+import type { Src } from '../../core/api/src-types';
+import type { MediaProviderLoader } from '../types';
+import { VideoProviderLoader } from '../video/loader';
+import type { HLSProvider } from './provider';
+export declare class HLSProviderLoader extends VideoProviderLoader implements MediaProviderLoader<HLSProvider> {
+    static supported: boolean;
+    readonly name = "hls";
+    canPlay(src: Src): boolean;
+    load(context: any): Promise<HLSProvider>;
+}