import { AbrMode } from '@playkit-js/playkit-js';
import { ActionCreatorsMapObject } from 'redux';
import { AudioTrack } from '@playkit-js/playkit-js';
import { BaseMiddleware } from '@playkit-js/playkit-js';
import { Component } from 'preact';
import { ComponentChild } from 'preact';
import { ComponentChildren } from 'preact';
import { createPortal } from 'preact/compat';
import { Dispatch } from 'redux';
import { EngineType } from '@playkit-js/playkit-js';
import { Error as Error_2 } from '@playkit-js/playkit-js';
import { EventManager } from '@playkit-js/playkit-js';
import { FakeEvent } from '@playkit-js/playkit-js';
import { FakeEventTarget } from '@playkit-js/playkit-js';
import { FunctionalComponent } from 'preact';
import { h } from 'preact';
import { KPUIAddComponent as KPUIAddComponent_2 } from '@playkit-js/playkit-js-ui';
import { KPUIRemoveComponent as KPUIRemoveComponent_2 } from '@playkit-js/playkit-js-ui';
import { LoggerLevels } from '@playkit-js/playkit-js';
import { MediaType } from '@playkit-js/playkit-js';
import { PKAbrConfigObject } from '@playkit-js/playkit-js';
import { PKDimensionsConfig } from '@playkit-js/playkit-js';
import { PKDrmDataObject } from '@playkit-js/playkit-js';
import { PKEventTypes } from '@playkit-js/playkit-js';
import { PKMediaSourceObject } from '@playkit-js/playkit-js';
import { PKMetadataConfigObject } from '@playkit-js/playkit-js';
import { PKPlaybackConfigObject } from '@playkit-js/playkit-js';
import { PKPlayerDimensions } from '@playkit-js/playkit-js';
import { PKSessionConfigObject } from '@playkit-js/playkit-js';
import { PKSourcesConfigObject } from '@playkit-js/playkit-js';
import { PKTextConfigObject } from '@playkit-js/playkit-js';
import { PKTextTrack } from '@playkit-js/playkit-js';
import * as preact_2 from 'preact';
import * as preactHooks from 'preact/hooks';
import * as preacti18n from 'preact-i18n';
import { Provider } from '@playkit-js/playkit-js-providers/ovp-provider';
import { ProviderEntryListObject } from '@playkit-js/playkit-js-providers/types';
import { ProviderMediaConfigSessionObject } from '@playkit-js/playkit-js-providers/types';
import { ProviderMediaConfigSourcesObject } from '@playkit-js/playkit-js-providers/types';
import { ProviderMediaInfoObject } from '@playkit-js/playkit-js-providers/types';
import { ProviderOptionsObject } from '@playkit-js/playkit-js-providers/types';
import { ProviderPlaylistInfoObject } from '@playkit-js/playkit-js-providers/types';
import { ProviderPlaylistMetadataObject } from '@playkit-js/playkit-js-providers/types';
import { ProviderPlaylistObject } from '@playkit-js/playkit-js-providers/types';
import * as redux from 'react-redux';
import { RenderableProps } from 'preact';
import { StateType } from '@playkit-js/playkit-js';
import { Store } from 'redux';
import { StreamType } from '@playkit-js/playkit-js';
import { TextStyle } from '@playkit-js/playkit-js';
import { ThumbnailInfo } from '@playkit-js/playkit-js';
import { TimedMetadata } from '@playkit-js/playkit-js';
import { Track } from '@playkit-js/playkit-js';
import { TrackType } from '@playkit-js/playkit-js';
import { TrackTypes } from '@playkit-js/playkit-js';
import { UIEventType as UIEventType_2 } from '@playkit-js/playkit-js-ui';
import { UIOptionsObject as UIOptionsObject_2 } from '@playkit-js/playkit-js-ui';
import { VideoTrack } from '@playkit-js/playkit-js';
import { VNode } from 'preact';

declare const actions: {
    updateConfig: (config: any) => {
        type: string;
        config: any;
    };
    updateComponentConfig: (componentAlias: string, config: UIOptionsObject) => {
        type: string;
        componentAlias: string;
        config: UIOptionsObject;
    };
};

declare const actions_10: {
    updateVolumeDraggingStatus: (draggingActive: boolean) => any;
    updateVolumeHover: (hover: boolean) => any;
};

declare const actions_11: {
    updateOverlay: (isOpen: boolean) => {
        type: string;
        isOpen: boolean;
    };
};

declare const actions_12: {
    updateControlsToMove: (controlsToMove: string[]) => {
        type: string;
        controlsToMove: string[];
    };
};

declare const actions_2: {
    updateCaptionsStyle: (style: string) => {
        type: string;
        style: string;
    };
};

declare const actions_3: {
    readonly updateHasError: (hasError: boolean) => {
        type: string;
        hasError: boolean;
    };
    readonly updateErrorDetails: (errorCategory: number, errorTitle?: string, errorMessage?: string) => {
        type: string;
        errorDetails: {
            errorCategory: number;
            errorTitle: string;
            errorMessage: string;
        };
    };
    readonly updatePlayerState: (prevoiusState: string, currentState: string) => {
        type: string;
        playerState: {
            prevoiusState: string;
            currentState: string;
        };
    };
    readonly updatePrePlayback: (prePlayback: boolean) => {
        type: string;
        prePlayback: boolean;
    };
    readonly updateIsPlaying: (isPlaying: boolean) => {
        type: string;
        isPlaying: boolean;
    };
    readonly updateIsPaused: (isPaused: boolean) => {
        type: string;
        isPaused: boolean;
    };
    readonly updateIsSeeking: (isSeeking: boolean) => {
        type: string;
        isSeeking: boolean;
    };
    readonly updateLastSeekPoint: (lastSeekPoint: number) => {
        type: string;
        lastSeekPoint: number;
    };
    readonly updateIsEnded: (isEnded: boolean) => {
        type: string;
        isEnded: boolean;
    };
    readonly updateIsPlaybackStarted: (isPlaybackStarted: boolean) => {
        type: string;
        isPlaybackStarted: boolean;
    };
    readonly updateIsPlaybackEnded: (isPlaybackEnded: boolean) => {
        type: string;
        isPlaybackEnded: boolean;
    };
    readonly updateCurrentTime: (currentTime: number) => {
        type: string;
        currentTime: number;
    };
    readonly updateDuration: (duration: number) => {
        type: string;
        duration: number;
    };
    readonly updateVolume: (volume: number) => {
        type: string;
        volume: number;
    };
    readonly updateMuted: (muted: boolean) => {
        type: string;
        muted: boolean;
    };
    readonly updateMetadataLoadingStatus: (metadataLoaded: boolean) => {
        type: string;
        metadataLoaded: boolean;
    };
    readonly updateDataLoadingStatus: (dataLoaded: boolean) => {
        type: string;
        dataLoaded: boolean;
    };
    readonly updateAudioTracks: (tracks: Array<any>) => {
        type: string;
        tracks: any[];
    };
    readonly updateVideoTracks: (tracks: Array<any>) => {
        type: string;
        tracks: any[];
    };
    readonly updateTextTracks: (tracks: Array<any>) => {
        type: string;
        tracks: any[];
    };
    readonly updateAdBreak: (adBreak: boolean) => {
        type: string;
        adBreak: boolean;
    };
    readonly updateAdBreakProgress: (currentTime: number, duration: number) => {
        type: string;
        adProgress: {
            currentTime: number;
            duration: number;
        };
    };
    readonly updateAdBreakCompleted: () => {
        type: string;
    };
    readonly updateAdIsPlaying: (adIsPlaying: boolean) => {
        type: string;
        adIsPlaying: boolean;
    };
    readonly updateAdSkipTimeOffset: (adSkipTimeOffset: boolean) => {
        type: string;
        adSkipTimeOffset: boolean;
    };
    readonly updateAdSkippableState: (adSkippableState: boolean) => {
        type: string;
        adSkippableState: boolean;
    };
    readonly updateAdClickUrl: (adUrl: string) => {
        type: string;
        adUrl: string;
    };
    readonly updateAdIsLinear: (adIsLinear: boolean) => {
        type: string;
        adIsLinear: boolean;
    };
    readonly updateAdIsBumper: (adIsBumper: boolean) => {
        type: string;
        adIsBumper: boolean;
    };
    readonly updateAdContentType: (adContentType: string) => {
        type: string;
        adContentType: string;
    };
    readonly updatePlayerPoster: (poster: string) => {
        type: string;
        poster: string;
    };
    readonly updateIsAudio: (isAudio: boolean) => {
        type: string;
        isAudio: boolean;
    };
    readonly updateIsLive: (isLive: boolean) => {
        type: string;
        isLive: boolean;
    };
    readonly updateIsDvr: (isDvr: boolean) => {
        type: string;
        isDvr: boolean;
    };
    readonly updateIsImg: (isImg: boolean) => {
        type: string;
        isImg: boolean;
    };
    readonly updateIsDocument: (isDocument: boolean) => {
        type: string;
        isDocument: boolean;
    };
    readonly updateIsIdle: (IsIdle: boolean) => {
        type: string;
        IsIdle: boolean;
    };
    readonly updateFallbackToMutedAutoPlay: (fallback: boolean) => {
        type: string;
        fallback: boolean;
    };
    readonly updateIsVr: (isVr: boolean) => {
        type: string;
        isVr: boolean;
    };
    readonly updateVrStereoMode: (vrStereoMode: boolean) => {
        type: string;
        vrStereoMode: boolean;
    };
    readonly updateIsCasting: (isCasting: boolean) => {
        type: string;
        isCasting: boolean;
    };
    readonly updateCastSession: (castSession: any) => {
        type: string;
        castSession: any;
    };
    readonly updateIsCastAvailable: (isCastAvailable: boolean) => {
        type: string;
        isCastAvailable: boolean;
    };
    readonly updateIsChangingSource: (isChangingSource: boolean) => {
        type: string;
        isChangingSource: boolean;
    };
    readonly updatePlaylist: (playlist: any) => {
        type: string;
        playlist: any;
    };
    readonly updatePictureInPictureSupport: (isPictureInPictureSupported: boolean) => {
        type: string;
        isPictureInPictureSupported: boolean;
    };
    readonly updateIsInPictureInPicture: (isInPictureInPicture: boolean) => {
        type: string;
        isInPictureInPicture: boolean;
    };
    readonly updateFullscreen: (fullscreen: boolean) => {
        type: string;
        fullscreen: boolean;
    };
};

declare const actions_4: {
    updateLoadingSpinnerState: (show: boolean) => {
        type: string;
        show: boolean;
    };
};

declare const actions_5: {
    updateOverlayActionIcon: (iconType: string | Array<string>) => {
        type: string;
        iconType: string | string[];
    };
};

declare const actions_6: {
    updatePlaylistCountdownCanceled: (countdownCanceled: boolean) => {
        type: string;
        countdownCanceled: boolean;
    };
};

declare const actions_7: {
    readonly updateSeekbarDraggingStatus: (draggingActive: boolean) => {
        type: string;
        draggingActive: boolean;
    };
    readonly updateSeekbarHoverActive: (hoverActive: boolean) => {
        type: string;
        hoverActive: boolean;
    };
    readonly updateSeekbarPreviewHoverActive: (previewHoverActive: boolean) => {
        type: string;
        previewHoverActive: boolean;
    };
    readonly updateSeekbarClientRect: (clientRect: any) => {
        type: string;
        clientRect: any;
    };
    readonly updateHideSeekbarPreview: (hidePreview: boolean) => {
        type: string;
        hidePreview: boolean;
    };
    readonly updateHideSeekbarTimeBubble: (hideTimeBubble: boolean) => {
        type: string;
        hideTimeBubble: boolean;
    };
    readonly updateCurrentTime: (currentTime: number) => {
        type: string;
        currentTime: number;
    };
    readonly updateVirtualTime: (virtualTime: number) => {
        type: string;
        virtualTime: number;
    };
    readonly updateHoveredSegment: (id: string, isHovered: boolean) => {
        type: string;
        id: string;
        isHovered: boolean;
    };
    readonly updateSegmentEndTime: (id: string, endTime: number) => {
        type: string;
        id: string;
        endTime: number;
    };
    readonly updateSeekbarSegments: (segments: any[]) => {
        type: string;
        segments: any[];
    };
    readonly addSeekbarClass: (className: string) => {
        type: string;
        className: string;
    };
    readonly removeSeekbarClass: (className: string) => {
        type: string;
        className: string;
    };
    readonly updatePreventSeek: (isPreventSeek: boolean) => {
        type: string;
        isPreventSeek: boolean;
    };
};

declare const actions_8: {
    updateQuality: (quality: string) => {
        type: string;
        quality: string;
    };
    updateSpeed: (speed: string) => {
        type: string;
        speed: string;
    };
    updateAudio: (audio: string) => {
        type: string;
        audio: string;
    };
    updateAdvancedAudioDesc: (isChecked: boolean) => {
        type: string;
        isChecked: boolean;
    };
    updateIsCaptionsEnabled: (isCaptionsEnabled: boolean) => {
        type: string;
        isCaptionsEnabled: boolean;
    };
};

declare const actions_9: {
    readonly addPlayerClass: (className: string) => {
        type: string;
        className: string;
    };
    readonly removePlayerClass: (className: string) => {
        type: string;
        className: string;
    };
    readonly updateIsMobile: (isMobile: boolean) => {
        type: string;
        isMobile: boolean;
    };
    readonly updatePlayerSize: (playerSize: string) => {
        type: string;
        playerSize: string;
    };
    readonly updateIsSmallSize: (isSmallSize: boolean) => {
        type: string;
        isSmallSize: boolean;
    };
    readonly updateGuiClientRect: (guiClientRect: any) => {
        type: string;
        guiClientRect: any;
    };
    readonly updatePlayerClientRect: (playerClientRect: any) => {
        type: string;
        playerClientRect: any;
    };
    readonly updateVideoClientRect: (videoClientRect: any) => {
        type: string;
        videoClientRect: any;
    };
    readonly updateDocumentWidth: (documentWidth: number) => {
        type: string;
        documentWidth: number;
    };
    readonly updatePlayerHoverState: (hover: boolean) => {
        type: string;
        hover: boolean;
    };
    readonly updatePlayerNavState: (nav: boolean) => {
        type: string;
        nav: boolean;
    };
    readonly updateSmartContainerOpen: (open: boolean) => {
        type: string;
        open: boolean;
    };
    readonly updateActivePresetName: (activePresetName: string) => {
        type: string;
        activePresetName: string;
    };
    readonly updateSidePanelMode: (position: string, sidePanelMode: string) => {
        type: string;
        position: string;
        sidePanelMode: string;
    };
    readonly updateSidePanelSize: (orientation: string, options: any) => {
        type: string;
        orientation: string;
        options: any;
    };
    readonly updatePresetSettings: (presetSettings: PresetSettings) => {
        type: string;
        presetSettings: PresetSettings;
    };
    readonly updateLayoutStyles: (layoutStyles: LayoutStyles) => {
        type: string;
        layoutStyles: LayoutStyles;
    };
};

/**
 * @class Ad
 * @param {string} id - Ad ID.
 * @param {PKAdOptions} options - Ad data options.
 */
declare class Ad {
    private readonly _id;
    private readonly _system;
    private readonly _url;
    private readonly _contentType;
    private readonly _title;
    private readonly _position;
    private readonly _duration;
    private readonly _clickThroughUrl;
    private _posterUrl;
    private readonly _skipOffset;
    private _linear;
    private readonly _width;
    private readonly _height;
    private readonly _bitrate;
    private readonly _bumper;
    private readonly _inStream;
    private readonly _vpaid;
    private readonly _streamId;
    private readonly _wrapperAdIds;
    private readonly _wrapperCreativeIds;
    private readonly _wrapperAdSystems;
    constructor(id: string, options: PKAdOptions);
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad ID.
     */
    get id(): string;
    /**
     * @instance
     * @memberof Ad
     * @return {string | undefined} - Ad system.
     */
    get system(): string | undefined;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad content type.
     */
    get contentType(): string | undefined;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad URL.
     */
    get url(): string | undefined;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad title.
     */
    get title(): string | undefined;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad position inside the ad break.
     */
    get position(): number | undefined;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad duration.
     */
    get duration(): number | undefined;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad click through URL.
     */
    get clickThroughUrl(): string | undefined;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad poster URL.
     */
    get posterUrl(): string | undefined;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad skip offset.
     */
    get skipOffset(): number | undefined;
    /**
     * @instance
     * @memberof Ad
     * @return {boolean} - Whether the ad is linear.
     */
    get linear(): boolean;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad width.
     */
    get width(): number;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad height.
     */
    get height(): number;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Ad bitrate.
     */
    get bitrate(): number;
    /**
     * @instance
     * @memberof Ad
     * @return {boolean} - Whether the ad is bumper.
     */
    get bumper(): boolean;
    /**
     * @instance
     * @memberof Ad
     * @return {boolean} - Whether the ad is imadai.
     */
    get inStream(): boolean;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - Whether the ad is skippable or not.
     */
    get skippable(): boolean;
    /**
     * @instance
     * @memberof Ad
     * @return {boolean} - Whether the ad is vpaid or not.
     */
    get vpaid(): boolean;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - The ad streamId.
     */
    get streamId(): string;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - The ad wrapperAdIds.
     */
    get wrapperAdIds(): Array<string>;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - The ad wrapperCreativeIds.
     */
    get wrapperCreativeIds(): Array<string>;
    /**
     * @instance
     * @memberof Ad
     * @return {string} - The ad wrapperAdSystems.
     */
    get wrapperAdSystems(): Array<string>;
    toJSON(): any;
}

declare class AdBreak {
    private readonly _type;
    private readonly _position;
    private readonly _numAds;
    constructor(options: PKAdBreakOptions);
    /**
     * @instance
     * @memberof AdBreak
     * @return {string} - Ad break type - pre/mid/post.
     */
    get type(): string | undefined;
    /**
     * @instance
     * @memberof AdBreak
     * @return {string} - Ad break position on the playback timeline.
     */
    get position(): number | undefined;
    /**
     * @instance
     * @memberof AdBreak
     * @return {string} - The number of ads inside the ad break.
     */
    get numAds(): number | undefined;
    toJSON(): any;
}

/**
 * @typedef {Object} KPAdBreakObject@typedef {Object} KPAdBreakObject
 * @property {number} position - The position; in seconds; to show the ad break.
 * @property {number} percentage - Alternative parameter to `position`. The position; in percentage of the media length; to show the ad break (optional).
 * @property {number} every - Alternative parameter to `position`. Play ad break every X seconds (optional).
 * @property {AdPod} ads - An array of ads to play (Ad pod).
 */
declare interface AdBreakObject {
    position: number;
    percentage?: number;
    every?: number;
    ads: AdObject[];
}

/**
 * AdLearnMore component
 *
 * @class AdLearnMore
 * @example <AdLearnMore />
 * @extends {Component}
 */
declare class AdLearnMore extends Component<AdLearnMoreProps, {}> {
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof AdLearnMore
     */
    render(props: any): h.JSX.Element;
}

declare type AdLearnMoreProps = {
    url?: string;
};

/**
 * AdNotice component
 *
 * @class AdNotice
 * @example <AdNotice />
 * @extends {Component}
 */
declare class AdNotice extends Component<{}, {}> {
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof AdNotice
     */
    render(): h.JSX.Element;
}

/**
 * @typedef {Object} KPAdObject@typedef {Object} KPAdObject
 * @property {Array<string>} url - List of urls; each one specifies the ad tag url that is requested from the ad server. The player will request the first url; if failed; it will request the second url and so on (aka waterfalling).
 * @property {Array<string>} response - List of XMLs; each one specifies a VAST 2.0 document to be used as the ads response instead of making a request via an ad tag url. The player will use the first XML; if failed; it will use the second and so on (aka waterfalling).
 * @property {boolean} bumper - Specifies whether this is a bumper.
 * @property {PrebidConfig} prebid - Specifies whether this is a prebid ad and add the relevant config for prebid request.
 */
declare interface AdObject {
    url?: Array<string>;
    response?: Array<string>;
    bumper?: boolean;
    prebid?: PrebidConfig;
}

declare interface AdPrebidConfig {
    adUnit: Object;
    params?: Object;
    options?: Object;
    timeout: number;
}

/**
 * @class AdsController
 * @param {Player} player - The player.
 * @param {IAdsController} adsPluginController - The controller of the current ads plugin instance.
 */
declare class AdsController extends FakeEventTarget implements IAdsController {
    private static _logger;
    private readonly _player;
    private _adsPluginControllers;
    private _allAdsCompleted;
    private _eventManager;
    private _liveEventManager;
    private _adBreaksLayout;
    private _adBreak;
    private _ad;
    private _adPlayed;
    private _snapback;
    private _configAdBreaks;
    private _adIsLoading;
    private _isAdPlaying;
    private _middleware;
    private readonly _prebidManager;
    private _liveSeeking;
    prerollReady: Promise<any>;
    constructor(player: KalturaPlayer, adsPluginControllers: Array<IAdsPluginController>);
    /**
     * @instance
     * @memberof AdsController
     * @returns {boolean} - Whether all ads completed.
     */
    get allAdsCompleted(): boolean;
    /**
     * @instance
     * @memberof AdsController
     * @returns {boolean} - Whether an ad is playing.
     */
    isAdPlaying(): boolean;
    /**
     * @instance
     * @memberof AdsController
     * @returns {boolean} - Whether we're in an ad break.
     */
    isAdBreak(): boolean;
    /**
     * @instance
     * @memberof AdsController
     * @returns {Array<number|string>} - The ad breaks layout (cue points).
     */
    getAdBreaksLayout(): Array<number | string>;
    /**
     * @instance
     * @memberof AdsController
     * @returns {?AdBreak} - Gets the current ad break data.
     */
    getAdBreak(): AdBreak | undefined;
    /**
     * @instance
     * @memberof AdsController
     * @returns {?Ad} - Gets the current ad data.
     */
    getAd(): Ad | undefined;
    /**
     * Skip on an ad.
     * @instance
     * @memberof AdsController
     * @returns {void}
     */
    skipAd(): void;
    /**
     * Play an ad on demand.
     * @param {KPAdPod} adPod - The ad pod play.
     * @instance
     * @memberof AdsController
     * @returns {void}
     */
    playAdNow(adPod: KPAdPod): void;
    getMiddleware(): BaseMiddleware;
    private _init;
    private _initMembers;
    private _addBindings;
    private _handleConfiguredAdBreaks;
    private _validateOneTimeConfig;
    private _dispatchAdManifestLoaded;
    private _handlePrebidAdConfig;
    private _getPrebidAds;
    private _handleConfiguredPreroll;
    private _handleEveryAndPercentage;
    private _attachLiveSeekedHandler;
    private _pushNextAdsForLive;
    private _handleConfiguredMidrolls;
    private _handleReturnToLive;
    private _playAdBreak;
    private _onAdManifestLoaded;
    private _onAdBreakStart;
    private _onAdLoaded;
    private _onAdStarted;
    private _onAdBreakEnd;
    private _onAdsCompleted;
    private _onAdError;
    private _isBumper;
    private _onEnded;
    private _onPlaybackEnded;
    private _handleConfiguredPostroll;
    private _reset;
    private _destroy;
    private _mergeAdBreaks;
}

/**
 * AdSkip component
 *
 * @class AdSkip
 * @example <AdSkip />
 * @extends {Component}
 */
declare class AdSkip extends Component<AdSkipProps & WithPlayerProps & WithLoggerProps, any> {
    /**
     * getting the number value of seconds left to be able to skip ad
     *
     * @returns {number} - number of seconds left to skip ad
     * @memberof AdSkip
     */
    private getSkipTimeOffset;
    private skipAd;
    /**
     * render component
     *
     * @returns {React$Element}  - component
     * @memberof AdSkip
     */
    render(): h.JSX.Element | undefined;
}

declare type AdSkipProps = {
    currentTime?: number;
    duration?: number;
    adSkipTimeOffset?: number;
    adSkippableState?: boolean;
};

/**
 * Ads ui interface
 *
 * @export
 * @param {*} props component props
 * @returns {?HTMLElement} player ui tree
 */
declare function adsUI(props: any): VNode<any> | undefined;

/**
 * AdvancedAudioDesc component
 *
 * @class AdvancedAudioDesc
 * @example <AdvancedAudioDesc step={5} />
 * @extends {Component}
 */
declare class AdvancedAudioDesc extends Component<any, any> implements IconComponent {
    constructor(props: any);
    get advancedAudioDesc(): boolean;
    registerComponent(): any;
    getComponentText: () => any;
    getSvgIcon: () => any;
    /**
     * should render component
     * @returns {boolean} - whether to render the component
     */
    private _shouldRender;
    /**
     * AdvancedAudioDesc click handler
     *
     * @returns {void}
     * @memberof AdvancedAudioDesc
     */
    private onClick;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof AdvancedAudioDesc
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof AdvancedAudioDesc
     */
    render({ innerRef }: any): VNode<any> | undefined;
}

/**
 * AdvancedAudioDescToggle component
 *
 * @class AdvancedAudioDescToggle
 * @example <AdvancedAudioDescToggle />
 * @extends {Component}
 */
