/// <reference types="react" />
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as Hls from 'hls.js';
import Hls__default, { Level, MediaPlaylist, HlsConfig } from 'hls.js';
import * as react from 'react';
import { ReactNode, HTMLAttributes } from 'react';
import * as _emotion_styled from '@emotion/styled';
import * as _emotion_react from '@emotion/react';

declare const PlayerTemplate: () => react_jsx_runtime.JSX.Element;

type LoadVideoFuncType = (src: string, type?: string, startTime?: number) => void;
type GenericEvents<T extends Record<string, string>> = {
    [eventName in keyof T]?: (data?: any) => void;
};
type StyleType = {
    dir: "rtl" | "ltr";
    iconColor: string;
    settingTextColor: string;
    toolbarBg: string;
    settingBg: string;
    settingBgHover: string;
    rangeFrontBg: string;
    rangeBackBg: string;
    bufferBg: string;
    settingFontSize: string;
    toolbarFontSize: string;
    settingTitleTextColor: string;
};
type IconsType = {
    setting: ReactNode;
    checkMark: ReactNode;
    arrow: ReactNode;
    play: ReactNode;
    pause: ReactNode;
    volumeUp: ReactNode;
    volumeDown: ReactNode;
    mute: ReactNode;
    picInPic: ReactNode;
    picOutPic: ReactNode;
    fullScreen: ReactNode;
    unFullScreen: ReactNode;
    speed: ReactNode;
    quality: ReactNode;
    subtitle: ReactNode;
    audioTrack: ReactNode;
    autoPlayOn: ReactNode;
    autoPlayOff: ReactNode;
    jumpBack: ReactNode;
    jumpForward: ReactNode;
    mic: ReactNode;
    playArrow: ReactNode;
};
type PlayerLocaleType = {
    setting_menu_change_speed_title?: string;
    setting_menu_change_quality_title?: string;
    setting_menu_quality_list_item_auto?: string;
    setting_menu_quality_active_list?: string;
    setting_menu_change_audio_track_title?: string;
    setting_menu_change_subtitle?: string;
    setting_menu_subtitle_off?: string;
    can_skip_text?: string;
    skip_text?: string;
};
type KeyValue = {
    key: string;
    value: number;
};
type SubTitle = {
    url: string;
    title: string;
    id: string;
    code: string;
    is_selected: boolean;
};
type AudioType = {
    name: string;
    url: string;
    groupId: string;
    lang: string;
};
type AdType = {
    src: string;
    startTime: number;
    canSkip?: boolean;
    skipTime?: number;
    hasPlayed?: boolean;
};
type OnUpdateTimeType = {
    time: number;
    duration: number;
    percentage: number;
};
interface PlayerConfigType {
    type: "HLS" | "MP4";
    loop: boolean;
    autoPlay: boolean;
    muted: boolean;
    locale: PlayerLocaleType;
    speeds: number[] | Record<string, number>;
    theme: "Red" | "Blue" | "Custom";
    timeForHideEl: number;
    icons: IconsType;
    style: StyleType;
    qualities: number[];
    audioTracks: string[];
    subTitle: any[];
    keyControl: boolean;
    defaultQuality?: string;
    thumbnail: string;
    ads?: AdType[];
    showToolbarOnAd?: boolean;
    showAdsAgain?: boolean;
    startTime?: number;
    videoTogglePlay?: boolean;
    onUpdateTime?: (e: OnUpdateTimeType) => void;
    onEnd?: (e: OnUpdateTimeType) => void;
    onLoading?: (e: boolean) => void;
    onPlayPause?: (e: OnUpdateTimeType) => void;
    onUpdateBuffer?: (e: number) => void;
    onChangeVolume?: (e: OnUpdateTimeType) => void;
    onChangeMute?: (e: boolean) => void;
    onReady?: () => void;
}
interface PlayerInstance extends PlayerConfigType {
    loadVideo: LoadVideoFuncType;
    changeLocale: (locale: PlayerLocaleType) => void;
    src?: string;
}
type PlayerState = {
    speeds?: KeyValue[];
    currentSpeed?: KeyValue;
    currentSubtitle?: SubTitle;
    subTitles: SubTitle[];
    currentBuffer?: {
        index: number;
        length: number;
    };
    prevSubtitle?: number;
    prevSpeed?: number;
    currentPlayingAd?: AdType;
    levels?: any[];
    currentLevelIndex?: number;
    isPlaying?: boolean;
    metaData?: {
        lines: string[];
        baseUrl: string;
    };
    audioTracks?: AudioType[];
};
interface PlayerContextType {
    setVideoRef: (ref: HTMLVideoElement) => void;
    getVideoRef: () => HTMLVideoElement | undefined;
    getVideoWrapperRef: () => HTMLDivElement | null;
    config: PlayerInstance;
    hls?: Hls__default;
    state: PlayerState;
}
type PlayerEventsType = {
    onUpdateTime: "onUpdateTime";
    onUpdateBuffer: "onUpdateBuffer";
    onLoading: "onLoading";
    onPlayPause: "onPlayPause";
    onEnd: "onEnd";
    onChangeLocale: "onChangeLocale";
    onChangeVolume: "onChangeVolume";
    onChangeMute: "onChangeMute";
    onReady: "onReady";
    onChangeSetting: "onChangeSetting";
    onActivateControls: "onActivateControls";
    onChangeSrc: "OnChangeSrc";
};

