@gcorevideo/player 2.19.6 → 2.19.8

package/dist/player.d.ts

@@ -0,0 +1,1977 @@
+/**
+ * Video player for the Gcore streaming platform
+ *
+ * @remarks
+ * This package provides a video player for the Gcore streaming platform.
+ * It is built on top of the Clappr library and provides a framework for building custom integrations.
+ *
+ * @packageDocumentation
+ */
+
+import { $ } from '@clappr/core';
+import { AudioTrackLoadedData } from 'hls.js';
+import { AudioTrackSwitchedData } from 'hls.js';
+import { Container } from '@clappr/core';
+import { ContainerPlugin } from '@clappr/core';
+import { Core } from '@clappr/core';
+import { CorePlugin } from '@clappr/core';
+import { Events } from 'hls.js';
+import { Logger } from '@gcorevideo/utils';
+import { LogTracer } from '@gcorevideo/utils';
+import { reportError as reportError_2 } from '@gcorevideo/utils';
+import { SentryTracer } from '@gcorevideo/utils';
+import { setTracer } from '@gcorevideo/utils';
+import { trace } from '@gcorevideo/utils';
+import { UIContainerPlugin } from '@clappr/core';
+import { UICorePlugin } from '@clappr/core';
+import { UIObject } from '@clappr/core';
+
+/**
+ * @beta
+ */
+export declare class AudioSelector extends UICorePlugin {
+    private selectedTrackId;
+    private currentTrack;
+    private tracks;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    static get version(): string;
+    get template(): any;
+    get attributes(): {
+        class: string;
+        'data-track-selector': string;
+    };
+    get events(): {
+        'click [data-track-selector-select]': string;
+        'click [data-track-selector-button]': string;
+    };
+    bindEvents(): void;
+    unBindEvents(): void;
+    private bindPlaybackEvents;
+    private setupAudioTrackListeners;
+    private onStop;
+    reload(): void;
+    private shouldRender;
+    render(): this;
+    private fillTracks;
+    private findTrackBy;
+    private onTrackSelect;
+    private setIndexTrack;
+    onShowLevelSelectMenu(): void;
+    hideSelectTrackMenu(): void;
+    toggleContextMenu(): void;
+    private buttonElement;
+    private buttonElementText;
+    private trackElement;
+    private getTitle;
+    startTrackSwitch(): void;
+    private updateText;
+    updateCurrentTrack(e: Events.AUDIO_TRACK_SWITCHED, info: AudioTrackSwitchedData | AudioTrackLoadedData): void;
+    private updateCurrentTrackW3C;
+    private setCurrentTrack;
+    highlightCurrentTrack(): void;
+}
+
+/**
+ * @beta
+ */
+export declare class BigMuteButton extends UICorePlugin {
+    private isBigMuteButtonHidden;
+    private _adIsPlaying;
+    private $bigMuteBtnContainer;
+    private $bigMuteButton;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get events(): {
+        'click .big-mute-icon': string;
+        'click .big-mute-icon-wrapper': string;
+    };
+    bindEvents(): void;
+    private unBindEvents;
+    private onCoreReady;
+    private onContainerVolume;
+    private onContainerStart;
+    private onPlaybackEnded;
+    private mediaControlRendered;
+    private onStartAd;
+    private onFinishAd;
+    private shouldRender;
+    render(): this;
+    private hideBigMuteBtn;
+    private showBigMuteBtn;
+    private destroyBigMuteBtn;
+    private handleBigMuteBtnClick;
+}
+
+declare type BitrateTrackRecord = {
+    start: number;
+    end?: number;
+    time?: number;
+    bitrate: number;
+};
+
+/**
+ * @beta
+ */
+export declare class BottomGear extends UICorePlugin {
+    private isHd;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    static get version(): string;
+    get template(): any;
+    get attributes(): {
+        class: string;
+        'data-track-selector': string;
+    };
+    get events(): {
+        'click .button-gear': string;
+    };
+    get container(): any;
+    bindEvents(): void;
+    unBindEvents(): void;
+    private onActiveContainerChanged;
+    private bindContainerEvents;
+    reload(): void;
+    private highDefinitionUpdate;
+    render(): this;
+    refresh(): void;
+    toggleGearMenu(): void;
+    hide(): void;
+}
+
+/**
+ * @beta
+ */
+export declare class ClapprNerdStats extends UICorePlugin {
+    private container;
+    private customMetrics;
+    private metrics;
+    private showing;
+    private shortcut;
+    private iconPosition;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get attributes(): {
+        'data-clappr-nerd-stats': string;
+        class: string;
+    };
+    get events(): {
+        'click [data-show-stats-button]': string;
+        'click [data-close-button]': string;
+        'click [data-refresh-button]': string;
+    };
+    get statsBoxElem(): string;
+    get statsBoxWidthThreshold(): number;
+    get playerWidth(): any;
+    get playerHeight(): any;
+    constructor(core: Core);
+    bindEvents(): void;
+    private init;
+    private showOrHide;
+    private show;
+    private hide;
+    private onPlayerResize;
+    private addGeneralMetrics;
+    private addCustomMetrics;
+    private updateMetrics;
+    private setStatsBoxSize;
+    render(): this;
+    private addToBottomGear;
+    private clearCustomMetrics;
+    private refreshSpeedTest;
+}
+
+/**
+ * @beta
+ */
+export declare class ClapprStats extends ContainerPlugin {
+    private bwMeasureCount;
+    private intervalId;
+    private lastDecodedFramesCount;
+    private metrics;
+    private completion;
+    private _onReport;
+    private runBandwidthTestEvery;
+    private runEach;
+    private timers;
+    private updateFn;
+    private urisToMeasureBandwidth;
+    private uriToMeasureLatency;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get _playbackName(): string;
+    get _playbackType(): any;
+    private _now;
+    private _inc;
+    private start;
+    private _stop;
+    setUpdateMetrics(updateMetricsFn: MetricsUpdateFn): void;
+    _defaultReport(metrics: Metrics): void;
+    constructor(container: Container);
+    bindEvents(): void;
+    destroy(): void;
+    exportMetrics(): Metrics;
+    onBitrate(newBitrate: QualityLevel): void;
+    stopReporting(): void;
+    startTimers(): void;
+    onFirstPlaying(): void;
+    playAfterPause(): void;
+    private onPlay;
+    private onPause;
+    private onSeek;
+    private onTimeUpdate;
+    private onContainerUpdateWhilePlaying;
+    private onBuffering;
+    private onBufferfull;
+    private onProgress;
+    private _newMetrics;
+    private _onCompletion;
+    _buildReport(): void;
+    private _fetchFPS;
+    private _calculateBitrates;
+    private _calculatePercentages;
+    private _html5FetchFPS;
+    private _measureLatency;
+    private _measureBandwidth;
+}
+
+export declare class ClickToPause extends ContainerPlugin {
+    private pointerEnabled;
+    private timer;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get config(): any;
+    bindEvents(): void;
+    private click;
+    private settingsUpdate;
+    private togglePlay;
+    private clearTimer;
+}
+
+export declare class ClipsPlugin extends UICorePlugin {
+    private clips;
+    private duration;
+    private durationGetting;
+    private _oldContainer;
+    private svgMask;
+    get name(): string;
+    get attributes(): {
+        class: string;
+    };
+    bindEvents(): void;
+    private _onCoreReady;
+    unbindEvents(): void;
+    private _onMediaControlContainerChanged;
+    private playerResize;
+    private _bindContainerEvents;
+    private onTimeUpdate;
+    private parseClips;
+    getText(time: number): string;
+    makeSvg(duration: number): void;
+    private setSVGMask;
+    private setClipText;
+}
+
+/**
+ * Dimensions of the player container DOM element.
+ * @beta
+ */
+export declare type ContainerSize = {
+    width: number;
+    height: number;
+};
+
+export declare class ContextMenu extends UICorePlugin {
+    private _label;
+    private _url;
+    private container;
+    private menuOptions;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get attributes(): {
+        class: string;
+    };
+    get mediaControl(): any;
+    get template(): any;
+    get label(): string;
+    get url(): string;
+    get exposeVersion(): {
+        label: string;
+        name: string;
+    };
+    get events(): {
+        'click [data-version]': string;
+    };
+    constructor(core: Core);
+    bindEvents(): void;
+    destroy(): UIObject;
+    private containerChanged;
+    private toggleContextMenu;
+    private show;
+    private hide;
+    private onOpenMainPage;
+    render(): this;
+}
+
+/**
+ * A plain JS object that must conform to the DASH.js settings schema.
+ * @beta
+ * {@link https://cdn.dashjs.org/latest/jsdoc/module-Settings.html | DASH.js settings}
+ */
+export declare type DashSettings = Record<string, unknown>;
+
+export declare class DisableControls extends UICorePlugin {
+    get name(): string;
+    get container(): any;
+    get supportedVersion(): {
+        min: string;
+    };
+    bindEvents(): void;
+    unbindEvents(): void;
+    private setDisableStyles;
+    private onCoreReady;
+    private enableControls;
+    private disableAllControls;
+}
+
+export declare class DvrControls extends UICorePlugin {
+    get template(): any;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get events(): {
+        'click .live-button': string;
+    };
+    get attributes(): {
+        class: string;
+        'data-dvr-controls': string;
+    };
+    constructor(core: Core);
+    bindEvents(): void;
+    private bindCoreEvents;
+    private bindContainerEvents;
+    private containerChanged;
+    private dvrChanged;
+    click(): void;
+    settingsUpdate(): void;
+    shouldRender(): boolean;
+    render(): this;
+}
+
+/**
+ * Levels of severity of errors. Non-fatal errors usually can be ignored.
+ * @beta
+ */
+export declare type ErrorLevel = 'FATAL' | 'WARN' | 'INFO';
+
+export declare class ErrorScreen extends UICorePlugin {
+    private _retry;
+    private err;
+    private hideValue;
+    private timeout;
+    private reloadButton;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get container(): any;
+    get attributes(): {
+        class: string;
+        'data-error-screen': string;
+    };
+    bindEvents(): void;
+    private onCoreReady;
+    private onPlay;
+    private destroyError;
+    unBindEvents(): void;
+    private bindReload;
+    private reload;
+    private unbindReload;
+    private onContainerChanged;
+    private onStartAd;
+    private onFinishAd;
+    private onError;
+    private drying;
+    show(err?: PresentationalError): void;
+    hide(): void;
+    render(): this;
+}
+
+export declare class Favicon extends CorePlugin {
+    private _container;
+    private oldIcon;
+    private playIcon;
+    private pauseIcon;
+    private stopIcon;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    constructor(core: Core);
+    configure(): void;
+    bindEvents(): void;
+    private containerChanged;
+    disable(): void;
+    destroy(): void;
+    private createIcon;
+    private setPlayIcon;
+    private setPauseIcon;
+    private resetIcon;
+    private changeIcon;
+}
+
+export declare class GoogleAnalytics extends ContainerPlugin {
+    private account;
+    private trackerName;
+    private domainName;
+    private currentHDState;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    constructor(container: Container);
+    embedScript(): void;
+    addEventListeners(): void;
+    onReady(): void;
+    onPlay(): void;
+    onStop(): void;
+    onEnded(): void;
+    onBuffering(): void;
+    onBufferFull(): void;
+    onError(): void;
+    onHD(isHD: boolean): void;
+    private onPlaybackChanged;
+    onDVR(dvrInUse: boolean): void;
+    onPause(): void;
+    onSeek(): void;
+    onVolumeChanged(): void;
+    onFullscreen(): void;
+    push(array: string[]): void;
+}
+
+declare type KeyboardEventHandler = (e: KeyboardEvent) => boolean | undefined;
+
+/**
+ * @internal
+ */
+export declare class Kibo {
+    private element;
+    private lastKeyCode;
+    private lastModifiers;
+    private keysDown;
+    private keysUp;
+    private downHandler;
+    private upHandler;
+    constructor(element?: Document | Element);
+    private handler;
+    private registerKeys;
+    private unregisterKeys;
+    off(keys: string | string[]): Kibo;
+    delegate(upOrDown: UpDown, keys: string | string[], func?: KeyboardEventHandler | null): Kibo;
+    down(keys: string | string[], func?: KeyboardEventHandler | null): Kibo;
+    up(keys: string | string[], func?: KeyboardEventHandler | null): Kibo;
+    lastKey(modifier?: string): string | boolean;
+    lastModifiersAndKey(): string;
+}
+
+/**
+ * An ISO 639-1 language code.
+ * @example `pt`
+ * @beta
+ */
+export declare type LangTag = string;
+
+/**
+ * Allows to control the quality level of the playback.
+ * @beta
+ *
+ * @remarks
+ * The plugin is rendered as a button in the gear menu.
+ * When clicked, it shows a list of quality levels to choose from.
+ *
+ * Configuration options:
+ *
+ * - `labels`: The labels to show in the level selector. [vertical resolution]: string
+ * - `restrictResolution`: The maximum resolution to allow in the level selector.
+ *
+ * @example
+ * ```ts
+ * {
+ *   levelSelector: {
+ *     restrictResolution: 360,
+ *     labels: { 360: '360p', 720: '720p' },
+ *   },
+ * }
+ * ```
+ */
+export declare class LevelSelector extends UICorePlugin {
+    private levels;
+    private levelLabels;
+    private removeAuto;
+    private isHd;
+    private isOpen;
+    private buttonTemplate;
+    private listTemplate;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    static get version(): string;
+    get attributes(): {
+        class: string;
+        'data-level-selector': string;
+    };
+    private currentText;
+    private selectedLevelId;
+    get events(): {
+        'click .gear-sub-menu_btn': string;
+        'click .gear-option': string;
+        'click .go-back': string;
+    };
+    bindEvents(): void;
+    private bindPlaybackEvents;
+    private onStop;
+    private shouldRender;
+    render(): this;
+    private renderButton;
+    private renderDropdown;
+    private get maxLevel();
+    private fillLevels;
+    private makeLevelsLabels;
+    private onLevelSelect;
+    private goBack;
+    private setLevel;
+    private onShowLevelSelectMenu;
+    private allLevelElements;
+    private levelElement;
+    private onLevelSwitchStart;
+    private onLevelSwitchEnd;
+    private updateText;
+    private getLevelLabel;
+    private updateCurrentLevel;
+    private highlightCurrentLevel;
+    private deferRender;
+}
+
+export { Logger }
+
+export declare class Logo extends UIContainerPlugin {
+    private hasStartedPlaying;
+    private $logoContainer;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get attributes(): {
+        class: string;
+        'data-logo': string;
+    };
+    private get shouldRender();
+    bindEvents(): void;
+    stopListening(): this;
+    private onPlay;
+    private onStop;
+    private update;
+    constructor(container: Container);
+    render(): this;
+    private setLogoImgAttrs;
+    private setLogoWidth;
+    private setPosition;
+    private setStyles;
+    private setStyle;
+}
+
+export { LogTracer }
+
+/**
+ * The MediaControl is responsible for displaying the Player controls.
+ * @beta
+ * @remarks
+ * This plugin provides a foundation for developing a media controls UI via additional plugins.
+ * The methods exposed are to be used by the other plugins that extend the media control UI.
+ */
+export declare class MediaControl extends UICorePlugin {
+    private advertisementPlaying;
+    private buttonsColor;
+    private currentDurationValue;
+    private currentPositionValue;
+    private currentSeekBarPercentage;
+    private disabledClickableList;
+    private displayedDuration;
+    private displayedPosition;
+    private displayedSeekBarPercentage;
+    private draggingSeekBar;
+    private draggingVolumeBar;
+    private fullScreenOnVideoTagSupported;
+    private hideId;
+    private hideVolumeId;
+    private intendedVolume;
+    private isHD;
+    private keepVisible;
+    private kibo;
+    private lastMouseX;
+    private lastMouseY;
+    private persistConfig;
+    private rendered;
+    private settings;
+    private svgMask;
+    private userDisabled;
+    private userKeepVisible;
+    private verticalVolume;
+    private $audioTracksSelector;
+    private $bottomGear;
+    private $clipText;
+    private $clipTextContainer;
+    private $duration;
+    private $fullscreenToggle;
+    private $multiCameraSelector;
+    private $pip;
+    private $playPauseToggle;
+    private $playStopToggle;
+    private $playbackRate;
+    private $position;
+    private $seekBarContainer;
+    private $seekBarHover;
+    private $seekBarLoaded;
+    private $seekBarPosition;
+    private $seekBarScrubber;
+    private $subtitlesSelector;
+    private $volumeBarContainer;
+    private $volumeBarBackground;
+    private $volumeBarFill;
+    private $volumeBarScrubber;
+    private $volumeContainer;
+    private $volumeIcon;
+    private readonly template;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get disabled(): any;
+    get container(): any;
+    get playback(): any;
+    get attributes(): {
+        class: string;
+        'data-media-control-skin-1': string;
+    };
+    get events(): {
+        'click [data-play]': string;
+        'click [data-pause]': string;
+        'click [data-playpause]': string;
+        'click [data-stop]': string;
+        'click [data-playstop]': string;
+        'click [data-fullscreen]': string;
+        'click .bar-container[data-seekbar]': string;
+        'click .bar-container[data-volume]': string;
+        'click .drawer-icon[data-volume]': string;
+        'mouseenter .drawer-container[data-volume]': string;
+        'mouseleave .drawer-container[data-volume]': string;
+        'mousedown .bar-container[data-volume]': string;
+        'touchstart .bar-container[data-volume]': string;
+        'mousemove .bar-container[data-volume]': string;
+        'touchmove .bar-container[data-volume]': string;
+        'mousedown .bar-scrubber[data-seekbar]': string;
+        'mousedown .bar-container[data-seekbar]': string;
+        'touchstart .bar-scrubber[data-seekbar]': string;
+        'touchstart .bar-container[data-seekbar]': string;
+        'mousemove .bar-container[data-seekbar]': string;
+        'touchmove .bar-container[data-seekbar]': string;
+        'mouseleave .bar-container[data-seekbar]': string;
+        'touchend .bar-container[data-seekbar]': string;
+        'mouseenter .media-control-layer[data-controls]': string;
+        'mouseleave .media-control-layer[data-controls]': string;
+    };
+    /**
+     * Current volume
+     */
+    get volume(): any;
+    /**
+     * Muted state
+     */
+    get muted(): boolean;
+    constructor(core: Core);
+    getExternalInterface(): {
+        setVolume: (value: number, isInitialVolume?: boolean) => void;
+        getVolume: () => any;
+    };
+    bindEvents(): void;
+    bindContainerEvents(): void;
+    disable(): void;
+    enable(): void;
+    /**
+     * Start the playback
+     */
+    play(): void;
+    /**
+     * Pause the playback
+     */
+    pause(): void;
+    /**
+     * Stop the playback
+     */
+    stop(): void;
+    /**
+     * Set the initial volume, which is preserved when playback is interrupted by an advertisement
+     */
+    setInitialVolume(): void;
+    private onVolumeChanged;
+    private onLoadedMetadataOnVideoTag;
+    private updateVolumeUI;
+    private changeTogglePlay;
+    private mousemoveOnSeekBar;
+    private mouseleaveOnSeekBar;
+    private onVolumeClick;
+    private mousemoveOnVolumeBar;
+    private playerResize;
+    private togglePlayPause;
+    private togglePlayStop;
+    private startSeekDrag;
+    private startVolumeDrag;
+    private stopDrag;
+    private updateDrag;
+    private getVolumeFromUIEvent;
+    private toggleMute;
+    /**
+     * Set the volume
+     * @param value - The volume value
+     * @param isInitialVolume - save as the initial volume
+     * @remarks
+     * Initial volume can be restored later
+     */
+    setVolume(value: number, isInitialVolume?: boolean): void;
+    private toggleFullscreen;
+    private onActiveContainerChanged;
+    private showVolumeBar;
+    private hideVolumeBar;
+    private ended;
+    private updateProgressBar;
+    private onTimeUpdate;
+    private renderSeekBar;
+    private drawDurationAndPosition;
+    private seek;
+    private setKeepVisible;
+    private resetKeepVisible;
+    private setUserKeepVisible;
+    private resetUserKeepVisible;
+    private isVisible;
+    private show;
+    private hide;
+    private updateCursorStyle;
+    private settingsUpdate;
+    private getSettings;
+    private highDefinitionUpdate;
+    private createCachedElements;
+    /**
+     * Get a media control element DOM node
+     * @param name - The name of the media control element
+     * @returns The DOM node to render the media control element
+     */
+    getElement(name: MediaControlElement): ZeptoResult | null;
+    private resetIndicators;
+    private initializeIcons;
+    private setSeekPercentage;
+    private seekRelative;
+    private bindKeyAndShow;
+    private bindKeyEvents;
+    private unbindKeyEvents;
+    private parseColors;
+    private applyButtonStyle;
+    destroy(): UIObject;
+    private configure;
+    render(): this;
+    private handleFullScreenOnBtn;
+    private onStartAd;
+    private onFinishAd;
+    private hideControllAds;
+    setMuted(value: boolean): void;
+    private static getPageX;
+    private static getPageY;
+    /**
+     * Enable the control button
+     */
+    enableControlButton(): void;
+    /**
+     * Disable the control button
+     */
+    disabledControlButton(): void;
+    private isSeekEnabledForHtml5Playback;
+}
+
+/**
+ * @beta
+ */
+export declare type MediaControlElement = 'clipText' | 'pip' | 'seekBarContainer';
+
+declare type MediaSourceInfo = {
+    live: boolean;
+    source: string;
+    id: number;
+    dvr: boolean;
+    projection: string | null;
+};
+
+/**
+ * Media delivery protocol
+ * @beta
+ */
+export declare type MediaTransport = 'dash' | 'hls';
+
+declare type Metrics = {
+    counters: {
+        play: number;
+        pause: number;
+        error: number;
+        buffering: number;
+        decodedFrames: number;
+        droppedFrames: number;
+        fps: number;
+        changeLevel: number;
+        seek: number;
+        fullscreen: number;
+        dvrUsage: number;
+    };
+    timers: {
+        startup: number;
+        watch: number;
+        pause: number;
+        buffering: number;
+        session: number;
+        latency: number;
+    };
+    extra: {
+        playbackName: string;
+        playbackType: string;
+        bitratesHistory: BitrateTrackRecord[];
+        bitrateWeightedMean: number;
+        bitrateMostUsed: number;
+        buffersize: number;
+        watchHistory: Array<[number, number]>;
+        watchedPercentage: number;
+        bufferingPercentage: number;
+        bandwidth: number;
+        duration: number;
+        currentTime: number;
+    };
+    custom: Record<string, unknown>;
+};
+
+declare type MetricsUpdateFn = (metrics: Metrics) => void;
+
+export declare class MultiCamera extends UICorePlugin {
+    private currentCamera;
+    private currentTime;
+    private playing;
+    private multicamera;
+    private noActiveStreams;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    static get version(): string;
+    get template(): any;
+    get attributes(): {
+        class: string;
+        'data-multicamera': string;
+    };
+    get events(): {
+        'click [data-multicamera-selector-select]': string;
+        'click [data-multicamera-button]': string;
+    };
+    constructor(core: Core);
+    bindEvents(): void;
+    unBindEvents(): void;
+    private onPlay;
+    private bindPlaybackEvents;
+    private reload;
+    private shouldRender;
+    render(): this;
+    private onCameraSelect;
+    activeById(id: number, active: boolean): void;
+    private setLiveStatus;
+    private behaviorLive;
+    private behaviorOne;
+    private behaviorAll;
+    private findAndInitNextStream;
+    private showError;
+    private hideError;
+    private changeById;
+    getCamerasList(): MediaSourceInfo[];
+    getCurrentCamera(): MediaSourceInfo | null;
+    private findElementById;
+    private findIndexById;
+    private onShowLevelSelectMenu;
+    private hideSelectLevelMenu;
+    private toggleContextMenu;
+    private levelElement;
+    private highlightCurrentLevel;
+}
+
+export declare class PictureInPicture extends UICorePlugin {
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    static get version(): string;
+    get events(): {
+        'click button': string;
+    };
+    get videoElement(): any;
+    bindEvents(): void;
+    private isPiPSupported;
+    render(): this;
+    togglePictureInPicture(): void;
+    requestPictureInPicture(): void;
+    exitPictureInPicture(): void;
+}
+
+/**
+ * An error occurred during the playback.
+ * @beta
+ */
+export declare interface PlaybackError {
+    /**
+     * Error code.
+     */
+    code: PlaybackErrorCode;
+    /**
+     * Detailed description of the error.
+     */
+    description: string;
+    /**
+     * Level of severity of the error.
+     */
+    level: ErrorLevel;
+    /**
+     * Error message. Non-fatal usually can be ignored.
+     */
+    message: string;
+    /**
+     * Exact component that originated the error.
+     * @example
+     * - 'core'
+     * - 'dash'
+     * - 'media_control'
+     */
+    origin: string;
+    /**
+     * Component subsystem of the error origin
+     */
+    scope: PlayerComponentType;
+}
+
+/**
+ * Codes of errors occurring within the playback component.
+ * @beta
+ */
+export declare enum PlaybackErrorCode {
+    /**
+     * An unknown or uncategorised error.
+     */
+    Generic = 0,
+    /**
+     * The media source is not available. Typically a network error.
+     */
+    MediaSourceUnavailable = 1,
+    /**
+     * The media source is not accessible due to some protection policy.
+     */
+    MediaSourceAccessDenied = 3
+}
+
+/**
+ * Module to perform the playback.
+ * @beta
+ */
+export declare type PlaybackModule = 'dash' | 'hls' | 'html5_video';
+
+export declare class PlaybackRate extends UICorePlugin {
+    private currentPlayback;
+    private playbackRates;
+    private prevSelectedRate;
+    private selectedRate;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get attributes(): {
+        class: string;
+        'data-playback-rate-select': string;
+    };
+    get events(): {
+        'click .gear-sub-menu_btn': string;
+        'click .gear-option': string;
+        'click .go-back': string;
+    };
+    bindEvents(): void;
+    unBindEvents(): void;
+    private allRateElements;
+    private rateElement;
+    private onDashRateChange;
+    private updateLiveStatus;
+    reload(): void;
+    private shouldRender;
+    render(): this;
+    onStartAd(): void;
+    onFinishAd(): void;
+    onPlay(): void;
+    onStop(): void;
+    onRateSelect(event: MouseEvent): boolean;
+    onShowMenu(): void;
+    goBack(): void;
+    updatePlaybackRate(rate: string): void;
+    setSelectedRate(rate: string): void;
+    getTitle(): string;
+    highlightCurrentRate(): void;
+}
+
+/**
+ * Type of a stream playback
+ * @beta
+ */
+export declare type PlaybackType = 'live' | 'vod';
+
+/**
+ * The main component to use in the application code.
+ * @beta
+ * @remarks
+ * The Player object provides very basic API to control playback.
+ * To build a sophisticated UI, use the plugins framework to tap into the Clappr core.
+ * {@link https://github.com/clappr/clappr/wiki/Architecture}
+ */
+export declare class Player {
+    private config;
+    private emitter;
+    private player;
+    private ready;
+    private rootNode;
+    private tuneInTimerId;
+    private tunedIn;
+    constructor(config: PlayerConfig);
+    /**
+     * Adds a listener to a player event
+     * @param event - event type, see {@link PlayerEvent}
+     * @param handler - a callback function to handle the event
+     */
+    on<E extends PlayerEvent>(event: E, handler: PlayerEventHandler<E>): void;
+    /**
+     * Removes a previously added event listener
+     * @param event - See {@link PlayerEvent}
+     * @param handler - a callback attached earlier to that event type
+     */
+    off<E extends PlayerEvent>(event: E, handler: PlayerEventHandler<E>): void;
+    /**
+     * Configures the player.
+     *
+     * @param config - complete or partial configuration
+     * @remarks
+     * Can be called multiple times.
+     * Each consequent call extends the previous configuration with only the new keys overridden.
+     *
+     * After a reconfiguration, if something significant has changed, it might make sense reinitialize the player (i.e, a `.destroy()` followed by an `.init()` call).
+     */
+    configure(config: Partial<PlayerConfig>): void;
+    /**
+     * Initializes the player at the given container element.
+     * @param playerElement - DOM element to host the player
+     * @remarks
+     * The player will be initialized and attached to the given element.
+     *
+     * All the core plugins will be initialized at this point.
+     *
+     * If no sources were configured, it will trigger an error.
+     *
+     * The player container will be initialized and then all the registered UI plugins.
+     *
+     * If the `autoPlay` option is set, then it will trigger playback immediately.
+     *
+     * It is an error to call this method twice. If you need to attache player to another DOM element,
+     * first call {@link Player.destroy} and then {@link Player.attachTo}.
+     *
+     * @example
+     * ```ts
+     * const player = new Player({
+     *   sources: [{ source: 'https://example.com/a.mpd', mimeType: 'application/dash+xml' }],
+     * })
+     * document.addEventListener('DOMContentLoaded', () => {
+     *   player.attachTo(document.getElementById('video-container'))
+     * })
+     * ```
+     */
+    attachTo(playerElement: HTMLElement): void;
+    /**
+     * Destroys the player, releasing all resources and unmounting its UI from the DOM.
+     */
+    destroy(): void;
+    /**
+     * Current playback (time since the beginning of the stream), if appropriate.
+     *
+     * @returns Time in seconds
+     * @remarks
+     * For live streams, it returns the current time within the current segment.
+     */
+    getCurrentTime(): number;
+    /**
+     * Duration of the current media in seconds, if appropriate.
+     *
+     * @returns Time in seconds
+     * @remarks
+     * For live streams, it returns the duration of the current segment.
+     */
+    getDuration(): number;
+    /**
+     * Indicates whether DVR is enabled.
+     */
+    isDvrEnabled(): boolean;
+    /**
+     * Indicates whether DVR is in use.
+     * @remarks
+     * DVR mode, if it is enabled, is triggered we a user seeks behind the live edge.
+     */
+    isDvrInUse(): boolean;
+    /**
+     * Indicates muted state of the video.
+     * @remarks
+     * Note that muted state is independent from the volume level.
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/muted}
+     */
+    isMuted(): boolean;
+    /**
+     * Indicates the playing state.
+     */
+    isPlaying(): boolean;
+    /**
+     * Mutes the sound of the video.
+     */
+    mute(): void;
+    /**
+     * Unmutes the video sound.
+     */
+    unmute(): void;
+    /**
+     * Pauses playback.
+     */
+    pause(): void;
+    /**
+     * Starts playback.
+     */
+    play(): void;
+    /**
+     * Resizes the player container element and everything within it.
+     * @param newSize - new size of the player
+     * @remarks
+     * Use this method when the player itself does not detect properly the change in size of its container element.
+     * It can be a case for orientation change on some mobile devices.
+     */
+    resize(newSize: ContainerSize): void;
+    /**
+     * Seeks to the given time.
+     * @param time - time to seek to in seconds (since the beginning of the stream)
+     */
+    seek(time: number): void;
+    /**
+     * Gets the current volume of the media content being played.
+     * @returns a number between 0 and 1
+     */
+    getVolume(): number;
+    /**
+     * Sets the current volume of the media content being played.
+     * @param volume - a number between 0 and 1
+     */
+    setVolume(volume: number): void;
+    /**
+     * Stops playback.
+     */
+    stop(): void;
+    /**
+     * Registers a plugin.
+     * @param plugin - a plugin class
+     * @remarks
+     * Use this method to extend the player with custom behavior.
+     * The plugin class must inherit from one of the Clappr UIPlugin, UIContainerPlugin or CorePlugin classes.
+     * A core plugin will be initialized and attached to the player when the player is initialized.
+     * A UI plugin will be initialized and attached to the player container is initialized.
+     *
+     * @see {@link https://github.com/clappr/clappr/wiki/Architecture}
+     * @example
+     * ```ts
+     * import MyPlugin from './MyPlugin.js'
+     *
+     * Player.registerPlugin(MyPlugin)
+     * ```
+     */
+    static registerPlugin(plugin: PlayerPlugin): void;
+    /**
+     * Unregisters a plugin registered earlier with {@link Player.registerPlugin}.
+     * @param plugin - a plugin class
+     */
+    static unregisterPlugin(plugin: PlayerPlugin): void;
+    private setConfig;
+    private initPlayer;
+    private tuneIn;
+    private safeTriggerEvent;
+    private events;
+    private buildCoreOptions;
+    private configurePlaybacks;
+    private buildMediaSourcesList;
+    private bindContainerEventListeners;
+    private bindSizeManagementListeners;
+}
+
+/**
+ * Subsystems of a player component.
+ * @beta
+ */
+export declare type PlayerComponentType = 'container' | 'core' | 'playback';
+
+/**
+ * Configuration options for the player
+ *
+ * @remarks
+ *  You can specify multiple sources, each in two forms: just a plain URL or a full object with `source` and `mimeType` fields {@link PlayerMediaSource}.
+ *  The player will pick the first viable media source according to the source availability, and either the transport preference or standard transport selection order.
+ *
+ * `priorityTransport` is used to specify the preferred transport protocol
+ * when multiple sources are available.
+ * It will first try to use the transport specified if it's supported (by a playback engine) and the source is available.
+ * Otherwise it will try the other transports in the regular order (dash, hls, mpegts).
+ *
+ * The `autoPlay` option should be used together with the {@link PlayerConfig.mute | mute} to avoid issues with the browsers' autoplay policies.
+ *
+ * Note that the `playbackType` is specified explicitly in the examle below, but a playback engine might be able to detect the type of the stream automatically.
+ *
+ * A plugin options can be specified in the configuration object under a unique key, typically corresponding to the plugin name.
+ * The plugin object will have access to the internal normalized configuration object that contains all the custom options.
+ * in the examle below, the `poster` field is the `Poster` plugin configuration options.
+ *
+ * @example
+ * ```ts
+ * {
+ *   autoPlay: true,
+ *   mute: true,
+ *   playbackType: 'live',
+ *   priorityTransport: 'dash',
+ *   sources: [{
+ *     source: 'https://example.com/myownair66.mpd',
+ *     mimeType: 'application/dash+xml',
+ *   }, {
+ *     source: 'https://example.com/myownair66.m3u8',
+ *     mimeType: 'application/x-mpegURL',
+ *   }],
+ *   poster: {
+ *     url: settings.poster,
+ *   },
+ * }
+ * ```
+ * @beta
+ */
+export declare interface PlayerConfig extends Record<string, unknown> {
+    /**
+     * Start playback automatically when the player is ready
+     * @defaultValue false
+     */
+    autoPlay?: boolean;
+    /**
+     * Configuration settings for the DASH playback engine
+     * @defaultValue \{\}
+     * {@link https://cdn.dashjs.org/latest/jsdoc/module-Settings.html}
+     */
+    dash?: DashSettings;
+    /**
+     * Controls the debug output level
+     * @defaultValue 'none'
+     */
+    debug?: PlayerDebugSettings;
+    /**
+     * A language code for the player UI, for example, `es`. Must reference a key in the {@link PlayerConfig.strings | strings} record.
+     * @defaultValue 'en'
+     */
+    language?: string;
+    /**
+     * Repeat playback when the media ends.
+     * Is used with the `vod` {@link PlayerConfig.playbackType | playbackType}
+     * @defaultValue false
+     */
+    loop?: boolean;
+    /**
+     * Mute the audio output in order to comply with browsers' autoplay policy.
+     * @defaultValue false
+     */
+    mute?: boolean;
+    /**
+     * The type of playback (live stream or video on demand).
+     *
+     * @defaultValue 'vod'
+     */
+    playbackType?: PlaybackType;
+    /**
+     * Preferred transport protocol when multiple sources are available.
+     * @defaultValue 'dash'
+     */
+    priorityTransport?: TransportPreference;
+    /**
+     * List of media sources, at least one is required.
+     */
+    sources: PlayerMediaSource[];
+    /**
+     * Localization strings for the player UI.
+     */
+    strings?: TranslationSettings;
+}
+
+/**
+ * @remarks `true` is equivalent to `'all'`, `false` is equivalent to `'none'`
+ * @beta
+ */
+export declare type PlayerDebugSettings = PlayerDebugTag | boolean;
+
+/**
+ * Debug output category selector
+ * @beta
+ */
+export declare type PlayerDebugTag = 'all' | 'clappr' | 'dash' | 'hls' | 'none';
+
+/**
+ * A top-level event on the player object
+ * @beta
+ */
+export declare enum PlayerEvent {
+    /**
+     * Playback has reached the end of the media.
+     */
+    Ended = "ended",
+    /**
+     * An error occurred.
+     * Parameters: {@link PlaybackError}
+     */
+    Error = "error",
+    /**
+     * The player has switched to or from the fullscreen mode.
+     * Parameters:`boolean` isFullscreen
+     */
+    Fullscreen = "fullscreen",
+    /**
+     * The player is ready to use.
+     */
+    Ready = "ready",
+    /**
+     * Playback has started.
+     */
+    Play = "play",
+    /**
+     * Playback has been paused.
+     */
+    Pause = "pause",
+    /**
+     * The player's container has been resized.
+     * Parameters: {@link ContainerSize}
+     */
+    Resize = "resize",
+    /**
+     * The player is seeking to a new position.
+     */
+    Seek = "seek",
+    /**
+     * Playback has been stopped.
+     */
+    Stop = "stop",
+    /**
+     * The current playback time has changed.
+     * Parameters: {@link TimePosition}
+     */
+    TimeUpdate = "timeupdate",
+    /**
+     * The volume has changed.
+     * Parameters: `number` volume in the range 0..1
+     */
+    VolumeUpdate = "volumeupdate"
+}
+
+/**
+ * Type of a listener callback function for a player event.
+ * See the description of the event parameters in {@link PlayerEvent}.
+ * @beta
+ */
+export declare type PlayerEventHandler<E extends PlayerEvent> = (...args: PlayerEventParams<E>) => void;
+
+/**
+ * @beta
+ */
+export declare type PlayerEventParams<E extends PlayerEvent> = E extends PlayerEvent.Seek ? [number] : E extends PlayerEvent.VolumeUpdate ? [number] : E extends PlayerEvent.TimeUpdate ? [TimePosition] : E extends PlayerEvent.Resize ? [{
+    width: number;
+    height: number;
+}] : E extends PlayerEvent.Fullscreen ? [boolean] : E extends PlayerEvent.Error ? [PlaybackError] : [];
+
+/**
+ * A media source to fetch the media data from
+ * @beta
+ */
+export declare type PlayerMediaSource = string | PlayerMediaSourceDesc;
+
+/**
+ * Describes a media source with its MIME type and URL.
+ *
+ * @remarks
+ * When the MIME type is provided, it helps the player determine the appropriate playback engine.
+ * If omitted, the player will attempt to detect the type from the source URL extension.
+ * @beta
+ */
+export declare interface PlayerMediaSourceDesc {
+    /**
+     * The MIME type of the media source (e.g. `"video/mp4"`, `"application/x-mpegURL"`).
+     * Necessary if the type cannot be detected from file extension of the source URL.
+     */
+    mimeType?: string;
+    /**
+     * URL of the media source
+     */
+    source: string;
+}
+
+/**
+ * @beta
+ * @see {@link https://clappr.github.io/classes/UIContainerPlugin.html}, {@link https://clappr.github.io/classes/ContainerPlugin.html}
+ */
+export declare type PlayerPlugin = {
+    new (...args: any[]): unknown;
+    name: string;
+};
+
+export declare type PluginSettings = {
+    /**
+     * Sends the statistics record to the storage.
+     * The actual delivery is presumably async and batched.
+     * @param data - The statistics record to send.
+     */
+    send: (data: StatisticsRecord) => void;
+};
+
+export declare class Poster extends UIContainerPlugin {
+    private hasFatalError;
+    private hasStartedPlaying;
+    private playRequested;
+    private $playButton;
+    private $playWrapper;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get shouldRender(): boolean;
+    get attributes(): {
+        class: string;
+        'data-poster': string;
+    };
+    get events(): {
+        click: string;
+    };
+    get showOnVideoEnd(): boolean;
+    bindEvents(): void;
+    enable(): void;
+    disable(): void;
+    private onError;
+    private onPlay;
+    private onPlayIntent;
+    private onStop;
+    private updatePlayButton;
+    private showPlayButton;
+    private hidePlayButton;
+    private clicked;
+    private shouldHideOnPlay;
+    private update;
+    private updatePoster;
+    private showPoster;
+    private hidePoster;
+    render(): this;
+    destroy(): this;
+}
+
+declare type PresentationalError = {
+    title: string;
+    message: string;
+    code: string;
+    icon: string;
+    reloadIcon: string;
+};
+
+/**
+ * A level of quality within a media source.
+ * @beta
+ */
+export declare interface QualityLevel {
+    /**
+     * Zero-based index of the quality level.
+     */
+    level: number;
+    /**
+     * Width of the video, pixels.
+     */
+    width: number;
+    /**
+     * Height of the video, pixels.
+     */
+    height: number;
+    /**
+     * Bitrate of the video, bps.
+     */
+    bitrate: number;
+}
+
+export { reportError_2 as reportError }
+
+export declare class SeekTime extends UICorePlugin {
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get attributes(): {
+        class: string;
+        'data-seek-time': string;
+    };
+    get mediaControl(): any;
+    get mediaControlContainer(): any;
+    get isLiveStreamWithDvr(): any;
+    get durationShown(): boolean;
+    private hoveringOverSeekBar;
+    private hoverPosition;
+    private displayedDuration;
+    private displayedSeekTime;
+    private duration;
+    private rendered;
+    private $durationEl;
+    private $seekTimeEl;
+    bindEvents(): void;
+    private onContainerChanged;
+    private updateDuration;
+    private showTime;
+    private hideTime;
+    private calculateHoverPosition;
+    getSeekTime(): {
+        seekTime: number;
+    };
+    update(): void;
+    shouldBeVisible(): any;
+    render(): this;
+}
+
+export { SentryTracer }
+
+export { setTracer }
+
+export declare class Share extends UICorePlugin {
+    private hide;
+    private container;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get attributes(): {
+        class: string;
+        'data-share': string;
+    };
+    get events(): {
+        'click [data-share-button]': string;
+        'click [data-share-close]': string;
+        'click [data-share-fb]': string;
+        'click [data-share-tw]': string;
+        'click [data-share-link]': string;
+        'click [data-share-embed]': string;
+    };
+    bindEvents(): void;
+    unBindEvents(): void;
+    canShowShare(): void;
+    private onReady;
+    render(): this;
+    hideShare(): void;
+    showShare(): void;
+    initializeIcons(): void;
+    onShareShow(): void;
+    onShareHide(): void;
+    onShareFB(): void;
+    onShareTW(): void;
+    onShareLinkClick(): void;
+    onShareEmbedClick(): void;
+}
+
+export declare class SkipTime extends UICorePlugin {
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get container(): any;
+    get template(): any;
+    get attributes(): {
+        class: string;
+        'data-skip-time': string;
+    };
+    private position;
+    get events(): {
+        'click [data-skip-left]': string;
+        'click [data-skip-mid]': string;
+        'click [data-skip-right]': string;
+    };
+    bindEvents(): void;
+    setBack(): void;
+    handleRewindClicks(): void;
+    setMidClick(): void;
+    setForward(): void;
+    toggleFullscreen(): void;
+    render(): this;
+}
+
+/**
+ * This plugin is responsible for managing the automatic failover between sources.
+ * @beta
+ * @remarks
+ * Have a look at the {@link https://miro.com/app/board/uXjVLiN15tY=/?share_link_id=390327585787 | source failover diagram} for the details
+ * on how sources ordering and selection works.
+ *
+ * This plugin does not expose any public methods apart from required by the Clappr plugin interface.
+ * It is supposed to work autonomously.
+ *
+ * @example
+ * ```ts
+ * import { SourceController } from '@gcorevideo/player'
+ *
+ * Player.registerPlugin(SourceController)
+ * ```
+ */
+export declare class SourceController extends CorePlugin {
+    private sourcesList;
+    private currentSourceIndex;
+    private sourcesDelay;
+    private active;
+    private sync;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    constructor(core: Core);
+    /**
+     * @internal
+     */
+    bindEvents(): void;
+    private onReady;
+    private bindContainerEventListeners;
+    private reset;
+    private retryPlayback;
+    private getNextMediaSource;
+    static get version(): string;
+}
+
+export declare class SpinnerThreeBounce extends UIContainerPlugin {
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get attributes(): {
+        'data-spinner': string;
+        class: string;
+    };
+    private showTimeout;
+    private template;
+    private hasFatalError;
+    private hasBuffering;
+    constructor(container: Container);
+    private onBuffering;
+    private onBufferFull;
+    private onPlay;
+    private onStop;
+    private onError;
+    show(immediate?: boolean): void;
+    hide(): void;
+    render(): this;
+}
+
+export declare class Statistics extends ContainerPlugin {
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    private started;
+    private timeStart;
+    private heatmapSent;
+    private heatmapLastTime;
+    private watchSent;
+    private bufTracking;
+    private lags;
+    /**
+     * The time when buffering last started.
+     */
+    private bufLastStarted;
+    /**
+     * The accumulated buffering duration.
+     */
+    private bufAccDuration;
+    constructor(container: Container);
+    bindEvents(): void;
+    private startLevelSwitch;
+    private stopLevelSwitch;
+    private onBuffering;
+    private onBufferFull;
+    private onReady;
+    private initEvent;
+    private sendMessage;
+    private send;
+    private sendHeatmap;
+    private onTimeUpdateLive;
+    private onStart;
+}
+
+declare type StatisticsEvent = 'init' | 'start' | 'watch' | 'heatmap';
+
+declare type StatisticsEventData = Record<string, string | number | boolean>;
+
+declare type StatisticsRecord = {
+    event: StatisticsEvent;
+    type: PlaybackType;
+} & StatisticsEventData;
+
+export declare class Subtitles extends UICorePlugin {
+    private currentContainer;
+    private currentLevel;
+    private currentPlayback;
+    private isShowing;
+    private tracks;
+    private $string;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    static get version(): string;
+    get template(): any;
+    get templateString(): any;
+    get attributes(): {
+        class: string;
+        'data-subtitles': string;
+    };
+    get events(): {
+        'click [data-subtitles-select]': string;
+        'click [data-subtitles-button]': string;
+    };
+    private isPreselectedApplied;
+    private track;
+    get preselectedLanguage(): string;
+    bindEvents(): void;
+    unBindEvents(): void;
+    private bindPlaybackEvents;
+    private getTracks;
+    private onStartAd;
+    private onFinishAd;
+    reload(): void;
+    private playerResize;
+    hide(): void;
+    show(): void;
+    private shouldRender;
+    private resizeFont;
+    render(): this;
+    private fillLevels;
+    private findLevelBy;
+    private selectLevel;
+    private onLevelSelect;
+    private applyPreselectedSubtitles;
+    private onShowLevelSelectMenu;
+    private hideSelectLevelMenu;
+    private toggleContextMenu;
+    buttonElement(): ZeptoResult;
+    levelElement(id?: string): ZeptoResult;
+    startLevelSwitch(): void;
+    stopLevelSwitch(): void;
+    selectSubtitles(): void;
+    private setSubtitleText;
+    private clearSubtitleText;
+    private updateCurrentLevel;
+    private highlightCurrentSubtitles;
+    private renderIcon;
+}
+
+export declare class Thumbnails extends UICorePlugin {
+    private _$spotlight;
+    private _$backdrop;
+    private $container;
+    private $img;
+    private _$carousel;
+    private $textThumbnail;
+    private _$backdropCarouselImgs;
+    private spriteSheetHeight;
+    private _hoverPosition;
+    private _show;
+    private _thumbsLoaded;
+    private _oldContainer;
+    private _thumbs;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get attributes(): {
+        class: string;
+    };
+    get template(): any;
+    private buildSpriteConfig;
+    bindEvents(): void;
+    private _bindContainerEvents;
+    private _onCoreReady;
+    private loadSpriteSheet;
+    private _onMediaControlContainerChanged;
+    private _init;
+    private _getOptions;
+    private _appendElToMediaControl;
+    private _onMouseMove;
+    private _onMouseLeave;
+    private _calculateHoverPosition;
+    private _buildImg;
+    private _loadBackdrop;
+    setText(time: TimeValue): void;
+    private _updateCarousel;
+    private _updateSpotlightThumb;
+    private _getThumbIndexForTime;
+    private _renderPlugin;
+    private _createElements;
+}
+
+/**
+ * Current playback time and total duration of the media.
+ * @beta
+ */
+export declare interface TimePosition {
+    /**
+     * Current playback time, 0..duration, seconds.
+     */
+    current: TimeValue;
+    /**
+     * Total duration of the media, seconds.
+     */
+    total: TimeValue;
+}
+
+/**
+ * For the plugin development
+ * @beta
+ */
+export declare type TimeProgress = TimePosition & {
+    start: number;
+};
+
+/**
+ * @internal
+ */
+export declare type TimerId = ReturnType<typeof setTimeout>;
+
+/**
+ * For the plugin development
+ * @beta
+ */
+export declare type TimeUpdate = TimePosition & {
+    firstFragDateTime: number;
+};
+
+/**
+ * Playback time in seconds since the beginning of the stream (or a segment for the live streams)
+ * @beta
+ */
+export declare type TimeValue = number;
+
+export { trace }
+
+/**
+ * @beta
+ */
+export declare type TranslationKey = string;
+
+/**
+ * Localization strings for the player UI.
+ * @remarks
+ * The keys are language codes, and the values are objects with keys being the translation keys and values being the translations.
+ *
+ * This dictionary is used to localize the player UI, including the error messages and is shared across all the player components (including the plugins).
+ *
+ * @example
+ * ```
+ * {
+ *   en: {
+ *     play: 'Play',
+ *     ...
+ *   },
+ *   es: {
+ *     play: 'Reproducir',
+ *     ...
+ *   },
+ *   ...
+ * }
+ * ```
+ *
+ * @beta
+ */
+export declare type TranslationSettings = Partial<Record<LangTag, Record<TranslationKey, string>>>;
+
+/**
+ * Preferred media delivery protocol
+ * @beta
+ */
+export declare type TransportPreference = MediaTransport;
+
+declare type UpDown = 'up' | 'down';
+
+/**
+ * Version information about the gplayer and its main dependencies
+ * @returns Version information about the gplayer and its main dependencies
+ * @beta
+ */
+export declare function version(): {
+    gplayer: string;
+    clappr: string;
+    dashjs: string;
+    hlsjs: string;
+};
+
+/**
+ * @beta
+ */
+export declare class VolumeFade extends UICorePlugin {
+    private _aboveBorderVolume;
+    private container;
+    private delay;
+    private interval;
+    get name(): string;
+    bindEvents(): void;
+    unBindEvents(): void;
+    private _onUserChangeVolume;
+    private _onVolumeConfig;
+    private onCoreReady;
+    private onEnter;
+    private numberTo;
+    private clearCurrentInterval;
+    private onLeave;
+}
+
+export declare enum VolumeFadeEvents {
+    FADE = "core:volume:fade"
+}
+
+/**
+ * @beta
+ */
+export declare type ZeptoResult = ReturnType<typeof $>;
+
+export { }