declare class AdvancedAudioDescToggle extends Component<any, any> {
    /**
     * Toggle the Advanced Audio Description option and update it in the store state
     *
     * @param {boolean} isChecked - Whether the feature is enabled or not
     * @returns {void}
     * @memberof AdvancedAudioDescToggle
     */
    onAdvancedAudioClick: (isChecked: boolean) => void;
    /**
     * render function
     *
     * @param {*} props - component props
     * @returns {React$Element} - component
     * @memberof AdvancedAudioDescToggle
     */
    render(props: any): h.JSX.Element;
}

/**
 * @typedef {Object} KPAdvertisingConfigObject@typedef {Object} KPAdvertisingConfigObject
 * @property {PrebidConfig} prebid - The prebid config.
 * @property {Array<KPAdBreakObject>} adBreaks - The ad breaks scheme.
 * @property {number} [playAdsAfterTime] - Only play ad breaks scheduled after this time (in seconds). This setting is strictly after - e.g. setting playAdsAfterTime to 15 will cause the player to ignore an ad break scheduled to play at 15s.
 * @property {boolean} [showAdBreakCuePoint] - Whether to show the ad breaks cue points.
 * @property {Object} [adBreakCuePointStyle] - Style options for the ad breaks cue points - See the options {@link https://github.com/kaltura/playkit-js-timeline/blob/main/docs/types.md#cuepointoptionsobject|Here}.
 */
declare interface AdvertisingConfig {
    prebid?: PrebidConfig;
    adBreaks: AdBreakObject[];
    playAdsAfterTime?: number;
    showAdBreakCuePoint?: boolean;
    adBreakCuePointStyle?: Object;
}

/**
 * AudioMenu component
 *
 * @class AudioMenu
 * @example <AudioMenu />
 * @extends {Component}
 */
declare class AudioMenu extends Component<AudioMenuProps & WithPlayerProps & WithEventDispatcherProps, any> {
    /**
     * call to player selectTrack method and change audio track
     *
     * @param {Object} audioTrack - audio track
     * @returns {void}
     * @memberof Settings
     */
    onAudioChange(audioTrack: any): void;
    /**
     * render function
     *
     * @param {*} props - component props
     * @returns {React$Element} - component
     * @memberof AudioMenu
     */
    render(props: any): h.JSX.Element;
}

declare type AudioMenuProps = {
    audioTracks?: any[];
    audioLabelText?: string;
};

declare const BadgeType: {
    qualityHd: string;
    qualityHdActive: string;
    quality4k: string;
    quality4kActive: string;
    quality8k: string;
    quality8kActive: string;
};

/**
 * Base component to be extended by other player UI components
 *
 * @class BaseComponent
 * @extends {Component}
 */
declare class BaseComponent extends Component<any, any> {
    protected player: KalturaPlayer;
    protected name: string;
    protected config: any;
    protected logger: any;
    protected eventManager: EventManager;
    /**
     * Components default props.
     * @type {Object}
     * @static
     */
    static defaultProps: any;
    /**
     * Creates an instance of BaseComponent.
     * @param {Object} [obj={ config: {} }] obj
     * @memberof BaseComponent
     */
    constructor(obj?: any);
    /**
     * Notify the store that a clickable component has been clicked.
     * @param {any} payload - Optional payload.
     * @returns {void}
     *
     * @memberof BaseComponent
     */
    notifyClick(payload?: any): void;
    /**
     * Notify the store that a changeable component has been change.
     * @param {any} payload - Optional payload.
     * @returns {void}
     *
     * @memberof BaseComponent
     */
    notifyChange(payload?: any): void;
    /**
     * Before component is mounted remove all event manager listeners.
     * @returns {void}
     *
     * @memberof BaseComponent
     */
    componentWillUnmount(): void;
    render(props?: RenderableProps<any>, state?: Readonly<any>, context?: any): ComponentChild;
}

/** The BasePlugin responsible to implement the plugin interface.
 * Contains several default implementations.
 * Other plugins should extend this class.
 * @classdesc
 */
declare class BasePlugin {
    protected logger: any;
    /**
     * The runtime configuration of the plugin.
     * @member
     */
    protected config: any;
    /**
     * The name of the plugin.
     * @member
     */
    name: string;
    /**
     * The logger of the plugin.
     * @member
     */
    /**
     * Reference to the actual player.
     * @member
     */
    protected player: KalturaPlayer;
    /**
     * The event manager of the plugin.
     * @member
     */
    protected eventManager: EventManager;
    /**
     * The default configuration of the plugin.
     * Inherited plugins should override this property.
     * @type {Object}
     * @static
     * @member
     */
    protected static defaultConfig: any;
    /**
     * Returns under what conditions the plugin is valid.
     * Plugin must implement this method.
     * @returns {boolean} - Whether the plugin is valid and can be initiated. Default implementation is true
     * @static
     * @public
     * @abstract
     */
    static isValid(): boolean;
    /**
     * constructor
     * @param {string} name - The plugin name
     * @param {Object} player - The player reference
     * @param {Object} config - The plugin configuration
     * @constructor
     * @private
     */
    constructor(name: string, player: KalturaPlayer, config?: any);
    /**
     * Getter for the configuration of the plugin.
     * @param {string} attr - The key in the plugin configuration (optional).
     * @returns {*} - If attribute is provided, returns its value. Else, Returns the config of the plugin.
     * @public
     */
    getConfig(attr?: string): any;
    /**
     * Getter for the ready promise of the plugin.
     * @returns {Promise<*>} - returns a resolved promise unless the plugin overrides this ready getter.
     * @public
     */
    protected get ready(): Promise<any>;
    /**
     * Updates the config of the plugin.
     * @param {Object} update - The updated configuration.
     * @public
     * @returns {void}
     */
    updateConfig(update: any): void;
    /**
     * Runs the loadMedia logic of the plugin.
     * plugin must implement this method.
     * @public
     * @virtual
     * @returns {void}
     */
    loadMedia(): void;
    /**
     * Runs the destroy logic of the plugin.
     * plugin must implement this method.
     * @public
     * @virtual
     * @returns {void}
     */
    destroy(): void;
    /**
     * Runs the reset logic of the plugin.
     * plugin must implement this method.
     * @public
     * @virtual
     * @returns {void}
     */
    reset(): void;
    /**
     * Getter for the plugin's name.
     * @returns {string} - The name of the plugin.
     * @public
     */
    getName(): string;
    /**
     * Dispatch an event via the plugin.
     * @param {string} name - The event name.
     * @param {any} payload - The event payload.
     * @returns {void}
     */
    dispatchEvent(name: string, payload?: any): void;
}

/**
 * Basic remote player.
 * Implements the Kaltura Player playback, ads, tracks,vr and cast APIs.
 * Remote players should extend this class and implement the needed API.
 * @class BaseRemotePlayer
 * @param {string} name - Remote player name.
 * @param {Object} config - Cast configuration.
 * @param {RemoteControl} remoteControl - Remote control.
 * @extends {FakeEventTarget}
 * @implements {IRemotePlayer}
 */
declare class BaseRemotePlayer extends FakeEventTarget implements IRemotePlayer {
    /**
     * Default configuration of the remote player.
     * @static
     * @type {Object}
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.defaultConfig // {}
     */
    private static defaultConfig;
    /**
     * Remote player type.
     * @static
     * @type {string}
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.Type // 'BaseRemotePlayer'
     */
    private static Type;
    /**
     * @static
     * @returns {boolean} - Whether the remote player is supported in the current environment.
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.isSupported() // true
     */
    static isSupported(): boolean;
    private static _logger;
    private _remoteControl;
    private _playerConfig;
    private _castConfig;
    private _eventManager;
    private _isCastInitiator;
    constructor(name: string, castConfig: any, remoteControl: RemoteControl);
    /**
     * Loads a media to the receiver application.
     * @param {Object} mediaInfo - The entry media info.
     * @returns {Promise<void>} - Promise to indicate load succeed or failed.
     * @instance
     * @memberof BaseRemotePlayer
     */
    loadMedia(mediaInfo: any): Promise<any>;
    /**
     * Sets a media to the remote player..
     * @param {Object} mediaConfig - Media configuration to set.
     * @instance
     * @returns {void}
     * @memberof BaseRemotePlayer
     */
    setMedia(mediaConfig: any): void;
    /**
     * Gets the media Info.
     * @returns {?Object} - The media info.
     * @instance
     * @memberof BaseRemotePlayer
     */
    getMediaInfo(): any;
    /**
     * Gets the media config.
     * @returns {?Object} - The media config.
     * @instance
     * @memberof BaseRemotePlayer
     */
    getMediaConfig(): any;
    /**
     * Configure the remote player
     * @param {Object} config - Configuration to set.
     * @instance
     * @returns {void}
     * @memberof BaseRemotePlayer
     */
    configure(config?: any): void;
    /**
     * The remote player readiness.
     * @returns {Promise<any>} - Promise which resolved when the remote player is ready.
     * @instance
     * @memberof BaseRemotePlayer
     */
    ready(): Promise<any>;
    /**
     * Load the remote player.
     * @instance
     * @returns {void}
     * @memberof BaseRemotePlayer
     */
    load(): void;
    /**
     * Play/resume the remote player.
     * @instance
     * @returns {void}
     * @memberof BaseRemotePlayer
     */
    play(): void;
    /**
     * Pause the remote player.
     * @instance
     * @returns {void}
     * @memberof BaseRemotePlayer
     */
    pause(): void;
    /**
     * Reset the remote player.
     * @instance
     * @returns {void}
     * @memberof BaseRemotePlayer
     */
    reset(): void;
    /**
     * Destroy the remote player.
     * @instance
     * @returns {void}
     * @memberof BaseRemotePlayer
     */
    destroy(): void;
    /**
     * @returns {boolean} - Whether the current playback is a live playback.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.isLive() // false
     */
    isLive(): boolean;
    /**
     * @returns {boolean} - Whether the current live playback has DVR window. In case of non-live playback will return false.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.isDvr() // false
     */
    isDvr(): boolean;
    /**
     * Seeks to the live edge.
     * @instance
     * @returns {void}
     * @memberof BaseRemotePlayer
     */
    seekToLiveEdge(): void;
    /**
     * @returns {number} - The start time of the DVR window.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.getStartTimeOfDvrWindow() // 0
     */
    getStartTimeOfDvrWindow(): number;
    /**
     * @param {string} [type] - Track type.
     * @returns {Array<Track>} - The remote player tracks.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.getTracks() // []
     */
    getTracks(type?: string): Array<Track>;
    /**
     * @returns {Object} - The remote player active tracks.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.getTracks() // {audio: undefined, video: undefined, text: undefined}
     */
    getActiveTracks(): any;
    /**
     * Select a certain track to be active.
     * @param {Track} track - The track to activate.
     * @returns {void}
     * @instance
     * @memberof BaseRemotePlayer
     */
    selectTrack(track: Track): void;
    /**
     * Hides the active text track.
     * @returns {void}
     * @instance
     * @memberof BaseRemotePlayer
     */
    hideTextTrack(): void;
    /**
     * @function enableAdaptiveBitrate
     * @description Enables automatic adaptive bitrate switching.
     * @returns {void}
     * @instance
     * @memberof BaseRemotePlayer
     */
    enableAdaptiveBitrate(): void;
    /**
     * @function isAdaptiveBitrateEnabled
     * @returns {boolean} - Whether adaptive bitrate is enabled.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.isAdaptiveBitrateEnabled() // true
     */
    isAdaptiveBitrateEnabled(): boolean;
    /**
     * Sets the text display settings.
     * @function setTextDisplaySettings
     * @param {Object} settings - Text settings.
     * @instance
     * @memberof BaseRemotePlayer
     * @returns {void}
     */
    setTextDisplaySettings(settings: any): void;
    /**
     * Start casting.
     * @returns {Promise<any>} - A promise to indicate session is starting, or failed
     * @instance
     * @memberof BaseRemotePlayer
     */
    startCasting(): Promise<void>;
    /**
     * Stops the current cast session.
     * @returns {void}
     * @instance
     * @memberof BaseRemotePlayer
     */
    stopCasting(): void;
    /**
     * @returns {boolean} - Whether casting is currently active.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.isCasting() // true
     */
    isCasting(): boolean;
    /**
     * @returns {boolean} - Whether casting is available.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.isCastAvailable() // true
     */
    isCastAvailable(): boolean;
    /**
     * Gets the current remote session.
     * @returns {RemoteSession} - The remote session.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.getCastSession() // new RemoteSession('', '')
     */
    getCastSession(): RemoteSession;
    /**
     * @returns {boolean} - Whether the current media is of VR type (360 content).
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.isVr() // false
     */
    isVr(): boolean;
    /**
     * Toggles VR mode on the current content.
     * @instance
     * @returns {void}
     * @memberof BaseRemotePlayer
     */
    toggleVrStereoMode(): void;
    /**
     * @returns {boolean} - Whether the current content displayed in VR mode.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.isInVrStereoMode() // false
     */
    isInVrStereoMode(): boolean;
    /**
     * The remote player ads controller.
     * @type {?Object}
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.ads // null
     */
    get ads(): any;
    /**
     * Setter.
     * @param {TextStyle} style - The text style to set.
     * @returns {void}
     * @instance
     * @memberof BaseRemotePlayer
     */
    set textStyle(style: TextStyle);
    /**
     * Getter.
     * @returns {TextStyle} - The current text style.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.textStyle // new TextStyle()
     */
    get textStyle(): TextStyle;
    /**
     * Gets the first buffered range of the remote player.
     * @returns {Array<any>} - First buffered range in seconds.
     * @public
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.buffered // []
     */
    get buffered(): Array<any>;
    /**
     * Setter.
     * @param {number} to - The number to set in seconds.
     * @returns {void}
     * @instance
     * @memberof BaseRemotePlayer
     */
    set currentTime(to: number);
    /**
     * Getter.
     * @returns {number} - The current time in seconds.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.currentTime // 0
     */
    get currentTime(): number;
    /**
     * @returns {number} - The duration in seconds.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.duration // 0
     */
    get duration(): number;
    /**
     * @returns {number} - The live duration in seconds.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.liveDuration // NaN
     */
    get liveDuration(): number;
    /**
     * Setter.
     * @param {number} vol - The volume to set in the range of 0-1.
     * @returns {void}
     * @instance
     * @memberof BaseRemotePlayer
     */
    set volume(vol: number);
    /**
     * Getter.
     * @returns {number} - The current volume in the range of 0-1.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.volume // 1
     */
    get volume(): number;
    /**
     * @returns {boolean} - Whether the cast player is in paused state.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.paused // false
     */
    get paused(): boolean;
    /**
     * @returns {boolean} - Whether the cast player is in ended state.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.ended // false
     */
    get ended(): boolean;
    /**
     * @returns {boolean} - Whether the cast player is in seeking state.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.seeking // false
     */
    get seeking(): boolean;
    /**
     * Setter.
     * @param {boolean} mute - The mute value to set.
     * @returns {void}
     * @instance
     * @memberof BaseRemotePlayer
     */
    set muted(mute: boolean);
    /**
     * Getter.
     * @returns {boolean} - The muted state.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.muted // false
     */
    get muted(): boolean;
    /**
     * @returns {string} - The current playing source url.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.src // ''
     */
    get src(): string;
    /**
     * @returns {string} - The current poster url.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.poster // ''
     */
    get poster(): string;
    /**
     * Setter.
     * @param {number} rate - The playback rate to set.
     * @instance
     * @memberof BaseRemotePlayer
     */
    set playbackRate(rate: number);
    /**
     * @returns {string} - The current playback rate.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.playbackRate // 1
     */
    get playbackRate(): number;
    /**
     * @returns {string} - The active engine type.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.engineType // ''
     */
    get engineType(): string;
    /**
     * @returns {string} - The active stream type.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.streamType // ''
     */
    get streamType(): string;
    /**
     * @returns {string} - The remote player type.
     * @instance
     * @memberof BaseRemotePlayer
     * @example
     * BaseRemotePlayer.prototype.type // BaseRemotePlayer.Type
     */
    get type(): string;
    /**
     * @returns {KPOptionsObject} - The runtime remote player config.
     * @instance
     * @memberof BaseRemotePlayer
     */
    get config(): any;
    set isCastInitiator(isCastInitiator: boolean);
    get isCastInitiator(): boolean;
}

/**
 * Binding redux actions to props utility
 *
 * @export
 * @param {ActionCreatorsMapObject} actions - Redux action creators
 * @returns {(dispatch: Dispatch) => ActionCreatorsMapObject} - Function that takes dispatch and returns bound action creators
 */
declare function bindActions<A, M extends ActionCreatorsMapObject<A>>(actions: M): (dispatch: Dispatch) => M;

/**
 * BottomBar component
 *
 * @class BottomBar
 * @example <BottomBar>...</BottomBar>
 * @extends {Component}
 */
declare class BottomBar extends Component<any, any> {
    private bottomBarContainerRef;
    private presetControls;
    private resizeObserver;
    private _currBarWidthArr;
    private _maxControlsWidthArr;
    private _isFullscreenModeChanging;
    constructor(props: any);
    /**
     * when component did update
     *
     * @returns {void}
     * @memberof BottomBar
     */
    componentDidMount(): void;
    componentWillUnmount(): void;
    private _getControlsWidth;
    private onBarWidthChange;
    private getMaxControlsWidth;
    private setMaxControlsWidth;
    private getCurrentBarWidth;
    private setCurrentBarWidth;
    private onToggleControl;
    private filterControls;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {?React$Element} - component element
     * @memberof BottomBar
     */
    render(props: any): any;
}

declare namespace bottomBar {
    export {
        types_12 as types,
        initialState_12 as initialState,
        _default_12 as default,
        actions_12 as actions
    }
}

declare interface BottomBarState {
    controlsToMove: string[];
}

/**
 * Button component
 *
 * @const Button
 * @example <Button/>
 */
declare const Button: FunctionalComponent<any>;

/**
 * ButtonControl component
 *
 * @const ButtonControl
 * @example <ButtonControl/>
 */
declare const ButtonControl: FunctionalComponent<any>;

/**
 * CaptionsControl component
 *
 * @class CaptionsControl
 * @example <CaptionsControl />
 * @extends {Component}
 */
declare const CaptionsControl: any;

/**
 * CaptionsMenu component
 *
 * @class CaptionsMenu
 * @example <CaptionsMenu />
 * @extends {Component}
 */
declare class CaptionsMenu extends Component<any, any> {
    /**
     * Select the given text track
     *
     * @param {Object} textTrack - text track
     * @returns {void}
     * @memberof CaptionsMenu
     */
    onCaptionsChange(textTrack: any | string): void;
    /**
     * render function
     *
     * @param {*} props - component props
     * @returns {React$Element} - component
     * @memberof CaptionsMenu
     */
    render(props: any): VNode<any>;
}

/**
 * Cast component
 *
 * @class Cast
 * @example <Cast />
 * @extends {Component}
 */
declare class Cast extends Component<any, any> {
    /**
     * should render component
     * @returns {boolean} - whether to render the component
     */
    _shouldRender(): boolean;
    /**
     * On click, mark the player which initiated the cast
     * @memberof Cast
     * @returns {void}
     */
    onClick: () => void;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof Cast
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {?React$Element} - component element
     * @memberof Cast
     */
    render(props: any): VNode<any> | undefined;
}

/**
 * CastAfterPlay component
 *
 * @class CastAfterPlay
 * @example <CastAfterPlay />
 * @extends {Component}
 */
declare class CastAfterPlay extends Component<any, any> {
    /**
     * @static
     * @type {Object} - Component default props
     */
    static defaultProps: any;
    _timeoutId: number | null;
    /**
     * on click call the stop casting API.
     *
     * @param {Event} e - click event
     * @returns {void}
     * @memberof CastAfterPlay
     */
    onClick: (e: Event) => void;
    /**
     * after component did mount, show the cast after play button.
     *
     * @returns {void}
     * @memberof CastAfterPlay
     */
    componentDidMount(): void;
    /**
     * after component unmount, clear timeouts
     *
     * @returns {void}
     * @memberof CastAfterPlay
     */
    componentWillUnmount(): void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {?React$Element} - component element
     * @memberof CastAfterPlay
     */
    render(props: any): VNode<any> | undefined;
}

/**
 * CastBeforePlay component
 *
 * @class CastBeforePlay
 * @example <CastBeforePlay />
 * @extends {Component}
 */
declare class CastBeforePlay extends Component<any, any> {
    _timeoutId: number | null;
    /**
     * @static
     * @type {Object} - Component default props
     */
    static defaultProps: any;
    /**
     * on click call the start casting API and set connecting state.
     *
     * @returns {void}
     * @memberof CastBeforePlay
     */
    onClick: () => void;
    _handleKeydown: (e: KeyboardEvent) => void;
    /**
     * after component did mount, show the cast before play button.
     *
     * @returns {void}
     * @memberof CastBeforePlay
     */
    componentDidMount(): void;
    /**
     * after component unmount, clear timeouts
     *
     * @returns {void}
     * @memberof CastBeforePlay
     */
    componentWillUnmount(): void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {?React$Element} - component element
     * @memberof CastBeforePlay
     */
    render(props: any): VNode<any> | undefined;
}

/**
 * @const {Object} CastEventType
 *
 * @example
 * // Events lifecycle
 * 1. CAST_AVAILABLE
 * 2. CAST_SESSION_STARTING
 * 3. CAST_SESSION_STARTED || CAST_SESSION_START_FAILED -> X
 * 4. CAST_SESSION_ENDING
 * 5. CAST_SESSION_ENDED
 * @example
 * // How to use
 * player.addEventListener(KalturaPlayer.cast.CastEventType.CAST_SESSION_STARTED, e => {
 *   console.log(e.session);
 * };
 */
declare const CastEventType: {
    /**
     * Fires when cast session start failed.
     * @event CAST_SESSION_START_FAILED
     * @memberof CastEventType
     */
    readonly CAST_SESSION_START_FAILED: "kaltura-player-castsessionstartfailed";
    /**
     * Fires when cast session starting.
     * @event CAST_SESSION_STARTING
     * @memberof CastEventType
     */
    readonly CAST_SESSION_STARTING: "kaltura-player-castsessionstarting";
    /**
     * Fires when cast session started.
     * @event CAST_SESSION_STARTED
     * @memberof CastEventType
     */
    readonly CAST_SESSION_STARTED: "kaltura-player-castsessionstarted";
    /**
     * Fires when cast session ending.
     * @event CAST_SESSION_ENDING
     * @memberof CastEventType
     */
    readonly CAST_SESSION_ENDING: "kaltura-player-castsessionending";
    /**
     * Fires when cast session ended.
     * @event CAST_SESSION_ENDED
     * @memberof CastEventType
     */
    readonly CAST_SESSION_ENDED: "kaltura-player-castsessionended";
    /**
     * Fires when cast is available.
     * @event CAST_AVAILABLE
     * @memberof CastEventType
     */
    readonly CAST_AVAILABLE: "kaltura-player-castavailable";
};

/**
 * CastOverlay component
 *
 * @class CastOverlay
 * @example <CastOverlay />
 * @extends {Component}
 */
declare class CastOverlay extends Component<any, any> {
    /**
     * @static
     * @type {Object} - Component default props
     */
    static defaultProps: any;
    /**
     * Gets the cast status.
     * @returns {React$Element} - The text status string.
     * @memberof CastOverlay
     */
    getStatus(): VNode<any>;
    /**
     * Gets the cast icon next to the status.
     * @returns {React$Element} - The cast icon.
     * @memberof CastOverlay
     */
    getIcon(): VNode<any>;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {?React$Element} - component element
     * @memberof CastOverlay
     */
    render(props: any): VNode<any> | undefined;
}

/**
 * ClosedCaptions component
 *
 * @class ClosedCaptions
 * @example <ClosedCaptions />
 * @extends {Component}
 */
declare const ClosedCaptions: any;

export declare type ColorType = {
    primary: string;
    secondary: string;
    success: string;
    danger: string;
    warning: string;
    live: string;
    playerBackground: string;
    paperSurface: string;
    elevatedSurface: string;
    protectionSurface: string;
    tone1: string;
    tone2: string;
    tone3: string;
    tone4: string;
    tone5: string;
    tone6: string;
    tone7: string;
    tone8: string;
};

declare namespace Components {
    export {
        AdLearnMore,
        AdSkip,
        AdNotice,
        BaseComponent,
        BottomBar,
        CVAAOverlay,
        DropDown,
        EngineConnector,
        ErrorOverlay,
        Icon,
        IconType,
        IconState,
        BadgeType,
        LiveTag,
        Loading,
        Menu,
        Overlay,
        OverlayAction,
        OverlayPortal,
        PrePlaybackPlayOverlay,
        SeekBarLivePlaybackContainer,
        SeekBarPlaybackContainer,
        Shell,
        PLAYER_SIZE,
        PLAYER_BREAK_POINTS,
        Slider,
        SmartContainer,
        SmartContainerItem,
        TimeDisplay,
        TimeDisplayAdsContainer,
        TimeDisplayPlaybackContainer,
        Tooltip,
        ToolTipType,
        TopBar,
        UnmuteIndication,
        VideoPlayer,
        Watermark,
        Logo,
        CastOverlay,
        CastBeforePlay,
        CastAfterPlay,
        PlaylistButton,
        PrevNext,
        PlaylistNextScreen,
        PictureInPicture,
        PlaybackControls,
        CopyButton,
        ButtonControl,
        Button,
        ToggleSwitch,
        AudioMenu,
        CaptionsMenu,
        SpeedMenu,
        QualityMenu,
        HeightResolution,
        getLabelBadgeType,
        AdvancedAudioDescToggle,
        AdvancedAudioDesc,
        ExpandableText,
        Scrollable,
        ProgressIndicator,
        SeekBarPreview,
        PlayerArea,
        withPlayerPreset,
        Remove,
        VideoArea,
        GuiArea,
        InteractiveArea,
        SidePanel,
        Keyboard as KeyboardControl,
        Cast,
        Cast as CastControl,
        Fullscreen,
        Fullscreen as FullscreenControl,
        PlayPause,
        PlayPause as PlayPauseControl,
        Rewind,
        Rewind as RewindControl,
        Forward,
        Forward as ForwardControl,
        SeekBar,
        SeekBar as SeekBarControl,
        Settings,
        Settings as SettingsControl,
        Volume,
        Volume as VolumeControl,
        VrStereo,
        VrStereo as VrStereoControl,
        ClosedCaptions,
        ClosedCaptions as ClosedCaptionsControl,
        CaptionsControl,
        EventDispatcherProvider,
        WithEventDispatcherProps,
        withEventDispatcher,
        Keyboard,
        withKeyboardEvent,
        KeyboardEventProvider,
        PlayerProvider,
        withPlayer,
        WithLoggerProps,
        withLogger
    }
}
export { Components }
export { Components as components }