declare const VideoPlayer: ({ children, config, src, }: {
    children?: React.ReactNode;
    config?: PlayerInstance | undefined;
    src?: string | undefined;
}) => react_jsx_runtime.JSX.Element;

declare const Play: () => react_jsx_runtime.JSX.Element;

declare const Loading: () => react_jsx_runtime.JSX.Element;

declare const TouchContainer: ({ children }: {
    children: ReactNode;
}) => react_jsx_runtime.JSX.Element;

declare const SensitiveArea: ({ children }: {
    children: ReactNode;
}) => react_jsx_runtime.JSX.Element;

declare const Video: () => react_jsx_runtime.JSX.Element;

declare const TimeLine: () => react_jsx_runtime.JSX.Element;

declare const Fullscreen: () => react_jsx_runtime.JSX.Element;

declare const Time: ({ type }: {
    type: "Current" | "Total" | "Remain";
}) => react_jsx_runtime.JSX.Element;

declare const JumpBack: ({ type }: {
    type: "back" | "forward";
}) => react_jsx_runtime.JSX.Element;

declare const Volume: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;

declare const Mute: () => react_jsx_runtime.JSX.Element;

type IconType = {
    type: keyof IconsType;
    isClickable: boolean;
    isSensitive?: boolean;
} & HTMLAttributes<HTMLElement>;
declare const Icon: ({ type, onClick, isSensitive, ...other }: IconType) => react_jsx_runtime.JSX.Element;

declare const Skip: () => react_jsx_runtime.JSX.Element | null;

