@flowplayer/player 3.14.1 → 3.15.0-rc.10

package/util/loader.d.ts

@@ -1,10 +1,31 @@
+/// <reference types="node" />
+
+import type { BitrateInfo } from 'dashjs';
 import type { MediaKeyFunc } from 'hls.js';
 
+/* Excluded from this release type: AnyLoader */
+
 declare type ArrayToIntersection<T extends Array<unknown>> = T extends [
 infer Current,
 ...infer Remaining
 ] ? Current & ArrayToIntersection<Remaining> : unknown;
 
+/**
+ * Each loader must
+ */
+declare type _AttachedEventCheck = {
+    on(event: `${string}:attached`, handler: (e: FPEvent<unknown>) => void): Player;
+};
+
+/* Excluded from this release type: AUDIO_ONLY_SOURCE */
+
+/* Excluded from this release type: AudioOnlySourceEventDetail */
+
+declare const AUTOPLAY = "is-autoplay";
+
+/**
+ * @public
+ */
 declare type Autoplay = BitOpts | boolean;
 
 declare enum AutoplayOpts {
@@ -13,19 +34,60 @@ declare enum AutoplayOpts {
     AUDIO_REQUIRED = 2
 }
 
-declare type BitOpts = number;
+/* Excluded from this release type: BEFORE_PAUSE */
 
-declare type Component = {
-    onrender?: (config: Config, root: PlayerRoot, player: Player) => void;
-    onremove?: (config: Config, root: PlayerRoot, player: Player) => void;
+/* Excluded from this release type: BEFORE_PLAY */
+
+/**
+ * @public
+ */
+declare type BeforePauseEventDetail = {
+    forced: boolean;
 };
 
-declare interface Components {
-    render(key: string, args: any[]): void;
-    remove(key: string, args: any[]): void;
-    put(key: string, args: Component): void;
-}
+/**
+ * @public
+ */
+declare type BeforePlayEventDetail = {
+    forced: boolean;
+};
+
+/**
+ * @public
+ */
+declare type BitOpts = number;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+CAN_PLAY = "canplay";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+CLICK = "click";
+
+/* Excluded from this release type: Component */
 
+/* Excluded from this release type: Components */
+
+/* Excluded from this release type: CONFIG */
+
+/**
+ * @public
+ */
 declare interface Config {
     src?: UnsafeSource;
     preload?: "none" | "metadata" | "auto";
@@ -35,7 +97,7 @@ declare interface Config {
     autopause?: boolean;
     rewind?: boolean;
     loop?: boolean;
-    seamless?: boolean;
+    /* Excluded from this release type: seamless */
     retry?: boolean;
     autoplay?: Autoplay;
     start_quality?: BitOpts;
@@ -43,10 +105,7 @@ declare interface Config {
     poster?: string;
     disabled?: boolean;
     muted?: boolean;
-    /**
-     * is src handled by one of plugins loaders
-     */
-    is_native?: boolean;
+    /* Excluded from this release type: is_native */
     /**
      * bitflags for UI options
      */
@@ -55,10 +114,7 @@ declare interface Config {
      * your user access token
      */
     token?: string;
-    /**
-     * manually configured duration for pre-rendering usually
-     */
-    duration?: number;
+    /* Excluded from this release type: duration */
     /**
      * can the content be seeked to any position
      */
@@ -76,18 +132,128 @@ declare interface Config {
     seconds_to_dvr?: number;
 }
 
+/* Excluded from this release type: ConfigEventDetail */
+
+/**
+ * @public
+ */
 declare type ConfigWith<T> = Config & T;
 
+/* Excluded from this release type: CONTENT_REAL_LOAD_START */
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+CONTEXT_MENU = "contextmenu";
+
+/**
+ * @public
+ */
+declare type ContextMenuEventDetail = null;
+
+/**
+ * @public
+ *  when a cuepoint becomes inactive
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ *  when a cuepoint becomes inactive
+ */
+CUEPOINT_END = "cuepointend";
+
+/**
+ * @public
+ * when a cuepoint is active
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * when a cuepoint is active
+ */
+CUEPOINT_START = "cuepointstart";
+
+/**
+ * @public
+ */
+declare type CuePointEndEventDetail = null;
+
+/**
+ * @public
+ * cuepoints parsing is asynchronous
+ * you cannot rely on them existing until
+ * this event is emitted
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * cuepoints parsing is asynchronous
+ * you cannot rely on them existing until
+ * this event is emitted
+ */
+CUEPOINTS = "cuepoints";
+
+/**
+ * @public
+ */
+declare type CuePointStartEventDetail = null;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+DATA = "loadeddata";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+DBL_CLICK = "dblclick";
+
 /**
- * adds support for asynchronous plugin loading`
+ * @public
+ * adds support for asynchronous plugin loading
  * issue/127
  */
-export declare function define<PluginOwnConfig extends KeyValue, PluginPlayerAPIExtension extends KeyValue = KeyValue, PublicAPI = unknown>(root: any, plugin: PluginCtor<NoInfer<PluginOwnConfig>, NoInfer<PluginPlayerAPIExtension>> & NoInfer<PublicAPI>): typeof plugin;
+export declare function define<PluginConfig extends Config = Config, PluginPlayer extends Player = Player, PublicAPI = unknown>(root: any, // TODO type this to PlayerRoot
+plugin: PluginCtor<NoInfer<PluginConfig>, NoInfer<PluginPlayer>> & NoInfer<PublicAPI>): typeof plugin;
+
+declare const DESTROYED = "is-destroyed";
+
+/* Excluded from this release type: DeviceId */
 
-declare type DeviceId = string;
+declare const DISABLED = "is-disabled";
 
+/**
+ * @public
+ */
 declare type DRM_KEYSYSTEM = "com.widevine.alpha" | "com.microsoft.playready" | "org.w3.clearkey" | "com.apple.fps.1_0";
 
+/**
+ * @public
+ */
 declare type DRMConfiguration = {
     license_server: string;
     http_headers?: Record<string, string>;
@@ -97,10 +263,16 @@ declare type DRMConfiguration = {
     query_params?: Record<string, string>;
 };
 
+/**
+ * @public
+ */
 declare type DRMSourceConfiguration = {
     [keysystem in DRM_KEYSYSTEM]?: DRMConfiguration;
 };
 
+/**
+ * @public
+ */
 declare type DRMVendorImplementation = {
     fairplay_fetch_certificate: (url: string, cb: (certificate_data: Uint8Array) => void) => void;
     fairplay_request_license: (url: string, params: {
@@ -109,41 +281,229 @@ declare type DRMVendorImplementation = {
     }, cb: (license_data: Uint8Array) => void) => void;
 };
 
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+DURATION_CHANGE = "durationchange";
+
+/**
+ * @public
+ * when the player has started playing dvr content
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * when the player has started playing dvr content
+ */
+DVR = "dvr";
+
+/**
+ * @public
+ */
+declare type DvrEventDetail = number;
+
+declare const ENDED = "is-ended";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+ENDED_2 = "ended";
+
+declare type EnsureOnAttached<P extends Function, T extends Player> = ExtractPureAPI<T> extends _AttachedEventCheck ? P : "Loaders must implement on('<pluginname>:attached') event";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+ERROR = "error";
+
+declare const ERRORED = "is-error";
+
+/**
+ * @public
+ */
+declare type ErrorEventDetail = {
+    src?: string;
+    type?: string;
+    code?: number | string;
+};
+
+/* Excluded from this release type: _ErrorEventDetail */
+
+declare namespace events {
+    export {
+        MOUNT,
+        ERROR,
+        CONTEXT_MENU,
+        CLICK,
+        DBL_CLICK,
+        KEYUP,
+        KEYDOWN,
+        LOAD,
+        MOUSE_ENTER,
+        MOUSE_LEAVE,
+        MOUSE_UP,
+        MOUSE_DOWN,
+        MOUSE_MOVE,
+        TOUCH_START,
+        TOUCH_MOVE,
+        TOUCH_END,
+        TOUCH_CANCEL,
+        RESIZE,
+        SCROLL,
+        FULLSCREEN_ENTER,
+        FULLSCREEN_EXIT,
+        FULLSCREEN_CHANGE,
+        METADATA,
+        DATA,
+        PROGRESS,
+        TIME_UPDATE,
+        LOAD_START,
+        VOLUME_CHANGE,
+        PAUSE,
+        PLAYING_2 as PLAYING,
+        PLAY,
+        WAITING_2 as WAITING,
+        CAN_PLAY,
+        ENDED_2 as ENDED,
+        SEEKED,
+        SEEKING_2 as SEEKING,
+        DURATION_CHANGE,
+        CUEPOINTS,
+        CUEPOINT_START,
+        CUEPOINT_END,
+        VIEW_ENTER,
+        VIEW_LEAVE,
+        SOURCE,
+        REAP,
+        QUALITIES,
+        VIDEO_TRACKS,
+        SET_QUALITY,
+        VIDEO_TRACK_SELECT,
+        RECOMMENDATIONS_READY,
+        LANDSCAPE,
+        PORTRAIT,
+        DVR,
+        LIVE_2 as LIVE
+    }
+}
+
+declare type ExtractPureAPI<T> = T extends PlayerWith<infer PureAPI> ? PureAPI : never;
+
+/**
+ * @public
+ */
 declare type FlowplayerCustomElementRegistry = Map<string, string>;
 
+/**
+ * @public
+ */
+declare type FlowplayerStates = typeof states;
+
+/**
+ * @public
+ */
 declare interface FlowplayerUMD extends FlowplayerUMDBase {
+    /**
+     * Configure flowplayer and display it in the UI
+     * @param selector - query selector of the HTML element where player will render
+     * @param config - configuration of flowplayer
+     */
     (selector: string, config?: Config): Player;
+    /**
+     * Configure flowplayer and display it in the UI
+     * @param element - HTML element where player will render
+     * @param config - configuration of flowplayer
+     */
     (element: HTMLElement, config?: Config): Player;
+    /**
+     * Configure flowplayer and display it in the UI
+     * @param selector - query selector of the HTML element where player will render
+     * @param config - configuration of flowplayer
+     */
     <T>(selector: string, config?: ConfigWith<T>): Player;
+    /**
+     * Configure flowplayer and display it in the UI
+     * @param element - HTML element where player will render
+     * @param config - configuration of flowplayer
+     */
     <T>(element: HTMLElement, config?: ConfigWith<T>): Player;
+    /**
+     * Register plugins in flowplayer
+     * @returns flowplayer instance with registered plugins
+     */
     <PluginCtors extends PluginCtor[]>(...plugins: PluginCtors): FlowplayerUMDWithPlugins<ConfigWith<MergeConfigs<PluginCtors>>, PlayerWith<MergePlayerAPIExtensions<PluginCtors>>>;
 }
 
 declare interface FlowplayerUMDBase {
+    /**
+     * All player instances on the page
+     */
     instances: Player[];
-    extensions: PluginCtor<KeyValue, any>[];
-    events: Record<string, string>;
-    ads?: {
-        events: Record<string, string>;
-    };
-    states: Record<string, string>;
+    /**
+     * Flowplayer core events
+     */
+    events: typeof events;
+    /**
+     * Flowplayer ui states map
+     */
+    states: FlowplayerStates;
     quality: typeof QualityOpts;
+    autoplay: typeof AutoplayOpts;
     commit: string;
     version: string;
+    /**
+     * Flowplayer's custom element registry
+     */
     customElements: FlowplayerCustomElementRegistry;
-    defaultElements: Record<string, string>;
-    components: Components;
-    support: any;
-    autoplay: typeof AutoplayOpts;
-    jwt: any;
-    loaders: any;
+    /* Excluded from this release type: extensions */
+    /* Excluded from this release type: defaultElements */
+    /* Excluded from this release type: components */
+    /* Excluded from this release type: support */
+    /* Excluded from this release type: jwt */
+    /* Excluded from this release type: loaders */
 }
 
-declare interface FlowplayerUMDWithPlugins<ConfigWithPlugins extends Config = Config, PluginPlayerAPIExtension extends Player = Player> extends FlowplayerUMDBase {
-    (selector: string, config?: ConfigWithPlugins): PluginPlayerAPIExtension;
-    (element: HTMLElement, config?: ConfigWithPlugins): PluginPlayerAPIExtension;
+/**
+ * @public
+ */
+declare interface FlowplayerUMDWithPlugins<ConfigWithPlugins extends Config = Config, PluginPlayer extends Player = Player> extends FlowplayerUMDBase {
+    /**
+     * Configure flowplayer, it's attached plugins and display flowplayer it in the UI
+     * @param selector - query selector of the HTML element where player will render
+     * @param config - Configuration of the flowplayer and the attached plugins
+     */
+    (selector: string, config?: ConfigWithPlugins): PluginPlayer;
+    /**
+     * Configure flowplayer, it's attached plugins and display flowplayer it in the UI
+     * @param element - HTML element where player will render
+     * @param config - Configuration of the flowplayer and the attached plugins
+     */
+    (element: HTMLElement, config?: ConfigWithPlugins): PluginPlayer;
 }
 
+/**
+ * @public
+ */
 declare interface FPEvent<T> extends CustomEvent<T> {
     /**
      * @deprecated
@@ -153,126 +513,1101 @@ declare interface FPEvent<T> extends CustomEvent<T> {
     data?: T;
 }
 
+declare const FULLSCREEN = "is-fullscreen";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+FULLSCREEN_CHANGE = "fullscreenchange";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+FULLSCREEN_ENTER = "fullscreenenter";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+FULLSCREEN_EXIT = "fullscreenexit";
+
+declare const GRABBING = "is-grabbing";
+
+declare const HAS_POSTER = "has-poster";
+
+declare const HOVERED = "is-hovered";
+
+declare const IN_VIEWPORT = "is-in-viewport";
+
+/* Excluded from this release type: INTERSECTIONCHANGE */
+
+/* Excluded from this release type: IntersectionChangeEventDetail */
+
+declare const IS_SOURCE_PROCESSING = "is-source-processing";
+
+/**
+ * @public
+ */
 export declare function isESM(): boolean;
 
 declare type JSONPlayer = any;
 
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+KEYDOWN = "keydown";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+KEYUP = "keyup";
+
+/**
+ * @public
+ */
 declare type KeyValue = Record<string, any>;
 
-declare interface Loader<PluginOwnConfig extends KeyValue = KeyValue, PluginPlayerAPIExtension extends KeyValue = KeyValue> extends Plugin_2<PluginOwnConfig, PluginPlayerAPIExtension> {
-    onload(config: ConfigWith<PluginOwnConfig>, root: PlayerRoot, video: PlayerWith<PluginPlayerAPIExtension>, src?: SourceObj): void;
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+LANDSCAPE = "landscape";
+
+declare const LIVE = "is-live";
+
+/**
+ * @public
+ * when src is a livestream
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * when src is a livestream
+ */
+LIVE_2 = "live";
+
+declare const LIVE_SEEKED = "is-live-seeked";
+
+/**
+ * @public
+ */
+declare type LiveEventDetail = null;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+LOAD = "load";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+LOAD_START = "loadstart";
+
+declare const LOADED = "is-loaded";
+
+/**
+ * @public A plugin that supports loading new media formats. Use 'class MyPlugin implements Loader\<...\>' when writing your custom Loader
+ * @typeParam PluginPlayer- Player API that will be implemented by the loader. Loader at least must implement on(\<loader-name\>:attached, ...) event handler
+ */
+declare interface Loader<PluginOwnConfig extends KeyValue, // FIXME extends Config
+PluginPlayer extends PlayerWith<_AttachedEventCheck>> extends Plugin_2<PluginOwnConfig, PluginPlayer> {
+    onload: EnsureOnAttached<(config: ConfigWith<PluginOwnConfig>, root: PlayerRoot, video: PlayerWith<PluginPlayer>, src: SourceObj) => void, PluginPlayer>;
     wants<S = SourceObj>(srcString: SourceStr, srcObj: S, config: ConfigWith<PluginOwnConfig>): boolean;
     wants<S = KeyValue>(srcString: SourceStr, srcObj: SourceWith<S>, config: ConfigWith<PluginOwnConfig>): boolean;
 }
 
+declare const LOADING = "is-loading";
+
 declare type MapToConfigs<Arr extends PluginCtor[]> = {
-    [PluginType in keyof Arr]: Arr[PluginType] extends PluginCtor<infer ConfigType> ? ConfigType : never;
+    [PluginType in keyof Arr]: Arr[PluginType] extends PluginCtor<ConfigWith<infer ConfigType>> ? ConfigType : never;
 };
 
 declare type MapToPlayerApiExtensions<Arr extends PluginCtor[]> = {
-    [PluginType in keyof Arr]: Arr[PluginType] extends PluginCtor<infer _uConfigType, infer PlayerAPIExtension> ? PlayerAPIExtension : never;
+    [PluginType in keyof Arr]: Arr[PluginType] extends PluginCtor<infer _uConfigType, PlayerWith<infer PlayerAPIExtension>> ? PlayerAPIExtension : never;
 };
 
+declare const MENU_OPENED = "has-menu-opened";
+
 declare type MergeConfigs<Arr extends PluginCtor[]> = ArrayToIntersection<MapToConfigs<Arr>>;
 
 declare type MergePlayerAPIExtensions<Arr extends PluginCtor[]> = ArrayToIntersection<MapToPlayerApiExtensions<Arr>>;
 
+/**
+ * @public
+ * general video events flowplayer uses internally
+ *  https://developer.mozilla.org/en-US/docs/Web/Guide/Events/Media_events
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * general video events flowplayer uses internally
+ *  https://developer.mozilla.org/en-US/docs/Web/Guide/Events/Media_events
+ */
+METADATA = "loadedmetadata";
+
+/**
+ * @public
+ */
 export declare function modules(): any;
 
-declare type NoInfer<T> = [T][T extends any ? 0 : never];
+/**
+ @public
+ * when a new player is inserted into the HTML
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ @public
+ * when a new player is inserted into the HTML
+ */ MOUNT = "mount";
 
-declare interface Player extends HTMLVideoElement {
-    renderPlugin: (pluginContainer: HTMLElement) => void;
-    toggleDisable: (flag: boolean) => void;
-    original_src: string;
-    root: PlayerRoot;
-    playerState: Record<string, boolean>;
-    reaper: Map<string, any> | 0;
-    hasState(state: PlayerState): boolean;
-    transitionState(to: PlayerState, from: PlayerState, timer?: number): void;
-    togglePlay(on?: boolean): Promise<void>;
-    toggleFullScreen(on?: boolean, state_only?: boolean): void;
-    toggleMute(on?: boolean): void;
-    destroy(): void;
-    render(): void;
-    render(component: string, args: any[]): void;
-    createComponents(...args: string[]): HTMLElement[];
-    setOpts(config: Config): void;
-    setSrc(sources: UnsafeSource): Player;
-    on<T>(event: string | string[], handler: (e: FPEvent<T>) => void): Player;
-    once<T>(event: string, handler: (e: FPEvent<T>) => void): Player;
-    off<T>(event: string, handler: (e: FPEvent<T>) => void): Player;
-    poll<T>(event: string, data?: T): FPEvent<T>;
-    emit<T>(event: string, data?: T): Player;
-    setAttrs(attrs: Config): Player;
-    opt<T>(key: string, fallback?: T): T;
-    enqueueSeek(offset: number): any;
-    setState(state: string, flag: boolean): Player;
-    toJSON(): JSONPlayer;
-    i18n(k: string, fallback?: string): string;
-    deviceId(): DeviceId;
-    live_state: {
-        dvr?: boolean;
-        dvr_window?: number;
-    };
-    opts: Config;
-    plugins: Array<Plugin_2 | Loader>;
-    dvr_offset?: number;
-    message?: {
-        events: Record<string, string>;
-    };
-    disabled: boolean;
-    started?: boolean;
-    token: string;
-    tracks?: VideoTrack[];
-    _customElements: FlowplayerCustomElementRegistry;
-    _storage: Storage;
-}
+/**
+ * @public
+ */
+declare type MountEventDetail = null;
 
-declare type PlayerRoot = HTMLElement & {
-    prevWidth?: number;
-};
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+MOUSE_DOWN = "mousedown";
 
-declare type PlayerState = string;
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+MOUSE_ENTER = "mouseenter";
 
-declare type PlayerWith<T> = T & Player;
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+MOUSE_LEAVE = "mouseleave";
 
-declare interface Plugin_2<PluginOwnConfig extends KeyValue = KeyValue, PluginPlayerAPIExtension extends KeyValue = KeyValue> {
-    /**
-     * a plugin must always implement the init method so a player instance knows how to initialize it
-     */
-    init(config: ConfigWith<PluginOwnConfig>, container: PlayerRoot, player: PlayerWith<PluginPlayerAPIExtension>): void;
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+MOUSE_MOVE = "mousemove";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+MOUSE_UP = "mouseup";
+
+declare const MUTED = "is-muted";
+
+declare const NO_CONTROLS = "no-controls";
+
+declare const NO_DVR = "no-timeline";
+
+declare type NoInfer<T> = [T][T extends any ? 0 : never];
+
+/* Excluded from this release type: NON_RECOVERABLE_ERROR */
+
+/* Excluded from this release type: NonRecoverableErrorEventDetail */
+
+/* Excluded from this release type: NQState */
+
+/**
+ * @public
+ */
+declare type OVPMetadata = {
+    player_id?: string;
+    media_id?: string;
+    ad_keywords?: string;
+    title?: string;
+    description?: string;
+    category_name?: string;
+    duration?: number;
+    tags?: string;
+};
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+PAUSE = "pause";
+
+declare const PAUSED = "is-paused";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+PLAY = "play";
+
+/**
+ * @public
+ */
+declare type Player = HTMLVideoElement & PlayerEventOverloads & {
+    /* Excluded from this release type: renderPlugin */
+    /**
+     * Disables and enables the player.
+     * @param flag -Forces disabled mode (true) or enabled mode (false). Disabled player cannot be seeked forward.
+     */
+    toggleDisable: (flag?: boolean) => void;
+    /* Excluded from this release type: original_src */
+    /**
+     * The root element of the video player. This is the immediate parent element of the video tag.
+     */
+    root: PlayerRoot;
+    /* Excluded from this release type: playerState */
+    /* Excluded from this release type: reaper */
+    /* Excluded from this release type: hasState */
+    /* Excluded from this release type: transitionState */
+    /**
+     * Toggles between playing and paused mode.
+     * @param on - Forces the playback (true) or paused state (false). Use this for initial playback of a source configured with setSrc() and when changing the state.
+     */
+    togglePlay(on?: boolean): Promise<void>;
+    /* Excluded from this release type: toggleFullScreen */
+    /**
+     * @public
+     * Toggles between normal and fullscreen mode. The optional flag attribute forces the normal sized (false) or fullscreen (false) mode.
+     * The custom fullscreenenter and fullscreenexit events are sent respectively.
+     */
+    toggleFullScreen(on?: boolean): void;
+    /* Excluded from this release type: toggleMute */
+    /**
+     * Toggles between muted and original volume level.
+     */
+    toggleMute(): void;
+    /**
+     * Removes a Flowplayer instance from `flowplayer.instances` and emits the `flowplayer.events.REAP` event, enabling cleanup of unsafe resources.
+     */
+    destroy(): void;
+    /* Excluded from this release type: render */
+    /* Excluded from this release type: render */
+    createComponents(...args: string[]): HTMLElement[];
+    /**
+     * Adds or changes configuration object. Usually used in conjunction with `setSrc()`. You can use all top-level config options like `subtitle:` , `logo:`, `ima:` etc.
+     * @example
+     * ```
+     * setOpts({
+     *   subtitles:{
+     *      tracks:[
+     *        {
+     *          src: "1.vtt",
+     *          label: "English",
+     *          default: true
+     *        }, {
+     *          src: "2.vtt",
+     *          label: "Spanish",
+     *           default : false }]},
+     *    logo: "https://myserver.com/logo.png"
+     * })
+     * ```
+     */
+    setOpts(config: Config): void;
+    /**
+     * Sets the video source to be played. The src attribute can be a string or an object similar to the src property.
+     */
+    setSrc(sources: UnsafeSource): void;
+    /* Excluded from this release type: setSrc */
+    /* Excluded from this release type: setAttrs */
+    /* Excluded from this release type: opt */
+    /* Excluded from this release type: enqueueSeek */
+    /* Excluded from this release type: setState */
+    setState(state: PlayerState, flag: boolean): void;
+    /* Excluded from this release type: toJSON */
+    /**
+     * Adds a language to the project. See {@link https://developer.wowza.com/docs/wowza-flowplayer/player/translations/#using-npm| Official documentation}
+     */
+    i18n(k: string, fallback?: string): string;
+    /* Excluded from this release type: deviceId */
+    /* Excluded from this release type: live_state */
+    /**
+     * A reference to the configuration state of the player.
+     */
+    opts: Config;
+    /* Excluded from this release type: plugins */
+    /* Excluded from this release type: dvr_offset */
+    message?: {
+        events: Record<string, string>;
+    };
+    /**
+     * A boolean specifying whether the player is disabled and the user cannot seek forward using the mouse or keyboard.
+     * Player is disabled and enabled with the `toggleDisable()` method.
+     */
+    disabled: boolean;
+    /* Excluded from this release type: started */
+    /* Excluded from this release type: token */
+    tracks?: VideoTrack[];
+    /* Excluded from this release type: _customElements */
+    /* Excluded from this release type: _storage */
+};
+
+declare type PlayerCustomEventName = keyof PlayerCustomEventsDetailMap;
+
+declare type PlayerCustomEventsDetailMap = {
+    [MOUNT]: MountEventDetail;
+    [ERROR]: ErrorEventDetail;
+    [CONTEXT_MENU]: ContextMenuEventDetail;
+    /* Excluded from this release type: beforeplay */
+    /* Excluded from this release type: beforepause */
+    /* Excluded from this release type: state */
+    [CUEPOINT_START]: CuePointStartEventDetail;
+    [CUEPOINT_END]: CuePointEndEventDetail;
+    [VIEW_ENTER]: ViewEnterEventDetail;
+    [VIEW_LEAVE]: ViewLeaveEventDetail;
+    [SOURCE]: SourceEventDetail;
+    /* Excluded from this release type: recover */
+    [REAP]: ReapEventDetail;
+    /* Excluded from this release type: config */
+    [QUALITIES]: QualitiesEventDetail;
+    /* Excluded from this release type: "error:fatal" */
+    [RECOMMENDATIONS_READY]: RecommendationsReadyEventDetail;
+    /* Excluded from this release type: audioonlysource */
+    /* Excluded from this release type: renderplugin */
+    [DVR]: DvrEventDetail;
+    [LIVE_2]: LiveEventDetail;
+    /* Excluded from this release type: "seek:queued" */
+    /* Excluded from this release type: "seek:cancel" */
+    /* Excluded from this release type: "plugin:registered" */
+    /* Excluded from this release type: intersectionchange */
+    /* Excluded from this release type: retry */
+};
+
+declare type PlayerCustomEventsOverloads = {
+    /**
+     * Sent when the player interface is completely rendered and you can access all the elements with CSS and JavaScript. Due to the way mounting works, this event is only accessible inside of a custom extension.
+     */
+    on(event: typeof MOUNT, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof MOUNT]>) => void): Player;
+    /**
+     * Sent when an error occurs. Learn more about error handling.
+     */
+    on(event: typeof ERROR, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof ERROR]>) => void): Player;
+    on(// FIXME - this event is in context-menu plugin
+    event: typeof CONTEXT_MENU, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof CONTEXT_MENU]>) => void): Player;
+    /* Excluded from this release type: on */
+    /* Excluded from this release type: on */
+    /* Excluded from this release type: on */
+    /**
+     * TODO - move to Cuepoints? Sent when a configured cuepoint is entered.
+     */
+    on(event: typeof CUEPOINT_START, // TODO: move to Cuepoints
+    handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof CUEPOINT_START]>) => void): Player;
+    /**
+     * Sent when a configured cuepoint is terminated.
+     */
+    on(event: typeof CUEPOINT_END, // TODO: move to Cuepoints
+    handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof CUEPOINT_END]>) => void): Player;
+    /**
+     * Sent when the player becomes visible for the user.
+     */
+    on(event: typeof VIEW_ENTER, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof VIEW_ENTER]>) => void): Player;
+    /**
+     * Sent when the player leaves the users viewport and is longer visible.
+     */
+    on(event: typeof VIEW_LEAVE, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof VIEW_LEAVE]>) => void): Player;
+    /**
+     * Sent right before the player src attribute is set. This allows you to change the video URL before playback.
+     */
+    on(event: typeof SOURCE, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof SOURCE]>) => void): Player;
+    /* Excluded from this release type: on */
+    /**
+     * Sent when a flowplayer instance is about to be removed from the DOM, and any unsafe references are about to be reaped, which allows Single Page Applications to perform the necessary resource cleanups. This is important when working with front-end frameworks like React. This event should never be emitted directly, only listened to.
+     */
+    on(event: typeof REAP, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof REAP]>) => void): Player;
+    /* Excluded from this release type: on */
+    /**
+     * Emitted when the set of underlying qualities has changed.
+     */
+    on(event: typeof QUALITIES, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof QUALITIES]>) => void): Player;
+    /* Excluded from this release type: on */
+    /**
+     * Listen to this event to create a recommendations grid using the data passed with the event.
+     */
+    on(event: typeof RECOMMENDATIONS_READY, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof RECOMMENDATIONS_READY]>) => void): Player;
+    /* Excluded from this release type: on */
+    /* Excluded from this release type: on */
+    /**
+     * when the player has started playing dvr content
+     */
+    on(event: typeof DVR, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof DVR]>) => void): Player;
+    /**
+     * when src is a livestream
+     */
+    on(event: typeof LIVE_2, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof LIVE_2]>) => void): Player;
+    /* Excluded from this release type: on */
+    /* Excluded from this release type: on */
+    /* Excluded from this release type: on */
+    /* Excluded from this release type: on */
+    /* Excluded from this release type: on */
+    on<T>(event: string, handler: (e: FPEvent<T>) => void): Player;
+    /* Excluded from this release type: on */
+    /**
+     * Same as `on()`, but the handler function is executed only once.
+     */
+    once<T extends PlayerCustomEventName>(event: T, handler: (e: FPEvent<PlayerCustomEventsDetailMap[T]>) => void): Player;
+    /**
+     * Same as `on()`, but the handler function is executed only once.
+     */
+    once<T extends PlayerNativeEventName>(event: T, handler: (e: PlayerNativeEventsDetailMap[T]) => void): Player;
+    once<T>(event: string, handler: (e: FPEvent<T>) => void): Player;
+    /**
+     * Removes the event handler with the specified event type.
+     */
+    off<T extends PlayerCustomEventName>(event: T, handler: (e: FPEvent<PlayerCustomEventsDetailMap[T]>) => void): Player;
+    /**
+     * Removes the event handler with the specified event type.
+     */
+    off<T extends PlayerNativeEventName>(event: T, handler: (e: PlayerNativeEventsDetailMap[T]) => void): Player;
+    /**
+     * Removes the event handler with the specified event type.
+     */
+    off<T>(event: string, handler: (e: FPEvent<T>) => void): Player;
+    /* Excluded from this release type: poll */
+    emit<T extends PlayerCustomEventName>(event: T, data?: PlayerCustomEventsDetailMap[T]): Player;
+    /* Excluded from this release type: emit */
+    emit<T, X extends string = string>(event: X & (X extends PlayerCustomEventName ? "Incorrect event detail type" : X), data?: T): Player;
+};
+
+declare type PlayerEventOverloads = PlayerNativeEventsOverloads & PlayerCustomEventsOverloads;
+
+declare type PlayerNativeEventName = keyof PlayerNativeEventsDetailMap;
+
+declare type PlayerNativeEventsDetailMap = Omit<HTMLVideoElementEventMap, "error">;
+
+declare type PlayerNativeEventsOverloads = {
+    on<K extends keyof PlayerNativeEventsDetailMap>(event: K, handler: (ev: PlayerNativeEventsDetailMap[K]) => void): Player;
+};
+
+/**
+ * @public
+ * The root element of the video player. This is the immediate parent element of the video tag.
+ */
+declare type PlayerRoot = HTMLElement & {
+    /* Excluded from this release type: prevWidth */
+};
+
+/**
+ * @public
+ */
+declare type PlayerState = FlowplayerStates[keyof FlowplayerStates];
+
+/* Excluded from this release type: _PlayerState */
+
+/* Excluded from this release type: PlayerStates */
+
+/**
+ * @public
+ */
+declare type PlayerWith<T> = T & Player;
+
+declare const PLAYING = "is-playing";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+PLAYING_2 = "playing";
+
+/**
+ * @public
+ */
+declare interface Plugin_2<PluginConfig extends Config = Config, PluginPlayer extends Player = Player> {
+    /**
+     * a plugin must always implement the init method so a player instance knows how to initialize it
+     */
+    init(config: PluginConfig, container: PlayerRoot, player: PluginPlayer): void;
 }
 