export declare type ComponentsConfig = {
    seekbar?: any;
    watermark?: WatermarkConfig;
    sidePanels?: SidePanelsConfig;
    vrStereo?: VrStereoConfig;
    logo?: LogoConfig;
    fullscreen?: FullscreenConfig;
};

declare namespace config {
    export {
        types,
        initialState,
        _default as default,
        actions
    }
}

declare type ConfigState = UIOptionsObject;

/**
 * CopyButton component
 *
 * @class CopyButton
 * @example <CopyButton/>
 * @extends {Component}
 */
declare class CopyButton extends Component<any, any> {
    _timeoutId: number | null;
    /**
     * Creates an instance of CopyButton.
     * @param {Object} props object
     * @memberof CopyButton
     */
    constructor(props: any);
    /**
     * after component unmount, clear timeouts
     *
     * @returns {void}
     * @memberof CopyButton
     */
    componentWillUnmount(): void;
    /**
     * copy and update the state
     * @returns {void}
     * @memberof CopyButton
     */
    copy: () => void;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - the keyboard event
     * @returns {void}
     * @memberof CopyButton
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {?CopyButton} - component element
     * @memberof CopyButton
     */
    render(props: any): VNode<any>;
}

export { createPortal }

declare interface CuePoint {
    id: string;
    startTime: number;
    endTime: number;
    metadata: any;
}

declare class CuePointManager {
    private _player;
    private _textTrack;
    constructor(player: KalturaPlayer);
    private _addTextTrack;
    private _getMetadataTracks;
    private _createTextTrackCue;
    private _cuesSorter;
    getAllCuePoints(): Array<TimedMetadata>;
    getActiveCuePoints(): Array<TimedMetadata>;
    private _getTextTrackCueById;
    private _removeTextTrackCue;
    addCuePoints(data: CuePoint[]): void;
    private _clearAllTextTrackCues;
    reset(): void;
    destroy(): void;
}

declare namespace cvaa {
    export {
        types_2 as types,
        initialState_2 as initialState,
        _default_2 as default,
        actions_2 as actions
    }
}

/**
 * CVAAOverlay component
 *
 * @class CVAAOverlay
 * @extends {Component}
 */
declare class CVAAOverlay extends Component<any, any> {
    /**
     * componentWillUnmount
     *
     * @returns {void}
     * @memberof CVAAOverlay
     */
    componentWillUnmount(): void;
    /**
     * componentWillMount
     *
     * @returns {void}
     * @memberof CVAAOverlay
     */
    componentWillMount(): void;
    /**
     * changing the overlay state
     *
     * @param {CvaaOverlayStateType} stateName - the new state name
     * @returns {void}
     * @memberof CVAAOverlay
     */
    transitionToState: (stateName: CvaaOverlayStateType) => void;
    /**
     * changing the captions style
     *
     * @param {Object} textStyle - TextStyle object
     * @returns {void}
     * @memberof CVAAOverlay
     */
    changeCaptionsStyle: (textStyle: any) => void;
    /**
     * get the css style of the preview element
     * @return {string} the css string
     * @private
     */
    getPreviewStyle: () => string;
    /**
     * change one or more properties in customTextStyle object in the internal state
     *
     * @param {Object} styleChanges style changes object
     * @returns {void}
     * @memberof CVAAOverlay
     */
    changeCustomStyle: (styleChanges: any) => void;
    focusPlayerButtonBadge: () => void;
    /**
     * render component
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof CVAAOverlay
     */
    render(props: any): VNode<any>;
}

declare type CvaaOverlayStateType = 'main' | 'custom-captions';

declare interface CvaaState {
    style: string;
}

declare const _default: (state: UIOptionsObject | undefined, action: any) => any;

declare const _default_10: (state: VolumeState | undefined, action: any) => {
    draggingActive: any;
    hover: boolean;
} | {
    hover: any;
    draggingActive: boolean;
};

declare const _default_11: (state: OverlayState | undefined, action: any) => {
    isOpen: any;
};

declare const _default_12: (state: BottomBarState | undefined, action: any) => {
    controlsToMove: any;
};

declare const _default_2: (state: CvaaState | undefined, action: any) => {
    style: any;
};

declare const _default_3: (state: EngineState | undefined, action: any) => any;

declare const _default_4: (state: LoadingState | undefined, action: any) => any;

declare const _default_5: (state: OverlayActionsState | undefined, action: any) => {
    iconType: any;
};

declare const _default_6: (state: PlaylistState | undefined, action: any) => {
    countdownCanceled: any;
};

declare const _default_7: (state: SeekbarState | undefined, action: any) => {
    draggingActive: any;
    currentTime: number;
    virtualTime: number;
    hoverActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
    isPreventSeek: boolean;
} | {
    hoverActive: any;
    currentTime: number;
    virtualTime: number;
    draggingActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
    isPreventSeek: boolean;
} | {
    previewHoverActive: any;
    currentTime: number;
    virtualTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
    isPreventSeek: boolean;
} | {
    clientRect: any;
    currentTime: number;
    virtualTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    previewHoverActive: boolean;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
    isPreventSeek: boolean;
} | {
    hidePreview: any;
    currentTime: number;
    virtualTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
    isPreventSeek: boolean;
} | {
    hideTimeBubble: any;
    currentTime: number;
    virtualTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
    isPreventSeek: boolean;
} | {
    currentTime: any;
    virtualTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
    isPreventSeek: boolean;
} | {
    virtualTime: any;
    currentTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
    isPreventSeek: boolean;
} | {
    segments: any;
    currentTime: number;
    virtualTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    seekbarClasses: string[];
    isPreventSeek: boolean;
} | {
    seekbarClasses: any[];
    currentTime: number;
    virtualTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    isPreventSeek: boolean;
} | {
    isPreventSeek: any;
    currentTime: number;
    virtualTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
};

declare const _default_8: (state: SettingsState | undefined, action: any) => {
    quality: any;
    speed: number;
    audio?: string | undefined;
    advancedAudioDesc: boolean;
} | {
    speed: any;
    quality: number;
    audio?: string | undefined;
    advancedAudioDesc: boolean;
} | {
    audio: any;
    quality: number;
    speed: number;
    advancedAudioDesc: boolean;
} | {
    advancedAudioDesc: any;
    quality: number;
    speed: number;
    audio?: string | undefined;
} | {
    isCaptionsEnabled: any;
    quality: number;
    speed: number;
    audio?: string | undefined;
    advancedAudioDesc: boolean;
};

declare const _default_9: (state: ShellState | undefined, action: any) => {
    playerClasses: any[];
    isMobile?: boolean | undefined;
    playerSize?: string | undefined;
    isSmallSize?: boolean | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    playerNav: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
    documentWidth?: number | undefined;
} | {
    isMobile: any;
    playerClasses: string[];
    playerSize?: string | undefined;
    isSmallSize?: boolean | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    playerNav: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
    documentWidth?: number | undefined;
} | {
    playerSize: any;
    playerClasses: string[];
    isMobile?: boolean | undefined;
    isSmallSize?: boolean | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    playerNav: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
    documentWidth?: number | undefined;
} | {
    isSmallSize: any;
    playerClasses: string[];
    isMobile?: boolean | undefined;
    playerSize?: string | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    playerNav: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
    documentWidth?: number | undefined;
} | {
    documentWidth: any;
    playerClasses: string[];
    isMobile?: boolean | undefined;
    playerSize?: string | undefined;
    isSmallSize?: boolean | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    playerNav: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
} | {
    playerHover: any;
    playerClasses: string[];
    isMobile?: boolean | undefined;
    playerSize?: string | undefined;
    isSmallSize?: boolean | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerNav: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
    documentWidth?: number | undefined;
} | {
    playerNav: any;
    playerClasses: string[];
    isMobile?: boolean | undefined;
    playerSize?: string | undefined;
    isSmallSize?: boolean | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
    documentWidth?: number | undefined;
} | {
    smartContainerOpen: any;
    playerClasses: string[];
    isMobile?: boolean | undefined;
    playerSize?: string | undefined;
    isSmallSize?: boolean | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    playerNav: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
    documentWidth?: number | undefined;
} | {
    activePresetName: any;
    playerClasses: string[];
    isMobile?: boolean | undefined;
    playerSize?: string | undefined;
    isSmallSize?: boolean | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    playerNav: boolean;
    smartContainerOpen: boolean;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
    documentWidth?: number | undefined;
} | {
    presetSettings: any;
    playerClasses: string[];
    isMobile?: boolean | undefined;
    playerSize?: string | undefined;
    isSmallSize?: boolean | undefined;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    playerNav: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    documentWidth?: number | undefined;
};

/**
 * Playback ui interface
 *
 * @export
 * @param {*} props component props
 * @returns {React$Element} player ui tree
 */
declare function docUI(props: any): VNode<any>;

/**
 * @typedef {Object} DRMSupportedObject@typedef {Object} DRMSupportedObject
 * @property {number} isDRMSupported - Specifies DRM supported option by the browser
 * @property {Array<string>} supportedDRMs - List of supported DRMs (optional values: widevine; playready; fairplay)
 */
declare type DRMSupportedObject = {
    isDRMSupported: number;
    supportedDRMs: Array<string>;
};

/**
 * DropDown component
 *
 * @class DropDown
 * @example <DropDown options={this.videoTrackOptions} />
 * @extends {Component}
 */
declare class DropDown extends Component<any, any> {
    _el: HTMLDivElement;
    /**
     * before component mounted, set initial internal state
     *
     * @returns {void}
     * @memberof DropDown
     */
    componentWillMount(): void;
    /**
     * after component mounted, set the callback to be called when parent selected
     * @returns {void}
     * @memberof DropDown
     */
    componentDidMount(): void;
    /**
     * is given option selected
     *
     * @param {Object} option - option object
     * @returns {boolean} - is the option selected
     * @memberof DropDown
     */
    isSelected(option: any): boolean;
    /**
     * on option select - pass the selected option to upper component through props and close the menu
     *
     * @param {Object} option - option object
     * @returns {void}
     * @memberof DropDown
     */
    onMenuChosen: (option: any) => void;
    /**
     * on click handler
     *
     * @returns {void}
     * @memberof DropDown
     */
    onClick: () => void;
    /**
     * on key down handler - on enter open toggle drop down menu
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof DropDown
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * listener function from Menu component to close the dropdown menu.
     * set the internal state of dropMenuActive to false.
     *
     * @returns {void}
     * @memberof DropDown
     */
    onClose: () => void;
    /**
     * get active option or first option
     *
     * @returns {Object} - active option
     * @memberof DropDown
     */
    getActiveOption(): any;
    /**
     * render for menu only which will render a native select element in this case (mobile)
     * @param {string} labelledby - the label id the describes the dropdown (for screen reader)
     * @returns {React$Element} - component element
     * @memberof DropDown
     */
    renderNativeSelect(labelledby: string): VNode<any>;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof DropDown
     */
    render(props: any): VNode<any>;
    /**
     * toggles the dropdown menu window
     * @returns {void}
     * @memberof DropDown
     */
    toggleDropDown(): void;
}

declare namespace engine {
    export {
        types_3 as types,
        initialState_3 as initialState,
        _default_3 as default,
        actions_3 as actions
    }
}

/**
 * EngineConnector component
 *
 * @class EngineConnector
 * @example <EngineConnector />
 * @extends {Component}
 */
declare class EngineConnector extends Component<EngineConnectorProps, any> {
    /**
     * after component mounted, set event listeners and update redux store
     *
     * @returns {void}
     * @memberof EngineConnector
     */
    componentDidMount(): void;
    /**
     * component shouldn't update the dom if props or internal state changed
     *
     * @returns {boolean} - should component update on changes or not
     * @memberof EngineConnector
     */
    shouldComponentUpdate(): boolean;
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof EngineConnector
     */
    render(): VNode<any>;
}

declare type EngineConnectorProps = {
    engine: EngineState;
    player: KalturaPlayer;
    eventManager: EventManager;
} & typeof actions_3 & typeof actions_4 & typeof actions_9 & {
    seekbarUpdateCurrentTime: typeof actions_7.updateCurrentTime;
} & {
    updateIsCaptionsEnabled: typeof actions_8.updateIsCaptionsEnabled;
};

declare interface EngineState {
    isIdle: boolean;
    isPlaying: boolean;
    isPaused: boolean;
    isSeeking: boolean;
    isEnded: boolean;
    isPlaybackStarted: boolean;
    isPlaybackEnded: boolean;
    isChangingSource: boolean;
    prePlayback: boolean;
    metadataLoaded: boolean;
    dataLoaded: boolean;
    playerState: {
        previousState: string;
        currentState: string;
    };
    fallbackToMutedAutoPlay: boolean;
    poster: string;
    currentTime: number;
    lastSeekPoint: number;
    duration: number;
    volume: number;
    muted: boolean;
    videoTracks: VideoTrack[];
    audioTracks: AudioTrack[];
    textTracks: PKTextTrack[];
    adIsLinear: boolean;
    adBreak: boolean;
    adIsPlaying: boolean;
    adSkipTimeOffset: number;
    adSkippableState: boolean;
    adIsBumper: boolean;
    adContentType: string | null;
    isLive: boolean;
    isDvr: boolean;
    isImg: boolean;
    isDocument: boolean;
    isAudio: boolean;
    adProgress: {
        currentTime: number;
        duration: number;
    };
    adUrl: string;
    hasError: boolean;
    isVr: boolean;
    vrStereoMode: boolean;
    isCasting: boolean;
    castSession: any;
    isCastAvailable: boolean;
    pictureInPictureSupported: boolean;
    isInPictureInPicture: boolean;
    playlist: any;
    fullscreen: boolean;
}

/**
 * errorOverlay component
 *
 * @class errorOverlay
 * @extends {Component}
 */
declare class ErrorOverlay extends Component<any, any> {
    private sessionEl;
    /**
     * copy input text based on input element.
     * on success, set success internal component state for 2 seconds
     * @returns {void}
     * @memberof ErrorOverlay
     */
    private copyError;
    /**
     * play on click
     *
     * @returns {void}
     * @memberof ErrorOverlay
     */
    private handleClick;
    /**
     * get background url
     *
     * @returns {string | undefined} - custom background URL
     * @memberof ErrorOverlay
     */
    private getBackgroundUrl;
    /**
     * render the sessionID line
     *
     * @returns {React$Element} - main state element
     * @memberof ErrorOverlay
     */
    private renderSessionID;
    /**
     * render the retry button
     *
     * @returns {React$Element} - main state element
     * @memberof ErrorOverlay
     */
    private renderRetryButton;
    /**
     * render the error head
     *
     * @returns {React$Element} - main state element
     * @memberof ErrorOverlay
     */
    private renderErrorHead;
    /**
     * render main state
     *
     * @returns {?React$Element} - main state element
     * @memberof ErrorOverlay
     */
    render(): VNode<any> | undefined;
}

/**
 * Error ui
 *
 * @export
 * @param {*} props component props
 * @returns {React$Element} player ui tree
 */
declare function errorUI(props: any): VNode<any>;

declare namespace Event_2 {
    export {
        withEventManager,
        EventType
    }
}
export { Event_2 as Event }

/**
 * PlayerProvider component
 *
 * @class EventDispatcherProvider
 * @example <EventDispatcherProvider player={this.player} store={this.store}>...</EventDispatcherProvider>
 * @extends {Component}
 */
declare class EventDispatcherProvider extends Component<any, any> {
    /**
     * bounded component click handler
     * @param {Object} payload - the click data payload
     * @returns {void}
     * @private
     */
    private _notifyClick;
    /**
     * bounded component state change handler
     * @param {Object} payload - the click data payload
     * @returns {void}
     * @private
     */
    private _notifyChange;
    /**
     * bounded hover change  handler
     * @param {Object} payload - the click data payload
     * @returns {void}
     * @private
     */
    private _notifyHoverChange;
    /**
     * create context player
     * @returns {void}
     */
    getChildContext(): {
        notifyClick: (payload: any) => void;
        notifyChange: (payload: any) => void;
        notifyHoverChange: (payload: any) => void;
    };
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof EventDispatcherProvider
     */
    render(): any;
}

declare const EventType: {
    readonly UI_CLICKED: "playkit-ui-uiclicked";
    readonly UI_VISIBILITY_CHANGED: "playkit-ui-uivisibilitychanged";
    readonly GUI_RESIZE: "playkit-ui-guiresize";
    readonly PLAYER_RESIZE: "playkit-ui-playerresize";
    readonly VIDEO_RESIZE: "playkit-ui-videoresize";
    readonly UI_PRESET_CHANGE: "playkit-ui-uipresetchange";
    readonly USER_CLICKED_PLAY: "playkit-ui-userclickedplay";
    readonly USER_CLICKED_PAUSE: "playkit-ui-userclickedpause";
    readonly USER_CLICKED_REWIND: "playkit-ui-userclickedrewind";
    readonly USER_CLICKED_FORWARD: "playkit-ui-userclickedforward";
    readonly USER_CLICKED_LIVE_TAG: "playkit-ui-userclickedlivetag";
    readonly USER_CLICKED_LOGO: "playkit-ui-userclickedlogo";
    readonly USER_CLICKED_MUTE: "playkit-ui-userclickedmute";
    readonly USER_CLICKED_UNMUTE: "playkit-ui-userclickedunmute";
    readonly USER_CLICKED_ADVANCED_AUDIO_DESCRIPTION: "playkit-ui-userclickedadvancedaudiodescription";
    readonly USER_CHANGED_VOLUME: "playkit-ui-userchangedvolume";
    readonly USER_SELECTED_CAPTION_TRACK: "playkit-ui-userselectedcaptiontrack";
    readonly USER_SHOWED_CAPTIONS: "playkit-ui-usershowedcaptions";
    readonly USER_HID_CAPTIONS: "playkit-ui-userhidcaptions";
    readonly USER_SELECTED_AUDIO_TRACK: "playkit-ui-userselectedaudiotrack";
    readonly USER_SELECTED_QUALITY_TRACK: "playkit-ui-userselectedqualitytrack";
    readonly USER_ENTERED_FULL_SCREEN: "playkit-ui-userenteredfullscreen";
    readonly USER_EXITED_FULL_SCREEN: "playkit-ui-userexitedfullscreen";
    readonly USER_ENTERED_PICTURE_IN_PICTURE: "playkit-ui-userenteredpictureinpicture";
    readonly USER_EXITED_PICTURE_IN_PICTURE: "playkit-ui-userexitedpictureinpicture";
    readonly USER_SELECTED_CAPTIONS_STYLE: "playkit-ui-userselectedcaptionsstyle";
    readonly USER_SELECTED_SPEED: "playkit-ui-userselectedspeed";
    readonly USER_SEEKED: "playkit-ui-userseeked";
    readonly RESIZE: "playkit-ui-resize";
    readonly USER_SELECTED_CAPTIONS_SIZE: "playkit-ui-userselectedcaptionssize";
    readonly USER_SELECTED_CAPTIONS_ALIGNMENT: "playkit-ui-userselectedcaptionsalignment";
    readonly USER_SELECTED_CAPTIONS_FONT_COLOR: "playkit-ui-userselectedcaptionsfontcolor";
    readonly USER_SELECTED_CAPTIONS_FONT_FAMILY: "playkit-ui-userselectedcaptionsfontfamily";
    readonly USER_SELECTED_CAPTIONS_FONT_STYLE: "playkit-ui-userselectedcaptionsfontstyle";
    readonly USER_SELECTED_CAPTIONS_FONT_OPACITY: "playkit-ui-userselectedcaptionsfontopacity";
    readonly USER_SELECTED_CAPTIONS_BACKGROUND_COLOR: "playkit-ui-userselectedcaptionsbackgroundcolor";
    readonly USER_SELECTED_CAPTIONS_BACKGROUND_OPACITY: "playkit-ui-userselectedcaptionsbackgroundopacity";
    readonly BOTTOM_BAR_CLIENT_RECT_CHANGED: "playkit-ui-bottombarclientrectchanged";
    readonly PLAYER_HOVERED: "playkit-ui-playerhovered";
    readonly USER_COPIED_DEBUG_INFO: "playkit-ui-usercopieddebuginfo";
};
export { EventType }
export { EventType as UIEventType }

declare const ExpandableText: new (props?: any, context?: any) => any;

declare interface ExternalThumbnailsConfig {
    vttUrl: string;
}

/**
 * focus element
 *
 * @export
 * @param {HTMLElement} element - reference element
 * @param {number} delay - delay number default 100
 * @returns {void}
 */
declare function focusElement(element: HTMLElement | null, delay?: number): void;

/**
 * Formatting input that has only numbers to valid time (hh:mm:ss), i.e. 1 to 00:01
 *
 * @param {string} val - the value to format
 * @returns {string} the formatted value
 */
declare function formatOnlyNumbersInput(val: string): string;

/**
 * Forward component
 *
 * @class Forward
 * @example <Forward step={5} />
 * @extends {Component}
 */
declare class Forward extends Component<any, any> {
    /**
     * should render component
     * @returns {boolean} - whether to render the component
     */
    _shouldRender(): boolean;
    /**
     * forward click handler
     *
     * @returns {void}
     * @memberof Forward
     */
    onClick: () => void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof Forward
     */
    render({ step, forwardText, innerRef }: any): VNode<any> | undefined;
}

/**
 * Fullscreen component
 *
 * @class Fullscreen
 * @example <Fullscreen />
 * @extends {Component}
 */
declare class Fullscreen extends Component<FullscreenProps & WithPlayerProps & WithLoggerProps & WithEventDispatcherProps & TextProps & WithKeyboardEventProps, any> {
    _keyboardEventHandlers: Array<KeyboardEventHandlers>;
    /**
     * on component mount
     *
     * @returns {void}
     * @memberof Fullscreen
     */
    componentDidMount(): void;
    /**
     * handle keyboard events
     *
     * @param {KeyboardEvent} event - keyboard event
     * @returns {void}
     * @memberof Fullscreen
     */
    handleKeydown: (event: KeyboardEvent) => void;
    /**
     * toggle fullscreen based on current fullscreen state in store
     *
     * @returns {void}
     * @memberof Fullscreen
     */
    toggleFullscreen: () => void;
    /**
     * render component
     *
     * @returns {React$Element} - component
     * @memberof Fullscreen
     */
    render(): VNode<any>;
}

export declare type FullscreenConfig = {
    disableDoubleClick: boolean;
};

declare type FullscreenProps = {
    isInFullscreen: boolean;
};

export declare const getDurationAsText: (seconds: number, locale: string, round?: boolean) => string | undefined;

/**
 * Determines the badge icon type of the quality option based on the height of the resolution.
 *
 * @param {number} videoTrackHeight - video track resolution height.
 * @returns {string | null} - the badge icon type or null depends on the resolution height.
 */
declare function getLabelBadgeType(videoTrackHeight: number): string | null;

/**
 * get a logger
 * @param {?string} name - the logger name
 * @returns {Object} - the logger class
 */
declare function getLogger(name?: string): any;

export declare const getOverlayPortalElement: (player: KalturaPlayer) => Element | null;

declare namespace getters {
    export {
        isPlayingAdOrPlayback
    }
}

/**
 * GuiArea component
 *
 * @class GuiArea
 * @extends {Component}
 */
declare class GuiArea extends Component<any, any> {
    _ref: HTMLDivElement;
    /**
     * this component should not render itself when player object changes.
     * @param {Object} nextProps - next props of the component
     * @param {Object} nextState - next state of the component
     *
     * @returns {void}
     */
    shouldComponentUpdate(nextProps: any, nextState: any): boolean;
    /**
     *
     * @param {HTMLDivElement} ref - ref
     * @returns {void}
     * @private
     */
    _setRef: (ref: HTMLDivElement | null) => void;
    /**
     * render component
     *
     * @returns {React$Element} - component element
     */
    render(): VNode<any>;
}

export { h }

declare const HeightResolution: {
    HD: number;
    UHD_4K: number;
    UHD_8K: number;
};

/**
 * @typedef {Object} HEVCConfigObject@typedef {Object} HEVCConfigObject
 * @property {number} width - Optional width of the video
 * @property {number} height - Optional height of the video
 * @property {number} bitrate - Optional number of bits used to encode a second of video
 * @property {number} framerate - Optional number of frames used in one second
 */
