@flowplayer/player 3.14.1 → 3.15.0-rc.10

package/index.d.ts

@@ -1,11 +1,31 @@
-import type { Level } from 'hls.js';
+/// <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
+ */
 export declare type Autoplay = BitOpts | boolean;
 
 declare enum AutoplayOpts {
@@ -14,19 +34,65 @@ 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
+ */
+export 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
+ */
+export 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";
+
+/**
+ * @public
+ */
+export declare type ClickEventDetail = PointerEvent;
+
+/* Excluded from this release type: Component */
+
+/* Excluded from this release type: Components */
+
+/* Excluded from this release type: CONFIG */
 
+/**
+ * @public
+ */
 export declare interface Config {
     src?: UnsafeSource;
     preload?: "none" | "metadata" | "auto";
@@ -36,7 +102,7 @@ export declare interface Config {
     autopause?: boolean;
     rewind?: boolean;
     loop?: boolean;
-    seamless?: boolean;
+    /* Excluded from this release type: seamless */
     retry?: boolean;
     autoplay?: Autoplay;
     start_quality?: BitOpts;
@@ -44,10 +110,7 @@ export 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
      */
@@ -56,10 +119,7 @@ export 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
      */
@@ -77,19 +137,128 @@ export declare interface Config {
     seconds_to_dvr?: number;
 }
 
+/* Excluded from this release type: ConfigEventDetail */
+
+/**
+ * @public
+ */
 export declare type ConfigWith<T> = Config & T;
 
-export declare type DashQualityChange = {
-    kind: "dash";
-};
+/* 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
+ */
+export 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
+ */
+export 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
+ */
+export 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";
+
+/**
+ * @public
+ */
+export declare type DblClickEventDetail = PointerEvent;
 
 declare const _default: FlowplayerUMD;
 export default _default;
 
-declare type DeviceId = string;
+declare const DESTROYED = "is-destroyed";
+
+/* Excluded from this release type: DeviceId */
 
-declare type DRM_KEYSYSTEM = "com.widevine.alpha" | "com.microsoft.playready" | "org.w3.clearkey" | "com.apple.fps.1_0";
+declare const DISABLED = "is-disabled";
 
+/**
+ * @public
+ */
+export declare type DRM_KEYSYSTEM = "com.widevine.alpha" | "com.microsoft.playready" | "org.w3.clearkey" | "com.apple.fps.1_0";
+
+/**
+ * @public
+ */
 export declare type DRMConfiguration = {
     license_server: string;
     http_headers?: Record<string, string>;
@@ -99,10 +268,16 @@ export declare type DRMConfiguration = {
     query_params?: Record<string, string>;
 };
 
+/**
+ * @public
+ */
 export declare type DRMSourceConfiguration = {
     [keysystem in DRM_KEYSYSTEM]?: DRMConfiguration;
 };
 
+/**
+ * @public
+ */
 export declare type DRMVendorImplementation = {
     fairplay_fetch_certificate: (url: string, cb: (certificate_data: Uint8Array) => void) => void;
     fairplay_request_license: (url: string, params: {
@@ -111,41 +286,229 @@ export 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
+ */
+export 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
+ */
+export 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
+ */
 export declare type FlowplayerCustomElementRegistry = Map<string, string>;
 
+/**
+ * @public
+ */
+export declare type FlowplayerStates = typeof states;
+
+/**
+ * @public
+ */
 export 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 */
 }
 
-export declare interface FlowplayerUMDWithPlugins<ConfigWithPlugins extends Config = Config, PluginPlayerAPIExtension extends Player = Player> extends FlowplayerUMDBase {
-    (selector: string, config?: ConfigWithPlugins): PluginPlayerAPIExtension;
-    (element: HTMLElement, config?: ConfigWithPlugins): PluginPlayerAPIExtension;
+/**
+ * @public
+ */
+export 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
+ */
 export declare interface FPEvent<T> extends CustomEvent<T> {
     /**
      * @deprecated
@@ -155,103 +518,697 @@ export declare interface FPEvent<T> extends CustomEvent<T> {
     data?: T;
 }
 
-export declare type HLSQualityChange = {
-    kind: "hls";
-    before?: Level;
-    after?: Level;
-};
+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";
 
 declare type JSONPlayer = any;
 
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+KEYDOWN = "keydown";
+
+/**
+ * @public
+ */
+export declare type KeyDownEventDetail = KeyboardEvent;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+KEYUP = "keyup";
+
+/**
+ * @public
+ */
+export declare type KeyUpEventDetail = KeyboardEvent;
+
+/**
+ * @public
+ */
 export declare type KeyValue = Record<string, any>;
 
-export 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
+ */
+export 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
+ */
+export 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>>;
 
-export declare interface Player extends HTMLVideoElement {
-    renderPlugin: (pluginContainer: HTMLElement) => void;
-    toggleDisable: (flag: boolean) => void;
-    original_src: string;
+/**
+ * @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
+ * 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";
+
+/**
+ * @public
+ */
+export declare type MountEventDetail = null;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+MOUSE_DOWN = "mousedown";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+MOUSE_ENTER = "mouseenter";
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+MOUSE_LEAVE = "mouseleave";
+
+/**
+ * @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";
+
+/**
+ * @public
+ */
+export declare type MouseDownEventDetail = MouseEvent;
+
+/**
+ * @public
+ */
+export declare type MouseEnterEventDetail = MouseEvent;
+
+/**
+ * @public
+ */
+export declare type MouseLeaveEventDetail = MouseEvent;
+
+/**
+ * @public
+ */
+export declare type MouseMoveEventDetail = MouseEvent;
+
+/**
+ * @public
+ */
+export declare type MouseUpEventDetail = MouseEvent;
+
+declare const MUTED = "is-muted";
+
+declare const NO_CONTROLS = "no-controls";
+
+declare const NO_DVR = "no-timeline";
+
+/* Excluded from this release type: NON_RECOVERABLE_ERROR */
+
+/* Excluded from this release type: NonRecoverableErrorEventDetail */
+
+/* Excluded from this release type: NQState */
+
+/**
+ * @public
+ */
+export 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
+ */
+export 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;
-    playerState: Record<string, boolean>;
-    reaper: Map<string, any> | 0;
-    hasState(state: PlayerState): boolean;
-    transitionState(to: PlayerState, from: PlayerState, timer?: number): void;
+    /* 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>;
-    toggleFullScreen(on?: boolean, state_only?: boolean): void;
-    toggleMute(on?: boolean): 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;
-    render(): void;
-    render(component: string, args: any[]): 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;
-    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;
+    /**
+     * 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;
-    deviceId(): DeviceId;
-    live_state: {
-        dvr?: boolean;
-        dvr_window?: number;
-    };
+    /* Excluded from this release type: deviceId */
+    /* Excluded from this release type: live_state */
+    /**
+     * A reference to the configuration state of the player.
+     */
     opts: Config;
-    plugins: Array<Plugin_2 | Loader>;
-    dvr_offset?: number;
+    /* 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;
-    started?: boolean;
-    token: string;
+    /* Excluded from this release type: started */
+    /* Excluded from this release type: token */
     tracks?: VideoTrack[];
-    _customElements: FlowplayerCustomElementRegistry;
-    _storage: Storage;
-}
+    /* 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.
+ */
 export declare type PlayerRoot = HTMLElement & {
-    prevWidth?: number;
+    /* Excluded from this release type: prevWidth */
 };
 
-declare type PlayerState = string;
+/**
+ * @public
+ */
+export declare type PlayerState = FlowplayerStates[keyof FlowplayerStates];
+
+/* Excluded from this release type: _PlayerState */
 
+/* Excluded from this release type: PlayerStates */
+
+/**
+ * @public
+ */
 export declare type PlayerWith<T> = T & Player;
 
-declare interface Plugin_2<PluginOwnConfig extends KeyValue = KeyValue, PluginPlayerAPIExtension extends KeyValue = KeyValue> {
+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: ConfigWith<PluginOwnConfig>, container: PlayerRoot, player: PlayerWith<PluginPlayerAPIExtension>): void;
+    init(config: PluginConfig, container: PlayerRoot, player: PluginPlayer): void;
 }
 export { Plugin_2 as Plugin }
 
-export 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
+ */
+export declare interface PluginCtor<PluginConfig extends Config = Config, PluginPlayer extends Player = Player> {
+    new (umd: FlowplayerUMD, player: PluginPlayer): Plugin_2<PluginConfig, PluginPlayer>;
 }
 
-export declare type QualityChangeEvent = HLSQualityChange | DashQualityChange;
+/* 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
+ */
+export declare type QualitiesEventDetail = QualityDetail[];
+
+/**
+ * @public
+ */
+export 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,
@@ -259,25 +1216,457 @@ declare enum QualityOpts {
     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
+ */
+export declare type ReapEventDetail = null;
+
+/**
+ * @public
+ */
+export 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
+ */
+export 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
+ */
+export declare type RenderPluginEventDetail = HTMLElement;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+RESIZE = "resize";
+
+/**
+ * @public
+ */
+export declare type ResizeEventDetail = ResizeObserverEntry | {
+    contentRect: {
+        height: number;
+        width: number;
+    };
+};
+
+/* Excluded from this release type: RETRY */
+
+/* Excluded from this release type: RetryEventDetail */
+
+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
+ */
+export declare type SourceEventDetail = SourceObj;
+
+/**
+ * @public
+ */
 export declare type SourceList = Array<SourceObj>;
 
+/**
+ * @public
+ */
 export declare type SourceObj = {
     src?: SourceStr;
+    /**
+     *  the MIME type (example `video/mp4` or `application/x-mpegurl`)
+     */
     type?: string;
     drm?: DRMSourceConfiguration;
 };
 
+/**
+ * @public
+ */
 export declare type SourceStr = string;
 
+/**
+ * @public
+ */
 export 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";
+
+/**
+ * @public
+ */
+export declare type TouchCancelEventDetail = TouchEvent;
+
+declare const TOUCHED = "is-touched";
+
+/**
+ * @public
+ */
+export declare type TouchEndEventDetail = TouchEvent;
+
+/**
+ * @public
+ */
+export declare type TouchMoveEventDetail = TouchEvent;
+
+/**
+ * @public
+ */
+export declare type TouchStartEventDetail = TouchEvent;
+
+declare const TV = "is-tv";
+
+/**
+ * @public
+ */
 export 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
+ */
 export 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
+ */
+export declare type ViewEnterEventDetail = null;
+
+/**
+ * @public
+ */
+export 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 { }