-declare interface PluginCtor<PluginOwnConfig extends KeyValue = KeyValue, PluginPlayerAPIExtension extends KeyValue = KeyValue> {
-    new (umd: FlowplayerUMD, player: PlayerWith<PluginPlayerAPIExtension>): Plugin_2<PluginOwnConfig, PluginPlayerAPIExtension>;
+/* Excluded from this release type: PLUGIN_REGISTERED */
+
+/**
+ * @public
+ */
+declare interface PluginCtor<PluginConfig extends Config = Config, PluginPlayer extends Player = Player> {
+    new (umd: FlowplayerUMD, player: PluginPlayer): Plugin_2<PluginConfig, PluginPlayer>;
 }
 
+/* Excluded from this release type: PluginRegisteredEventDetail */
+
+declare type PluginStates = string;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+PORTRAIT = "portrait";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+PROGRESS = "progress";
+
+/**
+ * @public
+ * emitted whenever a list of qualities has been made available
+ *  when index 0 is the highest quality and index 0+N is the lowest
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * emitted whenever a list of qualities has been made available
+ *  when index 0 is the highest quality and index 0+N is the lowest
+ */
+QUALITIES = "qualities";
+
+/**
+ * @public
+ */
+declare type QualitiesEventDetail = QualityDetail[];
+
+/**
+ * @public
+ */
+declare type QualityDetail = {
+    level: number;
+    text: string;
+    width: number;
+    height: number;
+    videoCodec: string;
+} | BitrateInfo | {
+    text: string | number;
+    encodingId: string;
+    spatialLayerId: number;
+    temporalLayerId: number;
+    maxSpatialLayerId: number;
+    maxTemporalLayerId: number;
+    height: number;
+    width: number;
+};
+
 declare enum QualityOpts {
     LOW = 1,
     MEDIUM = 2,
     HIGH = 4
 }
 
+/**
+ * @public
+ * emitted when it is safe to clean up a fp instance
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * emitted when it is safe to clean up a fp instance
+ */
+REAP = "reap";
+
+/**
+ * @public
+ */
+declare type ReapEventDetail = null;
+
+/**
+ * @public
+ */
+declare type RecommendationItem = {
+    poster?: string;
+    src?: UnsafeSource;
+    title?: string;
+    description?: string;
+    metadata: OVPMetadata;
+    chapters?: {
+        src: string;
+    };
+    thumbnails?: {
+        src: string;
+    };
+    subtitles?: string[];
+};
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @deprecated please use Endscreen.events.RECOMMENDATIONS_READY / flowplayer.endscreen.events.RECOMMENDATIONS_READY
+ **/
+/**
+ * @public
+ */
+RECOMMENDATIONS_READY = "recommendationsready";
+
+/**
+ * @public
+ */
+declare type RecommendationsReadyEventDetail = {
+    playlist: RecommendationItem[];
+};
+
+/* Excluded from this release type: RECOVER */
+
+/* Excluded from this release type: RecoverEventDetail */
+
+/* Excluded from this release type: REMOTE_SESSION_ENDED */
+
+/* Excluded from this release type: REMOTE_SESSION_STARTED */
+
+/* Excluded from this release type: RENDER_PLUGIN */
+
+/**
+ * @public
+ */
+declare type RenderPluginEventDetail = HTMLElement;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+RESIZE = "resize";
+
+/* Excluded from this release type: RETRY */
+
+/* Excluded from this release type: RetryEventDetail */
+
+/**
+ * @public
+ */
 export declare function root(): {};
 
+declare const RTL = "is-rtl";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+SCROLL = "scroll";
+
+declare const SEAMLESS = "is-seamless";
+
+/* Excluded from this release type: SEEK_CANCEL */
+
+/* Excluded from this release type: SEEK_QUEUED */
+
+declare const SEEKABLE = "is-seekable";
+
+/* Excluded from this release type: SeekCancelEventDetail */
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+SEEKED = "seeked";
+
+declare const SEEKING = "is-seeking";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+SEEKING_2 = "seeking";
+
+/* Excluded from this release type: SeekQueuedEventDetail */
+
+/**
+ * @public
+ *  allows plugins to listen for forced quality changes
+ * it should emit the index of the quality to set
+ * -1 is a special idx saying to use ABR if the plugin
+ * exposes an ABR implementation
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ *  allows plugins to listen for forced quality changes
+ * it should emit the index of the quality to set
+ * -1 is a special idx saying to use ABR if the plugin
+ * exposes an ABR implementation
+ */
+SET_QUALITY = "quality:set";
+
+declare const SMALL = "is-small";
+
+/**
+ * @public
+ * emitted when a valid source is found prior to mounting
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * emitted when a valid source is found prior to mounting
+ */
+SOURCE = "src";
+
+/**
+ * @public
+ */
+declare type SourceEventDetail = SourceObj;
+
+/**
+ * @public
+ */
 declare type SourceObj = {
     src?: SourceStr;
+    /**
+     *  the MIME type (example `video/mp4` or `application/x-mpegurl`)
+     */
     type?: string;
     drm?: DRMSourceConfiguration;
 };
 
+/**
+ * @public
+ */
 declare type SourceStr = string;
 
+/**
+ * @public
+ */
 declare type SourceWith<T> = SourceObj & T;
 
+declare const STARTING = "is-starting";
+
+/* Excluded from this release type: STATE */
+
+/* Excluded from this release type: StateEventDetail */
+
+declare namespace states {
+    export {
+        PLAYING,
+        FULLSCREEN,
+        PAUSED,
+        MUTED,
+        LOADED,
+        LOADING,
+        STARTING,
+        SEEKING,
+        GRABBING,
+        DISABLED,
+        SMALL,
+        TINY,
+        RTL,
+        TV,
+        ENDED,
+        LIVE,
+        ERRORED,
+        WAITING,
+        AUTOPLAY,
+        SEAMLESS,
+        TOGGLING,
+        LIVE_SEEKED,
+        NO_DVR,
+        HAS_POSTER,
+        WILL_PLAY,
+        WILL_PAUSE,
+        MENU_OPENED,
+        TOUCHED,
+        HOVERED,
+        TOUCH_DEVICE,
+        WILL_SEEK,
+        SEEKABLE,
+        IN_VIEWPORT,
+        NO_CONTROLS,
+        DESTROYED,
+        IS_SOURCE_PROCESSING
+    }
+}
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+TIME_UPDATE = "timeupdate";
+
+declare const TINY = "is-tiny";
+
+declare const TOGGLING = "is-toggling";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+TOUCH_CANCEL = "touchcancel";
+
+declare const TOUCH_DEVICE = "is-touch-device";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+TOUCH_END = "touchend";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+TOUCH_MOVE = "touchmove";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+TOUCH_START = "touchstart";
+
+declare const TOUCHED = "is-touched";
+
+declare const TV = "is-tv";
+
+/**
+ * @public
+ */
 declare type UnsafeSource = SourceStr | SourceObj | Array<SourceStr | SourceObj>;
 
+/**
+ * @public
+ * emitted when a video track is selected
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * emitted when a video track is selected
+ */
+VIDEO_TRACK_SELECT = "tracks:video:select";
+
+/**
+ * @public
+ * emitted whenever multiple video tracks are detected
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * emitted whenever multiple video tracks are detected
+ */
+VIDEO_TRACKS = "videoTracks";
+
+/**
+ * @public
+ */
 declare interface VideoTrack {
     name: string;
-    data: any;
+    /* Excluded from this release type: data */
     default: boolean;
     selected: boolean;
 }
 
+/**
+ * @public
+ * when a player enters the viewpoint
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * when a player enters the viewpoint
+ */
+VIEW_ENTER = "viewenter";
+
+/**
+ * @public
+ * when a player leaves the viewport
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * when a player leaves the viewport
+ */
+VIEW_LEAVE = "viewleave";
+
+/**
+ * @public
+ */
+declare type ViewEnterEventDetail = null;
+
+/**
+ * @public
+ */
+declare type ViewLeaveEventDetail = null;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+VOLUME_CHANGE = "volumechange";
+
+declare const WAITING = "is-waiting";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+WAITING_2 = "waiting";
+
+/* Excluded from this release type: WEBKIT_NEEDKEY */
+
+declare const WILL_PAUSE = "will-pause";
+
+declare const WILL_PLAY = "will-play";
+
+declare const WILL_SEEK = "will-seek";
+
 export { }