declare type HEVCConfigObject = {
    width?: number;
    height?: number;
    bitrate?: number;
    framerate?: number;
};

/**
 * @typedef {Object} HEVCSupportedObject@typedef {Object} HEVCSupportedObject
 * @property {number} isHEVCSupported - Specifies HEVC supported option by the browser
 * @property {number} isPowerEfficient - Specifies power efficiency supported option
 */
declare type HEVCSupportedObject = {
    isHEVCSupported: number;
    isPowerEfficient: number;
};

declare interface IAdsController {
    allAdsCompleted: boolean;
    isAdBreak(): boolean;
    getAdBreaksLayout(): Array<number | string>;
    getAdBreak(): AdBreak | undefined;
    getAd(): Ad | undefined;
    skipAd(): void;
    playAdNow(adPod: KPAdPod): void;
}

declare interface IAdsPluginController {
    skipAd(): void;
    playAdNow(adPod: KPAdPod): void;
    onPlaybackEnded(): Promise<void>;
    active: boolean;
    done: boolean;
    name: string;
}

/**
 * Icon component
 *
 * @class Icon
 * @example <Icon type={IconType.Play} />
 * @extends {Component}
 */
declare class Icon extends Component<any, any> {
    _defaultColor: string;
    _activeColor: string;
    _className: string;
    /**
     * @constructor
     * @param {Object} props - component props
     */
    constructor(props: any);
    /**
     * Creates a dynamic icon class with background image settings
     *
     * @param {Object} props - component props
     * @returns {void}
     * @memberof Icon
     */
    createDynamicIconClass: (props: any) => void;
    /**
     * Generates the encoded svg url for a certain svg path
     *
     * @param {string} path - svg path
     * @param {number} width - svg width
     * @param {number} height - svg height
     * @param {string} viewBox - svg viewBox
     * @param {string} fillRule - svg fill-rule
     * @returns {string} - encoded svg url
     * @memberof Icon
     */
    getSVGUrl: (path: string, width?: number, height?: number, viewBox?: string, fillRule?: string) => string;
    /**
     * @param {?number} state - icon state
     * @param {?string} color - external default color
     * @param {?string} activeColor - external active color
     * @returns {string} - svg fill color
     * @memberof Icon
     */
    getFillColor: (state?: number, color?: string, activeColor?: string) => string;
    /**
     * @param {string | Array<string>} pathProps - svg path or paths (if an icon contains multiple paths)
     * @param {string} fillColor - icon fill color
     * @returns {string} - icon path tag
     * @memberof Icon
     */
    getPathTag: (pathProps: any | Array<any>, fillColor: string) => string;
    /**
     * component will update
     * @param {Object} nextProps - the next props
     * @memberof Icon
     * @return {void}
     */
    componentWillUpdate(nextProps: any): void;
    /**
     * render icon based on props.type
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof Icon
     */
    render(props: any): VNode<any> | undefined;
}

declare interface IconComponent {
    registerComponent(): any;
    getSvgIcon(): any;
    getComponentText(): any;
}

declare const IconState: {
    [state: string]: number;
};

declare const IconType: {
    Maximize: string;
    Minimize: string;
    Play: string;
    Pause: string;
    VolumeBase: string;
    VolumeWaves: string;
    VolumeWave: string;
    VolumeMute: string;
    Close: string;
    Settings: string;
    Check: string;
    CheckActive: string;
    Language: string;
    Quality: string;
    Captions: string;
    Speed: string;
    SpeedDown: string;
    SpeedUp: string;
    Audio: string;
    ArrowDown: string;
    StartOver: string;
    SeekEnd: string;
    Rewind: string;
    Rewind10: string;
    Forward: string;
    Forward10: string;
    vrStereo: string;
    vrStereoFull: string;
    Cast: string;
    CastBrand: string;
    Next: string;
    Prev: string;
    PictureInPictureStart: string;
    PictureInPictureStop: string;
    ClosedCaptionsOn: string;
    ClosedCaptionsOff: string;
    AdvancedAudioDescription: string;
    AdvancedAudioDescriptionActive: string;
};

/**
 * Idle ui interface
 *
 * @export
 * @param {*} props component props
 * @returns {React$Element} player ui tree
 */
declare function idleUI(props: any): VNode<any>;

declare interface ImageSourceOptions {
    thumbnailAPIParams: {
        [parmaName: string]: string;
    };
}

/**
 * Playback ui interface
 *
 * @export
 * @param {*} props component props
 * @returns {React$Element} player ui tree
 */
declare function imgUI(props: any): VNode<any>;

declare const initialState: {
    targetId: string;
    forceTouchUI: boolean;
    showCCButton: boolean;
    openMenuFromCCButton: boolean;
    settings: {
        showAudioMenu: boolean;
        showCaptionsMenu: boolean;
        showQualityMenu: boolean;
        showSpeedMenu: boolean;
        showAdvancedAudioDescToggle: boolean;
        showAdvancedCaptionsMenu: boolean;
    };
    hoverTimeout: number;
    tinySizeDisabled: boolean;
    components: {
        watermark: any;
        seekbar: any;
        vrStereo: any;
        logo: any;
        fullscreen: any;
        sidePanels: any;
    };
};

declare const initialState_10: {
    draggingActive: boolean;
    hover: boolean;
};

declare const initialState_11: {
    isOpen: boolean;
};

declare const initialState_12: {
    controlsToMove: never[];
};

declare const initialState_2: {
    style: string;
};

declare const initialState_3: {
    isIdle: boolean;
    isPlaying: boolean;
    isPaused: boolean;
    isSeeking: boolean;
    isEnded: boolean;
    isPlaybackStarted: boolean;
    isPlaybackEnded: boolean;
    isChangingSource: boolean;
    prePlayback: boolean;
    metadataLoaded: boolean;
    dataLoaded: boolean;
    playerState: {
        previousState: string;
        currentState: string;
    };
    fallbackToMutedAutoPlay: boolean;
    poster: string;
    currentTime: number;
    lastSeekPoint: number;
    duration: number;
    volume: number;
    muted: boolean;
    videoTracks: never[];
    audioTracks: never[];
    textTracks: never[];
    adIsLinear: boolean;
    adBreak: boolean;
    adIsPlaying: boolean;
    adSkipTimeOffset: number;
    adSkippableState: boolean;
    adIsBumper: boolean;
    adContentType: null;
    isLive: boolean;
    isDvr: boolean;
    isImg: boolean;
    isDocument: boolean;
    isAudio: boolean;
    adProgress: {
        currentTime: number;
        duration: number;
    };
    adUrl: string;
    hasError: boolean;
    errorDetails: {
        errorCategory: undefined;
        errorTitle: undefined;
        errorMessage: undefined;
    };
    isVr: boolean;
    vrStereoMode: boolean;
    isCasting: boolean;
    castSession: null;
    isCastAvailable: boolean;
    pictureInPictureSupported: boolean;
    isInPictureInPicture: boolean;
    playlist: null;
    fullscreen: boolean;
};

declare const initialState_4: {
    show: boolean;
};

declare const initialState_5: {
    iconType: null;
};

declare const initialState_6: {
    countdownCanceled: boolean;
};

declare const initialState_7: SeekbarState;

declare const initialState_8: {
    quality: number;
    speed: number;
    advancedAudioDesc: boolean;
    isCaptionsEnabled: boolean;
};

declare const initialState_9: {
    playerClasses: never[];
    guiClientRect: {
        x: number;
        y: number;
        width: number;
        height: number;
        top: number;
        right: number;
        bottom: number;
        left: number;
    };
    playerClientRect: {
        x: number;
        y: number;
        width: number;
        height: number;
        top: number;
        right: number;
        bottom: number;
        left: number;
    };
    videoClientRect: {
        x: number;
        y: number;
        width: number;
        height: number;
        top: number;
        right: number;
        bottom: number;
        left: number;
    };
    layoutStyles: {
        video: {
            position: string;
            left: number;
            right: number;
            top: number;
            bottom: number;
        };
        gui: {
            position: string;
            left: number;
            right: number;
            top: number;
            bottom: number;
        };
        sidePanels: {
            left: any;
            right: any;
            top: any;
            bottom: any;
        };
    };
    playerHover: boolean;
    playerNav: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        left: string;
        right: string;
        top: string;
        bottom: string;
    };
    sidePanelsSizes: {
        [x: string]: {
            min: number;
            max: number;
            ratio: number;
        };
    };
    presetSettings: PresetSettings;
};

/**
 * InteractiveArea component
 *
 * @class InteractiveArea
 * @extends {Component}
 */
declare class InteractiveArea extends Component<any, any> {
    /**
     * should component update handler
     *
     * @returns {boolean} shouldComponentUpdate
     */
    shouldComponentUpdate(): boolean;
    /**
     * @returns {void}
     */
    render(): h.JSX.Element;
}

/**
 * @interface IRemotePlayer
 *
 */
declare interface IRemotePlayer {
    /**
     * @type {TextStyle}
     * @instance
     * @memberof IRemotePlayer
     */
    textStyle: TextStyle;
    /**
     * @type {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    muted: boolean;
    /**
     * @type {number}
     * @instance
     * @memberof IRemotePlayer
     */
    playbackRate: number;
    /**
     * @type {number}
     * @instance
     * @memberof IRemotePlayer
     */
    volume: number;
    /**
     * @type {number}
     * @instance
     * @memberof IRemotePlayer
     */
    currentTime: number;
    /**
     * @readonly
     * @type {number}
     * @instance
     * @memberof IRemotePlayer
     */
    buffered: Array<any>;
    /**
     * @readonly
     * @type {number}
     * @instance
     * @memberof IRemotePlayer
     */
    duration: number;
    /**
     * @readonly
     * @type {number}
     * @instance
     * @memberof IRemotePlayer
     */
    liveDuration: number;
    /**
     * @readonly
     * @type {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    paused: boolean;
    /**
     * @readonly
     * @type {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    ended: boolean;
    /**
     * @readonly
     * @type {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    seeking: boolean;
    /**
     * @readonly
     * @type {string}
     * @instance
     * @memberof IRemotePlayer
     */
    src: string;
    /**
     * @readonly
     * @type {string}
     * @instance
     * @memberof IRemotePlayer
     */
    poster: string;
    /**
     * @readonly
     * @type {string}
     * @instance
     * @memberof IRemotePlayer
     */
    engineType: string;
    /**
     * @readonly
     * @type {string}
     * @instance
     * @memberof IRemotePlayer
     */
    streamType: string;
    /**
     * @readonly
     * @type {string}
     * @instance
     * @memberof IRemotePlayer
     */
    type: string;
    /**
     * @readonly
     * @type {Object}
     * @memberof IRemotePlayer
     * @instance
     */
    ads: any;
    /**
     * @readonly
     * @type {KPOptionsObject}
     * @instance
     * @memberof IRemotePlayer
     */
    config: any;
    /**
     * @method
     * @param {string} type
     * @param {Function} listener
     * @instance
     * @memberof IRemotePlayer
     */
    addEventListener(type: string, listener: () => any): void;
    /**
     * @method
     * @param {string} type
     * @param {Function} listener
     * @instance
     * @memberof IRemotePlayer
     */
    removeEventListener(type: string, listener: () => any): void;
    /**
     * @method
     * @param {FakeEvent} event
     * @instance
     * @memberof IRemotePlayer
     */
    dispatchEvent(event: FakeEvent): void;
    /**
     * @method
     * @param {Object} mediaInfo
     * @instance
     * @memberof IRemotePlayer
     */
    loadMedia(mediaInfo: any): Promise<any>;
    /**
     * @method
     * @param {Object} mediaConfig
     * @instance
     * @memberof IRemotePlayer
     */
    setMedia(mediaConfig: any): void;
    /**
     * @method
     * @returns {Object}
     * @instance
     * @memberof IRemotePlayer
     */
    getMediaInfo(): ProviderMediaInfoObject;
    /**
     * @method
     * @returns {Object}
     * @instance
     * @memberof IRemotePlayer
     */
    getMediaConfig(): KPMediaConfig;
    /**
     * @method
     * @param {Object} config
     * @instance
     * @memberof IRemotePlayer
     */
    configure(config: any): void;
    /**
     * @method
     * @returns {Promise<any>}
     * @instance
     * @memberof IRemotePlayer
     */
    ready(): Promise<any>;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    load(): void;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    play(): void;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    pause(): void;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    reset(): void;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    destroy(): void;
    /**
     * @method
     * @returns {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    isLive(): boolean;
    /**
     * @method
     * @returns {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    isDvr(): boolean;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    seekToLiveEdge(): void;
    /**
     * @method
     * @returns {number}
     * @instance
     * @memberof IRemotePlayer
     */
    getStartTimeOfDvrWindow(): number;
    /**
     * @method
     * @param {string} [type]
     * @returns {Array<Track>}
     * @instance
     * @memberof IRemotePlayer
     */
    getTracks(type?: string): Array<Track>;
    /**
     * @method
     * @returns {Object}
     * @instance
     * @memberof IRemotePlayer
     */
    getActiveTracks(): any;
    /**
     * @method
     * @param {Track} track
     * @instance
     * @memberof IRemotePlayer
     */
    selectTrack(track: Track): void;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    hideTextTrack(): void;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    enableAdaptiveBitrate(): void;
    /**
     * @method
     * @returns {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    isAdaptiveBitrateEnabled(): boolean;
    /**
     * @method
     * @param {Object} settings
     * @instance
     * @memberof IRemotePlayer
     */
    setTextDisplaySettings(settings: any): void;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    startCasting(): void;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    stopCasting(): void;
    /**
     * @method
     * @returns {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    isCasting(): boolean;
    /**
     * @method
     * @returns {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    isCastAvailable(): boolean;
    /**
     * @method
     * @returns {RemoteSession}
     * @instance
     * @memberof IRemotePlayer
     */
    getCastSession(): RemoteSession;
    /**
     * @method
     * @returns {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    isVr(): boolean;
    /**
     * @method
     * @instance
     * @memberof IRemotePlayer
     */
    toggleVrStereoMode(): void;
    /**
     * @method
     * @returns {boolean}
     * @instance
     * @memberof IRemotePlayer
     */
    isInVrStereoMode(): boolean;
}

/**
 * @param {Object} state - state.
 * @returns {boolean} - Whether the player is playing ad or content.
 */
declare const isPlayingAdOrPlayback: (state: any) => boolean;

declare class KalturaPlayer extends FakeEventTarget {
    private static _logger;
    private _localPlayer;
    private _provider;
    private _uiWrapper;
    private _controllerProvider;
    private _adsController;
    private _eventManager;
    private _attachEventManager;
    private _playlistManager;
    private _remotePlayerManager;
    private _mediaInfo;
    _remotePlayer: BaseRemotePlayer | null;
    private _pluginManager;
    private _pluginsConfig;
    private _reset;
    private _firstPlay;
    private _sourceSelected;
    private _pluginReadinessMiddleware;
    private _configEvaluator;
    private _appPluginConfig;
    private _viewabilityManager;
    _playbackStart: boolean;
    private _thumbnailManager;
    private _cuepointManager;
    private _serviceProvider;
    private _isVisible;
    private _autoPaused;
    constructor(options: KalturaPlayerConfig);
    loadMedia(mediaInfo: ProviderMediaInfoObject, mediaOptions?: SourcesConfig): Promise<any>;
    setMedia(mediaConfig: KPMediaConfig): void;
    loadPlaylist(playlistInfo: ProviderPlaylistInfoObject, playlistConfig: PlaylistConfigObject): Promise<ProviderPlaylistObject>;
    loadPlaylistByEntryList(entryList: ProviderEntryListObject, playlistConfig: PlaylistConfigObject): Promise<ProviderPlaylistObject>;
    setPlaylist(playlistData: ProviderPlaylistObject, playlistConfig: PlaylistConfigObject, entryList?: ProviderEntryListObject): void;
    configure(config?: Partial<KalturaPlayerConfig>): void;
    updateKalturaPoster(playerSources: PKSourcesConfigObject, mediaSources: ProviderMediaConfigSourcesObject, dimensions: PKPlayerDimensions): void;
    shouldAddKs(mediaConfig?: KPMediaConfig): boolean;
    getMediaInfo(): ProviderMediaInfoObject;
    getDrmInfo(): PKDrmDataObject | null;
    getMediaConfig(): KPMediaConfig;
    setSourcesMetadata(sourcesMetadata: PKMetadataConfigObject): void;
    ready(): Promise<void>;
    load(): void;
    play(): void;
    pause(): void;
    getView(): HTMLElement;
    getVideoElement(): HTMLVideoElement | undefined;
    reset(isChangeMedia?: boolean): void;
    destroy(): void;
    isLive(): boolean;
    isOnLiveEdge(): boolean;
    isDvr(): boolean;
    isUntimedImg(): boolean;
    isUntimedDocument(): boolean;
    isImage(): boolean;
    isDocument(): boolean;
    isAudio(): boolean;
    seekToLiveEdge(): void;
    getStartTimeOfDvrWindow(): number;
    getTracks(type?: TrackTypes): Array<Track>;
    getActiveTracks(): any;
    selectTrack(track: Track): void;
    hideTextTrack(): void;
    showTextTrack(): void;
    enableAdaptiveBitrate(): void;
    isAdaptiveBitrateEnabled(): boolean;
    setTextDisplaySettings(settings: any): void;
    get textDisplaySetting(): any;
    isFullscreen(): boolean;
    notifyEnterFullscreen(): void;
    notifyExitFullscreen(): void;
    enterFullscreen(fullScreenElementId?: string): void;
    exitFullscreen(): void;
    enterPictureInPicture(): void;
    exitPictureInPicture(): void;
    isInPictureInPicture(): boolean;
    isPictureInPictureSupported(): boolean;
    getLogLevel(name?: string): any;
    startCasting(type: string): Promise<void>;
    setIsCastInitiator(type: string, isCastInitiator: boolean): void;
    isCastAvailable(type?: string): boolean;
    getCastSession(): RemoteSession | null;
    stopCasting(): void;
    isCasting(): boolean;
    isVr(): boolean;
    toggleVrStereoMode(): void;
    isInVrStereoMode(): boolean;
    setLogLevel(level: any, name?: string): void;
    getThumbnail(time?: number): ThumbnailInfo | null;
    set textStyle(style: TextStyle);
    get textStyle(): TextStyle;
    get buffered(): TimeRanges | null;
    get stats(): any;
    set currentTime(to: number);
    get currentTime(): number | null;
    get duration(): number | null;
    get liveDuration(): number | null;
    /**
     * In VOD playback this setter is like the regular `currentTime` setter.
     * In live playback this setter normalizes the seek point to be relative to the start of the DVR window.
     * This setter is useful to display a seekbar presents the available seek range only.
     * @param {Number} to - The number to set in seconds (from 0 to the normalized duration).
     */
    set normalizedCurrentTime(to: number);
    /**
     * In VOD playback this getter is like the regular `currentTime` getter.
     * In live playback this getter normalizes the current time to be relative to the start of the DVR window.
     * This getter is useful to display a seekbar presents the available seek range only.
     */
    get normalizedCurrentTime(): number | null;
    /**
     * In VOD playback this getter is like the regular `duration` getter.
     * In live playback this getter normalizes the duration to be relative to the start of the DVR window.
     * This getter is useful to display a seekbar presents the available seek range only.
     */
    get normalizedDuration(): number | null;
    set volume(vol: number);
    get volume(): number | null;
    get paused(): boolean | null;
    get seeking(): boolean | null;
    set playsinline(playsinline: boolean);
    get playsinline(): boolean | null;
    set muted(mute: boolean);
    get muted(): boolean | null;
    get src(): string | null;
    get videoHeight(): number | null;
    get videoWidth(): number | null;
    set dimensions(dimensions: PKPlayerDimensions);
    get dimensions(): PKPlayerDimensions;
    get poster(): string;
    get ended(): boolean | null;
    set playbackRate(rate: number);
    get playbackRate(): number | null;
    get playbackRates(): Array<number>;
    get defaultPlaybackRate(): number;
    get engineType(): string;
    get streamType(): string;
    get env(): any;
    get selectedSource(): PKMediaSourceObject | null;
    get sources(): PKSourcesConfigObject;
    get config(): KalturaPlayerConfig;
    get hasUserInteracted(): boolean;
    set loadingMedia(loading: boolean);
    get ads(): AdsController | undefined;
    get plugins(): {
        [name: string]: BasePlugin;
    };
    get provider(): Provider;
    get ui(): UIWrapper;
    /**
     * The playlist controller.
     * @type {PlaylistManager}
     * @instance
     * @memberof KalturaPlayer
     * @example
     * KalturaPlayer.playlist.playNext();
     */
    get playlist(): PlaylistManager;
    get Event(): KPEventTypes;
    get TextStyle(): typeof TextStyle;
    get ViewabilityType(): typeof ViewabilityType;
    get State(): typeof StateType;
    get Track(): typeof TrackType;
    get LogLevelType(): Record<keyof LoggerLevels, keyof LoggerLevels>;
    get LogLevel(): LoggerLevels;
    get AbrMode(): typeof AbrMode;
    get MediaType(): typeof MediaType;
    get StreamType(): typeof StreamType;
    get EngineType(): typeof EngineType;
    get Error(): typeof Error_2;
    private _addBindings;
    private _onChangeSourceEnded;
    private _onPlayerReset;
    private _onChangeSourceStarted;
    private _onEnded;
    private _onPlaybackEnded;
    private _onAdStarted;
    private _onAdAutoplayFailed;
    private _configureOrLoadPlugins;
    private _maybeCreateAdsController;
    attachMediaSource(): void;
    detachMediaSource(): void;
    private _resetProviderPluginsConfig;
    /**
     * Set crossOrigin attribute.
     * @param {?string} crossOrigin - 'anonymous', 'use-credentials' or null to remove attribute
     * anonymous: CORS requests for this element will not have the credentials flag set.
     * use-credentials: CORS requests for this element will have the credentials flag set; this means the request will provide credentials.
     */
    set crossOrigin(crossOrigin: string);
    /**
     * Get crossOrigin attribute.
     * @returns {?string} - 'anonymous' or 'use-credentials'
     */
    get crossOrigin(): string | null;
    /**
     * Gets the player visibility state
     * @returns {boolean} - whether the player is in the active browser tab and visible in the view port
     * @public
     */
    get isVisible(): boolean;
    /**
     * Gets the player viewability manager service
     * @returns {ViewabilityManager} - player viewability manager
     * @public
     */
    get viewabilityManager(): ViewabilityManager;
    private _handleVisibilityChange;
    private _handleAutoPause;
    /**
     * Gets a registered service of that name
     * @param {string} name - the service name
     * @returns {Object} - the service object
     */
    getService(name: string): any | void;
    /**
     * Checks if a service of that name has been registered
     * @param {string} name - the service name
     * @returns {boolean} - if the service exist
     */
    hasService(name: string): boolean;
    /**
     * Registers a service to be used across the player
     * @param {string} name - the service name
     * @param {Object} service - the service object
     * @returns {void}
     */
    registerService(name: string, service: any): void;
    get cuePointManager(): CuePointManager;
    /**
     * Add text track
     * @function addTextTrack
     * @param {string} kind - Specifies the kind of text track.
     * @param {?string} label - A string specifying the label for the text track.
     * @returns {?TextTrack} - A TextTrack Object, which represents the new text track.
     * @public
     */
    addTextTrack(kind: TextTrackKind, label?: string): TextTrack | undefined;
    /**
     * get the native text tracks
     * @function getNativeTextTracks
     * @returns {Array<TextTrack>} - The native TextTracks array.
     * @public
     */
    getNativeTextTracks(): Array<TextTrack>;
    get remotePlayerManager(): RemotePlayerManager;
    /**
     * get the media capabilities
     * @function getMediaCapabilities
     * @param {HEVCConfigObject} hevcConfig - The HEVC configuration to check (optional).
     * @returns {Promise<MediaCapabilitiesObject>} - The media capabilities object.
     * @public
     */
    getMediaCapabilities(hevcConfig?: HEVCConfigObject): Promise<MediaCapabilitiesObject>;
}

declare interface KalturaPlayerConfig {
    targetId: string;
    log?: LogConfig;
    disableUserCache?: boolean;
    text?: PKTextConfigObject;
    playback: PlaybackConfig;
    sources: PKSourcesConfigObject;
    plugins: PluginsConfig;
    advertising: AdvertisingConfig;
    session?: PKSessionConfigObject;
    provider: ProviderOptionsObject;
    playlist?: PlaylistConfig;
    dimensions?: PKDimensionsConfig;
    ui: UiConfig;
    cast?: {
        [key: string]: any;
    };
    productVersion?: string;
    viewability: ViewabilityConfig;
    network?: NetworkConfig;
    abr?: PKAbrConfigObject;
}

/**
 * Keyboard component
 *
 * @class Keyboard
 * @extends {Component}
 */
declare class Keyboard extends Component<any, any> {
    _lastActiveTextLanguage: string;
    _hoverTimeout: number | null;
    /**
     * creates an instance of Keyboard
     *
     * @param {Object} obj obj
     * @memberof Keyboard
     */
    constructor(obj: any);
    /**
     * We update the last language selected here upon trackTracks props change. This is done to make sure we update the
     * last text track lanague upon language menu selection and using the (C) keyboard key.
     * @param {Object} nextProps - the props that will replace the current props
     * @returns {void}
     */
    componentWillReceiveProps(nextProps: any): void;
    /**
     * handlers for keyboard commands
     * @type {Object} - maps key number to his handler
     *
     * @memberof Keyboard
     */
    keyboardHandlers: {
        [key: number]: (event: KeyboardEvent) => KeyboardEventResult;
    };
    render(): undefined;
}