declare const VideoWrapperStyle: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const CustomPlayWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & {
    isFaded: boolean;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const usePlayer: (playerConfig: {
    type?: "HLS" | "MP4" | undefined;
    loop?: boolean | undefined;
    autoPlay?: boolean | undefined;
    muted?: boolean | undefined;
    locale?: PlayerLocaleType | undefined;
    speeds?: Record<string, number> | number[] | undefined;
    theme?: "Red" | "Blue" | "Custom" | undefined;
    timeForHideEl?: number | undefined;
    icons?: IconsType | undefined;
    style?: StyleType | undefined;
    qualities?: number[] | undefined;
    audioTracks?: string[] | undefined;
    subTitle?: any[] | undefined;
    keyControl?: boolean | undefined;
    defaultQuality?: string | undefined;
    thumbnail?: string | undefined;
    ads?: AdType[] | undefined;
    showToolbarOnAd?: boolean | undefined;
    showAdsAgain?: boolean | undefined;
    startTime?: number | undefined;
    videoTogglePlay?: boolean | undefined;
    onUpdateTime?: ((e: OnUpdateTimeType) => void) | undefined;
    onEnd?: ((e: OnUpdateTimeType) => void) | undefined;
    onLoading?: ((e: boolean) => void) | undefined;
    onPlayPause?: ((e: OnUpdateTimeType) => void) | undefined;
    onUpdateBuffer?: ((e: number) => void) | undefined;
    onChangeVolume?: ((e: OnUpdateTimeType) => void) | undefined;
    onChangeMute?: ((e: boolean) => void) | undefined;
    onReady?: (() => void) | undefined;
}) => PlayerInstance;

type UseUpdateSubjectType<T> = {
    onUpdate: (listener: (newValue: T) => void) => () => void;
    value: T;
};
declare const useUpdate: <T>(value: T, key: string, context?: React.Context<any>) => {
    subject: UseUpdateSubjectType<T>;
    update: (newValue: T) => void;
};

declare const useVideo: (events?: GenericEvents<PlayerEventsType>) => {
    getVideoWrapperRef: () => HTMLDivElement | null;
    hls: Hls__default | undefined;
    setVideoRef: (el?: HTMLVideoElement) => void;
    getVideoRef: () => HTMLVideoElement | undefined;
    changePlayPause: (play: boolean) => void;
    getIsPlay: () => boolean | undefined;
    state: PlayerState;
    loadVideo: (src: string, type?: string, startTime?: number) => void;
    config: PlayerInstance;
    setTime: (el: HTMLVideoElement) => void;
    isPlay: UseUpdateSubjectType<boolean>;
    togglePlayPause: () => void;
};

declare const useFullScreen: (elRef: HTMLElement | null, videoTagRef: HTMLElement | null) => {
    toggleFullScreen: () => void;
    checkFullscreen: () => boolean;
    isFullscreen: UseUpdateSubjectType<boolean>;
};

declare const useSubTitle: () => {
    getSubtitles: () => SubTitle[];
    changeSubtitle: (index: number) => Promise<void>;
    initSubtitle: () => Promise<void>;
    getSubtitle: () => Hls.MediaPlaylist[] | undefined;
    getCurrentSubtitle: () => number | undefined;
    removeSubtitle: () => void;
    currentSubtitle: UseUpdateSubjectType<number>;
};

type LevelType = Level[];
type changeHlsLevelType = (level: number) => void;
type changeHlsSubtitleType = (level: number) => void;
type MediaPlaylistType = MediaPlaylist[];
type audioTrackObjType = {
    changeHlsAudioTrack: changeHlsSubtitleType;
};
type subtitleObjType = {
    changeHlsSubtitle: changeHlsSubtitleType;
};
type qualityObjType = {
    changeHlsLevel: changeHlsLevelType;
};
type UseVideoHlsType = {
    src: string;
    config?: HlsConfig;
    options?: {
        disabled: boolean;
    };
    getHlsSubtitle?: (subsArr: MediaPlaylistType, currentSubtitle: number) => void;
    getHlsAudioTrack?: (audioArr: MediaPlaylistType, currentAudio: number) => void;
    getHlsLevels?: (levels: LevelType) => void;
    getCurrentLevel?: (currentLevel: number) => void;
};

type AdsEventType = {
    onStartAd: "onStartAd";
    onEndAd: "onEndAd";
    onSkipAd: "onSkipAd";
};

declare const useAds: (events?: GenericEvents<AdsEventType>) => {
    isPlayingAd: () => boolean;
    showToolbar: () => boolean;
    ads: AdType[];
    currentAd: () => AdType | undefined;
    skipCurrentAd: () => void;
};

declare const useAudio: () => {
    getAudioTracks: () => Hls.MediaPlaylist[] | undefined;
    getAudioTrack: () => number | undefined;
    changeAudioTrack: (index: number) => void;
    currentAudioTrack: UseUpdateSubjectType<number | undefined>;
};

declare const useBuffer: () => {
    checkBuffer: (forceUpdate?: boolean) => void;
};

declare const useLevel: () => {
    levels: {
        level: number;
    }[];
    getLevels: () => {
        level: any;
    }[];
    getCurrentLevel: () => {
        currentLevel: number | undefined;
        isAuto: boolean | undefined;
        defaultQuality: string | null;
    };
    changeLevel: (index: number) => void;
    currentLevel: UseUpdateSubjectType<number | undefined>;
};

declare const useSpeed: () => {
    initSpeeds: () => void;
    changeSpeed: (index: number) => void;
    getSpeeds: () => KeyValue[] | undefined;
    currentSpeed: UseUpdateSubjectType<number | undefined>;
    getCurrentSpeed: () => KeyValue | undefined;
};

declare const useTime: () => {
    changeTime: (time: number) => void;
    increaseTime: (time: number) => void;
    decreaseTime: (time: number) => void;
    getDuration: () => number | undefined;
    getCurrentTime: () => number | undefined;
};

declare const useVolume: () => {
    getVolume: () => {
        volume: number;
        isMuted: boolean;
    } | undefined;
    changeMute: (e: boolean) => void;
    changeVolume: (newVolume: number) => void;
    isMute: UseUpdateSubjectType<boolean | undefined>;
    currentVolume: UseUpdateSubjectType<number | undefined>;
};

type SubjectType<T> = {
    value: T;
    onUpdate: (listener: (newValue: T) => void) => () => void;
};

declare const useSignal: <T>(subject: SubjectType<T>) => T;

export { AdType, AudioType, CustomPlayWrapper, VideoWrapperStyle as CustomVideoWrapper, Fullscreen, GenericEvents, Icon, IconsType, JumpBack as Jump, KeyValue, LevelType, LoadVideoFuncType, Loading, MediaPlaylistType, Mute, OnUpdateTimeType, Play, PlayerConfigType, PlayerContextType, PlayerEventsType, PlayerInstance, PlayerLocaleType, PlayerState, PlayerTemplate, SensitiveArea, Skip as SkipAd, StyleType, SubTitle, Time, TimeLine, TouchContainer, UseVideoHlsType, Video, VideoPlayer, Volume, audioTrackObjType, changeHlsLevelType, changeHlsSubtitleType, qualityObjType, subtitleObjType, useAds, useAudio, useBuffer, useFullScreen, useLevel, usePlayer, useSignal, useSpeed, useSubTitle, useTime, useUpdate, useVideo, useVolume };