@flowplayer/player 3.34.3 → 3.35.0-rc

package/package/plugins/ads.d.ts

@@ -0,0 +1,4468 @@
+import type { Get } from 'type-fest';
+import type { Level } from 'hls.js';
+import type { Paths } from 'type-fest';
+import type { Representation } from 'dashjs';
+import type { Translation } from '@flowplayer/translations';
+import type { TupleToUnion } from 'type-fest';
+
+declare const AD_ATTRIBUTION: number;
+
+/* Excluded from this release type: AD_BLOCKED */
+
+declare const AD_BREAK_COMPLETED = "ad-break-completed";
+
+declare const AD_CHOICES: number;
+
+/**
+ * When a single ad has finished
+ */
+declare const AD_COMPLETED = "ad-completed";
+
+/* Excluded from this release type: AD_ERROR */
+
+/* Excluded from this release type: AD_FULLSCREEN */
+
+/* Excluded from this release type: AD_INIT */
+
+/* Excluded from this release type: AD_MIDROLL_FINISHED */
+
+/**
+ * When the ad is muted
+ */
+declare const AD_MUTED = "ad-muted";
+
+declare const AD_PAUSE_CONTENT = "ad-pause-content";
+
+/**
+ * When the ad has been paused
+ */
+declare const AD_PAUSED = "ad-paused";
+
+declare const AD_PLAY_REQUESTED = "ad-play-requested";
+
+/**
+ * Ad request was successfull but ad fails to play
+ */
+declare const AD_PLAYBACK_ERROR = "ad-playback-error";
+
+/**
+ * When all ads for a specific timeslot have been shown
+ */
+declare const AD_POSTROLL_FINISHED = "ad-postroll-finished";
+
+/**
+ * Fires when both content and (possible) postroll are finished. Also fires when no postroll is configured.
+ */
+declare const AD_PREROLL_FINSIHED = "ad-preroll-finished";
+
+/**
+ * 	Fires when the ad progresses
+ */
+declare const AD_PROGRESS = "ad-progress";
+
+declare const AD_REQUEST_COMPLETED = "ad-request-completed";
+
+/**
+ * Ad was requested but the ad request fails
+ */
+declare const AD_REQUEST_ERROR = "ad-request-error";
+
+/**
+ * Fires when an ad request has been made
+ */
+declare const AD_REQUESTED = "ad-requested";
+
+/* Excluded from this release type: AD_RESIZE */
+
+/**
+ * When the ad resumes
+ */
+declare const AD_RESUMED = "ad-resumed";
+
+/* Excluded from this release type: AD_SET_UI_FLAGS */
+
+/* Excluded from this release type: AD_SHOW_FIRST_FRAME */
+
+/**
+ * When the skip button has been clicked
+ */
+declare const AD_SKIPPED = "ad-skipped";
+
+/**
+ * Ad was received and starts to show
+ */
+declare const AD_STARTED = "ad-started";
+
+declare const AD_TEARDOWN = "ad-teardown";
+
+declare const AD_TIMEOUT = "ad-timeout";
+
+declare const AD_VIDEOTAG_ATTACHED = "ad-videotag-attached";
+
+/**
+ * Volume has been changed during ad playback
+ */
+declare const AD_VOLUME_CHANGED = "ad-volume-changed";
+
+/* Excluded from this release type: AD_WAITING */
+
+declare interface Adapter {
+    initialize(opts: AdapterOpts): void;
+    getOpts(): AdapterOpts;
+    reset(): void;
+    destroy(): void;
+    destroyManager(): void;
+    stop(): void;
+    initAd(adTag: string, timeout?: number): Promise<void>;
+    playAd(): Promise<void>;
+    pause(): void;
+    resume(): void;
+    volume(level?: number): number | undefined;
+    contentComplete(): Promise<void>;
+    onResize(_obj: ResizeInfo): void;
+    isUiDisabled(): boolean;
+    onAdRequestEnd(): void;
+    isAdPod(): boolean;
+    canDismissNonLinear(): boolean;
+    setAdBreakTime: (time: number) => void;
+    getAdBreakTime: () => number;
+    init(opts: AdapterOpts): Promise<void>;
+    isReady(): boolean;
+    setVideoTag(tag: Player): void;
+    isPaused(): boolean;
+    isCustomPlaybackEnabled(): boolean;
+    isAttemptingPrerollOnIOS(): boolean;
+    setAttemptingPrerollOnIOS(preroll_on_ios: boolean): void;
+    isLinearAd(): boolean;
+    getVideoTag(): Player | undefined;
+    getDimensions(): Partial<{
+        width: number;
+        height: number;
+        linear: boolean;
+    }>;
+    getAdInfo(): AdInfo | undefined;
+}
+
+declare const ADAPTER_INIT_FAILED = "ad-adapter-init-failed";
+
+/**
+ *  @public
+ */
+export declare type AdapterInitFailedEventDetail = AdBasicInfo;
+
+/**
+ * @public
+ */
+export declare type AdapterOpts = Partial<ControllerConfig>;
+
+/**
+ * @public
+ * Basic info about current ad and it's config
+ */
+export declare type AdBasicInfo = AdapterOpts & TimeBasedAd & {
+    ad_type?: AdType;
+};
+
+/**
+ *  @public
+ */
+export declare type AdBreakCompletedEventDetail = AdBasicInfo;
+
+/**
+ *  @public
+ */
+export declare type AdCompletedEventDetail = AdBasicInfo & AdDetail;
+
+/**
+ * @public
+ * Detailed info about current ad
+ */
+export declare type AdDetail = {
+    ad: {
+        duration: number;
+        width: number;
+        height: number;
+        position: number | undefined;
+        totals: number | undefined;
+    };
+    volume: number;
+    vast_ad_id: string;
+    linear: boolean;
+    mime_type: string;
+    /* Excluded from this release type: ima_event */
+};
+
+/**
+ * @public
+ */
+export declare type AdError = {
+    vast_error_type: google.ima.AdError.Type;
+    reason: string;
+    vast_error: google.ima.AdError.ErrorCode;
+};
+
+/**
+ * @public
+ * Represents ad events.
+ */
+declare type AdEvents = typeof events_2;
+
+declare type AdEventsDetailMap = {
+    /* Excluded from this release type: "ad-initialized" */
+    [AD_PLAYBACK_ERROR]: AdPlaybackErrorEventDetail;
+    [AD_TEARDOWN]: AdTearDownEventDetail;
+    [AD_VIDEOTAG_ATTACHED]: AdVideoTagAttachedEventDetail;
+    [AD_REQUEST_ERROR]: AdRequestErrorEventDetail;
+    [AD_REQUESTED]: AdRequestedEventDetail;
+    [AD_REQUEST_COMPLETED]: AdRequestCompletedEventDetail;
+    [AD_PAUSE_CONTENT]: AdPauseContentEventDetail;
+    [AD_STARTED]: AdStartedEventDetail;
+    [AD_COMPLETED]: AdCompletedEventDetail;
+    [AD_PAUSED]: AdPausedEventDetail;
+    [AD_RESUMED]: AdResumedEventDetail;
+    [AD_PROGRESS]: AdProgressEventDetail;
+    [AD_SKIPPED]: AdSkippedEventDetail;
+    [AD_MUTED]: AdMutedEventDetail;
+    [AD_VOLUME_CHANGED]: AdVolumeChangedEventDetail;
+    [AD_TIMEOUT]: AdTimeoutEventDetail;
+    [AD_BREAK_COMPLETED]: AdBreakCompletedEventDetail;
+    [AD_POSTROLL_FINISHED]: AdPostrollFinishedEventDetail;
+    [AD_PREROLL_FINSIHED]: AdPrerollFinishedEventDetail;
+    /* Excluded from this release type: "vpaid-init" */
+    [IMA_ADAPTER_INIT]: ImaAdapterInitEventDetail;
+    [IMA_BEFORE_ADS_REQUEST]: ImaBeforeAdsRequestEventDetail;
+    [IMA_ADS_RENDERING_SETTINGS]: ImaAdsRenderingSettingsEventDetail;
+    [ADAPTER_INIT_FAILED]: AdapterInitFailedEventDetail;
+    [AD_PLAY_REQUESTED]: AdPlayRequestedEventDetail;
+    [RELOAD_AD_REQUESTED]: ReloadAdRequestedEventDetail;
+    [REQUEST_AD_PAUSE]: RequestAdPauseEventDetail;
+    [REQUEST_AD_PLAY]: RequestAdPlayEventDetail;
+    [REQUEST_AD_MUTE_UNMUTE]: RequestAdMuteUnmuteEventDetail;
+    [PBJS_AVAILABLE]: PBJSAvailebleEventDetail;
+};
+
+declare type AdInfo = {
+    duration: number;
+};
+
+/* Excluded from this release type: AdInitEventDetail */
+
+/**
+ *  @public
+ */
+export declare type AdMutedEventDetail = AdBasicInfo;
+
+/**
+ *  @public
+ */
+export declare type AdPauseContentEventDetail = AdBasicInfo & AdDetail;
+
+/**
+ *  @public
+ */
+export declare type AdPausedEventDetail = AdBasicInfo;
+
+/**
+ *  @public
+ */
+export declare type AdPlaybackErrorEventDetail = google.ima.AdErrorEvent;
+
+/**
+ *  @public
+ */
+export declare type AdPlayRequestedEventDetail = AdBasicInfo;
+
+/**
+ *  @public
+ */
+export declare type AdPostrollFinishedEventDetail = AdBasicInfo;
+
+/**
+ *  @public
+ */
+export declare type AdPrerollFinishedEventDetail = AdBasicInfo;
+
+/**
+ * @public
+ */
+export declare type AdProgressDetail = {
+    remaining: number;
+    duration: number;
+};
+
+/**
+ *  @public
+ */
+export declare type AdProgressEventDetail = AdBasicInfo & AdProgressDetail;
+
+/**
+ *  @public
+ */
+export declare type AdRequestCompletedEventDetail = AdBasicInfo & {
+    request_load_time: number;
+};
+
+/**
+ *  @public
+ */
+export declare type AdRequestedEventDetail = AdBasicInfo | AdTag;
+
+/**
+ *  @public
+ */
+export declare type AdRequestErrorEventDetail = AdError;
+
+/**
+ *  @public
+ */
+export declare type AdResumedEventDetail = AdBasicInfo;
+
+/**
+ * @public
+ * The Advertising plugin allows you to seamlessly integrate various ads into your video content, including pre-roll, mid-roll, and post-roll ads. These ads can be served from different ad networks or custom ad servers.
+ * See {@link https://developer.wowza.com/docs/wowza-flowplayer/plugins/advertising/|Official Documentation}
+ */
+declare const Ads: PluginCtor<NoInfer<AdsConfig>, NoInfer<AdsPlayer>> & NoInfer<AdsAPI>;
+export default Ads;
+
+/**
+ * @public
+ */
+export declare type AdsAPI = {
+    /**
+     * UI bit flags to be used in `ads.ui` configuration option
+     */
+    ui: AdsUI;
+    /**
+     * Event names in Ads Plugins
+     */
+    events: AdEvents;
+};
+
+/**
+ * @public
+ * Main configuration for the Ads plugin.
+ */
+export declare type AdsConfig = ConfigWith<{
+    /**
+     * Ads plugin configuration
+     */
+    ima?: PlayerIMAConfig;
+    /**
+     * Ads plugin configuration
+     */
+    ads?: AdsDetails;
+}>;
+
+declare class AdsController extends EventBus {
+    readonly adapter: Adapter;
+    readonly opts: Partial<ControllerConfig>;
+    readonly analytics: Analytics;
+    private _macros;
+    private _schedule;
+    private _state;
+    private _lastAd;
+    private content_processing_src;
+    constructor(params?: Partial<ControllerConfig>);
+    reset(): this;
+    destroy(): void;
+    stop(): void;
+    onContentNewSrc(): void;
+    wireup(): void;
+    initialize(ads: TimeBasedAd[] | false, opts?: Partial<ControllerConfig>, preload?: boolean): Promise<this>;
+    get videoTag(): Player | undefined;
+    get adInfo(): AdInfo | undefined;
+    setVideoTag(player: Player): Promise<void>;
+    waitForVideoTag(): Promise<unknown>;
+    adapterInitialized(preload?: boolean): Promise<void>;
+    fetchNextAd(time: number, depth?: number): Promise<void>;
+    skipAdsOnSeek(time: number): void;
+    setCurrentTime(time: number, preload?: boolean, seek?: boolean): Promise<void>;
+    playAd(): Promise<void>;
+    checkIfBreakComplete(): void;
+    resetScheduleCounter(): void;
+    setSchedule(ads: TimeBasedAd[], contentDuration?: number): void;
+    toJSON(): TimeBasedAd[];
+    trigger<EventName extends keyof AdEventsDetailMap>(name: EventName, data?: any): void;
+    dispatch<EventName extends keyof AdEventsDetailMap>(name: EventName, data: any): void;
+    get ad_type(): "preroll" | "midroll" | "postroll" | undefined;
+    shouldRestartContent(): boolean;
+    finished(cb: () => void): Promise<void>;
+    hasPreroll(): boolean | undefined;
+    shallPlayAd(time: number): boolean;
+    setLastAd(ad: TimeBasedAd): this;
+    setIsContentProcessingNewSrc(is_processing: boolean): void;
+    getLastAd(): Maybe<TimeBasedAd>;
+    getIsContentProcessingNewSrc(): boolean;
+    mergeMacros(macros?: {}): this;
+    /**
+     *
+     * public interface for plugin users, keep the signature unchanged
+     *
+     **/
+    get paused(): boolean;
+    pause(): void;
+    resume(): void;
+    resize(opts: Todo): void;
+    requestAd(ad: AdTag, idx?: number, timeout?: number | undefined): Promise<void>;
+    resetSchedule(ads: TimeBasedAd[]): void;
+    get adPlaying(): boolean;
+    get adBreak(): boolean;
+    get adRequesting(): boolean;
+    get adLinear(): boolean;
+}
+
+/**
+ * @public
+ */
+export declare type AdsControllerPublic = {
+    /**
+     * 	Pauses the ad
+     */
+    pause(): void;
+    /**
+     * 	Resumes the ad
+     */
+    resume(): void;
+    /**
+     * Attempts to request & play an adTag
+     * @param adTag - Ad tag
+     */
+    requestAd(adTag: string): Promise<void>;
+    /**
+     * Resets the internal ad schedule
+     * @param adSchedule - Ad schedule
+     */
+    resetSchedule(adSchedule: Array<{
+        adTag: string;
+        time: number;
+    }>): void;
+    /**
+     * Boolean to show when ad is playing
+     */
+    get adPlaying(): boolean;
+};
+
+/**
+ * @public
+ */
+export declare type AdsDetails = {
+    /**
+     * Adds a bitmask to configure {@link https://developer.wowza.com/docs/wowza-flowplayer/plugins/advertising/#ui-configuration|UI elements}. Default value is undefined.
+     */
+    ui?: number;
+    /**
+     * Configuration for Prebid.js integration.
+     */
+    prebid?: PrebidConfig;
+};
+
+/**
+ *  @public
+ */
+export declare type AdSkippedEventDetail = AdBasicInfo & AdDetail;
+
+/**
+ * @public
+ */
+export declare type AdsPlayer = PlayerWith<{
+    ads?: AdsControllerPublic;
+    on<EventName extends keyof AdEventsDetailMap>(event: EventName, handler: (e: FPEvent<AdEventsDetailMap[EventName]>) => void): Player;
+}>;
+
+/**
+ *  @public
+ */
+export declare type AdStartedEventDetail = AdBasicInfo & AdDetail;
+
+/**
+ * @public
+ * Represents the UI configuration for ads.
+ */
+export declare type AdsUI = typeof Flags_2;
+
+/**
+ * @public
+ * Represents an ad tag which can be a string, array of strings, LazyAdTag, or array of LazyAdTags.
+ */
+export declare type AdTag = string | LazyAdTag[] | string[] | (string | LazyAdTag)[] | LazyAdTag | TimeBasedAd;
+
+/**
+ *  @public
+ */
+export declare type AdTearDownEventDetail = AdBasicInfo;
+
+/**
+ *  @public
+ */
+export declare type AdTimeoutEventDetail = Error;
+
+/**
+ * @public
+ */
+export declare enum AdType {
+    Preroll = "preroll",
+    Midroll = "midroll",
+    Postroll = "postroll"
+}
+
+/**
+ *  @public
+ */
+export declare type AdVideoTagAttachedEventDetail = Player;
+
+/**
+ *  @public
+ */
+export declare type AdVolumeChangedEventDetail = number;
+
+declare class Analytics {
+    readonly emitter: Listenable;
+    /**
+     * pure creation interface
+     */
+    static of(emitter: Listenable, opts: Todo): Analytics;
+    /**
+     * check it there are any keys that the Analytics service
+     * considers to be require on an Object
+     */
+    static ensure_required_keys(analytics: Analytics, obj: Record<string, string | number>): string[];
+    /**
+     * takes an Object and plucks what the Analytics service
+     * considers to be valid keys
+     */
+    static pluck_valid_keys(analytics: Analytics, obj: Record<string, string | number>): {};
+    /**
+     * Assigns the metadata to the analytics.metadata
+     * only will propagate valid keys
+     *
+     * @param analytics - The Analytics object
+     * @param metadata - The metadata to assign
+     */
+    static mergeMetadata(analytics: Analytics, metadata?: {}): Analytics;
+    events: string[];
+    required_keys: string[];
+    optional_keys: string[];
+    valid_keys: string[];
+    metadata: Metadata_2;
+    /**
+     * Construct a new Analytics tracking object
+     */
+    constructor(emitter: Listenable, opts?: Partial<AnalyticsOpts>);
+    wireup(): void;
+    destroy(): void;
+}
+
+declare type AnalyticsOpts = {
+    metadata: Metadata_2;
+    required_keys: string[];
+    events: string[];
+    optional_keys: string[];
+};
+
+/* 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 {
+    OFF = 0,
+    ON = 1,
+    AUDIO_REQUIRED = 2
+}
+
+/**
+ * @public
+ */
+export declare type BaseAdObj = {
+    /**
+     * Defines an adTag URL to load VAST from. Several tags can be configured for waterfalling.
+     */
+    adTag: string | string[] | LazyAdTag;
+    /**
+     * Determines if the ad should attempt to restart the content. Default value is true.
+     */
+    restart?: boolean;
+    /* Excluded from this release type: lazy */
+    /**
+     * Indicates if the ad is an outstream ad.
+     */
+    outstream?: boolean;
+};
+
+/* Excluded from this release type: BEFORE_PAUSE */
+
+/* Excluded from this release type: BEFORE_PLAY */
+
+/**
+ * @public
+ */
+declare type BeforePauseEventDetail = {
+    forced: boolean;
+};
+
+/**
+ * @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";
+
+/**
+ * For plugins that add new properties to all source types, combine their src-mixins into one SourceObject
+ * @example
+ * ```
+ * type Combined = CombineGlobalSrcExtensions<DRMPlugin, PluginWithFooFieldInSrc> // Combined = SourceObject<DRMConfig & FooFieldConfig>
+ * ```
+ */
+declare type CombineGlobalSrcExtensions<PluginSrcs extends unknown[]> = HasGlobalSrcExtensios<PluginSrcs> extends false ? SourceObj : SourceObj & ArrayToIntersection<PickGlobalSrcExtension<PluginSrcs>>;
+
+/**
+ * For plugins that define a new src type, make a union of all new src.type declarations
+ * @example
+ * ```
+ * type Combined = CombineNewSourceTypes<RTSPlugin, SSAIPlugin> // Combined = DRMConfig | FooFieldConfig
+ * ```
+ */
+declare type CombineNewSourceTypes<PluginSrcs extends unknown[]> = TupleToUnion<FilterNewSourceTypes<PluginSrcs>>;
+
+declare type CombineSrc<PluginSrcs extends unknown[]> = UnsafeSource<CombineGlobalSrcExtensions<PluginSrcs> | (CombineNewSourceTypes<PluginSrcs> & CombineGlobalSrcExtensions<PluginSrcs>)>;
+
+/* 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";
+    controls?: boolean;
+    lang?: string;
+    start_time?: number;
+    autopause?: boolean;
+    rewind?: boolean;
+    loop?: boolean;
+    /**
+     * an access token for the media
+     * @public
+     */
+    playback_token?: string;
+    /* Excluded from this release type: seamless */
+    retry?: boolean;
+    autoplay?: Autoplay;
+    start_quality?: BitOpts;
+    live?: boolean;
+    poster?: string;
+    disabled?: boolean;
+    muted?: boolean;
+    /* Excluded from this release type: is_native */
+    /**
+     * bitflags for UI options
+     */
+    ui?: BitOpts;
+    /**
+     * your user access token
+     */
+    token?: string;
+    /* Excluded from this release type: duration */
+    /**
+     * can the content be seeked to any position
+     */
+    seekable?: boolean;
+    multiplay?: boolean;
+    ratio?: number | string;
+    logo?: string;
+    logo_href?: string;
+    logo_alt_text?: string;
+    title?: string;
+    description?: string;
+    /**
+     * the number of seconds to have in the buffer before dvr is activated
+     */
+    seconds_to_dvr?: number;
+}
+
+/* Excluded from this release type: ConfigEventDetail */
+
+/**
+ * @public
+ */
+declare type ConfigWith<T> = Config & T;
+
+declare type ConfigWithSourceExtensions<PluginBareConfigs extends unknown[]> = Omit<ConfigWith<ArrayToIntersection<PluginBareConfigs>>, "src"> & {
+    src?: CombineSrc<PickSrcExtensions<PluginBareConfigs>>;
+};
+
+/* 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
+ */
+export declare type ControllerConfig = {
+    parameters: MacrosMap;
+    muted: boolean;
+    autoplay: boolean;
+    timeout: number;
+    show_all_ads_on_seek: boolean;
+    preload_advance: number;
+    preload_ads: boolean;
+    video_source: string;
+};
+
+/**
+ * @public
+ * @deprecated
+ *  when a cuepoint becomes inactive
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * @deprecated
+ *  when a cuepoint becomes inactive
+ */
+CUEPOINT_END = "cuepointend";
+
+/**
+ * @public
+ * @deprecated
+ * when a cuepoint is active
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * @deprecated
+ * when a cuepoint is active
+ */
+CUEPOINT_START = "cuepointstart";
+
+/**
+ * @public
+ * @deprecated
+ * 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
+ * @deprecated
+ * cuepoints parsing is asynchronous
+ * you cannot rely on them existing until
+ * this event is emitted
+ */
+CUEPOINTS = "cuepoints";
+
+/**
+ * @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";
+
+declare const DESTROYED = "is-destroyed";
+
+/* Excluded from this release type: DeviceId */
+
+declare const DISABLED = "is-disabled";
+
+/**
+ * @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";
+
+declare class EventBus {
+    private _bus;
+    private _listeners;
+    constructor(_bus?: HTMLDivElement, _listeners?: Array<[string, Listener]>);
+    removeAllListeners(): void;
+    emit<T>(eventName: string, detail: T): void;
+    on<T>(eventName: string, handler: Listener<T>): void;
+    once<T>(eventName: string, handler: Listener<T>): void;
+    removeListener(eventName: string, handler: Listener): void;
+}
+
+declare namespace events {
+    export {
+        MOUNT,
+        RETRY,
+        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,
+        VIEW_ENTER,
+        VIEW_LEAVE,
+        SOURCE,
+        REAP,
+        QUALITIES,
+        QUALITY_CHANGE,
+        VIDEO_TRACKS,
+        SET_QUALITY,
+        VIDEO_TRACK_SELECT,
+        RECOMMENDATIONS_READY,
+        LANDSCAPE,
+        PORTRAIT,
+        DVR,
+        LIVE,
+        RECOVER,
+        CUEPOINTS,
+        CUEPOINT_START,
+        CUEPOINT_END,
+        STANDARD_ERROR
+    }
+}
+
+declare namespace events_2 {
+    export {
+        AD_PLAYBACK_ERROR,
+        AD_TEARDOWN,
+        AD_VIDEOTAG_ATTACHED,
+        AD_REQUEST_ERROR,
+        AD_REQUESTED,
+        AD_REQUEST_COMPLETED,
+        AD_PAUSE_CONTENT,
+        AD_STARTED,
+        AD_COMPLETED,
+        AD_PAUSED,
+        AD_RESUMED,
+        AD_PROGRESS,
+        AD_SKIPPED,
+        AD_MUTED,
+        AD_VOLUME_CHANGED,
+        AD_TIMEOUT,
+        AD_BREAK_COMPLETED,
+        AD_POSTROLL_FINISHED,
+        AD_PREROLL_FINSIHED,
+        IMA_ADAPTER_INIT,
+        IMA_BEFORE_ADS_REQUEST,
+        IMA_ADS_RENDERING_SETTINGS,
+        ADAPTER_INIT_FAILED,
+        AD_PLAY_REQUESTED,
+        RELOAD_AD_REQUESTED,
+        REQUEST_AD_PAUSE,
+        REQUEST_AD_PLAY,
+        REQUEST_AD_MUTE_UNMUTE,
+        PBJS_AVAILABLE
+    }
+}
+
+declare type ExtractBareConfig<Plugins extends PluginCtor> = Plugins extends PluginCtor<ConfigWith<infer ConfigType>> ? ConfigType : never;
+
+declare type ExtractPluginPlayerExtension<Plugin extends PluginCtor> = Plugin extends PluginCtor<infer _uConfigType, PlayerWith<infer PluginPlayer>> ? PluginPlayer : never;
+
+declare type ExtractPureAPI<T> = T extends PlayerWith<infer PureAPI> ? PureAPI : never;
+
+declare type ExtractSrcExtension<PluginBareConfig> = Get<PluginBareConfig, "src"> extends UnsafeSource<infer SrcMixinType> ? SrcMixinType : never;
+
+declare const FEATURE_USAGE = "flowplayer:feature";
+
+/* Excluded from this release type: FeatureUsageEventDetail */
+
+declare type FilterNewSourceTypes<PluginSrcs extends unknown[]> = {
+    [Index in keyof PluginSrcs]: PluginSrcs[Index] extends {
+        type: string;
+    } ? PluginSrcs[Index] : never;
+};
+
+declare namespace Flags_2 {
+    export {
+        STICKY_CONTROLS,
+        NO_FULLSCREEN,
+        NO_AD_INDICATOR,
+        AD_ATTRIBUTION,
+        AD_CHOICES,
+        REMAINING_TIME,
+        VOLUME_BAR
+    }
+}
+
+/**
+ * @public
+ */
+declare type FlowplayerCustomElementRegistry = Map<string, string>;
+
+declare class FlowplayerError extends Error {
+    readonly message: string;
+    readonly flowplayerErrorCode: FlowplayerErrorCode;
+    readonly config: FlowplayerErrorConfig;
+    static getErrorKey(code: FlowplayerErrorCode): FlowplayerErrorCodeName;
+    readonly id: string;
+    readonly isFatal: boolean;
+    readonly errorKey: string;
+    constructor(message: string, flowplayerErrorCode: FlowplayerErrorCode, config?: FlowplayerErrorConfig);
+    toJSON(): {
+        message: string;
+        flowplayer_error_code: FlowplayerErrorCode;
+        id: string;
+        root_error_id: string | undefined;
+        resource: string | undefined;
+        is_fatal: boolean;
+        is_retry: boolean;
+    };
+}
+
+declare type FlowplayerErrorCode = (typeof FlowplayerErrorCodeMap)[keyof typeof FlowplayerErrorCodeMap];
+
+declare const FlowplayerErrorCodeMap: {
+    /** Unknown */
+    readonly Unknown: "00-00";
+    /** Media Section */
+    readonly MediaUnknown: "01-00";
+    readonly MediaUnavailable: "01-01";
+    readonly MediaUnsupportedVideoFormat: "01-02";
+    readonly MediaUnsupportedAudioFormat: "01-03";
+    readonly MediaBitrateExceeded: "01-04";
+    readonly MediaBufferOverread: "01-05";
+    readonly MediaIntegerOverflow: "01-06";
+    readonly MediaQuotaExceeded: "01-07";
+    readonly MediaInvalidCompositionDuration: "01-08";
+    readonly MediaInvalidCompositionSourceDuration: "01-09";
+    readonly MediaInvalidCompositionSourceStartTime: "01-10";
+    readonly MediaMalformedDepth: "01-11";
+    /** Playback Section */
+    readonly PlaybackUnknown: "02-00";
+    readonly PlaybackVideoBufferUnderRun: "02-01";
+    readonly PlaybackAudioBufferUnderRun: "02-02";
+    readonly PlaybackVideoBufferingTimeout: "02-03";
+    readonly PlaybackAudioBufferingTimeout: "02-04";
+    readonly PlaybackManifestParseError: "02-05";
+    readonly PlaybackVideoDecodeError: "02-06";
+    readonly PlaybackAudioDecodeError: "02-07";
+    readonly PlaybackDroppedFramesExceeded: "02-08";
+    readonly PlaybackPlayheadExceedsDuration: "02-09";
+    readonly PlaybackUnsupportedDevice: "02-10";
+    readonly PlaybackManifestLoadError: "02-11";
+    readonly PlaybackManifestLoadTimeout: "02-12";
+    readonly PlaybackManifestParsingError: "02-13";
+    readonly PlaybackManifestIncompatibleCodecs: "02-14";
+    readonly PlaybackLevelEmptyError: "02-15";
+    readonly PlaybackLevelLoadError: "02-16";
+    readonly PlaybackLevelLoadTimeout: "02-17";
+    readonly PlaybackLevelSwitchError: "02-18";
+    readonly PlaybackAudioTrackLoadError: "02-19";
+    readonly PlaybackAudioTrackLoadTimeout: "02-20";
+    readonly PlaybackFragLoadError: "02-21";
+    readonly PlaybackFragLoadTimeout: "02-22";
+    readonly PlaybackFragDecryptError: "02-23";
+    readonly PlaybackFragParsingError: "02-24";
+    readonly PlaybackFragGap: "02-25";
+    readonly PlaybackRemuxAllocError: "02-26";
+    readonly PlaybackBufferAddCodecError: "02-27";
+    readonly PlaybackBufferIncompatibleCodecs: "02-28";
+    readonly PlaybackBufferAppendError: "02-29";
+    readonly PlaybackBufferStalledError: "02-30";
+    readonly PlaybackBufferFullError: "02-31";
+    readonly PlaybackBufferSeekOverHole: "02-32";
+    readonly PlaybackBufferNudgeOnStall: "02-33";
+    readonly PlaybackInternalException: "02-34";
+    readonly PlaybackInternalAborted: "02-35";
+    readonly PlaybackManifestLoaderFailure: "02-36";
+    readonly PlaybackSegmentBaseLoaderError: "02-37";
+    readonly PlaybackTimeSyncFailed: "02-38";
+    readonly PlaybackFragmentLoaderFailure: "02-39";
+    readonly PlaybackAppendError: "02-40";
+    readonly PlaybackRemoveError: "02-41";
+    readonly PlaybackDataUpdateFailed: "02-42";
+    readonly PlaybackManifestNoStreams: "02-43";
+    readonly PlaybackUnknownManifestType: "02-44";
+    readonly PlaybackDashInsufficientSegmentInfo: "02-45";
+    readonly PlaybackDashNoRepresentations: "02-46";
+    readonly PlaybackDashNoAdaptationSets: "02-47";
+    readonly PlaybackDashNoInitSegment: "02-48";
+    readonly PlaybackDashUnsupportedContainerFormat: "02-49";
+    readonly PlaybackDashKeySystemMismatch: "02-50";
+    readonly PlaybackMultipleKeyIDs: "02-51";
+    readonly PlaybackDashConflictingKeyIDs: "02-52";
+    readonly PlaybackRestrictedStreams: "02-53";
+    readonly PlaybackHlsMasterAndMediaTags: "02-54";
+    readonly PlaybackRepresentationIdConflict: "02-55";
+    readonly PlaybackHlsUnsupportedKeyFormats: "02-56";
+    readonly PlaybackManifestNoVariants: "02-57";
+    readonly PlaybackHlsUndeclaredVariables: "02-58";
+    readonly PlaybackAes128InvalidKeyLength: "02-59";
+    readonly PlaybackDashConflictingAes128Keys: "02-60";
+    readonly PlaybackDashUnsupportedAes128Encryption: "02-61";
+    readonly PlaybackManifestPatchMismatch: "02-62";
+    readonly PlaybackEmptyMediaPlaylist: "02-63";
+    readonly PlaybackNonContiguousCompositionTrack: "02-64";
+    readonly PlaybackDecoderNotFound: "02-65";
+    readonly PlaybackDecoderTemporarilyUnavailable: "02-66";
+    readonly PlaybackIncompatibleAsset: "02-67";
+    readonly PlaybackNoCompatibleExternalDisplay: "02-69";
+    readonly PlaybackOutOfMemory: "02-70";
+    readonly PlaybackToneMappingFailed: "02-71";
+    readonly PlaybackVideoCompositorFailed: "02-72";
+    /** Network Section */
+    readonly NetworkUnknown: "03-00";
+    readonly NetworkNoInternet: "03-01";
+    readonly NetworkRequestTimeout: "03-02";
+    readonly NetworkUnableToResolveHost: "03-03";
+    readonly NetworkResourceNotFound: "03-04";
+    readonly NetworkExpiredUrl: "03-05";
+    readonly NetworkUrlResolutionFailed: "03-06";
+    readonly NetworkDownloadErrorIdManifest: "03-07";
+    readonly NetworkDownloadErrorIdSidx: "03-08";
+    readonly NetworkDownloadErrorIdContent: "03-09";
+    readonly NetworkDownloadErrorIdInitialization: "03-10";
+    readonly NetworkDownloadErrorIdXlink: "03-11";
+    readonly NetworkHttpRequestFailed: "03-12";
+    readonly NetworkMaxRetriesExceeded: "03-13";
+    readonly NetworkSegmentMissing: "03-14";
+    /** HTTP Error Codes */
+    readonly NetworkHttp400BadRequest: "03-400";
+    readonly NetworkHttp401Unauthorized: "03-401";
+    readonly NetworkHttp402PaymentRequired: "03-402";
+    readonly NetworkHttp403Forbidden: "03-403";
+    readonly NetworkHttp404NotFound: "03-404";
+    readonly NetworkHttp405MethodNotAllowed: "03-405";
+    readonly NetworkHttp406NotAcceptable: "03-406";
+    readonly NetworkHttp407ProxyAuthenticationRequired: "03-407";
+    readonly NetworkHttp408RequestTimeout: "03-408";
+    readonly NetworkHttp409Conflict: "03-409";
+    readonly NetworkHttp410Gone: "03-410";
+    readonly NetworkHttp411LengthRequired: "03-411";
+    readonly NetworkHttp412PreconditionFailed: "03-412";
+    readonly NetworkHttp413PayloadTooLarge: "03-413";
+    readonly NetworkHttp414URITooLong: "03-414";
+    readonly NetworkHttp415UnsupportedMediaType: "03-415";
+    readonly NetworkHttp416RangeNotSatisfiable: "03-416";
+    readonly NetworkHttp417ExpectationFailed: "03-417";
+    readonly NetworkHttp418ImATeapot: "03-418";
+    readonly NetworkHttp421MisdirectedRequest: "03-421";
+    readonly NetworkHttp422UnprocessableEntity: "03-422";
+    readonly NetworkHttp423Locked: "03-423";
+    readonly NetworkHttp424FailedDependency: "03-424";
+    readonly NetworkHttp425TooEarly: "03-425";
+    readonly NetworkHttp426UpgradeRequired: "03-426";
+    readonly NetworkHttp428PreconditionRequired: "03-428";
+    readonly NetworkHttp429TooManyRequests: "03-429";
+    readonly NetworkHttp431RequestHeaderFieldsTooLarge: "03-431";
+    readonly NetworkHttp451UnavailableForLegalReasons: "03-451";
+    readonly NetworkHttp500InternalServerError: "03-500";
+    readonly NetworkHttp501NotImplemented: "03-501";
+    readonly NetworkHttp502BadGateway: "03-502";
+    readonly NetworkHttp503ServiceUnavailable: "03-503";
+    readonly NetworkHttp504GatewayTimeout: "03-504";
+    readonly NetworkHttp505HTTPVersionNotSupported: "03-505";
+    readonly NetworkHttp506VariantAlsoNegotiates: "03-506";
+    readonly NetworkHttp507InsufficientStorage: "03-507";
+    readonly NetworkHttp508LoopDetected: "03-508";
+    readonly NetworkHttp510NotExtended: "03-510";
+    readonly NetworkHttp511NetworkAuthenticationRequired: "03-511";
+    /** Content Protection Section */
+    readonly ContentProtectionUnknown: "04-00";
+    readonly ContentProtectionConcurrentStreamLimitExceeded: "04-01";
+    readonly ContentProtectionEntitlementRefused: "04-02";
+    readonly ContentProtectionLicenseExpired: "04-03";
+    readonly ContentProtectionBadLicenseRequest: "04-04";
+    readonly ContentProtectionLicenseServerTimeout: "04-05";
+    readonly ContentProtectionInsufficientHDCPSupport: "04-06";
+    readonly ContentProtectionGeoRestricted: "04-07";
+    readonly ContentProtectionParentalControlRestricted: "04-08";
+    readonly ContentProtectionCDNUnauthorized: "04-09";
+    readonly ContentProtectionInvalidAccessToken: "04-10";
+    readonly ContentProtectionKeySystemNoKeys: "04-11";
+    readonly ContentProtectionKeySystemNoAccess: "04-12";
+    readonly ContentProtectionKeySystemNoSession: "04-13";
+    readonly ContentProtectionKeySystemNoConfiguredLicense: "04-14";
+    readonly ContentProtectionKeySystemCertificateRequestFailed: "04-15";
+    readonly ContentProtectionKeySystemCertificateUpdateFailed: "04-16";
+    /** Key System: Session update failed */
+    readonly ContentProtectionKeySystemSessionUpdateFailed: "04-17";
+    /** Key System: Status output restricted */
+    readonly ContentProtectionKeySystemStatusOutputRestricted: "04-18";
+    /** Key System: Status internal error */
+    readonly ContentProtectionKeySystemStatusInternalError: "04-19";
+    /** Key Load Error */
+    readonly ContentProtectionKeyLoadError: "04-20";
+    /** Key Load Timeout */
+    readonly ContentProtectionKeyLoadTimeout: "04-21";
+    /** Capability MediaKeys Error */
+    readonly ContentProtectionCapabilityMediaKeysError: "04-22";
+    /** Manifest indicated protected content, but unable to determine key systems */
+    readonly ContentProtectionManifestKeySystemUnknown: "04-23";
+    /**
+     * None of the requested key system configurations are available.
+     * Possible reasons:
+     * - Key system not supported
+     * - Requested features (e.g., persistent state) not supported
+     * - User denied access in prompt
+     * - Key system unavailable in insecure contexts (requires HTTPS)
+     */
+    readonly ContentProtectionKeySystemUnavailable: "04-24";
+    /** Browser found requested key system, but failed to create CDM instance */
+    readonly ContentProtectionCDMCreationFailed: "04-25";
+    /** Browser created CDM instance but failed to attach it to the video */
+    readonly ContentProtectionCDMAttachFailed: "04-26";
+    /** CDM rejected the server certificate (malformed or unsupported format) */
+    readonly ContentProtectionCDMServerCertificateRejected: "04-27";
+    /** CDM refused to create a session for unknown reasons */
+    readonly ContentProtectionCDMSessionCreationFailed: "04-28";
+    /** CDM unable to generate a license request due to malformed or unsupported init data */
+    readonly ContentProtectionCDMLicenseRequestFailed: "04-29";
+    /** License response rejected by the CDM (invalid/malformed response) */
+    readonly ContentProtectionCDMLicenseResponseRejected: "04-30";
+    /** Manifest does not specify DRM info, but content is encrypted */
+    readonly ContentProtectionManifestMissingDRMInfo: "04-31";
+    /** No license server was provided for the key system signaled by the manifest */
+    readonly ContentProtectionLicenseServerMissing: "04-32";
+    /** A required offline session was removed, affecting playback */
+    readonly ContentProtectionOfflineSessionRemoved: "04-33";
+    /** Error while executing init data transformation */
+    readonly ContentProtectionInitDataTransformationError: "04-34";
+    /** Server certificate request failed */
+    readonly ContentProtectionServerCertificateRequestFailed: "04-35";
+    /** HDCP version does not meet the requirements */
+    readonly ContentProtectionInsufficientHDCPVersion: "04-36";
+    /** Error when checking HDCP version */
+    readonly ContentProtectionHDCPVersionCheckFailed: "04-37";
+    /** Ads Section */
+    readonly AdsUnknown: "08-00";
+    readonly AdsVastParseError: "08-100";
+    readonly AdsInvalidVastSchema: "08-101";
+    readonly AdsVastVersionNotSupported: "08-102";
+    readonly AdsUnexpectedAdType: "08-200";
+    readonly AdsCreativeLinearityMismatch: "08-201";
+    readonly AdsCreativeDurationMismatch: "08-202";
+    readonly AdsCreativeSizeMismatch: "08-203";
+    readonly AdsWrapperVastError: "08-300";
+    readonly AdsVastResponseRedirectTimeout: "08-301";
+    readonly AdsWrapperLimitReached: "08-302";
+    readonly AdsVastResponseEmpty: "08-303";
+    readonly AdsLinearAdDisplayError: "08-400";
+    readonly AdsMediaFileNotFound: "08-401";
+    readonly AdsMediaFileUnavailable: "08-402";
+    readonly AdsUnsupportedMimeType: "08-403";
+    readonly AdsUnableToDisplayMediaFile: "08-405";
+    readonly AdsMezzanineFileMissing: "08-406";
+    readonly AdsMezzanineFileDownloaded: "08-407";
+    readonly AdsRejectedAd: "08-408";
+    readonly AdsInteractiveCreativeError: "08-409";
+    readonly AdsVerificationNodeExecutionError: "08-410";
+    readonly AdsNonLinearAdDisplayError: "08-500";
+    readonly AdsNonLinearAdSizeMismatch: "08-501";
+    readonly AdsNonLinearAdFetchError: "08-502";
+    readonly AdsNonLinearUnsupportedType: "08-503";
+    readonly AdsCompanionAdDisplayError: "08-600";
+    readonly AdsCompanionAdSizeMismatch: "08-601";
+    readonly AdsRequiredCompanionAdError: "08-602";
+    readonly AdsCompanionAdFetchError: "08-603";
+    readonly AdsUndefinedVastError: "08-900";
+    readonly AdsUnknownVpaidError: "08-901";
+    readonly AdsVastDocumentEmpty: "08-999";
+};
+
+declare type FlowplayerErrorCodeName = keyof typeof FlowplayerErrorCodeMap;
+
+declare type FlowplayerErrorConfig = Partial<{
+    isFatal: boolean;
+    showErrorUI: boolean;
+    isRetry: boolean;
+    resource: string;
+    rootErrorId: string;
+    retryOpts: Partial<{
+        retry: (typeof RetryMap)[keyof typeof RetryMap];
+        retryTimeout: number;
+    }>;
+}> & Record<string, any>;
+
+declare type FlowplayerErrorEventDetail = {
+    error: FlowplayerError;
+};
+
+/**
+ * @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<MergeConfigs<PluginCtors>, PlayerWith<MergePlayerExtensions<PluginCtors>>>;
+}
+
+declare interface FlowplayerUMDBase {
+    /**
+     * All player instances on the page
+     */
+    instances: Player[];
+    /**
+     * Flowplayer core events
+     */
+    events: typeof events;
+    /**
+     * Flowplayer ui states map
+     */
+    states: FlowplayerStates;
+    /**
+     * Flowplayer errors map
+     */
+    errors: typeof FlowplayerErrorCodeMap;
+    quality: typeof QualityOpts;
+    autoplay: typeof AutoplayOpts;
+    commit: string;
+    version: string;
+    /**
+     * Flowplayer's custom element registry
+     */
+    customElements: FlowplayerCustomElementRegistry;
+    /* 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 */
+    /**
+     * @public
+     * Translations dictionaries to be used with `@flowplayer/translations` package
+     *
+     * See [official documentation](https://developer.wowza.com/docs/wowza-flowplayer/player/translations/)
+     */
+    i18n: typeof I18n;
+}
+
+/**
+ * @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): PlayerWithOpts<PluginPlayer, ConfigWithPlugins>;
+    /**
+     * 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): PlayerWithOpts<PluginPlayer, ConfigWithPlugins>;
+}
+
+/**
+ * @public
+ */
+declare interface FPEvent<T> extends CustomEvent<T> {
+    /**
+     * @deprecated
+     the data attribute has been migrated to details to match the CustomEvent spec
+     more info: https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/CustomEvent
+     */
+    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";
+
+export declare namespace google {
+    /**
+     * The Google IMA SDK for HTML5 V3 allows developers to request and track VAST ads in a HTML5 video environment. For platform compatibility information and a detailed list of the video ad features supported by each of the IMA SDKs, see Support and Compatibility.
+     *
+     * Download the code samples to assist with implementing the IMA HTML5 SDK.
+     */
+    export namespace ima {
+        /**
+         * An ad class that's extended by classes representing different ad types.
+         */
+        export interface Ad {
+            /**
+             * Ad ID is used to synchronize master ad and companion ads.
+             * @returns The ID of the ad, or the empty string if this information is unavailable.
+             */
+            getAdId(): string;
+            /**
+             * Returns the ad's pod information.
+             * @returns The ad's pod information.
+             */
+            getAdPodInfo(): AdPodInfo;
+            /**
+             * The source ad server information included in the ad response.
+             * @returns The source ad server of the ad, or the empty string if this information is unavailable.
+             */
+            getAdSystem(): string;
+            /**
+             * The advertiser name as defined by the serving party.
+             * @returns The advertiser name, or the empty string if this information is unavailable.
+             */
+            getAdvertiserName(): string;
+            /**
+             * Identifies the API needed to execute the ad. This corresponds with the apiFramework specified in vast.
+             * @returns The API framework need to execute the ad, or null if this information is unavailable.
+             */
+            getApiFramework(): string | null;
+            /**
+             * Gets the companion ads for this ad based on companion ad slot size. Optionally, advanced selection settings are accepted. Note that this method will only return non-empty array for ad instances acquired on or after STARTED event. Specifically, ads from the LOADED event will return an empty array.
+             * @param adSlotWidth Width of the companion ad slot.
+             * @param adSlotHeight Height of the companion ad slot.
+             * @param settings The selection settings for companion ads.
+             * @returns Array of companion ads that matches the settings and the slot size.
+             */
+            getCompanionAds(
+            adSlotWidth: number,
+            adSlotHeight: number,
+            settings?: CompanionAdSelectionSettings
+            ): CompanionAd[];
+            /**
+             * Returns the content type of the currently selected creative, or empty string if no creative is selected or the content type is unavailable. For linear ads, the content type is only going to be available after the START event, when the media file is selected.
+             * @returns The content type, empty string if not available.
+             */
+            getContentType(): string;
+            /**
+             * Returns the ISCI (Industry Standard Commercial Identifier) code for an ad, or empty string if the code is unavailable. This is the Ad-ID of the creative in the VAST response.
+             */
+            getCreativeAdId(): string;
+            /**
+             * Retrieves the ID of the selected creative for the ad.
+             * @returns The ID of the selected creative for the ad, or the empty string if this information is unavailable.
+             */
+            getCreativeId(): string;
+            /**
+             * Returns the first deal ID present in the wrapper chain for the current ad, starting from the top. Returns the empty string if unavailable.
+             */
+            getDealId(): string;
+            /**
+             * Returns the description of this ad from the VAST response.
+             * @returns The description, empty if not specified.
+             */
+            getDescription(): string;
+            /**
+             * Returns the duration of the selected creative, or -1 for non-linear creatives.
+             * @returns The selected creative duration in seconds, -1 if non-linear.
+             */
+            getDuration(): number;
+            /**
+             * Returns the height of the selected non-linear creative.
+             * @returns The height of the selected non-linear creative or 0 for a linear creative.
+             */
+            getHeight(): number;
+            /**
+             * Returns the URL of the media file chosen from the ad based on the media selection settings currently in use. Returns null if this information is unavailable. Available on STARTED event.
+             */
+            getMediaUrl(): string | null;
+            /**
+             * Returns the minimum suggested duration in seconds that the nonlinear creative should be displayed. Returns -2 if the minimum suggested duration is unknown. For linear creative it returns the entire duration of the ad.
+             * @returns The minimum suggested duration in seconds that a creative should be displayed.
+             */
+            getMinSuggestedDuration(): number;
+            /**
+             * The number of seconds of playback before the ad becomes skippable. -1 is returned for non skippable ads or if this is unavailable.
+             * @returns The offset in seconds, or -1.
+             */
+            getSkipTimeOffset(): number;
+            /**
+             * Returns the URL associated with the survey for the given ad. Returns null if unavailable.
+             */
+            getSurveyUrl(): string | null;
+            /**
+             * Returns the title of this ad from the VAST response.
+             * @returns The title, empty if not specified.
+             */
+            getTitle(): string;
+            /**
+             * Gets custom parameters associated with the ad at the time of ad trafficking.
+             * @returns A mapping of trafficking keys to their values, or the empty Object if this information is not available.
+             */
+            getTraffickingParameters(): any;
+            /**
+             * Gets custom parameters associated with the ad at the time of ad trafficking. Returns a raw string version of the parsed parameters from getTraffickingParameters.
+             * @returns Trafficking parameters, or the empty string if this information is not available.
+             */
+            getTraffickingParametersString(): string;
+            /**
+             * Returns the UI elements that are being displayed when this ad is played. Refer to UiElements for possible elements of the array returned.
+             * @returns The UI elements being displayed.
+             */
+            getUiElements(): UiElements[];
+            /**
+             * The registry associated with cataloging the UniversalAdId of the selected creative for the ad.
+             * @returns Returns the registry value, or "unknown" if unavailable.
+             */
+            getUniversalAdIdRegistry(): string;
+            /**
+             * The UniversalAdId of the selected creative for the ad.
+             * @returns Returns the id value or "unknown" if unavailable.
+             */
+            getUniversalAdIdValue(): string;
+            /**
+             * Returns the VAST media height of the selected creative.
+             * @returns The VAST media height of the selected creative or 0 if none is selected.
+             */
+            getVastMediaHeight(): number;
+            /**
+             * Returns the VAST media width of the selected creative.
+             * @returns The VAST media width of the selected creative or 0 if none is selected.
+             */
+            getVastMediaWidth(): number;
+            /**
+             * Returns the width of the selected creative.
+             * @returns The width of the selected non-linear creative or 0 for a linear creative.
+             */
+            getWidth(): number;
+            /**
+             * Ad IDs used for wrapper ads. The IDs returned starts at the inline ad (innermost) and traverses to the outermost wrapper ad. An empty array is returned if there are no wrapper ads.
+             * @returns The IDs of the ads, starting at the inline ad, or an empty array if there are no wrapper ads.
+             */
+            getWrapperAdIds(): string[];
+            /**
+             * Ad systems used for wrapper ads. The ad systems returned starts at the inline ad and traverses to the outermost wrapper ad. An empty array is returned if there are no wrapper ads.
+             * @returns The ad systems of the ads, starting at the inline ad, or an empty array if there are no wrapper ads.
+             */
+            getWrapperAdSystems(): string[];
+            /**
+             * Selected creative IDs used for wrapper ads. The creative IDs returned starts at the inline ad and traverses to the outermost wrapper ad. An empty array is returned if there are no wrapper ads.
+             * @returns The IDs of the ads' creatives, starting at the inline ad, or an empty array if there are no wrapper ads.
+             */
+            getWrapperCreativeIds(): string[];
+            /**
+             * Indicates whether the ad’s current mode of operation is linear or non-linear. If the value is true, it indicates that the ad is in linear playback mode; if false, it indicates non-linear mode. The player checks the linear property and updates its state according to the details of the ad placement. While the ad is in linear mode, the player pauses the content video. If linear is true initially, and the ad is a pre-roll (defined externally), the player may choose to delay loading the content video until near the end of the ad playback.
+             * @returns True if the ad is linear, false otherwise.
+             */
+            isLinear(): boolean;
+        }
+
+        /**
+         * This class represents a container for displaying ads. The SDK will automatically create structures inside the containerElement parameter to house video and overlay ads.
+         *
+         * When an instance of this class is created, it creates an IFRAME in the containerElement and loads the SDK core. This IFRAME must be preserved in order for the SDK to function properly. Once all ads have been played and the SDK is no longer needed, use the destroy() method to unload the SDK.
+         *
+         * The containerElement parameter must be an element that is part of the DOM. It is necessary to correctly position the containerElement in order for the ads to be displayed correctly. It is recommended to position it above the content video player and size it to cover the whole video player. Please refer to the SDK documentation for details about recommended implementations.
+         */
+        export class AdDisplayContainer {
+            /**
+             *
+             * @param containerElement The element to display the ads in. The element must be inserted into the DOM before creating ima.AdDisplayContainer.
+             * @param videoElement Specifies the alternative video ad playback element. We recommend always passing in your content video player. Refer to Custom Ad Playback for more information.
+             * @param clickTrackingElement Specifies the alternative video ad click element. Leave this null to let the SDK handle clicks. Even if supplied, the SDK will only use the custom click tracking element when non-AdSense/AdX creatives are displayed in environments that do not support UI elements overlaying a video player (e.g. iPhone or pre-4.0 Android). The custom click tracking element should never be rendered over the video player because it can intercept clicks to UI elements that the SDK renders. Also note that the SDK will not modify the visibility of the custom click tracking element. This means that if a custom click tracking element is supplied, it must be properly displayed when the linear ad is played. You can check ima.AdsManager.isCustomClickTrackingUsed when the google.ima.AdEvent.Type.STARTED event is fired to determine whether or not to display your custom click tracking element. If appropriate for your UI, you should hide the click tracking element when the google.ima.AdEvent.Type.CONTENT_RESUME_REQUESTED event fires.
+             */
+            constructor(
+            containerElement: HTMLElement,
+            videoElement?: HTMLVideoElement,
+            clickTrackingElement?: HTMLElement
+            );
+            /**
+             * Destroys internal state and previously created DOM elements. The IMA SDK will be unloaded and no further calls to any APIs should be made.
+             */
+            public destroy(): void;
+            /**
+             * Initializes the video playback. On mobile platforms, including iOS and Android browsers, first interaction with video playback is only allowed within a user action (a click or tap) to prevent unexpected bandwidth costs. Call this method as a direct result of a user action before starting the ad playback. This method has no effect on desktop platforms and when custom video playback is used.
+             */
+            public initialize(): void;
+        }
+
+        /**
+         * AdError surfaces information to the user about whether a failure occurred during ad loading or playing. The errorType accessor provides information about whether the error occurred during ad loading or ad playing.
+         */
+        export class AdError extends Error {
+            /**
+             * Constructs the ad error based on the error data.
+             * @param data The ad error message data.
+             * @returns The constructed ad error object.
+             */
+            public static deserialize(data: any): AdError;
+            /**
+             * @returns The error code, as defined in google.ima.AdError.ErrorCode.
+             */
+            public getErrorCode(): AdError.ErrorCode;
+            /**
+             * Returns the Error that caused this one.
+             * @returns Inner error that occurred during processing, or null if this information is unavailable. This error may either be a native error or an google.ima.AdError, a subclass of a native error. This may return null if the error that caused this one is not available.
+             */
+            public getInnerError(): Error | null;
+            /**
+             * @returns The message for this error.
+             */
+            public getMessage(): string;
+            /**
+             * @returns The type of this error, as defined in google.ima.AdError.Type.
+             */
+            public getType(): string;
+            /**
+             * @returns If VAST error code is available, returns it, otherwise returns ima.AdError.ErrorCode.UNKNOWN_ERROR.
+             */
+            public getVastErrorCode(): number;
+            /**
+             * Serializes an ad to JSON-friendly object for channel transmission.
+             * @returns The transmittable ad error.
+             */
+            public serialize(): any;
+            public toString(): string;
+        }
+
+        export namespace AdError {
+            /**
+             * The possible error codes raised while loading or playing ads.
+             */
+            export enum ErrorCode {
+                /**
+                 * There was a problem requesting ads from the server. VAST error code 1012
+                 */
+                ADS_REQUEST_NETWORK_ERROR = 1012,
+                /**
+                 * There was an error with asset fallback. VAST error code 1021
+                 */
+                ASSET_FALLBACK_FAILED = 1021,
+                /**
+                 * The browser prevented playback initiated without user interaction. VAST error code 1205
+                 */
+                AUTOPLAY_DISALLOWED = 1205,
+                /**
+                 * A companion ad failed to load or render. VAST error code 603
+                 */
+                COMPANION_AD_LOADING_FAILED = 603,
+                /**
+                 * Unable to display one or more required companions. The master ad is discarded since the required companions could not be displayed. VAST error code 602
+                 */
+                COMPANION_REQUIRED_ERROR = 602,
+                /**
+                 * There was a problem requesting ads from the server. VAST error code 1005
+                 */
+                FAILED_TO_REQUEST_ADS = 1005,
+                /**
+                 * The ad tag url specified was invalid. It needs to be properly encoded. VAST error code 1013
+                 */
+                INVALID_AD_TAG = 1013,
+                /**
+                 * An invalid AdX extension was found. VAST error code 1105
+                 */
+                INVALID_ADX_EXTENSION = 1105,
+                /**
+                 * Invalid arguments were provided to SDK methods. VAST error code 1101
+                 */
+                INVALID_ARGUMENTS = 1101,
+                /**
+                 * Unable to display NonLinear ad because creative dimensions do not align with creative display area (i.e. creative dimension too large). VAST error code 501
+                 */
+                NONLINEAR_DIMENSIONS_ERROR = 501,
+                /**
+                 * An overlay ad failed to load. VAST error code 502
+                 */
+                OVERLAY_AD_LOADING_FAILED = 502,
+                /**
+                 * An overlay ad failed to render. VAST error code 500
+                 */
+                OVERLAY_AD_PLAYING_FAILED = 500,
+                /**
+                 * There was an error with stream initialization during server side ad insertion. VAST error code 1020
+                 */
+                STREAM_INITIALIZATION_FAILED = 1020,
+                /**
+                 * The ad response was not understood and cannot be parsed. VAST error code 1010
+                 */
+                UNKNOWN_AD_RESPONSE = 1010,
+                /**
+                 * An unexpected error occurred and the cause is not known. Refer to the inner error for more information. VAST error code 900
+                 */
+                UNKNOWN_ERROR = 900,
+                /**
+                 * Locale specified for the SDK is not supported. VAST error code 1011
+                 */
+                UNSUPPORTED_LOCALE = 1011,
+                /**
+                 * No assets were found in the VAST ad response. VAST error code 1007
+                 */
+                VAST_ASSET_NOT_FOUND = 1007,
+                /**
+                 * Empty VAST response. VAST error code 1009
+                 */
+                VAST_EMPTY_RESPONSE = 1009,
+                /**
+                 * Assets were found in the VAST ad response for linear ad, but none of them matched the video player's capabilities. VAST error code 403
+                 */
+                VAST_LINEAR_ASSET_MISMATCH = 403,
+                /**
+                 * The VAST URI provided, or a VAST URI provided in a subsequent wrapper element, was either unavailable or reached a timeout, as defined by the video player. The timeout is 5 seconds for initial VAST requests and each subsequent wrapper. VAST error code 301
+                 */
+                VAST_LOAD_TIMEOUT = 301,
+                /**
+                 * The ad response was not recognized as a valid VAST ad. VAST error code 100
+                 */
+                VAST_MALFORMED_RESPONSE = 100,
+                /**
+                 * Failed to load media assets from a VAST response. The default timeout for media loading is 8 seconds. VAST error code 402
+                 */
+                VAST_MEDIA_LOAD_TIMEOUT = 402,
+                /**
+                 * No Ads VAST response after one or more wrappers. VAST error code 303
+                 */
+                VAST_NO_ADS_AFTER_WRAPPER = 303,
+                /**
+                 * Assets were found in the VAST ad response for nonlinear ad, but none of them matched the video player's capabilities. VAST error code 503
+                 */
+                VAST_NONLINEAR_ASSET_MISMATCH = 503,
+                /**
+                 * Problem displaying MediaFile. Currently used if video playback is stopped due to poor playback quality. VAST error code 405
+                 */
+                VAST_PROBLEM_DISPLAYING_MEDIA_FILE = 405,
+                /**
+                 * VAST schema validation error. VAST error code 101
+                 */
+                VAST_SCHEMA_VALIDATION_ERROR = 101,
+                /**
+                 * The maximum number of VAST wrapper redirects has been reached. VAST error code 302
+                 */
+                VAST_TOO_MANY_REDIRECTS = 302,
+                /**
+                 * Trafficking error. Video player received an ad type that it was not expecting and/or cannot display. VAST error code 200
+                 */
+                VAST_TRAFFICKING_ERROR = 200,
+                /**
+                 * VAST duration is different from the actual media file duration. VAST error code 202
+                 */
+                VAST_UNEXPECTED_DURATION_ERROR = 202,
+                /**
+                 * Ad linearity is different from what the video player is expecting. VAST error code 201
+                 */
+                VAST_UNEXPECTED_LINEARITY = 201,
+                /**
+                 * The ad response contained an unsupported VAST version. VAST error code 102
+                 */
+                VAST_UNSUPPORTED_VERSION = 102,
+                /**
+                 * General VAST wrapper error. VAST error code 300
+                 */
+                VAST_WRAPPER_ERROR = 300,
+                /**
+                 * There was an error playing the video ad. VAST error code 400
+                 */
+                VIDEO_PLAY_ERROR = 400,
+                /**
+                 * A VPAID error occurred. Refer to the inner error for more information. VAST error code 901
+                 */
+                VPAID_ERROR = 901,
+            }
+
+            /**
+             * The possible error types for ad loading and playing.
+             */
+            export enum Type {
+                /**
+                 * Indicates that the error was encountered when the ad was being loaded. Possible causes: there was no response from the ad server, malformed ad response was returned, or ad request parameters failed to pass validation.
+                 */
+                AD_LOAD = "adLoadError",
+                /**
+                 * Indicates that the error was encountered after the ad loaded, during ad play. Possible causes: ad assets could not be loaded, etc.
+                 */
+                AD_PLAY = "adPlayError",
+            }
+        }
+
+        /**
+         * This event is raised when an error occurs when loading an ad from the Google or DoubleClick servers. The types on which you can register for the event are AdsLoader and AdsManager.
+         */
+        export class AdErrorEvent {
+            /**
+             * @returns The AdError that caused this event.
+             */
+            public getError(): AdError;
+            /**
+             * During ads load request it is possible to provide an object that is available once the ads load is complete or fails. One possible use case: relate ads response to a specific request and use user request content object as the key for identifying the response. If an error occurred during ads load, you can find out which request caused this failure.
+             * @returns Object that was provided during ads request.
+             */
+            public getUserRequestContext(): any;
+        }
+
+        export namespace AdErrorEvent {
+            /**
+             * Types of AdErrorEvents
+             */
+            export enum Type {
+                /**
+                 * Fired when an error occurred while the ad was loading or playing.
+                 */
+                AD_ERROR = "adError",
+            }
+
+            export type Listener = (event: AdErrorEvent) => void;
+        }
+
+        /**
+         * This event type is raised by the ad as a notification when the ad state changes and when users interact with the ad. For example, when the ad starts playing, is clicked on, etc. You can register for the various state changed events on AdsManager.
+         */
+        export class AdEvent {
+            /**
+             * Get the current ad that is playing or just played.
+             * @returns The ad associated with the event, or null if there is no relevant ad.
+             */
+            public getAd(): Ad | null;
+            /**
+             * Allows extra data to be passed from the ad.
+             * @returns Extra data for the event. Log events raised for error carry object of type 'google.ima.AdError' which can be accessed using 'adError' key.
+             */
+            public getAdData(): any;
+        }
+
+        export namespace AdEvent {
+            /**
+             * Types of AdEvents
+             */
+            export enum Type {
+                /**
+                 * Fired when an ad rule or a VMAP ad break would have played if autoPlayAdBreaks is false.
+                 */
+                AD_BREAK_READY = "adBreakReady",
+                /**
+                 * Fired when the ad has stalled playback to buffer.
+                 */
+                AD_BUFFERING = "adBuffering",
+                /**
+                 * Fired when an ads list is loaded.
+                 */
+                AD_METADATA = "adMetadata",
+                /**
+                 * Fired when the ad's current time value changes. Calling getAdData() on this event will return an AdProgressData object.
+                 */
+                AD_PROGRESS = "adProgress",
+                /**
+                 * Fired when the ads manager is done playing all the ads.
+                 */
+                ALL_ADS_COMPLETED = "allAdsCompleted",
+                /**
+                 * Fired when the ad is clicked.
+                 */
+                CLICK = "click",
+                /**
+                 * Fired when the ad completes playing.
+                 */
+                COMPLETE = "complete",
+                /**
+                 * Fired when content should be paused. This usually happens right before an ad is about to cover the content.
+                 */
+                CONTENT_PAUSE_REQUESTED = "contentPauseRequested",
+                /**
+                 * Fired when content should be resumed. This usually happens when an ad finishes or collapses.
+                 */
+                CONTENT_RESUME_REQUESTED = "contentResumeRequested",
+                /**
+                 * Fired when the ad's duration changes.
+                 */
+                DURATION_CHANGE = "durationChange",
+                /**
+                 * Fired when the ad playhead crosses first quartile.
+                 */
+                FIRST_QUARTILE = "firstQuartile",
+                /**
+                 * Fired when the impression URL has been pinged.
+                 */
+                IMPRESSION = "impression",
+                /**
+                 * Fired when an ad triggers the interaction callback. Ad interactions contain an interaction ID string in the ad data.
+                 */
+                INTERACTION = "interaction",
+                /**
+                 * Fired when the displayed ad changes from linear to nonlinear, or vice versa.
+                 */
+                LINEAR_CHANGED = "linearChanged",
+                /**
+                 * Fired when ad data is available.
+                 */
+                LOADED = "loaded",
+                /**
+                 * Fired when a non-fatal error is encountered. The user need not take any action since the SDK will continue with the same or next ad playback depending on the error situation.
+                 */
+                LOG = "log",
+                /**
+                 * Fired when the ad playhead crosses midpoint.
+                 */
+                MIDPOINT = "midpoint",
+                /**
+                 * Fired when the ad is paused.
+                 */
+                PAUSED = "pause",
+                /**
+                 * Fired when the ad is resumed.
+                 */
+                RESUMED = "resume",
+                /**
+                 * Fired when the displayed ads skippable state is changed.
+                 */
+                SKIPPABLE_STATE_CHANGED = "skippableStateChanged",
+                /**
+                 * Fired when the ad is skipped by the user.
+                 */
+                SKIPPED = "skip",
+                /**
+                 * Fired when the ad starts playing.
+                 */
+                STARTED = "start",
+                /**
+                 * Fired when the ad playhead crosses third quartile.
+                 */
+                THIRD_QUARTILE = "thirdQuartile",
+                /**
+                 * Fired when the ad is closed by the user.
+                 */
+                USER_CLOSE = "userClose",
+                /**
+                 * Fired when the ad volume has changed.
+                 */
+                VOLUME_CHANGED = "volumeChange",
+                /**
+                 * Fired when the ad volume has been muted.
+                 */
+                VOLUME_MUTED = "mute",
+            }
+
+            export type Listener = (event: AdEvent) => void;
+        }
+
+        /**
+         * An ad may be part of a pod of ads. This object exposes metadata related to that pod, such as the number of ads in the pod and ad position within the pod.
+         *
+         * The getTotalAds API contained within this object is often correct, but in certain scenarios, it represents the SDK's best guess. See that method's documentation for more information.
+         */
+        export interface AdPodInfo {
+            /**
+             * Returns the position of the ad.
+             * @returns The position of the ad within the pod. The value returned is one-based, i.e. 1 of 2, 2 of 2, etc.
+             */
+            getAdPosition(): number;
+            /**
+             * Returns true if the ad is a bumper ad. Bumper ads are short linear ads that can indicate to a user when the user is entering into or exiting from an ad break.
+             * @returns Whether the ad is a bumper ad.
+             */
+            getIsBumper(): boolean;
+            /**
+             * The maximum duration of the pod in seconds. For unknown duration, -1 is returned.
+             * @returns The maximum duration of the ads in this pod in seconds.
+             */
+            getMaxDuration(): number;
+            /**
+             * Returns the index of the ad pod.
+             *
+             * For preroll pod, 0 is returned. For midrolls, 1, 2, ... N is returned. For postroll, -1 is returned.
+             *
+             * For pods in VOD streams with dynamically inserted ads, 0...N is returned regardless of whether the ad is a pre-, mid-, or post-roll.
+             *
+             * Defaults to 0 if this ad is not part of a pod, or the pod is not part of an ad playlist.
+             *
+             * @returns The index of the pod in the ad playlist.
+             */
+            getPodIndex(): number;
+            /**
+             * Returns the content time offset at which the current ad pod was scheduled. For pods in VOD streams with dynamically inserted ads, stream time is returned.
+             *
+             * For preroll pod, 0 is returned. For midrolls, the scheduled time is returned. For postroll, -1 is returned.
+             *
+             * Defaults to 0 if this ad is not part of a pod, or the pod is not part of an ad playlist.
+             *
+             * @returns The time offset for the current ad pod.
+             */
+            getTimeOffset(): number;
+            /**
+             * The total number of ads contained within this pod, including bumpers. Bumper ads are short linear ads that can indicate to a user when the user is entering into or exiting from an ad break.
+             *
+             * Defaults to 1 if this ad is not part of a pod.
+             *
+             * In certain scenarios, the SDK does not know for sure how many ads are contained within this ad pod. These scenarios include ad pods, which are multiple ads within a single ad tag. In these scenarios, the first few AdEvents fired (AD_METADATA, LOADED, etc.) may have just the total number of ad tags from the playlist response. We recommend using the STARTED event as the event in which publishers pull information from this object and update the visual elements of the player, if any.
+             *
+             * @returns Total number of ads in the pod.
+             */
+            getTotalAds(): number;
+        }
+
+        /**
+         * AdsLoader allows clients to request ads from ad servers. To do so, users must register for the AdsManagerLoadedEvent event and then request ads.
+         */
+        export class AdsLoader {
+            /**
+             * @param container The display container for ads.
+             */
+            constructor(container: AdDisplayContainer);
+            /**
+             * Adds an event listener for the specified type.
+             * @param type The event type to listen to.
+             * @param listener The function to call when the event is triggered.
+             * @param useCapture Optional
+             */
+            public addEventListener(
+            type: AdsManagerLoadedEvent.Type,
+            listener: AdsManagerLoadedEvent.Listener,
+            useCapture?: boolean
+            ): void;
+            /**
+             * Adds an event listener for the specified type.
+             * @param type The event type to listen to.
+             * @param listener The function to call when the event is triggered.
+             * @param useCapture Optional
+             */
+            public addEventListener(
+            type: AdErrorEvent.Type,
+            listener: AdErrorEvent.Listener,
+            useCapture?: boolean
+            ): void;
+            /**
+             * Removes an event listener for the specified type.
+             * @param type The event type for which to remove an event listener.
+             * @param listener The function of the event handler to remove from the event target.
+             * @param useCapture Optional
+             */
+            public removeEventListener(
+            type: AdsManagerLoadedEvent.Type,
+            listener: AdsManagerLoadedEvent.Listener,
+            useCapture?: boolean
+            ): void;
+            /**
+             * Removes an event listener for the specified type.
+             * @param type The event type for which to remove an event listener.
+             * @param listener The function of the event handler to remove from the event target.
+             * @param useCapture Optional
+             */
+            public removeEventListener(
+            type: AdErrorEvent.Type,
+            listener: AdErrorEvent.Listener,
+            useCapture?: boolean
+            ): void;
+            /**
+             * Signals to the SDK that the content is finished. This will allow the SDK to play post-roll ads, if any are loaded via ad rules.
+             */
+            public contentComplete(): void;
+            /**
+             * Cleans up the internal state.
+             */
+            public destroy(): void;
+            /**
+             * Returns the IMA SDK settings instance. To change the settings, just call the methods on the instance. The changes will apply for all the ad requests made with this ads loader.
+             * @returns The settings instance.
+             */
+            public getSettings(): ImaSdkSettings;
+            /**
+             * Request ads from a server.
+             * @param adsRequest AdsRequest instance containing data for the ads request.
+             * @param userRequestContext User-provided object that is associated with the ads request. It can be retrieved when the ads are loaded.
+             */
+            public requestAds(adsRequest: AdsRequest, userRequestContext?: any): void;
+        }
+
+        /**
+         * This class is responsible for playing ads.
+         */
+        export interface AdsManager {
+            /**
+             * Adds an event listener for the specified type.
+             * @param type The event type to listen to
+             * @param listener The function to call when the event is triggered
+             * @param useCapture Optional
+             */
+            addEventListener(
+            type: AdEvent.Type,
+            listener: AdEvent.Listener,
+            useCapture?: boolean
+            ): void;
+            /**
+             * Adds an event listener for the specified type.
+             * @param type The event type to listen to
+             * @param listener The function to call when the event is triggered
+             * @param useCapture Optional
+             */
+            addEventListener(
+            type: AdErrorEvent.Type,
+            listener: AdErrorEvent.Listener,
+            useCapture?: boolean
+            ): void;
+            /**
+             * Removes an event listener for the specified type.
+             * @param type The event type for which to remove an event listener.
+             * @param listener The function of the event handler to remove from the event target.
+             * @param useCapture Optional
+             */
+            removeEventListener(
+            type: AdEvent.Type,
+            listener: AdEvent.Listener,
+            useCapture?: boolean
+            ): void;
+            /**
+             * Removes an event listener for the specified type.
+             * @param type The event type for which to remove an event listener.
+             * @param listener The function of the event handler to remove from the event target.
+             * @param useCapture Optional
+             */
+            removeEventListener(
+            type: AdErrorEvent.Type,
+            listener: AdErrorEvent.Listener,
+            useCapture?: boolean
+            ): void;
+            /**
+             * Collapse the current ad. This is no-op for HTML5 SDK.
+             */
+            collapse(): void;
+            /**
+             * Removes ad assets loaded at runtime that need to be properly removed at the time of ad completion and stops the ad and all tracking.
+             */
+            destroy(): void;
+            /**
+             * If an ad break is currently playing, discard it and resume content. Otherwise, ignore the next scheduled ad break. For example, this can be called immediately after the ads manager loads to ignore a preroll without losing future midrolls or postrolls. This is a no-op unless the ad request returned a playlist or VMAP response.
+             */
+            discardAdBreak(): void;
+            /**
+             * Expand the current ad. This is no-op for HTML5 SDK.
+             */
+            expand(): void;
+            /**
+             * Returns true if the ad can currently be skipped. When this value changes, the AdsManager fires an AdEvent.SKIPPABLE_STATE_CHANGED event.
+             * @returns True if the ad can currently be skipped, false otherwise.
+             */
+            getAdSkippableState(): boolean;
+            /**
+             * Returns an array of offsets in seconds indicating when a scheduled ad break will play. A preroll is represented by 0, and a postroll is represented by -1. An empty array indicates the ad or ad pod has no schedule and can be played at any time.
+             * @returns List of time offsets in seconds.
+             */
+            getCuePoints(): number[];
+            /**
+             * Get the remaining time of the current ad that is playing. If the ad is not loaded yet or has finished playing, the API would return -1.
+             * @returns Returns the time remaining for current ad. If the remaining time is undefined for the current ad (for example custom ads), the value returns -1.
+             */
+            getRemainingTime(): number;
+            /**
+             * Get the volume for the current ad.
+             * @returns The volume of the current ad, from 0 (muted) to 1 (loudest).
+             */
+            getVolume(): number;
+            /**
+             * Call init to initialize the ad experience on the ads manager.
+             * @param width The desired width of the ad.
+             * @param height The desired height of the ad.
+             * @param viewMode The desired view mode.
+             * @param videoElement The video element for custom playback. This video element overrides the one provided in the AdDisplayContainer constructor. Only use this property if absolutely necessary - otherwise we recommend specifying this video element while creating the AdDisplayContainer.
+             */
+            init(
+            width: number,
+            height: number,
+            viewMode: ViewMode,
+            videoElement?: HTMLVideoElement
+            ): void;
+            /**
+             * Returns true if a custom click tracking element is being used for click tracking on the current ad. Custom click tracking is only used when an optional click tracking element is provided to the AdDisplayContainer, custom playback is used, and the current ad is not an AdSense/AdX ad.
+             * @returns Whether custom click tracking is used.
+             */
+            isCustomClickTrackingUsed(): boolean;
+            /**
+             * Returns true if a custom video element is being used to play the current ad. Custom playback occurs when an optional video element is provided to the AdDisplayContainer on platforms where a custom video element would provide a more seamless ad viewing experience.
+             * @returns Whether custom playback is used.
+             */
+            isCustomPlaybackUsed(): boolean;
+            /**
+             * Pauses the current ad that is playing. This function will be no-op when a static overlay is being shown or if the ad is not loaded yet or is done playing.
+             */
+            pause(): void;
+            /**
+             * Resizes the current ad.
+             * @param width New ad slot width.
+             * @param height New ad slot height.
+             * @param viewMode The new view mode.
+             */
+            resize(width: number, height: number, viewMode: ViewMode): void;
+            /**
+             * Resumes the current ad that is loaded and paused. This function will be no-op when a static overlay is being shown or if the ad is not loaded yet or is done playing.
+             */
+            resume(): void;
+            /**
+             * Set the volume for the current ad.
+             * @param volume The volume to set, from 0 (muted) to 1 (loudest).
+             */
+            setVolume(volume: number): void;
+            /**
+             * Skips the current ad when AdsManager.getAdSkippableState() is true. When called under other circumstances, skip has no effect. After the skip is completed the AdsManager fires an AdEvent.SKIPPED event.
+             */
+            skip(): void;
+            /**
+             * Start playing the ads.
+             */
+            start(): void;
+            /**
+             * Stop playing the ads. Calling this will get publisher back to the content.
+             */
+            stop(): void;
+            /**
+             * Updates the ads rendering settings. This should be used specifically for VMAP use cases between ad breaks when ads rendering settings such as bitrate need to be updated.
+             * @param adsRenderingSettings The updated ads rendering settings.
+             */
+            updateAdsRenderingSettings(
+            adsRenderingSettings: Partial<AdsRenderingSettings>
+            ): void;
+        }
+
+        /**
+         * This event is raised when ads are successfully loaded from the Google or DoubleClick ad servers via an AdsLoader. You can register for this event on AdsLoader.
+         */
+        export class AdsManagerLoadedEvent {
+            /**
+             * After ads are loaded from the Google or DoubleClick ad servers, the publisher needs to play these ads either in their own video player or in the Google-provided video player. This method returns an AdsManager object. The AdsManager supports playing ads and allows the publisher to subscribe to various events during ad playback.
+             * @param contentPlayback Player that plays back publisher's content. This must be an object that contains the property currentTime, which allows the SDK to query playhead position to properly display midrolls in case ad server responds with an ad rule, and the duration property. The HMTL5 video element fulfills these requirements. You may optionally implement your own playhead tracker, as long as it fulfills the above requirements.
+             * @param adsRenderingSettings Optional settings to control the rendering of ads.
+             * @returns AdsManager that manages and plays ads.
+             */
+            public getAdsManager(
+            contentPlayback: {
+                currentTime: number;
+                duration: number;
+            },
+            adsRenderingSettings?: Partial<AdsRenderingSettings>
+            ): AdsManager;
+            /**
+             * @returns During ads load request it is possible to provide an object that is available once the ads load is complete. One possible use case: relate ads response to a specific request and use user request content object as a key for identifying the response.
+             */
+            public getUserRequestContext(): any;
+        }
+
+        export namespace AdsManagerLoadedEvent {
+            /**
+             * Types of AdsManagerLoadedEvents.
+             */
+            export enum Type {
+                /**
+                 * Fired when the ads have been loaded and an AdsManager is available.
+                 */
+                ADS_MANAGER_LOADED = "adsManagerLoaded",
+            }
+
+            export type Listener = (event: AdsManagerLoadedEvent) => void;
+        }
+
+        /**
+         * Defines parameters that control the rendering of ads.
+         */
+        export class AdsRenderingSettings {
+            /**
+             * Set to false if you wish to have fine grained control over the positioning of all non-linear ads. If this value is true, the ad is positioned in the bottom center. If this value is false, the ad is positioned in the top left corner. The default value is true.
+             */
+            public autoAlign: boolean;
+            /**
+             * Maximum recommended bitrate. The value is in kbit/s. The SDK will pick media with bitrate below the specified max, or the closest bitrate if there is no media with lower bitrate found. Default value, -1, means the bitrate will be selected by the SDK.
+             */
+            public bitrate: number;
+            /**
+             * Enables preloading of video assets. For more info see our guide to preloading media.
+             */
+            public enablePreloading: boolean;
+            /**
+             * Timeout (in milliseconds) when loading a video ad media file. If loading takes longer than this timeout, the ad playback is canceled and the next ad in the pod plays, if available. Use -1 for the default of 8 seconds.
+             */
+            public loadVideoTimeout: number;
+            /**
+             * Only supported for linear video mime types. If specified, the SDK will include media that matches the MIME type(s) specified in the list and exclude media that does not match the specified MIME type(s). The format is a list of strings, e.g., [ 'video/mp4', 'video/webm', ... ] If not specified, the SDK will pick the media based on player capabilities.
+             */
+            public mimeTypes: string[];
+            /**
+             * For VMAP and ad rules playlists, only play ad breaks scheduled after this time (in seconds). This setting is strictly after - e.g. setting playAdsAfterTime to 15 will cause IMA to ignore an ad break scheduled to play at 15s.
+             */
+            public playAdsAfterTime: number;
+            /**
+             * Specifies whether or not the SDK should restore the custom playback state after an ad break completes. This is setting is used primarily when the publisher passes in its content player to use for custom ad playback.
+             */
+            public restoreCustomPlaybackStateOnAdBreakComplete: boolean;
+            /**
+             * Specifies whether the UI elements that should be displayed. The elements in this array are ignored for AdSense/AdX ads.
+             */
+            public uiElements: UiElements[];
+            /**
+             * Render linear ads with full UI styling. This setting does not apply to AdSense/AdX ads or ads played in a mobile context that already use full UI styling by default.
+             */
+            public useStyledLinearAds: boolean;
+            /**
+             * Render non-linear ads with a close and recall button.
+             */
+            public useStyledNonLinearAds: boolean;
+        }
+
+        /**
+         * A class for specifying properties of the ad request.
+         */
+        export class AdsRequest {
+            /**
+             * Specifies a VAST 2.0 document to be used as the ads response instead of making a request via an ad tag url. This can be useful for debugging and other situations where a VAST response is already available.
+             *
+             * This parameter is optional.
+             */
+            public adsResponse?: string;
+            /**
+             * Specifies the ad tag url that is requested from the ad server. For details on constructing the ad tag url, see Create a master video tag manually.
+             *
+             * This parameter is required.
+             */
+            public adTagUrl: string;
+            /**
+             * Specifies the duration of the content in seconds to be shown. Used in AdX requests.
+             *
+             * This parameter is optional.
+             */
+            public contentDuration?: number;
+            /**
+             * Specifies the keywords used to describe the content to be shown. Used in AdX requests.
+             *
+             * This parameter is optional.
+             */
+            public contentKeywords?: string[];
+            /**
+             * Specifies the title of the content to be shown. Used in AdX requests.
+             *
+             * This parameter is optional.
+             */
+            public contentTitle?: string;
+            /**
+             * Forces non-linear AdSense ads to render as linear fullslot. If set, the content video will be paused and the non-linear text or image ad will be rendered as fullslot. The content video will resume once the ad has been skipped or closed.
+             */
+            public forceNonLinearFullSlot?: boolean;
+            /**
+             * Specifies the height of the rectangular area within which a linear ad is displayed. This value is used as one of the criteria for ads selection. This value does not need to match actual ad's height.
+             *
+             * This parameter is required.
+             */
+            public linearAdSlotHeight: number;
+            /**
+             * Specifies the width of the rectangular area within which a linear ad is displayed. This value is used as one of the criteria for ads selection. This value does not need to match actual ad's width.
+             *
+             * This parameter is required.
+             */
+            public linearAdSlotWidth: number;
+            /**
+             * Specifies the maximum amount of time to wait in seconds, after calling requestAds, before requesting the ad tag URL. This can be used to stagger requests during a live-stream event, in order to mitigate spikes in the number of requests.
+             */
+            public liveStreamPrefetchSeconds?: number;
+            /**
+             * Specifies the height of the rectangular area within which a non linear ad is displayed. This value is used as one of the criteria for ads selection. This value does not need to match actual ad's height.
+             *
+             * This parameter is required.
+             */
+            public nonLinearAdSlotHeight: number;
+            /**
+             * Specifies the width of the rectangular area within which a non linear ad is displayed. This value is used as one of the criteria for ads selection. This value does not need to match actual ad's width.
+             *
+             * This parameter is required.
+             */
+            public nonLinearAdSlotWidth: number;
+            /**
+             * Specifies the full url of the page that will be included in the Google ad request for targeting purposes. The url needs to be a valid url. If specified, this value will be used for the [PAGEURL] VAST macro.
+             *
+             * This parameter is optional.
+             */
+            public pageUrl?: string;
+            /**
+             * Override for default VAST load timeout in milliseconds for a single wrapper. The default timeout is 5000ms.
+             *
+             * This parameter is optional.
+             */
+            public vastLoadTimeout?: number;
+
+            /**
+             * Notifies the SDK whether the player intends to start the content and ad in response to a user action or whether it will be automatically played. Changing this setting will have no impact on ad playback.
+             * @param autoPlay Whether the content and the ad will be autoplayed or whether it will be started by a user action.
+             */
+            public setAdWillAutoPlay(autoPlay: boolean): void;
+            /**
+             * Notifies the SDK whether the player intends to start ad while muted. Changing this setting will have no impact on ad playback, but will send the appropriate signal in the ad request to allow buyers to bid on muted inventory.
+             * @param muted Whether the ad will be played while muted.
+             */
+            public setAdWillPlayMuted(muted: boolean): void;
+            /**
+             * Notifies the SDK whether the player intends to continuously play the content videos one after another similar to TV broadcast. Changing this setting will have no impact on the ad playback, but will send the appropriate signal in this ad request to allow buyers to bid on the type of ad inventory.
+             * @param continuousPlayback Whether the content video is played one after another continuously.
+             */
+            public setContinuousPlayback(continuousPlayback: boolean): void;
+        }
+
+        /**
+         * A companion ad class that is extended by companion ads of different ad types.
+         */
+        export interface CompanionAd {
+            /**
+             * @returns Returns the ad slot id for this companion.
+             */
+            getAdSlotId(): string;
+            /**
+             * Returns the HTML content for the companion ad that can be added to the publisher page.
+             * @returns The HTML content.
+             */
+            getContent(): string;
+            /**
+             * @returns The content type of the Companion Ad. This may return null if the content type is not known (such as in the case of a VAST HTMLResource or IFrameResource).
+             */
+            getContentType(): string | null;
+            /**
+             * @returns Returns the height of the companion in pixels.
+             */
+            getHeight(): number;
+            /**
+             * @returns Returns the width of the companion in pixels.
+             */
+            getWidth(): number;
+        }
+
+        /**
+         * CompanionAdSelectionSettings object is used to define the selection criteria when calling the ima.Ad.getCompanionAds function.
+         */
+        export class CompanionAdSelectionSettings {
+            /**
+             * The companion ad slot ids to be used for matching set by the user.
+             */
+            public adSlotIds: string[];
+            /**
+             * Creative type setting set by the user.
+             */
+            public creativeType: CompanionAdSelectionSettings.CreativeType;
+            /**
+             * The near fit percent set by the user.
+             */
+            public nearMatchPercent: number;
+            /**
+             * Resource type setting set by the user.
+             */
+            public resourceType: CompanionAdSelectionSettings.ResourceType;
+            /**
+             * Size criteria setting set by the user.
+             */
+            public sizeCriteria: CompanionAdSelectionSettings.SizeCriteria;
+        }
+
+        export namespace CompanionAdSelectionSettings {
+            /**
+             * Available choices for creative type of a companion ad. The user can specify any of these choices as a criterion for selecting companion ads.
+             */
+            export enum CreativeType {
+                /**
+                 * Specifies all creative types.
+                 */
+                ALL = "All",
+                /**
+                 * Specifies Flash creatives.
+                 */
+                FLASH = "Flash",
+                /**
+                 * Specifies image creatives (such as JPEG, PNG, GIF, etc).
+                 */
+                IMAGE = "Image",
+            }
+
+            /**
+             * Available choices for resource type of a companion ad. The user can specify any of these choices as a criterion for selecting companion ads.
+             */
+            export enum ResourceType {
+                /**
+                 * Specifies that the resource can be any type of resource.
+                 */
+                ALL = "All",
+                /**
+                 * Specifies that the resource should be an HTML snippet.
+                 */
+                HTML = "Html",
+                /**
+                 * Specifies that the resource should be a URL that should be used as the source of an iframe.
+                 */
+                IFRAME = "IFrame",
+                /**
+                 * Specifies that the resource should be a static file (usually the URL of an image of SWF).
+                 */
+                STATIC = "Static",
+            }
+
+            /**
+             * Available choices for size selection criteria. The user can specify any of these choices for selecting companion ads.
+             */
+            export enum SizeCriteria {
+                /**
+                 * Specifies that size should be ignored when choosing companions.
+                 */
+                IGNORE = "IgnoreSize",
+                /**
+                 * Specifies that only companions that match the size of the companion ad slot exactly should be chosen.
+                 */
+                SELECT_EXACT_MATCH = "SelectExactMatch",
+                /**
+                 * Specifies that any companion close to the size of the companion ad slot should be chosen.
+                 */
+                SELECT_NEAR_MATCH = "SelectNearMatch",
+            }
+        }
+
+        /**
+         * This class contains SDK-wide settings.
+         */
+        export class ImaSdkSettings {
+            /**
+             * Returns the current companion backfill mode.
+             * @returns The current value.
+             */
+            public getCompanionBackfill(): ImaSdkSettings.CompanionBackfillMode;
+            /**
+             * Gets whether to disable custom playback on iOS 10+ browsers. The default value is false.
+             */
+            public getDisableCustomPlaybackForIOS10Plus(): boolean;
+            /**
+             * @returns Whether flash ads should be disabled.
+             */
+            public getDisableFlashAds(): boolean;
+            /**
+             * Returns the publisher provided locale.
+             * @returns Publisher provided locale.
+             */
+            public getLocale(): string;
+            /**
+             * Returns the maximum number of redirects for subsequent redirects will be denied.
+             * @returns The maximum number of redirects.
+             */
+            public getNumRedirects(): number;
+            /**
+             * Returns the partner provided player type.
+             * @returns Partner player type.
+             */
+            public getPlayerType(): string;
+            /**
+             * Returns the partner provided player version.
+             * @returns Partner player version.
+             */
+            public getPlayerVersion(): string;
+            /**
+             * Returns the publisher provided id.
+             * @returns Publisher provided id.
+             */
+            public getPpid(): string;
+            /**
+             * Sets whether VMAP and ad rules ad breaks are automatically played
+             * @param autoPlayAdBreaks Whether to autoPlay the ad breaks.
+             */
+            public setAutoPlayAdBreaks(autoPlayAdBreaks: boolean): void;
+            /**
+             * Sets the companion backfill mode. Please see the various modes available in google.ima.ImaSdkSettings.CompanionBackfillMode.
+             *
+             * The default mode is ima.ImaSdkSettings.CompanionBackfillMode.ALWAYS.
+             *
+             * @param mode The desired companion backfill mode.
+             */
+            public setCompanionBackfill(
+            mode: ImaSdkSettings.CompanionBackfillMode
+            ): void;
+            /**
+             * Sets whether to disable custom playback on iOS 10+ browsers. If true, ads will play inline if the content video is inline. This enables TrueView skippable ads. However, the ad will stay inline and not support iOS's native fullscreen. When false, ads will play in the same player as your content. The value set here when an AdDisplayContainer is created is used for the lifetime of the container. The default value is false.
+             * @param disable Whether or not to disable custom playback.
+             */
+            public setDisableCustomPlaybackForIOS10Plus(disable: boolean): void;
+            /**
+             * Sets whether flash ads should be disabled.
+             * @param disableFlashAds Whether flash ads should be disabled.
+             */
+            public setDisableFlashAds(disableFlashAds: boolean): void;
+            /**
+             * Sets the publisher provided locale. Must be called before creating AdsLoader or AdDisplayContainer. The locale specifies the language in which to display UI elements and can be any two-letter ISO 639-1 code.
+             * @param locale Publisher-provided locale.
+             */
+            public setLocale(locale: string): void;
+            /**
+             * Specifies the maximum number of redirects before the subsequent redirects will be denied, and the ad load aborted. The number of redirects directly affects latency and thus user experience. This applies to all VAST wrapper ads.
+             * @param numRedirects The maximum number of redirects.
+             */
+            public setNumRedirects(numRedirects: number): void;
+            /**
+             * Sets the partner provided player type. This setting should be used to specify the name of the player being integrated with the SDK. Player type greater than 20 characters will be truncated. The player type specified should be short and unique. This is an optional setting used to improve SDK usability by tracking player types.
+             * @param playerType The type of the partner player.
+             */
+            public setPlayerType(playerType: string): void;
+            /**
+             * Sets the partner provided player version. This setting should be used to specify the version of the partner player being integrated with the SDK. Player versions greater than 20 characters will be truncated. This is an optional setting used to improve SDK usability by tracking player version.
+             * @param playerVersion The version of the partner player.
+             */
+            public setPlayerVersion(playerVersion: string): void;
+            /**
+             * Sets the publisher provided id.
+             * @param ppid Publisher provided id.
+             */
+            public setPpid(ppid: string): void;
+            /**
+             * Sets whether VPAID creatives are allowed.
+             * @param allowVpaid Whether to allow VPAID creatives.
+             * @deprecated Please use setVpaidMode.
+             */
+            public setVpaidAllowed(allowVpaid: boolean): void;
+            /**
+             * Sets VPAID playback mode.
+             * @param vpaidMode Sets how VPAID ads will be played. Default is to not allow VPAID ads.
+             */
+            public setVpaidMode(vpaidMode: ImaSdkSettings.VpaidMode): void;
+        }
+
+        export namespace ImaSdkSettings {
+            /**
+             * Defines a set of constants for the companion backfill setting. This setting indicates whether companions should be backfilled in various scenarios.
+             *
+             * The default value is ALWAYS.
+             *
+             * Note that client-side companion backfill requires tagging your companions properly with a Google Publisher Tag (GPT).
+             */
+            export enum CompanionBackfillMode {
+                /**
+                 * If the value is ALWAYS, companion backfill will be attempted in all situations, even when there is no master ad returned.
+                 */
+                ALWAYS = "always",
+                /**
+                 * If the value is ON_MASTER_AD, companion backfill will be attempted if there is a master ad with fewer companions than there are companion slots. The missing companions will be backfilled.
+                 */
+                ON_MASTER_AD = "on_master_ad",
+            }
+
+            /**
+             * A set of constants for enabling VPAID functionality.
+             */
+            export enum VpaidMode {
+                /**
+                 * VPAID ads will not play and an error will be returned.
+                 */
+                DISABLED = 0,
+                /**
+                 * VPAID ads are enabled using a cross domain iframe. The VPAID ad cannot access the site. VPAID ads that depend on friendly iframe access may error. This is the default.
+                 */
+                ENABLED = 1,
+                /**
+                 * VPAID ads are enabled using a friendly iframe. This allows the ad access to the site via JavaScript.
+                 */
+                INSECURE = 2,
+            }
+        }
+
+        /**
+         * Enum specifying different UI elements that can be configured to be displayed or hidden. These settings may be ignored for AdSense and ADX ads.
+         */
+        export enum UiElements {
+            /**
+             * Displays the "Ad" text in the ad UI. Must be present to show the countdown timer.
+             */
+            AD_ATTRIBUTION = "adAttribution",
+            /**
+             * Ad attribution is required for a countdown timer to be displayed. Both UiElements.COUNTDOWN and UiElements.AD_ATTRIBUTION must be present in AdsRenderingSettings.uiElements.
+             */
+            COUNTDOWN = "countdown",
+        }
+
+        /**
+         * Enum specifying different VPAID view modes for ads.
+         */
+        export enum ViewMode {
+            /**
+             * Fullscreen ad view mode. Indicates to the ads manager that the publisher considers the current AdDisplayContainer arrangement as fullscreen (i.e. simulated fullscreen). This does not cause the ads manager to enter fullscreen.
+             */
+            FULLSCREEN = "fullscreen",
+            /**
+             * Normal ad view mode.
+             */
+            NORMAL = "normal",
+        }
+
+        /**
+         * A string containing the full version of the SDK.
+         */
+        const VERSION: string;
+
+        /**
+         * Settings for the Google IMA SDK.
+         */
+        const settings: ImaSdkSettings;
+    }
+}
+
+declare const GRABBING = "is-grabbing";
+
+declare const HAS_POSTER = "has-poster";
+
+declare type HasGlobalSrcExtensios<PluginSrcs extends unknown[]> = ArrayToIntersection<PickGlobalSrcExtension<PluginSrcs>>;
+
+declare type HasSrcExtensions<PluginBareConfigs extends unknown[]> = TupleToUnion<PickSrcExtensions<PluginBareConfigs>> extends never ? false : true;
+
+declare const HOVERED = "is-hovered";
+
+declare class I18n implements Plugin_2 {
+    static pluginName: string;
+    static en: {
+        ads: {
+            ad: string;
+            ads: string;
+            advertisement: string;
+            indicator: string;
+            adchoices: string;
+        };
+        audio: {
+            button_txt: string;
+            menu_title: string;
+        };
+        cc: {
+            button: string;
+            menu_title: string;
+            options: string;
+            tracks: string;
+            reset: string;
+            colors: {
+                Black: string;
+                Blue: string;
+                Cyan: string;
+                Green: string;
+                Magenta: string;
+                Red: string;
+                White: string;
+                Yellow: string;
+            };
+            edgeStyle: {
+                None: string;
+                "Drop shadow": string;
+                Raised: string;
+                Depressed: string;
+                Outline: string;
+            };
+            fontFamily: {
+                "Monospaced Serif": string;
+                "Proportional Serif": string;
+                "Monospaced Sans-Serif": string;
+                "Proportional Sans-Serif": string;
+                Casual: string;
+                Cursive: string;
+            };
+            properties: {
+                fontFamily: string;
+                fontSize: string;
+                fontColor: string;
+                fontOpacity: string;
+                backgroundColor: string;
+                backgroundOpacity: string;
+                characterEdgeStyle: string;
+            };
+        };
+        chromecast: {
+            start: string;
+            stop: string;
+        };
+        core: {
+            exit_fullscreen: string;
+            fullscreen: string;
+            mute: string;
+            muted: string;
+            pause: string;
+            play: string;
+            seconds: string;
+            timeline_aria_label: string;
+            unmute: string;
+            volume: string;
+            close: string;
+            "skip-next": string;
+            "skip-prev": string;
+        };
+        ovp: {
+            starting_in: string;
+        };
+        playlist: {
+            cancel: string;
+            up_next: string;
+            autoplay: string;
+            now_playing: string;
+            turn_off_autoplay: string;
+            playlist: string;
+        };
+        qsel: {
+            menu_title: string;
+        };
+        share: {
+            clipboard_failure: string;
+            clipboard_success: string;
+            embed: string;
+            link: string;
+            menu_title: string;
+        };
+        speed: {
+            menu_title: string;
+        };
+        vtsel: {
+            button_txt: string;
+            menu_title: string;
+        };
+    };
+    init(config: Config, _root: never, video: Player): void;
+    /* Excluded from this release type: _nonLanguageFields */
+    /* Excluded from this release type: languagesLoaded */
+}
+
+declare class IMA implements Adapter {
+    readonly eventHandler: AdsController;
+    readonly log: Logger;
+    private _timers;
+    private _started;
+    private _volumeLevel;
+    private _adLoaded;
+    private _currentDuration;
+    private _currentRemaining;
+    private _currentDisplayTs;
+    private _adLinear?;
+    private _dimensions?;
+    private _adHandlers;
+    private opts;
+    private _adsManager;
+    private _adsLoader;
+    private _adDisplayContainer;
+    private videoTag;
+    private customPlaybackEnabled;
+    private _paused;
+    private loadingController;
+    private _all_ads_completed;
+    private google;
+    private _isInitialized;
+    private _adBreakTime;
+    private _prepared;
+    /**
+     * creates an instance of ImaAdapter
+     */
+    constructor(eventHandler: AdsController);
+    init(opts: any): Promise<void>;
+    initAdapter(): Promise<void>;
+    isReady(): boolean;
+    setVideoTag(tag: Player): void;
+    setAdBreakTime(time: number): void;
+    getAdBreakTime(): number;
+    isCustomPlaybackEnabled(): boolean;
+    isAttemptingPrerollOnIOS(): boolean;
+    setAttemptingPrerollOnIOS(preroll_ios: boolean): void;
+    isLinearAd(): boolean;
+    getVideoTag(): Maybe<Player>;
+    getDimensions(): Partial<{
+        width: number;
+        height: number;
+        linear: boolean;
+    }>;
+    getOpts(): Partial<IMAOpts>;
+    isPaused(): boolean;
+    destroy(): void;
+    stop(): void;
+    initialize(opts: Todo): void;
+    destroyManager(label?: string): void;
+    reset(): void;
+    cleanup(): void;
+    /**
+     * returns a Promise of the IMA AdManager
+     */
+    waitForAdsManager(): Promise<unknown>;
+    initAd(adTag: string, timeout?: number): Promise<void>;
+    requestAd(adTag: string, timeout: number): Promise<any>;
+    playAd(): Promise<void>;
+    /**
+     * returns a Promise of a completed Ad
+     */
+    startAndWaitForAdCompletion(adsManager: google.ima.AdsManager, linear: boolean): Promise<void> | undefined;
+    pause(): void;
+    resume(): void;
+    volume(level?: number): number | undefined;
+    onResize({ width, height, linear, silent, resize_non_linear }: ResizeInfo): void;
+    onAdRequestEnd(): void;
+    getAdInfo(): {
+        duration: number;
+        currentTime: number;
+    } | undefined;
+    currentAd(): google.ima.Ad | undefined;
+    isAdPod(): boolean;
+    /**
+     * fetch the cuepoints from this adapter
+     * allowing the flowplayer ad manager to schedule ads
+     * without caring about their requests
+     */
+    cuepoints(): number[] | undefined;
+    /**
+     * ad pods with ads in a postroll postion need this
+     * to signal to play post rolls
+     */
+    contentComplete(): Promise<void>;
+    isUiDisabled(): any;
+    getAdPodInfo(): google.ima.AdPodInfo | null | undefined;
+    canDismissNonLinear(): boolean;
+    /**
+     * better error unwrapping
+     * https://github.com/flowplayer/ads/issues/87
+     */
+    static unwrapError(err?: google.ima.AdError | Error, fallback?: string): string;
+    /**
+     * polls to ensure that an error has not happened
+     * and that an Ad is progressing
+     */
+    static pollForFatalError({ err, ima }: {
+        err: google.ima.AdErrorEvent;
+        ima: IMA;
+    }): Promise<{
+        ok?: 1;
+        err?: any;
+    }>;
+    /**
+     * generate an interval polling for the time remaining
+     * that will expose this value to the external wrapper
+     */
+    static pollRemaining({ ima, adsManager }: {
+        ima: IMA;
+        adsManager: google.ima.AdsManager;
+    }): number;
+    once(obj: Todo, evType: string, handler: Todo): void;
+    static race(obj: Todo, evTypes: string[], handler: Todo): void;
+    clearAdHandlers(): void;
+    emitWithAd<EventName extends keyof AdEventsDetailMap>(event: EventName, ad: google.ima.Ad): void;
+    emitError<EventName extends keyof AdEventsDetailMap>(event: EventName, error: google.ima.AdErrorEvent): void;
+    debugEvent(e: google.ima.AdEvent): void;
+}
+
+/**
+ * A special event to expose the IMA SDK AdsManager instance for custom event handling. The AdsManager instance is passed as a parameter to the event handler.
+ */
+declare const IMA_ADAPTER_INIT = "ad-ima-adapter-init";
+
+/**
+ * A special event to expose the IMA SDK AdsRenderingSettings
+ * {@link  https://developers.google.com/interactive-media-ads/docs/sdks/html5/client-side/reference/js/google.ima.AdsRenderingSettings}
+ */
+declare const IMA_ADS_RENDERING_SETTINGS = "ad-ima-rendering-settings";
+
+/**
+ * A special event to expose the IMA SDK AdsRequest
+ * {@link https://developers.google.com/interactive-media-ads/docs/sdks/html5/client-side/reference/js/google.ima.AdsRequest}
+ */
+declare const IMA_BEFORE_ADS_REQUEST = "ad-ima-before-ads-request";
+
+/**
+ *  @public
+ *  Event that exposes IMA's AdsManager for the users
+ */
+export declare type ImaAdapterInitEventDetail = google.ima.AdsManager;
+
+/**
+ *  @public
+ */
+export declare type ImaAdsRenderingSettingsEventDetail = google.ima.AdsRenderingSettings;
+
+/**
+ * @public
+ */
+export declare type ImaBeforeAdsRequestDetail = {
+    request: google.ima.AdsRequest;
+};
+
+/**
+ *  @public
+ */
+export declare type ImaBeforeAdsRequestEventDetail = AdBasicInfo & ImaBeforeAdsRequestDetail;
+
+declare type IMAOpts = {
+    width: number;
+    height: number;
+    autoplay: boolean;
+    disable_non_linear_ads: boolean;
+    media_timeout: number;
+    total_loading_timeout: number;
+};
+
+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
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+KEYUP = "keyup";
+
+/**
+ * @public
+ */
+declare type KeyValue = Record<string, any>;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+LANDSCAPE = "landscape";
+
+/**
+ * @public
+ * Represents a lazy-loaded ad tag.
+ */
+export declare interface LazyAdTag {
+    (): Promise<string>;
+}
+
+declare type Listenable = {
+    on<T>(eventName: string, handler: Listener<T>): void;
+};
+
+declare type Listener<T = any> = {
+    (e: FPEvent<T>): void;
+};
+
+/**
+ * @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 = "live";
+
+declare const LIVE_2 = "is-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 interface Logger {
+    (...args: any[]): void;
+    log(...args: any[]): void;
+}
+
+/**
+ * @public
+ */
+export declare type Macro = string | number | boolean | undefined | null;
+
+/**
+ * @public
+ */
+export declare type MacrosMap = Record<string, Macro>;
+
+declare type MapToBareConfigs<Plugins extends PluginCtor[]> = {
+    [PluginType in keyof Plugins]: ExtractBareConfig<Plugins[PluginType]>;
+};
+
+declare type MapToPlayerExtensions<Plugins extends PluginCtor[]> = {
+    [PluginIndex in keyof Plugins]: ExtractPluginPlayerExtension<Plugins[PluginIndex]>;
+};
+
+declare type Maybe<T> = undefined | T;
+
+declare const MENU_OPENED = "has-menu-opened";
+
+/**
+ * Combines plugin config and returns a type derived from Config
+ */
+declare type MergeConfigs<Plugins extends PluginCtor[]> = MergePluginConfigs<MapToBareConfigs<Plugins>>;
+
+declare type MergePlayerExtensions<Plugins extends PluginCtor[]> = ArrayToIntersection<MapToPlayerExtensions<Plugins>>;
+
+declare type MergePluginConfigs<PluginBareConfigs extends unknown[]> = HasSrcExtensions<PluginBareConfigs> extends true ? ConfigWithSourceExtensions<PluginBareConfigs> : ConfigWith<ArrayToIntersection<PluginBareConfigs>>;
+
+/**
+ * @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";
+
+declare type Metadata_2 = Record<string, string | number>;
+
+/**
+ @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
+ */
+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";
+
+declare const MUTED = "is-muted";
+
+declare const NO_AD_INDICATOR: number;
+
+declare const NO_CONTROLS = "no-controls";
+
+declare const NO_DVR = "no-timeline";
+
+declare const NO_FULLSCREEN: number;
+
+/* 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
+ * Emitted when the Prebid.js library is loaded so you can get a reference to Prebid.js and configure the pbjs object if necessary. For more, see Prebid properties https://developer.wowza.com/docs/wowza-flowplayer/plugins/advertising/#prebid-properties
+ */
+declare const PBJS_AVAILABLE = "ad/pbjs";
+
+/**
+ * @public
+ */
+declare type PBJSAvailebleEventDetail = {
+    pbjs: any;
+};
+
+declare type PickGlobalSrcExtension<PluginSrcs extends unknown[]> = {
+    [Index in keyof PluginSrcs]: PluginSrcs[Index] extends {
+        type: string;
+    } ? unknown : PluginSrcs[Index];
+};
+
+/**
+ * Maps incoming array to the src extension type
+ * @example
+ * ```
+ * PickSrcExtensions<[
+ *    {configProp: boolean, src: UnsafeSource<{srcProp: boolean}>},
+ *    {}
+ * ]> // = [{srcProp: boolean}, never]
+ * ```
+ */
+declare type PickSrcExtensions<PluginBareConfigs extends unknown[]> = {
+    [PluginType in keyof PluginBareConfigs]: ExtractSrcExtension<PluginBareConfigs[PluginType]>;
+};
+
+/**
+ * @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: TranslationKey): string;
+    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 */
+    /* Excluded from this release type: _customElements */
+    /* Excluded from this release type: _storage */
+};
+
+declare type PlayerCustomEventName = keyof PlayerCustomEventsDetailMap;
+
+declare type PlayerCustomEventsDetailMap = PlayerEmittableCustomEventsDetailMap & {
+    [REAP]: ReapEventDetail;
+    [SOURCE]: SourceEventDetail;
+    [MOUNT]: MountEventDetail;
+    [LIVE]: LiveEventDetail;
+    [DVR]: DvrEventDetail;
+    [RETRY]: RetryEventDetail;
+    [RECOVER]: RecoverEventDetail;
+    [QUALITIES]: QualitiesEventDetail;
+    [QUALITY_CHANGE]: QualityChangeEventDetail;
+    [STANDARD_ERROR]: FlowplayerErrorEventDetail;
+    /* Excluded from this release type: audioonlysource */
+    /* Excluded from this release type: renderplugin */
+    /* 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: "flowplayer:feature" */
+    /* Excluded from this release type: beforeplay */
+    /* Excluded from this release type: beforepause */
+    /* Excluded from this release type: state */
+    /* Excluded from this release type: config */
+    /* Excluded from this release type: "error:fatal" */
+};
+
+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(// 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 */
+    /**
+     * 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;
+    /**
+     * Emitted when an Error recovery is attempted
+     */
+    on(event: typeof RECOVER, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof RECOVER]>) => void): Player;
+    /**
+     * 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;
+    /**
+     * Emitted when a player will retry to reload
+     */
+    on(event: typeof RETRY, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof RETRY]>) => 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;
+    /**
+     * Emitted when the media changes quality.
+     */
+    on(event: typeof QUALITY_CHANGE, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof QUALITY_CHANGE]>) => void): Player;
+    /**
+     * Emitted when a standard FlowplayerError is encountered
+     */
+    on(event: typeof STANDARD_ERROR, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof STANDARD_ERROR]>) => 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, handler: (e: FPEvent<PlayerCustomEventsDetailMap[typeof LIVE]>) => 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 */
+    /* Excluded from this release type: on */
+    /**
+     * TODO: this is a workaround, since not all event overloads are typed. when all plugin work is finished, remove this
+     * https://wowzamedia.jira.com/browse/PLAY-653
+     */
+    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 PlayerEmittableEventNames>(event: T, data?: PlayerCustomEventsDetailMap[T]): Player;
+    emit(event: never, data?: never): Player;
+    /* Excluded from this release type: emit */
+    /* Excluded from this release type: emit */
+};
+
+declare type PlayerEmittableCustomEventsDetailMap = {
+    [CONTEXT_MENU]: ContextMenuEventDetail;
+    [VIEW_ENTER]: ViewEnterEventDetail;
+    [VIEW_LEAVE]: ViewLeaveEventDetail;
+    [RECOMMENDATIONS_READY]: RecommendationsReadyEventDetail;
+};
+
+declare type PlayerEmittableEventNames = keyof PlayerEmittableCustomEventsDetailMap;
+
+/**
+ * @public
+ */
+declare type PlayerEventOverloads = PlayerNativeEventsOverloads & PlayerCustomEventsOverloads;
+
+declare type PlayerHeight = number;
+
+/**
+ * @public
+ */
+export declare type PlayerIMAConfig = {
+    NumRedirects?: number;
+    /**
+     * Defines how long to wait for ad response from the network in milliseconds. Default value is 5000.
+     */
+    timeout?: number;
+    /**
+     * Defines how long to wait for both the ad response and the loading of the video ad in milliseconds. Default value is undefined.
+     */
+    total_loading_timeout?: number;
+    /**
+     * Shows all ad breaks between current time and new seek position when the viewer seeks ahead in the timeline. Default value is true.
+     */
+    show_all_ads_on_seek?: boolean;
+    /**
+     * Defines a list of ads to display.
+     */
+    ads: TimeBasedAd[];
+    /**
+     * Sets the locale. This is proxied to the {@link https://developers.google.com/interactive-media-ads/docs/sdks/html5/client-side/reference/js/google.ima.ImaSdkSettings#setLocale|setLocale()} method
+     */
+    Locale?: string;
+    /**
+     * Injects custom Ad Macro parameters into the {@link https://developer.wowza.com/docs/wowza-flowplayer/plugins/advertising/#pass-metadata-with-macros|Macro replacement engine}.
+     */
+    parameters?: MacrosMap;
+    /**
+     * Determines if ads should automatically pause when the player is out of the viewport. Default value is true.
+     */
+    autopause?: boolean;
+};
+
+declare type PlayerNativeEventName = keyof PlayerNativeEventsDetailMap;
+
+declare type PlayerNativeEventsDetailMap = HTMLVideoElementEventMap;
+
+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 */
+
+declare type PlayerWidth = number;
+
+/**
+ * @public
+ */
+declare type PlayerWith<T> = T & Player;
+
+declare type PlayerWithOpts<PluginPlayer extends Player = Player, PluginConfig extends Config = Config> = {
+    /* Excluded from this release type: on */
+} & Omit<PluginPlayer, "opts" | "setOpts"> & {
+    opts: PluginConfig;
+    setOpts: (config: PluginConfig) => void;
+};
+
+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;
+}
+
+/* Excluded from this release type: PLUGIN_REGISTERED */
+
+/**
+ * @public
+ */
+declare interface PluginCtor<PluginConfig extends Config = Config, PluginPlayer extends Player = Player> {
+    new (umd: FlowplayerUMD, player: Player): Plugin_2<PluginConfig, PluginPlayer>;
+    pluginName: string;
+}
+
+/* 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
+ * Represents a bidder configuration for Prebid.js.
+ */
+export declare type PrebidBidder = {
+    /**
+     * the bidder name as documented in: https://docs.prebid.org/dev-docs/bidders.html
+     */
+    bidder: string;
+    /**
+     * these are received from the specific ad network bidder and are different for every one!
+     * each bidder's parameters can be found here: https://docs.prebid.org/dev-docs/bidders.html
+     */
+    params: Record<string, any>;
+};
+
+/**
+ * @public
+ * Configuration for Prebid.js integration.
+ */
+export declare type PrebidConfig = {
+    /**
+     * @public
+     * Defines a list of multiple bidders. Each object within the array represents a single bidder and the parameters required to request the bid.
+     */
+    bidders: Array<PrebidBidder>;
+    /**
+     * @public
+     * Determines the timing of ad breaks within the video content. Represented as an array of time values in seconds.
+     */
+    breaks: Array<number>;
+    /**
+     * @public
+     * Passes a set of key value pairs as custom parameters when requesting bids from an ad network.
+     */
+    custom_params?: Record<string, string>;
+    /**
+     * @public
+     * Enables the configuration of top-level {@link https://docs.prebid.org/dev-docs/publisher-api-reference/setConfig.html|pbjs.setConfig} options that overwrite supplied values. Some bidders require this top-level configuration.
+     */
+    pbjs?: Record<string, any>;
+    /* Excluded from this release type: code */
+    /* Excluded from this release type: iu */
+    /* Excluded from this release type: video */
+};
+
+/* Excluded from this release type: PrebidVideoInfo */
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+PROGRESS = "progress";
+
+/**
+ * @public
+ */
+declare type QselOption = (Level & {
+    level: number;
+}) | Representation | {
+    name: string | number;
+    encodingId: string;
+    spatialLayerId: number;
+    temporalLayerId: number;
+    maxSpatialLayerId: number;
+    maxTemporalLayerId: number;
+    height: number;
+    width: number;
+};
+
+/**
+ * @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 = QselOption[];
+
+/**
+ * @public
+ * emitted whenever the media changes quality
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * emitted whenever the media changes quality
+ */
+QUALITY_CHANGE = "qualitychange";
+
+/**
+ * @public
+ */
+declare type QualityChangeEventDetail = {
+    before?: (Level & {
+        level?: number;
+    }) | Representation;
+    after: (Level & {
+        level?: number;
+    }) | Representation;
+    plugin: string;
+    automatic: boolean;
+    /* Excluded from this release type: downscale */
+};
+
+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[];
+};
+
+/**
+ * @public
+ * emitted when an Error recovery is attempted
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * emitted when an Error recovery is attempted
+ */
+RECOVER = "recover";
+
+/**
+ * @public
+ */
+declare type RecoverEventDetail = null;
+
+declare const RELOAD_AD_REQUESTED = "reload-ad-requested";
+
+/**
+ *  @public
+ */
+export declare type ReloadAdRequestedEventDetail = boolean;
+
+declare const REMAINING_TIME: number;
+
+/* 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;
+
+/**
+ * used by ui elements to toggle mute / unmute
+ */
+declare const REQUEST_AD_MUTE_UNMUTE = "request/ad/muteunmute";
+
+/**
+ * used by ui elements to signal to the ads controller that the current ad should be paused by the adapter
+ */
+declare const REQUEST_AD_PAUSE = "request/ad/pause";
+
+/**
+ * used by ui elements to signal to the ads controller that the current ad playback should be resumed by the adapter
+ */
+declare const REQUEST_AD_PLAY = "request/ad/play";
+
+/**
+ *  @public
+ */
+export declare type RequestAdMuteUnmuteEventDetail = null;
+
+/**
+ *  @public
+ */
+export declare type RequestAdPauseEventDetail = null;
+
+/**
+ *  @public
+ */
+export declare type RequestAdPlayEventDetail = null;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+RESIZE = "resize";
+
+declare type ResizeInfo = {
+    width: number;
+    height: number;
+    linear: boolean;
+    silent: boolean;
+    resize_non_linear: boolean;
+};
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+RETRY = "retry";
+
+/**
+ * @public
+ */
+declare type RetryEventDetail = FlowplayerErrorEventDetail;
+
+declare const RetryMap: {
+    readonly ON: "on";
+    readonly WITHOUT_RECOVERY: "without_recovery";
+    readonly OFF: "off";
+};
+
+declare const RTL = "is-rtl";
+
+declare const SampleRate: {
+    /**
+     * for new features with low adoption rates, or features that are likely to not be used frequently, will include every single instance in the sample.
+     */
+    readonly All: 1;
+    /**
+     * for events we anticipate receive a lot of usage and maybe happen frequently per session
+     */
+    readonly High: 0.1;
+    /**
+     * for events that can happen quickly, but not in massive amounts
+     */
+    readonly Medium: 0.01;
+    /**
+     * for very high volume events where you only want to sample a low amount of them (think volumechange | timeupdate)
+     */
+    readonly Low: 0.001;
+    /**
+     * placeholder for never sampling something, useful in situations where we want to add code to sample, but maybe not turn it on just yet.
+     */
+    readonly None: 0;
+};
+
+/**
+ * @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
+ * @deprecated please use Qsel.events.SET_QUALITY
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ * @deprecated please use Qsel.events.SET_QUALITY
+ */
+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<T = unknown> = {
+    src?: SourceStr;
+    /**
+     *  the MIME type (example `video/mp4` or `application/x-mpegurl`)
+     */
+    type?: string;
+} & T;
+
+/**
+ * @public
+ */
+declare type SourceStr = string;
+
+/**
+ * @public
+ */
+declare type SourceWith<T> = SourceObj & T;
+
+/**
+ * @public
+ *  emitted to handle playback related errors
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ *  emitted to handle playback related errors
+ */
+STANDARD_ERROR = "flowplayer:error";
+
+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_2 as 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
+    }
+}
+
+declare const STICKY_CONTROLS: number;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+TIME_UPDATE = "timeupdate";
+
+/**
+ * @public
+ * Configuration for a time-based ad.
+ */
+export declare type TimeBasedAd = BaseAdObj & {
+    /**
+     * Specifies a time to show the adTag: 0 is a pre-roll, -1 is post-roll. Values above 0 set the ad time in seconds.
+     */
+    time: number;
+};
+
+declare const TINY = "is-tiny";
+
+/**
+ * placeholder for todo types that we can use our editors to easily trace
+ */
+declare type Todo = any;
+
+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";
+
+/**
+ * @public
+ * All possible full paths to each translation,  i.e. "core.mute"| "core.play" | "ads.ad" etc.
+ * This type is useful for developers using translation querying based on path, like in lodash's get()
+ */
+declare type TranslationKey = Paths<Translation, {
+    leavesOnly: true;
+}>;
+
+declare type TSampleRate = typeof SampleRate;
+
+declare const TV = "is-tv";
+
+/**
+ * @public
+ */
+declare type UnsafeSource<SrcMixin = unknown> = SourceStr | SourceObj<SrcMixin> | Array<SourceStr | SourceObj<SrcMixin>>;
+
+declare type ValidSampleRate = TSampleRate[keyof TSampleRate];
+
+/**
+ * @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
+ * 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;
+
+declare const VOLUME_BAR: number;
+
+/**
+ * @public
+ */
+declare const /**
+@public
+* when a new player is inserted into the HTML
+*/ /**
+ * @public
+ */
+VOLUME_CHANGE = "volumechange";
+
+/* Excluded from this release type: VPAID_INIT */
+
+/* Excluded from this release type: VpaidInitEventDetail */
+
+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 { }