export declare type KeyboardEventHandlers = {
    eventType?: string;
    key: KeyboardKey;
    action: Function;
};

/**
 * KeyboardEventProvider component
 *
 * @class KeyboardEventProvider
 * @extends {Component}
 */
declare class KeyboardEventProvider extends Component<any, any> {
    _keyboardListeners: any[];
    _isKeyboardEnable: boolean;
    _componentToHandle: string | null;
    keyEventHandler: any;
    /**
     * constructor
     * @return {void}
     */
    componentDidMount(): void;
    /**
     *
     * @returns {boolean} should not rerender
     * @memberof KeyboardEventProvider
     */
    shouldComponentUpdate(): boolean;
    /**
     * handles key events
     * @param {KeyboardEvent} event - the keyboard event
     * @returns {void}
     * @memberof KeyboardEventProvider
     */
    _keyEventHandler(event: KeyboardEvent): void;
    /**
     * check if keyboard handlers are relevant
     * @returns {boolean} - if keyboard handlers are relevant
     * @private
     */
    _shouldHandleKeyboardEvents(): boolean;
    /**
     * add keyboard event handler
     * @param {string} componentName - event type
     * @param {string} eventType - event type
     * @param {KeyboardKey} key - the click data payload
     * @param {Function} callback - the click data payload
     * @returns {void}
     * @private
     */
    _addKeyboardHandler: (componentName: string, eventType: string, key: KeyboardKey, callback: (args: any) => any) => void;
    /**
     * remove keyboard event handler
     * @param {string} eventType - event type
     * @param {KeyboardKey} key - the click data payload
     * @returns {void}
     * @private
     */
    _removeKeyboardHandler: (eventType: string, key: KeyboardKey) => void;
    /**
     * update the listeners status
     * @param {boolean} isEnable - keyboard status listeners
     * @returns {void}
     * @private
     */
    _updateIsKeyboardEnabled: (isEnable: boolean) => void;
    /**
     * update specific component to handle
     * @param {?string} componentName - component is scoped and only this component handler should work
     * @returns {void}
     * @private
     */
    _setKeyboardEventToScope: (componentName: string) => void;
    /**
     * create key code from sequence of controls
     * @param {string} eventType - keyboard event type
     * @param {KeyboardKey} key - the key to register for
     * @returns {number} the key for handler
     * @private
     */
    _createKeyCode(eventType: string, key: KeyboardKey): number;
    /**
     * create context for keyboard event handler
     * @returns {void}
     */
    getChildContext(): {
        addKeyboardHandler: (componentName: string, eventType: string, key: KeyboardKey, callback: (args: any) => any) => void;
        removeKeyboardHandler: (eventType: string, key: KeyboardKey) => void;
        updateIsKeyboardEnabled: (isEnable: boolean) => void;
        setKeyboardEventToScope: (componentName: string) => void;
    };
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof KeyboardEventProvider
     */
    render(): any;
}

export declare type KeyboardEventResult = {
    preventDefault: boolean;
    payload: any;
};

export declare type KeyboardKey = {
    code: number;
    altKey?: boolean;
    ctrlKey?: boolean;
    metaKey?: boolean;
    shiftKey?: boolean;
};

declare const KeyCode: {
    Backspace: string;
    Tab: string;
    Enter: string;
    ShiftLeft: string;
    ShiftRight: string;
    ControlLeft: string;
    ControlRight: string;
    AltLeft: string;
    AltRight: string;
    Pause: string;
    CapsLock: string;
    Escape: string;
    Space: string;
    PageUp: string;
    PageDown: string;
    End: string;
    Home: string;
    ArrowLeft: string;
    ArrowUp: string;
    ArrowRight: string;
    ArrowDown: string;
    Insert: string;
    Delete: string;
    KeyP: string;
    KeyC: string;
    KeyF: string;
    KeyM: string;
    KeyD: string;
    Numpad0: string;
    Semicolon: string;
    Equal: string;
    Comma: string;
    Minus: string;
    Period: string;
    Slash: string;
};

/**
 * @deprecated Use the `KeyCode` object instead.
 * see here: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode
 * For more information on keyboard event codes, refer to the MDN documentation:
 * https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code/code_values
 */
declare const KeyMap: {
    [key: string]: number;
};

/**
 * @typedef {Object} KPAdObject@typedef {Object} KPAdObject
 * @property {Array<string>} url - List of urls, each one specifies the ad tag url that is requested from the ad server. The player will request the first url, if failed, it will request the second url and so on (aka waterfalling).
 * @property {Array<string>} response - List of XMLs, each one specifies a VAST 2.0 document to be used as the ads response instead of making a request via an ad tag url. The player will use the first XML, if failed, it will use the second and so on (aka waterfalling).
 * @property {boolean} bumper - Specifies whether this is a bumper.
 * @property {KPAdPrebidConfig} prebid - Specifies whether this is a prebid ad and add the relevant config for prebid request.
 */
declare type KPAdObject = {
    url?: Array<string>;
    response?: Array<string>;
    bumper?: boolean;
    prebid?: KPAdPrebidConfig;
};

/**
 * @typedef {Array<KPAdObject>} KPAdPod
 */
declare type KPAdPod = Array<KPAdObject>;

declare interface KPAdPrebidConfig {
    adUnit: any;
    params?: Object;
    options?: Object;
    timeout: number;
}

declare type KPEventTypes = {
    Core: PKEventTypes;
    UI: typeof UIEventType_2;
    Cast: typeof CastEventType;
    Playlist: typeof PlaylistEventType;
    VISIBILITY_CHANGE: 'visibilitychange';
};

/**
 * @typedef {Object} KPMediaConfig@typedef {Object} KPMediaConfig
 * @property {ProviderMediaConfigSourcesObject} sources
 * @property {ProviderMediaConfigSessionObject} session
 * @property {{[plugin: string]: Object}} plugins
 */
declare interface KPMediaConfig extends PlaybackConfig {
    sources: ProviderMediaConfigSourcesObject;
    session?: ProviderMediaConfigSessionObject;
    plugins?: {
        [plugin: string]: Object;
    };
}

/**
 * @typedef {Object} KPPlaylistItemConfigObject@typedef {Object} KPPlaylistItemConfigObject
 * @property {KPPlaylistCountdownOptions} [countdown] - Countdown options
 */
declare type KPPlaylistItemConfigObject = {
    countdown?: PlaylistCountdownOptions;
};

/**
 * @typedef {Object} KPPlaylistObject@typedef {Object} KPPlaylistObject
 * @property {string} id - This is playlist's ID.
 * @property {ProviderPlaylistMetadataObject} metadata - This is the playlist metadata.
 * @property {KPPlaylistOptions} options - These are the playlist options.
 * @property {KPPlaylistCountdownOptions} countdown - This is the playlist countdown configuration.
 * @property {Array<PlaylistItem>} items - These are the playlist items.
 */
declare interface KPPlaylistObject extends PlaylistConfigObject {
    id?: string;
    metadata?: ProviderPlaylistMetadataObject;
    poster?: string;
}

export declare interface KPUIAddComponent extends KPUIComponentOptions {
    get: (() => any) | string;
    props?: object;
}

export declare interface KPUIComponent extends KPUIAddComponent, KPUIRemoveComponent {
}

export declare interface KPUIComponentOptions {
    label: string;
    presets: Array<string>;
    area: string;
    /** @deprecated Use area instead. */
    container?: string;
    beforeComponent?: string;
    afterComponent?: string;
    replaceComponent?: string;
}

export declare interface KPUIRemoveComponent {
    /** @deprecated Use area instead. */
    container?: string;
    removeComponent: string;
    presets: Array<string>;
    area: string;
}

declare type LayoutStyles = {
    sidePanels: {
        top: any;
        bottom: any;
        left: any;
        right: any;
    };
    video: any;
    gui: any;
};

declare type ListenerType = (visible: boolean, reason: string) => any;

/**
 * LiveTag component
 *
 * @class LiveTag
 * @example <LiveTag />
 * @extends {Component}
 */
declare class LiveTag extends Component<any, any> {
    /**
     * returns a boolean to detect if player is on live edge
     *
     * @returns {boolean} - is player on live edge
     * @memberof LiveTag
     */
    isOnLiveEdge(): boolean;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof LiveTag
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * click handler to live tag
     * if not on live edge, seeking to live edge and if paused, call play method
     *
     * @returns {void}
     * @memberof LiveTag
     */
    onClick: () => void;
    /**
     * render live tag component
     *
     * @param {*} props - component props
     * @returns {React$Element} component element
     * @memberof LiveTag
     */
    render(props: any): VNode<any>;
}

/**
 * Live ui interface
 *
 * @export
 * @param {*} props component props
 * @returns {React$Element<any>} player ui tree
 */
declare function liveUI(props: any): VNode<any>;

/**
 * Loading component
 *
 * @class Loading
 * @example <Loading />
 * @extends {Component}
 */
declare class Loading extends Component<any, any> {
    /**
     * Creates an instance of Loading.
     * @memberof Loading
     */
    constructor();
    /**
     * after component mounted, set event listener to player state change and update the state of loading spinner accordingly.
     *
     * @returns {void}
     * @memberof Loading
     */
    componentDidMount(): void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof Loading
     */
    render(props: any): VNode | undefined;
}

declare namespace loading {
    export {
        types_4 as types,
        initialState_4 as initialState,
        _default_4 as default,
        actions_4 as actions
    }
}

declare interface LoadingState {
    show: boolean;
}

declare interface LogConfig {
    playerVersion?: boolean;
    level: string;
    handler?: (messages: any[], context: Object) => void;
}

declare type loggerFunctionType = {
    VERSION: string;
    DEBUG: LogLevelObject;
    ERROR: LogLevelObject;
    INFO: LogLevelObject;
    OFF: LogLevelObject;
    TIME: LogLevelObject;
    TRACE: LogLevelObject;
    WARN: LogLevelObject;
    createDefaultHandler: Function;
    debug: Function;
    enabledFor: Function;
    error: Function;
    get: Function;
    getLevel: Function;
    info: Function;
    log: Function;
    setHandler: Function;
    setLevel: Function;
    time: Function;
    timeEnd: Function;
    trace: Function;
    useDefaults: Function;
    warn: Function;
};

declare type LoggerType = {
    getLogger: loggerFunctionType;
    LogLevel: LogLevelType;
};

declare type LogLevelObject = {
    value: number;
    name: string;
};

declare type LogLevelType = {
    [level: string]: LogLevelObject;
};

/**
 * Logo component
 *
 * @class Logo
 * @example <Logo />
 * @extends {Component}
 */
declare class Logo extends Component<any, any> {
    /**
     * @constructor
     * @param {*} props props
     */
    constructor(props: any);
    /**
     * when component did mount
     *
     * @returns {void}
     * @memberof Logo
     */
    componentDidMount(): void;
    /**
     * handles the logo url
     * if the url contains ${entryId}, then replace it with the played entry id
     *
     * @returns {void}
     * @memberof Logo
     */
    private _handleLogoUrl;
    _handleKeyDown: (e: KeyboardEvent) => void;
    _handleOnClick: () => void;
    /**
     * sets the url with the entry id
     * @param {string} url - the url configured on the logo
     * @returns {boolean} - whether the url was set with entry id or not
     * @memberof Logo
     */
    private _setLogoUrlWithEntryId;
    /**
     * should render component
     * @returns {boolean} - whether to render the component
     */
    private _shouldRender;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {?React$Element} - component
     * @memberof Logo
     */
    render(props: any): VNode<any> | undefined;
}

export declare type LogoConfig = {
    text: string;
    url: string;
    img: string;
};

/**
 * @typedef {Object} MediaCapabilitiesObject
 */
declare type MediaCapabilitiesObject = HEVCSupportedObject & DRMSupportedObject;

declare interface MediaSourceOptionsObject {
    forceRedirectExternalStreams: boolean;
    redirectExternalStreamsHandler: () => void | undefined;
    redirectExternalStreamsTimeout: number | undefined;
}

/**
 * Menu component
 *
 * @class Menu
 * @example <Menu
 *  options={this.videoTrackOptions}
 *  onSelect={track => this.videoTrackChangeHandler(track)}
 *  onClose={() => this.onClose()}
 * />
 * @extends {Component}
 */
declare class Menu extends Component<MenuProps & WithEventManagerProps, any> {
    _menuElement: HTMLDivElement;
    /**
     * before component mounted, set initial state of the menu position
     * @returns {void}
     * @memberof Menu
     */
    componentWillMount(): void;
    /**
     * after component mounted, listen to click outside of the component
     * @returns {void}
     * @memberof Menu
     */
    componentDidMount(): void;
    /**
     * get menu position based on document boundaries
     *
     * @returns {Array} position style classes array
     * @memberof Menu
     */
    getPosition(): Array<string>;
    /**
     * handler to click outside of the component event listener.
     * if not mobile device and clicked outside the component, call the onClose callback
     *
     * @param {*} e click event
     * @returns {void}
     * @memberof Menu
     */
    handleClickOutside: (e: any) => void;
    /**
     * indication if option is active or not
     *
     * @param {Object} option option object
     * @returns {boolean} is option active boolean
     * @memberof Menu
     */
    isSelected(option: any): boolean;
    /**
     * when option selected, change the active prop immediately for instant ui change
     * and call the onSelect callback with the option value
     *
     * @param {Object} option - option object
     * @returns {void}
     * @memberof Menu
     */
    onSelect(option: OptionType): void;
    /**
     * on change handler
     * @param {Event} e - event
     * @returns {void}
     * @memberof Menu
     */
    onChange: (e: Event) => void;
    /**
     * render native select element
     * @param {string} labelledby - the label id the describes the dropdown (for screen reader)
     * @returns {React$Element} - component element
     * @memberof Menu
     */
    renderNativeSelect(labelledby: string): VNode<any>;
    /**
     * if mobile device detected, renders the native select element.
     * otherwise, render the styled menu
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof Menu
     */
    render(props: any): VNode<any>;
}

declare type MenuProps = {
    isMobile?: boolean;
    isSmallSize?: boolean;
    guiClientRect?: DOMRect;
    options: OptionType[];
    labelledby?: string;
    pushRef?: (HTMLElement: any) => void;
    onMenuChosen: (value: any) => void;
    onClose: () => void;
    hideSelect?: boolean;
    parentEl?: HTMLDivElement;
};

export declare const NAME: string;

declare interface NetworkConfig {
    requestFilter?: () => void;
    responseFilter?: () => void;
    maxStaleLevelReloads: number;
}

declare type OptionType = {
    value: any;
    label: string;
    active: boolean;
};

/**
 * Overlay component
 * @class Overlay
 * @example <Overlay
 *  type='share'
 *  onClose={() => this.closeShareOverlay()}
 * >
 *  ...
 * </Overlay>
 * @extends {Component}
 */
declare class Overlay extends Component<OverlayProps, any> {
    private _timeoutId;
    private _wasPlayed;
    static defaultProps: {
        closeAriaLabel: string;
    };
    /**
     * componentWillMount
     *
     * @returns {void}
     * @memberof Overlay
     */
    componentDidMount(): void;
    /**
     * componentWillUnmount
     *
     * @returns {void}
     * @memberof Overlay
     */
    componentWillUnmount(): void;
    componentDidUpdate(previousProps: Readonly<OverlayProps>): void;
    /**
     * on close button key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof Overlay
     */
    private onCloseButtonKeyDown;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof Overlay
     */
    private onKeyDown;
    /**
     * closeButton
     * @param {any} props - props
     * @returns {React$Element | void} close button element
     * @memberof Overlay
     */
    private renderCloseButton;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component
     * @memberof Overlay
     */
    render({ type, open, ariaLabel, ariaLabelledBy }: any): VNode<any>;
}

declare namespace overlay {
    export {
        types_11 as types,
        initialState_11 as initialState,
        _default_11 as default,
        actions_11 as actions
    }
}

/**
 * OverlayAction component
 *
 * @class OverlayAction
 * @example <OverlayAction />
 * @extends {Component}
 */
declare class OverlayAction extends Component<any, any> {
    _iconTimeout: number | null;
    _pointerDownPosX: number;
    _pointerDownPosY: number;
    _firstClickTime: number;
    _clickTimeout: number | null;
    /**
     * after component unmount, clear timeouts
     *
     * @returns {void}
     * @memberof OverlayAction
     */
    componentWillUnmount(): void;
    /**
     * toggle play pause and set animation to icon change
     *
     * @returns {void}
     * @memberof OverlayAction
     */
    togglePlayPause: () => void;
    /**
     * toggle exit-enter fullscreen
     *
     * @returns {void}
     * @memberof OverlayAction
     */
    toggleFullscreen(): void;
    /**
     * Handler for overlay pointer (mouse/touch) down
     *
     * @param {*} event - mousedown/touchstart event
     * @returns {void}
     * @memberof OverlayAction
     */
    onOverlayPointerDown: (event: any) => void;
    /**
     * Handler for overlay mouse up
     *
     * @param {*} event - mouseup event
     * @returns {void}
     * @memberof OverlayAction
     */
    private onOverlayMouseUp;
    /**
     * handler for overlay touch end
     *
     * @param {*} event - touchend event
     * @returns {void}
     * @memberof OverlayAction
     */
    onOverlayTouchEnd: (event: any) => void;
    /**
     * Whether the user is dragging
     *
     * @param {*} event - mouseup/touchend event
     * @returns {boolean} - is dragging
     */
    isDragging(event: any): boolean;
    /**
     * click action
     *
     * @returns {void}
     * @memberof OverlayAction
     */
    overlayClick(): void;
    /**
     * cancel the clickTimeout
     *
     * @returns {void}
     * @memberof OverlayAction
     */
    cancelClickTimeout(): void;
    /**
     * cancel the clickTimeout
     *
     * @returns {void}
     * @memberof OverlayAction
     */
    cancelIconTimeout(): void;
    /**
     * should component update handler
     *
     * @returns {boolean} - always update component
     * @param {Object} nextProps - next props of the component
     * @memberof OverlayAction
     */
    shouldComponentUpdate(nextProps: any): boolean;
    /**
     * toggles the overlay action icon
     *
     * @param {string | Array<string>} iconType - the icon string or array of icon strings
     * @returns {void}
     * @memberof OverlayAction
     */
    toggleOverlayActionIcon(iconType: string | Array<string>): void;
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof OverlayAction
     */
    render(): VNode<any>;
    /**
     * renders the icons
     *
     * @returns {React$Element} - icon element/s
     * @memberof OverlayAction
     */
    renderIcons(): ComponentChild;
    /**
     * component did update handler
     *
     * @returns {void}
     * @memberof OverlayAction
     */
    componentDidUpdate(): void;
}

declare namespace overlayAction {
    export {
        types_5 as types,
        initialState_5 as initialState,
        _default_5 as default,
        actions_5 as actions
    }
}

declare interface OverlayActionsState {
    iconType: string | null;
}

/**
 * OverlayPortal component
 *
 * @class OverlayPortal
 * @example <OverlayPortal>...</OverlayPortal>
 * @extends {Component}
 */
declare class OverlayPortal extends Component<any, any> {
    /**
     * change in component props or state shouldn't render the component again
     *
     * @returns {boolean} shouldComponentUpdate
     * @memberof OverlayPortal
     */
    shouldComponentUpdate(): boolean;
    /**
     * render component
     *
     * @param {*} props - comonent props
     * @returns {React$Element} - component element
     * @memberof OverlayPortal
     */
    render(props: any): VNode<any>;
}

declare interface OverlayProps {
    type?: string;
    open?: boolean;
    ariaLabel?: string;
    ariaLabelledBy?: string;
    onClose?: (e?: KeyboardEvent, byKeyboard?: true) => void;
    handleKeyDown?: (e: KeyboardEvent) => void;
    addPlayerClass?: (className: string) => void;
    removePlayerClass?: (className: string) => void;
    updateOverlay?: (isOpen: boolean) => void;
    overlayOpen?: boolean;
    dontCheckOverlayPortal?: boolean;
    permanent?: boolean;
    player?: any;
    addAccessibleChild?: (el: HTMLElement) => void;
    pauseOnOpen?: boolean;
    closeAriaLabel?: string;
}

declare interface OverlayState {
    isOpen: boolean;
}

/**
 * PictureInPicture component
 *
 * @class PictureInPicture
 * @extends {Component}
 */
declare class PictureInPicture extends Component<any, any> implements IconComponent {
    _keyboardEventHandlers: Array<KeyboardEventHandlers>;
    /**
     * Creates an instance of PictureInPicture.
     * @memberof PictureInPicture
     */
    constructor(props: any);
    registerComponent(): any;
    getSvgIcon: () => any;
    getComponentText: () => string;
    /**
     * component mounted
     *
     * @returns {void}
     * @memberof PictureInPicture
     */
    componentDidMount(): void;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof PictureInPicture
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * should render component
     * @returns {boolean} - whether to render the component
     */
    _shouldRender(): boolean;
    /**
     * toggle pip
     * @returns {void}
     *
     * @memberof PictureInPicture
     */
    togglePip: () => void;
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof PictureInPicture
     */
    render(): VNode<any> | undefined;
}

declare interface PKAdBreakOptions {
    type?: string;
    position?: number;
    numAds?: number;
}

declare interface PKAdOptions {
    system?: string;
    url?: string;
    contentType?: string;
    title?: string;
    position?: number;
    duration?: number;
    clickThroughUrl?: string;
    posterUrl?: string;
    skipOffset?: number;
    linear: boolean;
    width: number;
    height: number;
    bitrate: number;
    bumper: boolean;
    inStream?: boolean;
    vpaid?: boolean;
    streamId?: string;
    wrapperAdIds: Array<string>;
    wrapperCreativeIds: Array<string>;
    wrapperAdSystems: Array<string>;
}

declare interface PlaybackConfig extends PKPlaybackConfigObject {
    autopause: boolean;
    loop: boolean;
}

/**
 * PlaybackControls component
 *
 * @class PlaybackControls
 * @example <PlaybackControls>...</PlaybackControls>
 * @extends {Component}
 */
declare class PlaybackControls extends Component<any, any> {
    /**
     * component did mount
     * @return {void}
     */
    componentDidMount(): void;
    /**
     * component will update
     * @param {Object} prevProps - the next props
     * @return {void}
     */
    componentDidUpdate(prevProps: any): void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof PlaybackControls
     */
    render({ showPreview, playlist, className }: any): VNode<any>;
}

/**
 * Playback ui interface
 *
 * @export
 * @param {*} props component props
 * @returns {React$Element} player ui tree
 */
declare function playbackUI(props: any): VNode<any>;

declare const PLAYER_BREAK_POINTS: {
    [size: string]: number;
};

declare const PLAYER_SIZE: {
    [size: string]: string;
};

/**
 * A video PlayerArea enabling injecting components by preset, PlayerArea and position
 */
declare class PlayerArea extends Component<any, any> {
    static defaultProps: {
        show: boolean;
    };
    _unregisterListenerCallback: ((args?: any) => any) | null;
    _actualChildren: ComponentChildren;
    /**
     * should component update handler
     *
     * @returns {boolean} - always update component
     * @param {Object} nextProps - next props of the component
     * @param {Object} nextState - next state of the component
     * @memberof OverlayAction
     */
    shouldComponentUpdate(nextProps: any, nextState: any): boolean;
    /**
     * component did update handler
     *
     * @param {Object} prevProps - prev props of the component
     * @returns {void}
     * @memberof OverlayAction
     */
    componentDidUpdate(prevProps: any): void;
    /**
     * @returns {void}
     */
    _unregisterListener(): void;
    /**
     * @returns {void}
     */
    _registerListener(): void;
    /**
     * @param {Array<Object>} playerAreaComponents - playerAreaComponents
     * @returns {void}
     * @private
     */
    _updateAreaComponents: (playerAreaComponents: Array<any>) => void;
    /**
     * component did mount
     * @return {void}
     */
    componentDidMount(): void;
    /**
     * component will update
     * @param {Object} nextProps - the next props
     * @return {void}
     */
    componentWillUpdate(nextProps: any): void;
    /**
     * componentWillUnmount
     *
     * @returns {void}
     */
    componentWillUnmount(): void;
    /**
     *  render preset component
     * @param {KPUIComponent} uiComponent uiComponent
     * @returns {*} component
     * @private
     */
    _renderUIComponent(uiComponent: KPUIComponent): VNode<any> | null;
    /**
     * render PlayerArea content
     * @param {*} children children
     * @returns {*} component
     */
    renderContent(children: ComponentChildren): h.JSX.Element;
    /**
     * get positioned components
     * @param {*} children children
     * @returns {*} new children
     */
    _getPositionedComponents(children: ComponentChildren): Array<any>;
    /**
     * render component
     *
     * @returns {null | *} - component
     * @memberof PlayerArea
     */
    render(): ComponentChild;
}

/**
 * PlayerProvider component
 *
 * @class PlayerProvider
 * @example <PlayerProvider player={this.player}>...</PlayerProvider>
 * @extends {Component}
 */
declare class PlayerProvider extends Component<any, any> {
    /**
     * create context player
     * @returns {void}
     */
    getChildContext(): {
        player: any;
    };
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof PlayerProvider
     */
    render(): any;
}

declare namespace playlist {
    export {
        types_6 as types,
        initialState_6 as initialState,
        _default_6 as default,
        actions_6 as actions
    }
}

/**
 * PlaylistButton component
 *
 * @class PlaylistButton
 * @example <PlaylistButton type="next"/>
 * @extends {Component}
 */
declare class PlaylistButton extends Component<any, any> {
    /**
     * playlist button click handler
     *
     * @returns {void}
     * @memberof PlaylistButton
     */
    onClick: () => void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof PlaylistButton
     */
    render(props: any): VNode<any> | undefined;
}

declare interface PlaylistConfig {
    id: string;
    metadata: ProviderPlaylistMetadataObject;
    poster?: string;
    options?: PlaylistOptions;
    countdown?: PlaylistCountdownOptions;
    items: Array<PlaylistItem>;
}

declare interface PlaylistConfigObject {
    options?: PlaylistOptions;
    countdown?: PlaylistCountdownOptions;
    items: Array<PlaylistItem>;
}

/**
 * @typedef {Object} KPPlaylistCountdownOptions@typedef {Object} KPPlaylistCountdownOptions
 * @property {number} [timeToShow] - Shows when the countdown is scheduled to appear (by default, this is towards the end).
 * @property {number} [duration=10] - Shows for how long the countdown will appear.
 * @property {boolean} [showing=true] - Determines whether to show the countdown.
 */
declare interface PlaylistCountdownOptions {
    timeToShow?: number;
    duration: number;
    showing: boolean;
}

/**
 * @const {Object} PlaylistEventType
 *
 * @example
 * // Events lifecycle
 * 1. PLAYLIST_LOADED
 * 2. PLAYLIST_ITEM_CHANGED (multiple)
 * 3. PLAYLIST_ENDED
 * @example
 * // How to use
 * player.addEventListener(KalturaPlayer.playlist.PlaylistEventType.PLAYLIST_LOADED, e => {
 *   console.log(e.payload.playlist.metadata.name);
 * };
 */
declare const PlaylistEventType: {
    /**
     * Fires when the playlist has been loaded.
     * @event PLAYLIST_LOADED
     * @memberof PlaylistEventType
     */
    readonly PLAYLIST_LOADED: "kaltura-player-playlistloaded";
    /**
     * Fires when a playlist item start to changed.
     * @event PLAYLIST_ITEM_CHANGED
     * @memberof PlaylistEventType
     */
    readonly PLAYLIST_ITEM_CHANGED: "kaltura-player-playlistitemchanged";
    /**
     * Fires when the playlist has finished.
     * @event PLAYLIST_ENDED
     * @memberof PlaylistEventType
     */
    readonly PLAYLIST_ENDED: "kaltura-player-playlistended";
};

/**
 * @class PlaylistItem
 * @param {PKSourcesConfigObject} [sources] - The item sources
 * @param {KPPlaylistItemConfigObject} [config] - The item config
 */
declare class PlaylistItem {
    private _sources;
    private _config;
    private _plugins;
    private _index;
    constructor(sources: SourcesConfig, config: KPPlaylistItemConfigObject, index: number);
    /**
     * Update the playlist item sources
     * @param {PKSourcesConfigObject} sourcesObject - The sources
     * @returns {void}
     * @instance
     * @memberof PlaylistItem
     */
    updateSources(sourcesObject: SourcesConfig): void;
    /**
     * Update the playlist item plugins (e.g. bumper from BE)
     * @param {KPPluginsConfigObject} pluginsObject - The plugins
     * @returns {void}
     * @instance
     * @memberof PlaylistItem
     */
    updatePlugins(pluginsObject: PluginsConfig): void;
    /**
     * Playlist item sources
     * @type {?PKSourcesConfigObject}
     * @instance
     * @memberof PlaylistItem
     */
    get sources(): SourcesConfig;
    /**
     * Playlist item config
     * @type {?KPPlaylistItemConfigObject}
     * @instance
     * @memberof PlaylistItem
     */
    get config(): KPPlaylistItemConfigObject;
    /**
     * Playlist item plugins
     * @type {KPPluginsConfigObject}
     * @instance
     * @memberof PlaylistItem
     */
    get plugins(): PluginsConfig;
    /**
     * Playlist item index
     * @type {number}
     * @instance
     * @memberof PlaylistItem
     */
    get index(): number;
    /**
     * @returns {boolean} = Whether the playlist item has sources to play
     * @instance
     * @memberof PlaylistItem
     */
    isPlayable(): boolean;
}

/**
 * @class PlaylistManager
 * @param {KalturaPlayer} player - The player instance
 * @param {KPOptionsObject} options - The player config object
 */
declare class PlaylistManager {
    private static _logger;
    private readonly _player;
    private _eventManager;
    private _playlist;
    private readonly _options;
    private readonly _countdown;
    private _playerOptions;
    private _mediaInfoList;
    private _appPluginConfig;
    constructor(player: KalturaPlayer, options: KalturaPlayerConfig);
    /**
     * Config the playlist
     * @param {KPPlaylistObject} [config] - The playlist config
     * @param {ProviderEntryListObject} [entryList] - Entry list
     * @returns {void}
     * @instance
     * @memberof PlaylistManager
     */
    configure(config: KPPlaylistObject, entryList?: ProviderEntryListObject): void;
    /**
     * Load a playlist
     * @param {KPPlaylistObject} playlistData - The playlist data
     * @param {KPPlaylistConfigObject} [playlistConfig] - The playlist config
     * @param {ProviderEntryListObject} [entryList] - Entry list
     * @returns {void}
     * @instance
     * @memberof PlaylistManager
     */
    load(playlistData: ProviderPlaylistObject, playlistConfig: PlaylistConfigObject, entryList?: ProviderEntryListObject): void;
    /**
     * Reset the playlist
     * @returns {void}
     * @instance
     * @memberof PlaylistManager
     */
    reset(): void;
    /**
     * Play the next item
     * @returns {void}
     * @instance
     * @memberof PlaylistManager
     */
    playNext(): void;
    /**
     * Play the previous item
     * @returns {void}
     * @instance
     * @memberof PlaylistManager
     */
    playPrev(): void;
    /**
     * Play a specific item
     * @param {number} index - The index of the item to play
     * @returns {void}
     * @instance
     * @memberof PlaylistManager
     */
    playItem(index: number): void;
    /**
     * Playlist items
     * @type {Array<PlaylistItem>}
     * @instance
     * @memberof PlaylistManager
     */
    get items(): Array<PlaylistItem>;
    /**
     * Current item
     * @type {?PlaylistItem}
     * @instance
     * @memberof PlaylistManager
     */
    get current(): PlaylistItem | undefined;
    /**
     * Next item
     * @type {?PlaylistItem}
     * @instance
     * @memberof PlaylistManager
     */
    get next(): PlaylistItem | undefined;
    /**
     * Previous item
     * @type {?PlaylistItem}
     * @instance
     * @memberof PlaylistManager
     */
    get prev(): PlaylistItem | undefined;
    /**
     * Playlist id
     * @type {string}
     * @instance
     * @memberof PlaylistManager
     */
    get id(): string;
    /**
     * Playlist metadata
     * @type {ProviderPlaylistMetadataObject}
     * @instance
     * @memberof PlaylistManager
     */
    get metadata(): ProviderPlaylistMetadataObject;
    /**
     * Playlist poster
     * @type {?string}
     * @instance
     * @memberof PlaylistManager
     */
    get poster(): string | undefined;
    /**
     * Playlist countdown
     * @type {KPPlaylistCountdownOptions}
     * @instance
     * @memberof PlaylistManager
     */
    get countdown(): PlaylistCountdownOptions;
    /**
     * Playlist options
     * @type {KPPlaylistOptions}
     * @instance
     * @memberof PlaylistManager
     */
    get options(): PlaylistOptions;
    private _getMergedPlaylistData;
    private _addBindings;
    private _onPlaybackEnded;
    private _onChangeSourceStarted;
    private _setItem;
    private _resetProviderPluginsConfig;
    destroy(): void;
}

/**
 * PlaylistNextScreen component
 *
 * @class PlaylistNextScreen
 * @example <PlaylistNextScreen type="next"/>
 * @extends {Component}
 */
declare class PlaylistNextScreen extends Component<any, any> {
    focusElement: HTMLDivElement;
    /**
     * after component updated, if was renderd and now should then focus for keyboard a11y
     * @param {Object} previousProps - previous props
     * @returns {void}
     * @memberof PlaylistNextScreen
     */
    componentDidUpdate(previousProps: any): void;
    /**
     * should render component
     * @param {*} props - component props
     * @returns {boolean} - component element
     */
    _shouldRender(props: any): boolean;
    /**
     * next poster click handler
     *
     * @returns {void}
     * @memberof PlaylistNextScreen
     */
    onPosterClick: () => void;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof PlaylistNextScreen
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * @private
     * @memberof PlaylistNextScreen
     * @returns {string} - Next poster URL
     */
    _getPosterUrl(): string;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof PlaylistNextScreen
     */
    render(props: any): VNode<any> | undefined;
}

/**
 * @typedef {Object} KPPlaylistOptions@typedef {Object} KPPlaylistOptions
 * @property {boolean} [autoContinue=true] - Determines whether to continue to the next item automatically.
 * @property {boolean} [loop=false] - Determines whether to play the playlist in a loop. When selected, the playlist will play automatically even if autoContinue is set to false.
 * @property {string} [startAtEntryId] - Determines which entry id to start to the play the playlist from.
 */
declare interface PlaylistOptions {
    autoContinue: boolean;
    loop: boolean;
    imageDuration: number;
    documentDuration: number;
    startAtEntryId?: string;
}

declare interface PlaylistState {
    countdownCanceled: boolean;
}

/**
 * PlayPause component
 *
 * @class PlayPause
 * @example <PlayPause />
 * @extends {Component}
 */
declare class PlayPause extends Component<any, any> {
    private _playPauseButtonRef?;
    state: {
        entryName: string;
    };
    /**
     * component mounted
     *
     * @returns {void}
     * @memberof PlayPause
     */
    componentDidMount(): void;
    /**
     * toggle play / pause
     *
     * @returns {void}
     * @memberof PlayPause
     */
    togglePlayPause: () => void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof PlayPause
     */
    render(props: any): VNode<any> | undefined;
}

declare interface PluginsConfig {
    [plugin: string]: BasePlugin;
}

export { preact_2 as preact }

export { preactHooks }

export { preacti18n }

declare interface PrebidConfig extends AdPrebidConfig {
    libUrl: string;
}

/**
 * PrePlaybackPlayOverlay component
 *
 * @class PrePlaybackPlayOverlay
 * @example <PrePlaybackPlayOverlay />
 * @extends {Component}
 */
declare class PrePlaybackPlayOverlay extends Component<any, any> {
    /**
     * play on click
     *
     * @returns {void}
     * @memberof PrePlaybackPlayOverlay
     */
    handleClick: () => void;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof PrePlaybackPlayOverlay
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * on mouse over handler
     *
     * @param {Event} e - event
     * @returns {void}
     * @memberof PrePlaybackPlayOverlay
     */
    onMouseOver: (e: Event) => void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof PrePlaybackPlayOverlay
     */
    render(props: any): VNode<any> | undefined;
}

declare namespace Presets {
    export {
        idleUI,
        playbackUI,
        adsUI,
        errorUI,
        liveUI,
        imgUI,
        docUI
    }
}
export { Presets }
export { Presets as presets }

declare type PresetSettings = {
    allowSidePanels: boolean;
    allowPlayerArea: boolean;
};

declare class PrevNext extends Component<any, any> {
    render(props: any): VNode<any>;
}

/**
 * ProgressBar component
 *
 * @class ProgressIndicator
 * @extends {Component}
 */
declare class ProgressIndicator extends Component<any, any> {
    /**
     * get current buffered percent from the player
     *
     * @returns {number} - current buffered percent
     * @memberof ProgressIndicator
     */
    getBufferedPercent(): number;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component
     * @memberof ProgressIndicator
     */
    render(props: any): VNode<any>;
}

/**
 * QualityMenu component
 *
 * @class QualityMenu
 * @example <QualityMenu />
 * @extends {Component}
 */
declare class QualityMenu extends Component<any, any> {
    /**
     * change quality track or if value is 'auto', enable player adaptive bitrate
     *
     * @param {(Object | string)} videoTrack - video track
     * @returns {void}
     * @memberof QualityMenu
     */
    onQualityChange(videoTrack: any | string): void;
    /**
     * This function gets an array and increases it if needed in each iteration. The function checks if the last element
     * in the sorted array has the same label as the new current track element. If so, it compares their bandwidth
     * and selects the one with the higher. If the resolution is different then it just adds it to the array
     *
     * @param {Array} qualities - sorted (!) video tracks array
     * @param {object} currentTrack - a track
     * @returns {Array<any>} - an array with unique values, compared by their height. if the new track (currenttrack) has
     * the same height value, then we take the one with the higher bandwidth (replace it if needed)
     * @memberof QualityMenu
     */
    filterUniqueQualities(qualities: Array<any>, currentTrack: any): Array<any>;
    /**
     * render function
     *
     * @param {*} props - component props
     * @returns {React$Element} - component
     * @memberof QualityMenu
     */
    render(props: any): VNode<any> | undefined;
}

declare namespace Reducers {
    export {
        config,
        cvaa,
        engine,
        getters,
        loading,
        overlayAction,
        playlist,
        seekbar,
        setting,
        shell,
        volume,
        overlay,
        bottomBar
    }
}
export { Reducers }
export { Reducers as reducers }

export { redux }

declare interface ReduxStateProps {
    playerClientRect?: DOMRect;
    guiClientRect?: DOMRect;
    isMobile?: boolean;
}

/**
 * @class RemoteControl
 * @param {KalturaPlayer} player - The Kaltura player.
 */
declare class RemoteControl {
    static _logger: any;
    /**
     * Gets the player snapshot.
     * @returns {PlayerSnapshot} - player snapshot.
     * @memberof RemoteControl
     * @instance
     */
    getPlayerSnapshot: () => void;
    /**
     * Gets the UI wrapper.
     * @returns {UIWrapper} - The UI wrapper.
     * @memberof RemoteControl
     * @instance
     */
    getUIWrapper: () => void;
    /**
     * On remote device disconnected handler.
     * @param {RemoteDisconnectedPayload} payload - disconnected payload.
     * @returns {void}
     * @memberof RemoteControl
     * @instance
     */
    onRemoteDeviceDisconnected: () => void;
    /**
     * On remote device connected handler.
     * @param {RemoteConnectedPayload} payload - connected payload.
     * @returns {void}
     * @memberof RemoteControl
     * @instance
     */
    onRemoteDeviceConnected: () => void;
    /**
     * On remote device available handler.
     * @param {RemoteAvailablePayload} payload - available payload.
     * @returns {void}
     * @memberof RemoteControl
     * @instance
     */
    onRemoteDeviceAvailable: () => void;
    /**
     * On remote device connecting handler.
     * @returns {void}
     * @memberof RemoteControl
     * @instance
     * @fires CastEventType:CAST_SESSION_STARTING
     */
    onRemoteDeviceConnecting: () => void;
    /**
     * On remote device disconnecting handler.
     * @returns {void}
     * @memberof RemoteControl
     * @instance
     */
    onRemoteDeviceDisconnecting: () => void;
    /**
     * On remote device connect failed handler.
     * @returns {void}
     * @memberof RemoteControl
     * @instance
     */
    onRemoteDeviceConnectFailed: () => void;
    constructor(player: KalturaPlayer);
}

declare class RemotePlayerManager {
    private static _registry;
    private static _logger;
    private _remotePlayers;
    static register(type: string, remotePlayer: BaseRemotePlayer): void;
    load(castConfig: any, player: KalturaPlayer): void;
    startCasting(type?: string): Promise<any>;
    isCastAvailable(type?: string): boolean;
    destroy(): void;
    setIsCastInitiator(type: string, isCastInitiator: boolean): void;
    private _getRemotePlayer;
}

/**
 * @class RemoteSession
 * @param {string} id - Session ID.
 * @param {string} friendlyName - Receiver friendly name.
 * @param {boolean} [resuming] - Whether the session is resuming.
 */
declare class RemoteSession {
    private readonly _id;
    private readonly _friendlyName;
    private readonly _resuming;
    constructor(id: string, friendlyName: string, resuming?: boolean);
    /**
     * Receiver friendly name.
     * @type {string}
     * @instance
     * @memberof RemoteSession
     */
    get deviceFriendlyName(): string;
    /**
     * Session ID.
     * @type {string}
     * @instance
     * @memberof RemoteSession
     */
    get id(): string;
    /**
     * Whether the session is resuming.
     * @type {?boolean}
     * @instance
     * @memberof RemoteSession
     */
    get resuming(): boolean | undefined;
}

declare const Remove = "remove";

export declare const ReservedPresetAreas: {
    PlayerArea: string;
    PresetArea: string;
    InteractiveArea: string;
    VideoArea: string;
    GuiArea: string;
    TopBar: string;
    BottomBar: string;
    PresetFloating: string;
    TopBarLeftControls: string;
    TopBarRightControls: string;
    BottomBarLeftControls: string;
    BottomBarRightControls: string;
    SidePanelTop: string;
    SidePanelLeft: string;
    SidePanelRight: string;
    SidePanelBottom: string;
    SeekBar: string;
    LoadingSpinner: string;
};

export declare const ReservedPresetNames: {
    Playback: string;
    Live: string;
    Ads: string;
    Error: string;
    Idle: string;
    Img: string;
    Document: string;
    MiniAudioUI: string;
};

/**
 * A Factory class to create a resize observer for the player.
 */
declare class ResizeWatcher extends FakeEventTarget {
    private _observer;
    private _el;
    /**
     * Removes resize listeners.
     * @returns {void}
     */
    destroy(): void;
    /**
     * Start listening to a resize of the element.
     * @param {?HTMLElement} el - the element to listen to.
     * @returns {void}
     */
    init(el?: HTMLElement): void;
    /**
     *
     * @returns {void}
     */
    private _createNativeObserver;
    /**
     *
     * @returns {void}
     */
    private _createIframeObserver;
    /**
     *
     * @returns {void}
     */
    private _triggerResize;
}

/**
 * Rewind component
 *
 * @class Rewind
 * @example <Rewind step={5} />
 * @extends {Component}
 */
declare class Rewind extends Component<any, any> {
    /**
     * rewind click handler
     *
     * @returns {void}
     * @memberof Rewind
     */
    onClick: () => void;
    /**
     * should render component
     * @returns {boolean} - whether to render the component
     */
    _shouldRender(): boolean;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof Rewind
     */
    render({ step, rewindText, innerRef }: any): VNode<any> | undefined;
}

export declare interface RootState {
    config: ConfigState;
    engine: EngineState;
    shell: ShellState;
    seekbar: SeekbarState;
    volume: VolumeState;
    loading: LoadingState;
    cvaa: CvaaState;
    settings: SettingsState;
    overlayAction: OverlayActionsState;
    playlist: PlaylistState;
    overlay: OverlayState;
    bottomBar: BottomBarState;
}

/**
 * Wraps around child components and displays a styled scrollbar with vertical or horizontal orientation.
 *
 * @param {object} props Component props.
 * @param {ComponentChildren} props.children Child components.
 * @param {boolean} props.isVertical If true, scrollbar has vertical orientation, otherwise - it has horizontal orientation.
 * @returns {any} Scrollable component
 */
declare const Scrollable: ({ children, isVertical }: {
    children: ComponentChildren;
    isVertical: boolean;
}) => h.JSX.Element;

/**
 * SeekBar component
 *
 * @class SeekBar
 * @extends {Component}
 */
declare class SeekBar extends Component<any, any> {
    _seekBarElement: HTMLDivElement;
    _framePreviewElement: HTMLDivElement;
    _timeBubbleElement: HTMLDivElement;
    _keyboardEventHandlers: Array<KeyboardEventHandlers>;
    handleUpdateSeekBarClientRect: () => void;
    /**
     * on component mount, bind mouseup and mousemove events to top player element
     *
     * @returns {void}
     * @memberof SeekBar
     */
    componentDidMount(): void;
    /**
     * before component unmounted, remove event listeners
     *
     * @returns {void}
     * @memberof SeekBar
     */
    componentWillUnmount(): void;
    /**
     * seekbar mouse down handler
     *
     * @param {Event} e - mouse down event
     * @returns {void}
     * @memberof SeekBar
     */
    onSeekbarMouseDown: (e: Event) => void;
    /**
     * player mouse up handler for seekbar porpuses
     *
     * @param {Event} e - mouse up event
     * @returns {void}
     * @memberof SeekBar
     */
    onPlayerMouseUp: (e: Event) => void;
    /**
     * player mouse move handler for seekbar porpuses
     *
     * @param {Event} e - mouse move event
     * @returns {void}
     * @memberof SeekBar
     */
    onPlayerMouseMove: (e: Event) => void;
    /**
     * seekbar mouse move handler
     *
     * @param {Event} e - mouse move event
     * @returns {void}
     * @memberof SeekBar
     */
    onSeekbarMouseMove: (e: Event) => void;
    /**
     * seekbar touch start handler
     *
     * @param {Event} e - touch start event
     * @returns {void}
     * @memberof SeekBar
     */
    onSeekbarTouchStart: (e: Event) => void;
    /**
     * seekbar touch move handler
     *
     * @param {Event} e - touch move event
     * @returns {void}
     * @memberof SeekBar
     */
    onSeekbarTouchMove: (e: Event) => void;
    /**
     * seekbar key down handler
     *
     * @returns {void}
     * @param {KeyboardEvent} event - keyboardEvent event
     * @param {boolean} isAccessibility - accessibility handler
     * @memberof SeekBar
     */
    handleKeydown(event: KeyboardEvent, isAccessibility: boolean): void;
    /**
     * seekbar keydown accessibility handler
     *
     * @param {Event} e - mouse end event
     * @returns {void}
     * @memberof SeekBar
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * toggle play/pause
     *
     * @returns {void}
     * @memberof SeekBar
     */
    togglePlayPause: () => void;
    /**
     * seekbar touch end handler
     *
     * @param {Event} e - mouse end event
     * @returns {void}
     * @memberof SeekBar
     */
    onSeekbarTouchEnd: (e: Event) => void;
    /**
     * seekbar mouse over handler
     *
     * @returns {void}
     * @memberof SeekBar
     */
    onSeekbarMouseOver: () => void;
    /**
     * seekbar mouse leave handler
     *
     * @returns {void}
     * @memberof SeekBar
     */
    onSeekbarMouseLeave: () => void;
    /**
     * abstract function to update virtual progress ui using component state or report to upper component of time change
     *
     * @param {number} currentTime - current time
     * @param {number} duration - duration
     * @param {boolean} [virtual=false] - virtual relates to the hover seekbar position
     * @returns {void}
     * @memberof SeekBar
     */
    updateSeekBarProgress(currentTime: number, duration: number, virtual?: boolean): void;
    /**
     * utility function to get element offset from window
     *
     * @param {*} element - element to get the offset for
     * @returns {{ top: number, left: number }} - object with offset in both asixs
     * @memberof SeekBar
     */
    getOffset(element: any): {
        top: number;
        left: number;
    };
    /**
     * calculating the transform of an element
     * @param {HTMLElement} element - the element to calculate the transform offset for
     * @returns {number} - the transform
     * @private
     */
    _getTransformX(element: HTMLElement): number;
    /**
     * get current time based on position of the mouseEvent on the seekbar
     *
     * @param {*} e - event
     * @returns {number} - current time in seconds
     * @memberof SeekBar
     */
    getTime(e: any): number;
    /**
     * get the left position the frame preview element should be in
     *
     * @returns {number} left position
     * @memberof SeekBar
     */
    getFramePreviewOffset(): number;
    /**
     * get the left position to time bubble should be in
     *
     * @returns {number} left position
     * @memberof SeekBar
     */
    getTimeBubbleOffset(): number;
    /**
     * render frame preview
     *
     * @returns {React$Element} - component
     * @memberof SeekBar
     */
    renderFramePreview(): VNode<any> | undefined;
    /**
     * Gets the style of the frame preview.
     * @returns {string} - The css style string.
     * @memberof SeekBar
     * @private
     */
    _getFramePreviewStyle(): string;
    /**
     * render time bubble
     *
     * @returns {React$Element} - component
     * @memberof SeekBar
     */
    renderTimeBubble(): VNode<any> | undefined;
    /**
     * render component
     *
     * @param {*} props - component props
     * @param {Object} state - component state
     * @returns {React$Element} - component
     * @memberof SeekBar
     */
    render(props: any, state: any): VNode<any>;
}

declare namespace seekbar {
    export {
        types_7 as types,
        initialState_7 as initialState,
        _default_7 as default,
        actions_7 as actions
    }
}

declare interface SeekbarClientRect {
    x: number;
    y: number;
    width: number;
    height: number;
    top: number;
    right: number;
    bottom: number;
    left: number;
}

/**
 * SeekBarLivePlaybackContainer component
 *
 * @class SeekBarLivePlaybackContainer
 * @example <SeekBarLivePlaybackContainer />
 * @extends {Component}
 */
declare class SeekBarLivePlaybackContainer extends Component<any, any> {
    /**
     * after component mounted, listen to time update event and if dragging not active,
     * update the current time in the store
     *
     * @returns {void}
     * @memberof SeekBarLivePlaybackContainer
     */
    componentDidMount(): void;
    /**
     *
     * @returns {number} - the currentTime of the video to show
     * @memberof SeekBarLivePlaybackContainer
     */
    get currentTime(): number;
    /**
     *
     * @returns {number} - the duration of the video to show
     * @memberof SeekBarLivePlaybackContainer
     */
    get duration(): number;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof SeekBarLivePlaybackContainer
     */
    render(props: any): h.JSX.Element | undefined;
}

/**
 * SeekBarPlaybackContainer component
 *
 * @class SeekBarPlaybackContainer
 * @example <SeekBarPlaybackContainer />
 * @extends {Component}
 */
declare class SeekBarPlaybackContainer extends Component<any, any> {
    /**
     * after component mounted, listen to time update event and if dragging not active,
     * update the current time in the store
     *
     * @returns {void}
     * @memberof SeekBarPlaybackContainer
     */
    componentDidMount(): void;
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof SeekBarPlaybackContainer
     */
    render(): VNode<any>;
}

/**
 * SeekBarPreview component
 *
 * @class SeekBarPreview
 * @extends {Component}
 */
declare class SeekBarPreview extends Component<WithPlayerProps & SeekBarPreviewProps, any> {
    /**
     * Gets the style of the frame preview image.
     * @param {Object} thumbnailInfo  - The thumbnail info data.
     * @returns {string} - The css style string.
     * @private
     */
    _getFramePreviewImgStyle(thumbnailInfo: any): string;
    /**
     * Gets the style of the frame preview image container.
     * @param {Object} thumbnailInfo  - The thumbnail info data.
     * @returns {Object} - The css object style.
     * @private
     */
    _getFramePreviewImgContainerStyle(thumbnailInfo: ThumbnailInfo): {
        height: string;
        width: string;
    };
    /**
     * render component
     * @returns {React$Element} - component element
     */
    render(): h.JSX.Element | undefined;
}

declare type SeekBarPreviewProps = {
    duration?: number;
    virtualTime: number;
};

declare interface SeekbarSegment {
    id: string;
    isHovered?: boolean;
    endTime?: number;
}

declare interface SeekbarState {
    currentTime: number;
    virtualTime: number;
    draggingActive: boolean;
    hoverActive: boolean;
    previewHoverActive: boolean;
    clientRect: SeekbarClientRect;
    hidePreview: boolean;
    hideTimeBubble: boolean;
    segments: SeekbarSegment[];
    seekbarClasses: string[];
    isPreventSeek: boolean;
}

declare namespace setting {
    export {
        types_8 as types,
        initialState_8 as initialState,
        _default_8 as default,
        actions_8 as actions
    }
}

/**
 * Settings component
 *
 * @class Settings
 * @example <Settings />
 * @extends {Component}
 */
declare class Settings extends Component<any, any> {
    _controlSettingsElement: HTMLDivElement;
    _buttonRef: HTMLButtonElement | null;
    _lastActiveTextLanguage: string;
    _keyboardEventHandlers: Array<KeyboardEventHandlers>;
    /**
     * before component mounted, set initial state
     *
     * @returns {void}
     * @memberof Settings
     */
    componentWillMount(): void;
    /**
     * after component mounted, set event listener to click outside of the component
     *
     * @returns {void}
     * @memberof Settings
     */
    componentDidMount(): void;
    /**
     * on settings control key down, update the settings in case of up/down keys
     *
     * @method handleKeydown
     * @param {KeyboardEvent} event - keyboardEvent event
     * @returns {void}
     * @memberof SpeedMenu
     */
    handleKeydown(event: KeyboardEvent): void;
    handleCCToggle(event: KeyboardEvent): void;
    /**
     * We update the last language selected here upon trackTracks props change. This is done to make sure we update the
     * last text track lanague upon language menu selection and using the (C) keyboard key.
     * @param {Object} nextProps - the props that will replace the current props
     * @returns {void}
     */
    componentWillReceiveProps(nextProps: any): void;
    /**
     * event listener for clicking outside handler.
     *
     * @param {*} e - click event
     * @returns {void}
     * @memberof Settings
     */
    handleClickOutside(e: any): void;
    /**
     * toggle smart container internal state on control button click
     *
     * @param {KeyboardEvent} e - keyboard event
     * @param {boolean} byKeyboard - is keydown
     * @returns {void}
     * @memberof Settings
     */
    onControlButtonClick: (e?: KeyboardEvent, byKeyboard?: boolean) => void;
    /**
     * set button reference
     *
     * @param {HTMLButtonElement} ref - button reference
     * @returns {void}
     * @memberof Settings
     */
    setButtonRef: (ref: HTMLButtonElement | null) => void;
    toggleCVAAOverlay: () => void;
    /**
     * handle the closure of cvaa overlay
     *
     * @param {KeyboardEvent} e - keyboard event
     * @param {boolean} byKeyboard - is keydown
     * @returns {void}
     * @memberof Settings
     */
    onCVAAOverlayClose: (e?: KeyboardEvent, byKeyboard?: boolean) => void;
    /**
     * returns The badge icon type of the active quality option based on the height of the resolution
     *
     * @returns {string | null} - the badge icon type or null depends on the resolution height.
     * @memberof Settings
     */
    getButtonBadgeType(): string | null;
    getQualityLabel(buttonBadgeType: any): string;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof Settings
     */
    render(props: any): VNode<any> | undefined;
}

declare interface SettingsState {
    quality: number;
    speed: number;
    audio?: string;
    advancedAudioDesc: boolean;
}

/**
 * Shell component
 *
 * @class Shell
 * @example <Shell />
 * @extends {Component}
 */
declare class Shell extends Component<any, any> {
    hoverTimeout: number | null;
    _environmentClasses: string[];
    _playerResizeWatcher: ResizeWatcher;
    _playerRef: HTMLDivElement | null;
    /**
     * on mouse leave, remove the hover class (hide the player gui)
     * @param {Event} event - the mouse leave event
     * @returns {void}
     * @memberof Shell
     */
    onMouseLeave: (event: Event) => void;
    /**
     * if ui hidden and mouse move, show the ui by adding the hover class
     *
     * @returns {void}
     * @memberof Shell
     */
    onMouseMove: () => void;
    /**
     * if the ui is in fallback to muted autoplay mode, unmute the player on any mouse down
     *
     * @returns {void}
     * @memberof Shell
     */
    onMouseUp: () => void;
    /**
     * if the ui is in fallback to muted autoplay mode, unmute the player
     *
     * @returns {void}
     * @memberof Shell
     */
    unMuteFallback(): void;
    toggleFullscreen(): void;
    /**
     * on touch end handler
     * @param {TouchEvent} e - touch event

     * @returns {void}
     * @memberof Shell
     */
    onTouchEnd: (e: TouchEvent) => void;
    /**
     * key down handler
     *
     * @param {KeyboardEvent} e - event object
     * @returns {void}
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * componentWillMount
     *
     * @returns {void}
     * @memberof Shell
     */
    componentWillMount(): void;
    /**
     * after component mounted, update the isMobile indication in the store state,
     * add event listener to get the player width and update these on resize as well.
     * also, update document width initially and on resize.
     *
     * @returns {void}
     * @memberof Shell
     */
    componentDidMount(): void;
    /**
     * handler to click outside the component event listener.
     * if not mobile device and clicked outside the component, update nav state
     *
     * @param {*} e click event
     * @returns {void}
     * @memberof Menu
     */
    _handleClickOutside: ({ target }: MouseEvent) => void;
    /**
     * window resize handler
     *
     * @returns {void}
     * @memberof Shell
     */
    _onWindowResize: () => void;
    /**
     * update the player rect
     *
     * @returns {void}
     * @memberof Shell
     */
    _updatePlayerClientRect: () => void;
    /**
     * before component mounted, remove event listeners
     *
     * @returns {void}
     * @memberof Shell
     */
    componentWillUnmount(): void;
    /**
     * updates the player hover state
     * @returns {void}
     * @memberof Shell
     */
    _updatePlayerHoverState(): void;
    /**
     * update hover as atomic change - all props for hover change at one place
     * to be able to know to handle outside changes for player hover
     * @returns {void} - if hover state can be ended
     * @param {boolean} hover - is needed to update to hover or not
     * @private
     * @memberof Shell
     */
    _updatePlayerHover(hover: boolean): void;
    /**
     * checks if hover state can be ended based on other components states
     * @returns {boolean} - if hover state can be ended
     * @private
     * @memberof Shell
     */
    _canEndHoverState(): boolean;
    /**
     * starts the hover timeout.
     * @returns {void}
     * @private
     * @memberof Shell
     */
    _startHoverTimeout(): void;
    /**
     * clears the hover timeout.
     * @returns {void}
     * @private
     * @memberof Shell
     */
    _clearHoverTimeout(): void;
    /**
     * when component did update and change its props from prePlayback to !prePlayback
     * update the hover state
     *
     * @param {Object} prevProps - previous props
     * @returns {void}
     * @memberof Shell
     */
    componentDidUpdate(prevProps: any): void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof Shell
     */
    render(props: any): VNode<any>;
}

declare namespace shell {
    export {
        types_9 as types,
        SidePanelOrientation,
        SidePanelPositions,
        SidePanelModes,
        ReservedPresetNames,
        ReservedPresetAreas,
        initialState_9 as initialState,
        _default_9 as default,
        actions_9 as actions
    }
}

declare interface ShellState {
    playerClasses: string[];
    isMobile?: boolean;
    playerSize?: string;
    isSmallSize?: boolean;
    guiClientRect: any;
    playerClientRect: any;
    videoClientRect: any;
    layoutStyles: LayoutStyles;
    playerHover: boolean;
    playerNav: boolean;
    smartContainerOpen: boolean;
    activePresetName: string;
    sidePanelsModes: {
        [key: string]: string;
    };
    sidePanelsSizes: {
        [key: string]: any;
    };
    presetSettings: PresetSettings;
    documentWidth?: number;
}

/**
 * SidePanel component
 *
 * @class SidePanel
 * @example <SidePanel>...</SidePanel>
 * @extends {Component}
 */
declare class SidePanel extends Component<any, any> {
    /**
     * this component should not render itself when player object changes.
     *
     * @param {Object} nextProps - next props of the component
     * @returns {void}
     * @memberof VideoPlayer
     */
    shouldComponentUpdate(nextProps: any): boolean;
    /**
     * render component
     *
     * @param {object} props - the component props
     * @returns {React$Element} - component element
     * @memberof SidePanel
     */
    render(props: any): VNode<any>;
}

export declare const SidePanelModes: {
    ALONGSIDE: string;
    HIDDEN: string;
    OVER: string;
};

declare const SidePanelOrientation: {
    VERTICAL: string;
    HORIZONTAL: string;
};

export declare const SidePanelPositions: {
    readonly LEFT: "left";
    readonly TOP: "top";
    readonly BOTTOM: "bottom";
    readonly RIGHT: "right";
};

export declare type SidePanelsConfig = {
    verticalSizes: {
        min?: number;
        max?: number;
        ratio?: number;
    };
    horizontalSizes: {
        min?: number;
        max?: number;
        ratio?: number;
    };
};

/**
 * Slider component
 *
 * @class Slider
 * @example <Slider onChange={value => this.onOpacityChange(value)} value={this.initialOpacity} min={0} max={100} />
 * @extends {Component}
 */
declare class Slider extends Component<any, any> {
    sliderWidth: number;
    _sliderElement: HTMLElement;
    _sliderElementOffsetLeft: number;
    /**
     * before component mounted, set initial state of the slider
     *
     * @returns {void}
     * @memberof Slider
     */
    componentWillMount(): void;
    /**
     * before component unmounted, remove event listeners
     *
     * @returns {void}
     * @memberof Slider
     */
    componentWillUnmount(): void;
    /**
     * after component mounted, save the sliderWidth
     *
     * @returns {void}
     * @memberof Slider
     */
    componentDidMount(): void;
    /**
     * mousedown slider handler
     *
     * @param {*} e event
     * @returns {void}
     * @memberof Slider
     */
    mouseDownHandler: (e: any) => void;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof Slider
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * key down handler if dragging via keyboard
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof Slider
     */
    onKeyboardDragging(e: KeyboardEvent): void;
    /**
     * document mousemove handler if dragging active
     *
     * @param {*} e event
     * @returns {void}
     * @memberof Slider
     */
    mouseMoveHandler: (e: any) => void;
    /**
     * document mouseup handler if dragging active
     *
     * @param {*} e event
     * @returns {void}
     * @memberof Slider
     */
    mouseUpHandler: (e: any) => void;
    /**
     * get slider value based on mouse event
     *
     * @param {*} e event
     * @param {Object} state - current component state
     * @returns {number} slider value
     * @memberof Slider
     */
    mouseEventToValue(e: any, state: any): number;
    /**
     * get slider value based on persentage value
     *
     * @param {any} persentage progress persentage of slider
     * @returns {number} slider value
     * @memberof Slider
     */
    getValueByPersentage(persentage: number): number;
    /**
     * get progress percentage by slider value
     *
     * @returns {number} percentage
     * @memberof Slider
     */
    getPercentageByValue(): number;
    /**
     * component render function
     * @param {*} props - component props
     * @returns {React$Element<any>} component element
     * @memberof Slider
     */
    render(props: any): VNode<any>;
}

/**
 * SmartContainer component
 *
 * @class SmartContainer
 * @example <SmartContainer title='Language' onClose={() => this.controlButtonClickHandler()}>
 *   <SmartContainerItem
 *     icon={IconType.Audio}
 *     label='Audio'
 *     options={audioTrackOptions}
 *     onSelect={audioTrack => this.audioTrackChangeHandler(audioTrack)}
 *   />
 *   ...
 * </SmartContainer>
 * @extends {Component}
 */
declare class SmartContainer extends Component<any, any> {
    /**
     * before component mounted, add player css class
     *
     * @returns {void}
     * @memberof SmartContainer
     */
    componentWillMount(): void;
    /**
     * after component unmounted, remove player css class
     *
     * @returns {void}
     * @memberof SmartContainer
     */
    componentWillUnmount(): void;
    /**
     * after component mounted, set A11y HOC to modal if is portal
     * @returns {void}
     * @memberof SmartContainer
     */
    componentDidMount(): void;
    /**
     * calc to show in portal mode
     * @returns {boolean} - is portal
     */
    get isPortal(): boolean;
    /**
     * if mobile detected, smart container representation is an overlay. hence, render overlay with its children.
     * otherwise, render smart container
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof SmartContainer
     */
    render(props: any): VNode<any>;
    /**
     * adds the children pushref prop to forward to keyboard accessibility popup hoc
     * @param {any} props - smart containers props
     * @returns {React$Element<any>} the rendered jsx
     */
    renderChildren(props: any): Array<VNode | undefined>;
}

/**
 * SmartContainerItem component
 *
 * @class SmartContainerItem
 * @extends {Component}
 */
declare class SmartContainerItem extends Component<any, any> {
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof SmartContainer
     */
    render(props: any): VNode<any>;
}

declare interface SourcesConfig extends Omit<ProviderMediaConfigSourcesObject, 'poster'> {
    thumbnails?: ExternalThumbnailsConfig;
    options: MediaSourceOptionsObject;
    startTime: number;
    imageSourceOptions?: ImageSourceOptions;
    poster?: string;
}

/**
 * SpeedMenu component
 *
 * @class SpeedMenu
 * @example <SpeedMenu />
 * @extends {Component}
 */
declare class SpeedMenu extends Component<any, any> {
    /**
     * change player playback rate and update it in the store state
     *
     * @param {number} playbackRate - playback rate value
     * @returns {void}
     * @memberof SpeedMenu
     */
    onSpeedChange: (playbackRate: number) => void;
    /**
     * render function
     *
     * @param {*} props - component props
     * @returns {React$Element} - component
     * @memberof SpeedMenu
     */
    render(props: any): VNode<any> | undefined;
}

export declare const style: {
    [key: string]: string;
};

declare class _TargetObserveredBinding {
    lastVisible: boolean;
    lastIntersectionRatio: number;
    threshold: number;
    listener: ListenerType;
    constructor(threshold: number, listener: ListenerType);
}

declare type TextProps = {
    fullscreenText: string;
    fullscreenExitText: string;
};

declare class ThemesManager {
    private player;
    private readonly config?;
    private playerContainerElement;
    constructor(player: any, config: UserTheme | undefined, targetId: string);
    /**
     * Apply the user theme from config (should be called only after the UI was build and the css vars are exist in the DOM).
     * @returns {void}
     */
    applyUserTheme(): void;
    /**
     * Makes color value for text.
     * @param {string} inputColor  - css color in HEX format
     * @returns {string} hex  - css color in HEX format
     */
    private makeTextContrastColor;
    /**
     * Override the colors from config.
     * @param {UserTheme} config  -
     * @returns {void}
     */
    private setColors;
    /**
     * Override the specified css var value.
     * @param {string} colorTitle -
     * @param {string} color  -
     * @returns {void}
     */
    private setAccentOrAcknowledgementColor;
    /**
     * Override the specified css var value.
     * @param {string} cssVarName -
     * @param {string} color  -
     * @returns {void}
     */
    private setColor;
    /**
     * Update the SVG url (of dynamic SVGs) with the new primary color and contrast text color.
     * @param {string} color  -
     * @returns {void}
     */
    private setSvgFillColor;
    /**
     * Return a css variable value
     * @param {string} variableName - CSS variable name
     * @returns {string} CSS variable value
     */
    getCSSVariable(variableName: string): string;
    /**
     * Return a css variable name
     * @param {string} variableName - CSS variable name
     * @param {string} value - CSS variable value
     * @returns {void}
     */
    setCSSVariable(variableName: string, value: string): void;
}

/**
 * TimeDisplay component
 *
 * @class TimeDisplay
 * @example <TimeDisplay
 *  currentTime={this.props.player.currentTime}
 *  duration={this.props.player.duration}
 *  format='currentTime / duration'
 * />
 * @extends {Component}
 */
declare class TimeDisplay extends Component<any, any> {
    /**
     * get formatted time display based on defined format
     *
     * @method getTimeDisplay
     * @param {number} currentTime current time
     * @param {number} duration duration
     * @param {string} [format] string that can use one or more of: 'current' / 'total' / 'left' and will be replaced with the relevant value
     * @returns {string} formatted time display
     * @memberof TimeDisplay
     */
    getTimeDisplay(currentTime: number, duration: number, format?: string): string;
    /**
     * render component
     *
     * @method render
     * @param {*} props - component props
     * @returns {React$Element} - component
     * @memberof TimeDisplay
     */
    render({ currentTime, duration, format }: any): VNode<any>;
}

/**
 * TimeDisplayAdsContainer component
 *
 * @class TimeDisplayAdsContainer
 * @example <TimeDisplayAdsContainer format='-left seconds left' />
 * @extends {Component}
 */
declare class TimeDisplayAdsContainer extends Component<any, any> {
    /**
     * render component
     *
     * @param {*} props component props
     * @returns {React$Element} - component element
     * @memberof TimeDisplayAdsContainer
     */
    render(props: any): VNode<any>;
}

/**
 * TimeDisplayPlaybackContainer component
 *
 * @class TimeDisplayPlaybackContainer
 * @example <TimeDisplayPlaybackContainer format='currentTime / duration' />
 * @extends {Component}
 */
declare class TimeDisplayPlaybackContainer extends Component<any, any> {
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof TimeDisplayPlaybackContainer
     */
    render(props: any): VNode<any>;
}

/**
 * Toggle Switch component
 *
 * @class ToggleSwitch
 * @example <ToggleSwitch />
 * @extends {Component}
 */
declare class ToggleSwitch extends Component<any, any> {
    /**
     * render Toggle Switch component
     *
     * @param {boolean} isChecked - - Whether the input is checked or not
     * @returns {void}
     * @member ToggleSwitch
     */
    onChange: (isChecked: boolean) => void;
    /**
     * render Toggle Switch component
     *
     * @param {KeyboardEvent} event - - Keyboard Event
     * @returns {void}
     * @member ToggleSwitch
     */
    handleOnKeyDown: (event: KeyboardEvent) => void;
    /**
     * render Toggle Switch component
     *
     * @param {*} props - component props
     * @returns {React$Element} component element
     * @memberof ToggleSwitch
     */
    render(props: any): VNode<any>;
}

/**
 * Formatting seconds input into time format
 *
 * @param {number} input number of seconds
 * @returns {string} formatted time string
 */
declare function toHHMMSS(input: string | number): string;

/**
 * Tooltip component
 *
 * @class Tooltip
 * @example <Tooltip>...</Tooltip>
 * @extends {Component}
 */
declare class Tooltip extends Component<TooltipProps & WithEventManagerProps, any> {
    _hoverTimeout: number | null;
    textElement: HTMLSpanElement;
    tooltipElement: HTMLDivElement;
    lastAlternativeTypeIndex: number;
    _buttonRef: HTMLButtonElement | null;
    /**
     * default component props
     * @type {Object}
     * @memberof Tooltip
     */
    static defaultProps: {
        type: ToolTipPosition;
        maxWidth: string;
        strictPosition: boolean;
    };
    /**
     * clear hover timeout
     *
     * @returns {void}
     * @memberof Tooltip
     */
    _clearHoverTimeout(): void;
    /**
     * displays tooltip.
     * @memberof Tooltip
     * @returns {void}
     */
    showTooltip: () => void;
    /**
     * hide tooltip.
     * @memberof Tooltip
     * @returns {void}
     */
    hideTooltip: () => void;
    /**
     * handle keyDown
     * @memberof Tooltip
     * @returns {void}
     */
    handleKeyDown: (event: KeyboardEvent) => void;
    /**
     * set button ref
     * @memberof Tooltip
     * @returns {void}
     */
    setButtonRef: (element: HTMLButtonElement | null) => void;
    /**
     * handle focus on wrapped element
     * @memberof Tooltip
     * @returns {void}
     */
    handleFocusOnChildren: () => void;
    /**
     * handle blur on wrapped element
     * @memberof Tooltip
     * @returns {void}
     */
    handleBlurOnChildren: () => void;
    /**
     * on mouse over handler.
     * @memberof Tooltip
     * @returns {void}
     */
    onMouseOver: () => void;
    /**
     * on mouse leave handler.
     * @memberof Tooltip
     * @returns {void}
     */
    onMouseLeave: () => void;
    /**
     * brings another tooltip type which hasn't been marked as invalid
     * @memberof Tooltip
     * @returns {string} tooltip type
     */
    getAlternateType(): string | undefined;
    /**
     * checks if the current tooltip type is within the player boundaries
     * @memberof Tooltip
     * @returns {string} is in boundaries
     */
    isToolTipInBoundaries(): boolean;
    /**
     * sets the requested type prop of the tooltip as a state cause it can change if is not valid
     * @memberof Tooltip
     * @returns {void}
     */
    componentWillMount(): void;
    /**
     * after component mounted, set event listener to click outside the component
     *
     * @returns {void}
     * @memberof Tooltip
     */
    componentDidMount(): void;
    /**
     * event listener for clicking outside handler.
     *
     * @param {*} e - click event
     * @returns {void}
     * @memberof Tooltip
     */
    handleClickOutside(e: any): void;
    /**
     * checks if after the render the tooltip is within boundaries of the player
     * if not it will try to set a new type which will be checked after the next render
     * @param {Object} prevProps - previous component props
     * @memberof Tooltip
     * @returns {void}
     */
    componentDidUpdate(prevProps: any): void;
    /**
     * after component unmount, clear timeouts
     *
     * @returns {void}
     * @memberof Tooltip
     */
    componentWillUnmount(): void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof Tooltip
     */
    render(props: any): VNode<any>;
}

declare interface TooltipOwnProps {
    type?: ToolTipPosition;
    maxWidth?: string;
    label: string;
    strictPosition?: boolean;
    className?: string;
}

declare type ToolTipPosition = 'top' | 'bottom' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'left' | 'right';

declare type TooltipProps = ReduxStateProps & TooltipOwnProps;

declare const ToolTipType: {
    [type: string]: ToolTipPosition;
};

/**
 * TopBar component
 *
 * @class TopBar
 * @example <TopBar>...</TopBar>
 * @extends {Component}
 */
declare class TopBar extends Component<any, any> {
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {?React$Element} - component element
     * @memberof TopBar
     */
    render(props: any): VNode<any>;
}

/**
 * Converting formatted time into seconds
 *
 * @param {string} input formatted time
 * @returns {number} number of seconds
 */
declare function toSecondsFromHHMMSS(input: string): number;

declare const types: {
    UPDATE: string;
    UPDATE_COMPONENT: string;
    RESET: string;
};

declare const types_10: {
    UPDATE_VOLUME_DRAGGING_STATUS: string;
    UPDATE_HOVER: string;
};

declare const types_11: {
    UPDATE_OVERLAY: string;
};

declare const types_12: {
    UPDATE_CONTROLS_TO_MOVE: string;
};

declare const types_2: {
    UPDATE_CAPTIONS_STYLE: string;
};

declare const types_3: {
    UPDATE_PLAYER_STATE: string;
    UPDATE_PRE_PLAYBACK: string;
    UPDATE_IS_PLAYING: string;
    UPDATE_IS_PAUSED: string;
    UPDATE_IS_SEEKING: string;
    UPDATE_LAST_SEEK_POINT: string;
    UPDATE_IS_CHANGING_SOURCE: string;
    UPDATE_IS_ENDED: string;
    UPDATE_IS_PLAYBACK_STARTED: string;
    UPDATE_IS_PLAYBACK_ENDED: string;
    UPDATE_CURRENT_TIME: string;
    UPDATE_DURATION: string;
    UPDATE_VOLUME: string;
    UPDATE_MUTED: string;
    UPDATE_METADATA_LOADING_STATUS: string;
    UPDATE_DATA_LOADING_STATUS: string;
    UPDATE_AUDIO_TRACKS: string;
    UPDATE_VIDEO_TRACKS: string;
    UPDATE_TEXT_TRACKS: string;
    UPDATE_AD_BREAK: string;
    UPDATE_AD_BREAK_PROGRESS: string;
    UPDATE_AD_BREAK_COMPLETED: string;
    UPDATE_AD_IS_PLAYING: string;
    UPDATE_AD_SKIP_TIME_OFFSET: string;
    UPDATE_AD_SKIPPABLE_STATE: string;
    UPDATE_AD_URL: string;
    UPDATE_AD_IS_LINEAR: string;
    UPDATE_AD_IS_BUMPER: string;
    UPDATE_AD_CONTENT_TYPE: string;
    UPDATE_PLAYER_POSTER: string;
    UPDATE_IS_AUDIO: string;
    UPDATE_IS_LIVE: string;
    UPDATE_IS_DVR: string;
    UPDATE_IS_IMG: string;
    UPDATE_IS_DOCUMENT: string;
    UPDATE_ERROR: string;
    UPDATE_ERROR_DETAILS: string;
    UPDATE_IS_IDLE: string;
    UPDATE_FALLBACK_TO_MUTED_AUTOPLAY: string;
    UPDATE_IS_VR: string;
    UPDATE_VR_STEREO_MODE: string;
    UPDATE_IS_CASTING: string;
    UPDATE_CAST_SESSION: string;
    UPDATE_IS_CAST_AVAILABLE: string;
    UPDATE_PLAYLIST: string;
    UPDATE_PICTURE_IN_PICTURE_SUPPORTED: string;
    UPDATE_PICTURE_IN_PICTURE_MODE: string;
    UPDATE_FULLSCREEN: string;
};

declare const types_4: {
    UPDATE_LOADING_SPINNER_STATE: string;
};

declare const types_5: {
    UPDATE_ACTION_ICON: string;
};

declare const types_6: {
    UPDATE_PLAYLIST_COUNTDOWN_CANCELED: string;
};

declare const types_7: {
    UPDATE_SEEKBAR_DRAGGING_STATUS: string;
    UPDATE_SEEKBAR_HOVER_ACTIVE: string;
    UPDATE_SEEKBAR_PREVIEW_HOVER_ACTIVE: string;
    UPDATE_SEEKBAR_CLIENT_RECT: string;
    UPDATE_HIDE_SEEKBAR_PREVIEW: string;
    UPDATE_HIDE_SEEKBAR_TIME_BUBBLE: string;
    UPDATE_CURRENT_TIME: string;
    UPDATE_VIRTUAL_TIME: string;
    UPDATE_HOVERED_SEGMENT: string;
    UPDATE_SEEKBAR_SEGMENTS: string;
    UPDATE_SEGMENT_END_TIME: string;
    ADD_SEEKBAR_CLASS: string;
    REMOVE_SEEKBAR_CLASS: string;
    UPDATE_PREVENT_SEEK: string;
};

declare const types_8: {
    UPDATE_QUALITY: string;
    UPDATE_SPEED: string;
    UPDATE_AUDIO: string;
    UPDATE_ADVANCED_AUDIO_DESC: string;
    UPDATE_IS_CAPTIONS_ENABLED: string;
};

declare const types_9: {
    ADD_PLAYER_CLASS: string;
    REMOVE_PLAYER_CLASS: string;
    UPDATE_IS_MOBILE: string;
    UPDATE_PLAYER_SIZE: string;
    UPDATE_IS_SMALL_SIZE: string;
    UPDATE_GUI_CLIENT_RECT: string;
    UPDATE_PLAYER_CLIENT_RECT: string;
    UPDATE_VIDEO_CLIENT_RECT: string;
    UPDATE_DOCUMENT_WIDTH: string;
    UPDATE_PLAYER_HOVER_STATE: string;
    UPDATE_PLAYER_NAV_STATE: string;
    UPDATE_SMART_CONTAINER_OPEN: string;
    UPDATE_ACTIVE_PRESET_NAME: string;
    UPDATE_SIDE_PANEL_MODE: string;
    UPDATE_SIDE_PANEL_SIZE: string;
    UPDATE_PRESET_SETTINGS: string;
    UPDATE_LAYOUT_STYLES: string;
};

declare interface UiConfig extends UIOptionsObject_2 {
    disable?: boolean;
    css?: string;
    customPreset?: {
        template: () => any;
        condition: () => any;
    }[];
}

/**
 * API used for building UIs based on state conditions
 *
 * @class UIManager
 */
export declare class UIManager {
    player: KalturaPlayer;
    targetId: string;
    store: Store<RootState, any>;
    container: HTMLDivElement;
    _translations: {
        [langKey: string]: any;
    };
    _locale: string;
    _uiComponents: Array<KPUIComponent>;
    _themesManager: ThemesManager;
    /**
     * Creates an instance of UIManager.
     * @param {Object} player - player instance
     * @param {UIOptionsObject} config - ui config
     * @memberof UIManager
     */
    constructor(player: any, config: UIOptionsObject);
    /**
     * Gets the updated state from the config reducer.
     * @public
     * @returns {UIOptionsObject} - The UI manager config.
     */
    get config(): UIOptionsObject;
    /**
     * Sets the player and ui config in the store
     *
     * @param {Object} config - new config object
     * @param {string} componentAlias - component alias (optional)
     * @returns {void}
     * @memberof UIManager
     */
    setConfig(config: UIOptionsObject, componentAlias?: string): void;
    /**
     * Add a component dynamically
     *
     * @param {KPUIComponent} component - The component to add
     * @returns {Function} - Removal function
     * @memberof UIManager
     */
    addComponent(component: KPUIAddComponent): () => void;
    /**
     * build default UIs
     *
     * @returns {void}
     * @memberof UIManager
     */
    buildDefaultUI(): void;
    /**
     * build custom UIs
     *
     * @param {Array<UIPreset>} uis - UIs array with conditions based on state
     * @returns {void}
     * @memberof UIManager
     */
    buildCustomUI(uis: Array<UIPreset>): void;
    /**
     * set the language translations
     * @param {UIOptionsObject} config - config
     * @private
     * @returns {void}
     */
    _setLocaleTranslations(config: UIOptionsObject): void;
    /**
     * Creates the redux store.
     * @param {UIOptionsObject} config - The UI config.
     * @private
     * @returns {void}
     */
    _createStore(config: UIOptionsObject): void;
    /**
     * build the UI and render to targetId configured in player config
     *
     * @param {Array<UIPreset>} [uis] - UI array with conditions
     * @returns {void}
     * @memberof UIManager
     */
    _buildUI(uis?: Array<UIPreset>): void;
    /**
     * Destroy the ui manager.
     * @returns {void}
     */
    destroy(): void;
    /**
     * get the log level
     * @param {?string} name - the logger name
     * @returns {Object} - the log level
     */
    getLogLevel(name?: string): any;
    /**
     * sets the logger level
     * @param {Object} level - the log level
     * @param {?string} name - the logger name
     * @returns {void}
     */
    setLogLevel(level: any, name?: string): void;
    /**
     * Get the ui manager log level.
     * @returns {LogLevelType} - The log levels of the player.
     * @public
     */
    get LogLevel(): LogLevelType;
    /**
     * Gets the ui manager event enums.
     * @returns {Object} - The ui manager event enums.
     * @public
     */
    get Event(): {
        [event: string]: string;
    };
    /**
     * Return a css variable value
     * @param {string} variableName - CSS variable name
     * @returns {string} CSS variable value
     */
    getCSSVariable(variableName: string): string;
    /**
     * Return a css variable name
     * @param {string} variableName - CSS variable name
     * @param {string} value - CSS variable value
     * @returns {void}
     */
    setCSSVariable(variableName: string, value: string): void;
}

export declare interface UIOptionsObject {
    targetId: string;
    debugActions?: boolean;
    forceTouchUI?: boolean;
    showCCButton?: boolean;
    openMenuFromCCButton?: boolean;
    settings?: {
        showAudioMenu?: boolean;
        showCaptionsMenu?: boolean;
        showQualityMenu?: boolean;
        showSpeedMenu?: boolean;
        showAdvancedAudioDescToggle?: boolean;
        showAdvancedCaptionsMenu?: boolean;
    };
    hoverTimeout?: number;
    logger?: LoggerType;
    components?: ComponentsConfig;
    uiComponents?: Array<KPUIComponent>;
    translations?: {
        [langKey: string]: any;
    };
    locale?: string;
    userTheme?: UserTheme;
    isCopyProtected?: boolean;
}

export declare type UIPreset = {
    template: (props: any) => ComponentChild;
    condition?: (state: any) => boolean;
};

/**
 * The logger of the UIWrapper class.
 * @private
 * @const
 */
declare class UIWrapper {
    private static _logger;
    private _uiManager;
    private readonly _disabled;
    private _player;
    constructor(player: KalturaPlayer, options: KalturaPlayerConfig);
    destroy(): void;
    reset(): void;
    setConfig(config: any, componentAlias?: string): void;
    /**
     * Add a component dynamically
     *
     * @param {KPUIAddComponent} component - The component to add
     * @returns {Function} - Removal function
     */
    addComponent(component: KPUIAddComponent_2): () => void;
    /**
     * Remove a component dynamically
     *
     * @param {KPUIRemoveComponent} component - The component to remove
     * @returns {Function} - Undo removal function
     */
    removeComponent(component: KPUIRemoveComponent_2): () => void;
    get store(): any;
    /**
     * Deprecated - left for backward compatibility - use instead registerService in KalturaPlayer
     * @param {string} name - the manager name
     * @param {Object} manager - the manager object
     * @returns {void}
     */
    registerManager(name: string, manager: any): void;
    /**
     * Deprecated - left for backward compatibility - use instead getService in KalturaPlayer
     * @param {string} name - the manager name
     * @returns {Object} - the manager object
     */
    getManager(name: string): any | void;
    /**
     * Deprecated - left for backward compatibility - use instead hasService in KalturaPlayer
     * @param {string} name - the manager name
     * @returns {boolean} - if the manager exist
     */
    hasManager(name: string): boolean;
    setLoadingSpinnerState(show: boolean): void;
    private _resetErrorState;
    private _handleExternalCSS;
    private _handleVr;
    private _setStereoConfig;
}

/**
 * UnmuteIndication component
 *
 * @class UnmuteIndication
 * @example <UnmuteIndication />
 * @extends {Component}
 */
declare class UnmuteIndication extends Component<any, any> {
    _iconTimeout: number | null;
    /**
     * after component updated, check the fallbackToMutedAutoPlay prop for updating the state of the component
     *
     * @param {Object} prevProps - previous component props
     * @method componentDidUpdate
     * @returns {void}
     * @memberof UnmuteIndication
     */
    componentDidUpdate(prevProps: any): void;
    /**
     * after component unmount, clear timeouts
     *
     * @returns {void}
     * @memberof UnmuteIndication
     */
    componentWillUnmount(): void;
    /**
     * The icon only timeout handler
     * @private
     * @memberof UnmuteIndication
     * @returns {void}
     */
    _iconOnlyTimeout(): void;
    /**
     * @param {KeyboardEvent} e - the keyDown Event
     * @private
     * @memberof UnmuteIndication
     * @returns {void}
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * @private
     * @memberof UnmuteIndication
     * @returns {void}
     */
    onMouseOver: () => void;
    /**
     * @private
     * @memberof UnmuteIndication
     * @returns {void}
     */
    onMouseOut: () => void;
    /**
     * @private
     * @memberof UnmuteIndication
     * @returns {void}
     */
    onMouseUp: () => boolean;
    /**
     * @param {Event} e - the touch end event
     * @private
     * @memberof UnmuteIndication
     * @returns {void}
     */
    onTouchEnd: (e: Event) => void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {?React$Element} component element
     * @memberof UnmuteIndication
     */
    render(props: any): VNode<any> | undefined;
}

export declare type UserTheme = {
    colors: ColorType;
};

declare namespace Utils {
    export {
        bindActions,
        focusElement,
        KeyMap,
        KeyCode,
        getLogger,
        withKeyboardA11y,
        getDurationAsText,
        toHHMMSS,
        toSecondsFromHHMMSS,
        formatOnlyNumbersInput
    }
}
export { Utils }
export { Utils as utils }

export declare const VERSION: string;

/**
 * VideoArea
 */
declare class VideoArea extends Component<any, any> {
    /**
     * this component should not render itself when player object changes.
     *
     * @param {Object} nextProps - next props of the component
     * @returns {void}
     */
    shouldComponentUpdate(nextProps: any): boolean;
    /**
     * render component
     *
     * @returns {React$Element} - component element
     */
    render(): VNode<any>;
}

/**
 * VideoPlayer component
 *
 * @class VideoPlayer
 * @example <VideoPlayer>...</VideoPlayer>
 * @extends {Component}
 */
declare class VideoPlayer extends Component<any, any> {
    _el: HTMLDivElement;
    _videoResizeWatcher: ResizeWatcher;
    /**
     * this component should not render itself when player object changes.
     *
     * @param {Object} nextProps - next props of the component
     * @returns {void}
     * @memberof VideoPlayer
     */
    shouldComponentUpdate(nextProps: any): boolean;
    /**
     * @return {void}
     */
    componentDidMount(): void;
    /**
     * @return {void}
     * @private
     */
    _onVideoResize: () => void;
    /**
     *
     * @param {HTMLElement} ref - ref
     * @return {void}
     * @private
     */
    _setRef: (ref: HTMLDivElement | null) => void;
    /**
     * before component mounted, remove event listeners
     *
     * @returns {void}
     * @memberof Shell
     */
    componentWillUnmount(): void;
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof VideoPlayer
     */
    render(): VNode<any>;
}

declare interface ViewabilityConfig {
    observedThresholds: Array<number>;
    playerThreshold: number;
}

/**
 * A service class to observe viewability of elements in the view port.
 */
declare class ViewabilityManager {
    private readonly _observer;
    private _targetsObserved;
    private _config;
    private _eventManager;
    private _visibilityTabChangeEventName;
    private _visibilityTabHiddenAttr;
    /**
     * Whether the player browser tab is active or not
     * @type {boolean}
     * @private
     */
    private _isTabVisible;
    /**
     * @param {number} viewabilityConfig - the configuration needed to create the manager
     * @constructor
     */
    constructor(viewabilityConfig?: ViewabilityConfig);
    private _intersectionChangedHandler;
    private _handleTabVisibilityChange;
    private _initTabVisibility;
    /**
     * @param {HTMLElement} target - the targeted element to check its visibility
     * @param {Function} listener - the callback to be invoked when visibility is changed (and when starting to observe). The callback is called with a boolean param representing the visibility state
     * @param {?number} optionalThreshold - a number between 0 to 100 that represents the minimum visible percentage considered as visible
     * @returns {void}
     */
    observe(target: HTMLElement, listener: ListenerType, optionalThreshold?: number): void;
    /**
     * Remove the listener from the target
     * @param {HTMLElement} target - the targeted element to remove the listener
     * @param {Function} listener - the callback function to be removed
     * @returns {void}
     */
    unObserve(target: HTMLElement, listener: _TargetObserveredBinding): void;
    /**
     * cleans all memory allocations.
     * @override
     */
    destroy(): void;
}

declare const ViewabilityType: {
    readonly VIEWPORT: "viewport";
    readonly TAB: "tab";
};

/**
 * Volume component
 *
 * @class Volume
 * @example <Volume />
 * @extends {Component}
 */
declare class Volume extends Component<any, any> {
    _volumeControlElement: HTMLDivElement;
    _volumeSliderElement: HTMLDivElement;
    _volumeProgressBarElement: HTMLDivElement;
    _keyboardEventHandlers: Array<KeyboardEventHandlers>;
    /**
     * after component mounted, update initial volume and muted value and listen to volume change
     *
     * @method componentDidMount
     * @returns {void}
     * @memberof Volume
     */
    componentDidMount(): void;
    /**
     * should render component
     * @returns {boolean} - whether to render the component
     */
    _shouldRender(): boolean;
    /**
     * event listener for clicking outside handler.
     *
     * @param {*} e - click event
     * @returns {void}
     * @memberof Volume
     */
    handleClickOutside(e: any): void;
    /**
     * get the volume progress bar height percentage string
     *
     * @method getVolumeProgessHeight
     * @returns {string} - volume progress bar new height based on volume
     * @memberof Volume
     */
    getVolumeProgressHeight(): string;
    /**
     * on volume progress bar mouse down, update volume dragging status in store state
     *
     * @method onVolumeProgressBarMouseDown
     * @returns {void}
     * @memberof Volume
     */
    onVolumeProgressBarMouseDown: () => void;
    /**
     * on volume progress bar mouse move, update the volume if dragging is active
     *
     * @method onVolumeProgressBarMouseMove
     * @param {FakeEvent} e - mouse move event
     * @returns {void}
     * @memberof Volume
     */
    onVolumeProgressBarMouseMove: (e: MouseEvent) => void;
    /**
     * volume mouse over handler
     *
     * @returns {void}
     * @memberof Volume
     */
    onMouseOver: () => void;
    /**
     * volume mouse over handler
     *
     * @returns {void}
     * @memberof Volume
     */
    onMouseOut: () => void;
    /**
     * on volume control key down, update the volume in case of up/down keys
     *
     * @method handleKeydown
     * @param {KeyboardEvent} event - keyboardEvent event
     * @returns {void}
     * @memberof Volume
     */
    handleKeydown(event: KeyboardEvent, preventMute?: boolean): void;
    /**
     * on volume control key down, update the volume in case of up/down keys
     *
     * @param {KeyboardEvent} event - keyboardEvent event
     * @method onKeyDown
     * @returns {void}
     * @memberof Volume
     */
    onKeyDown: (event: KeyboardEvent) => void;
    /**
     * on focus handler
     *
     * @returns {void}
     * @memberof Volume
     */
    onFocus: () => void;
    /**
     * on touch end handler
     *
     * @param {Event} e - event
     * @returns {void}
     * @memberof Volume
     */
    onTouchEnd: (e: Event) => void;
    /**
     * on volume progress bar mouse up, update the volume and change the dragging status to false
     *
     * @method onVolumeProgressBarMouseUp
     * @param {FakeEvent} e - mouse up event
     * @returns {void}
     * @memberof Volume
     */
    onVolumeProgressBarMouseUp: (e: MouseEvent) => void;
    /**
     * on volume control button Mouse Down, toggle mute in player and store state
     *
     * @method toggleMute
     * @returns {void}
     * @memberof Volume
     */
    toggleMute: () => void;
    /**
     * change volume based on event mouse position compared to volume progress bar element
     * if muted value is true in store state, change it to false both in store state and in player instance.
     *
     * @method changeVolume
     * @param {FakeEvent} e - event to get the position from
     * @returns {void}
     * @memberof Volume
     */
    changeVolume(e: MouseEvent): void;
    /**
     * Computes & returns the volume of the player according to the user horizontal click / mouse move.
     * @param {Object} dimensions - dimensions of the horizontal volume bar
     * @param {FakeEvent} e - click / move event
     * @return {number} - the volume of the player. a number in the range of 0 and 1.
     * @private
     */
    _getHorizontalVolume(dimensions: any, e: MouseEvent): number;
    /**
     * Computes & returns the volume of the player according to the user vertical click / mouse move.
     * @param {Object} dimensions - dimensions of the vertical volume bar
     * @param {FakeEvent} e - click / move event
     * @return {number} - the volume of the player. a number in the range of 0 and 1.
     * @private
     */
    _getVerticalVolume(dimensions: any, e: MouseEvent): number;
    /**
     * on volume progress bar key down
     *
     * @param {KeyboardEvent} event - keyboardEvent event
     * @method onProgressBarKeyDown
     * @returns {void}
     * @memberof Volume
     */
    onProgressBarKeyDown: (event: KeyboardEvent) => void;
    handleClickOnVolumeButton: (e: Event) => void;
    /**
     * render component
     *
     * @returns {React$Element} - component element
     * @memberof Volume
     */
    render(): VNode<any> | undefined;
}

declare namespace volume {
    export {
        types_10 as types,
        initialState_10 as initialState,
        _default_10 as default,
        actions_10 as actions
    }
}

declare interface VolumeState {
    draggingActive: boolean;
    hover: boolean;
}

/**
 * VrStereo component
 *
 * @class VrStereo
 * @example <VrStereo />
 * @extends {Component}
 */
declare class VrStereo extends Component<any, any> implements IconComponent {
    /**
     * Creates an instance of PictureInPicture.
     * @memberof VrStereo
     */
    constructor(props: any);
    registerComponent(): any;
    getComponentText: () => any;
    getSvgIcon(): any;
    /**
     * should render component
     * @returns {boolean} - whether to render the component
     */
    _shouldRender(): boolean;
    /**
     * Vr-Stereo click handler
     *
     * @returns {void}
     * @memberof VrStereo
     */
    onClick: () => void;
    /**
     * on key down handler
     *
     * @param {KeyboardEvent} e - keyboard event
     * @returns {void}
     * @memberof VrStereo
     */
    onKeyDown: (e: KeyboardEvent) => void;
    /**
     * before component mounted, set initial state
     *
     * @returns {void}
     * @memberof VrStereo
     */
    componentWillMount(): void;
    /**
     * render component
     *
     * @param {*} props - component props
     * @returns {React$Element} - component element
     * @memberof VrStereo
     */
    render(): VNode<any> | undefined;
}

export declare type VrStereoConfig = {
    vrStereoMode: boolean;
};

/**
 * Watermark component
 * @class Watermark
 * @example <Watermark />
 * @extends {Component}
 */
declare class Watermark extends Component<any, any> {
    _timeoutId: number | null;
    _imgAspectRatio: number | null;
    _originalImgWidth: number | null;
    _originalImgHeight: number | null;
    _playerHeight: number | null;
    _playerWidth: number | null;
    /**
     * Creates an instance of Watermark.
     * @memberof Watermark
     */
    constructor(props: any);
    componentWillMount(): void;
    /**
     * After component mounted, listen to relevant player event for updating the state of the component
     * @method componentDidMount
     * @returns {void}
     * @memberof Watermark
     */
    componentDidMount(): void;
    /**
     * handles the watermark url
     * if the url contains ${entryId}, then replace it with the played entry id
     *
     * @returns {void}
     * @memberof Watermark
     */
    private _handleWatermarkUrl;
    private _loadImageDimension;
    private _loadPlayerDimension;
    private onPlayerResize;
    /**
     * sets the url with the entry id
     * @param {string} url - the url configured on the watermark
     * @returns {boolean} - whether the url was set with entry id or not
     * @memberof Watermark
     */
    private _setWatermarkUrlWithEntryId;
    /**
     * componentWillUnmount
     *
     * @returns {void}
     * @memberof Watermark
     */
    componentWillUnmount(): void;
    /**
     * Render component
     * @param {*} props - component props
     * @returns {?React$Element} - component element
     * @memberof Watermark
     */
    render(props: any): VNode<any> | undefined;
}

export declare type WatermarkConfig = {
    img: string;
    url: string;
    placement?: string;
    timeout?: number;
};

/**
 *
 * @param {string} name - the component name
 * @returns {Component} - the wrapped component
 */
declare const withEventDispatcher: <P extends object>(name: string) => (WrappedComponent: any) => any;

declare type WithEventDispatcherProps = {
    notifyClick?(payload?: any): void;
    notifyChange?(payload?: any): void;
    notifyHoverChange?(payload?: any): void;
};

/**
 * withEventManager component
 * @param {Component} ComponentToWrap - the component to wrap
 * @returns {React$Element} - component element
 */
declare const withEventManager: <P extends object>(ComponentToWrap: any) => any;

declare type WithEventManagerProps = {
    eventManager?: EventManager;
};

/**
 * wraps a component and handles all key navigation and focus
 * @param {Component} WrappedComponent - The popup component to implement keyboard accessibility
 * @returns {Component} - HOC that handles animation
 */
declare const withKeyboardA11y: (WrappedComponent: any) => any;

/**
 *
 * @param {string} name - the component to wrap
 // * @param {Component} WrappedComponent - the component to wrap
 * @returns {React$Element} - component element
 */
declare const withKeyboardEvent: <P extends object>(name: string) => (WrappedComponent: any) => any;

declare type WithKeyboardEventProps = {
    registerKeyboardEvents(eventHandlers: Array<KeyboardEventHandlers>): void;
    setKeyboardEventToScope(isScoped: boolean): void;
    updateIsKeyboardEnabled(isEnable: boolean): void;
};

/**
 * @param {string} name - the component display name
 * @returns {Component} - the wrapped component
 */
declare const withLogger: <P extends object>(name: string) => (WrappedComponent: any) => any;

declare type WithLoggerProps = {
    logger?: any;
};

/**
 * withPlayer component
 * @param {Component} ComponentToWrap - the component to wrap
 * @returns {ComponentType<P & WithPlayerProps>} - component element
 */
declare const withPlayer: <P extends object>(ComponentToWrap: any) => any;

/**
 * connect decorator
 * @param {Object} options - options
 * @returns {function(*): *} connect
 */
declare const withPlayerPreset: (options: any) => (InnerComponent: any) => any;

declare type WithPlayerProps = {
    player?: KalturaPlayer;
};

export { }