video-react-player 0.1.0

package/dist/actions/player.d.ts

@@ -0,0 +1,124 @@
+/**
+
+ * Copyright (c) 2016 Video-React contributors
+ * Copyright (c) 2025 ZingMe.Vn
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type Manager from '../Manager';
+import type { OperationState } from '../reducers/operation';
+import type { PlayerState } from '../reducers/player';
+export declare const OPERATE = "video-react-player/OPERATE";
+export declare const FULLSCREEN_CHANGE = "video-react-player/FULLSCREEN_CHANGE";
+export declare const PLAYER_ACTIVATE = "video-react-player/PLAYER_ACTIVATE";
+export declare const USER_ACTIVATE = "video-react-player/USER_ACTIVATE";
+type OperationPayload = OperationState['operation'];
+export declare function handleFullscreenChange(isFullscreen: boolean): {
+    type: string;
+    isFullscreen: boolean;
+};
+export declare function activate(activity: boolean): {
+    type: string;
+    activity: boolean;
+};
+export declare function userActivate(activity: boolean): {
+    type: string;
+    activity: boolean;
+};
+export declare function play(this: Manager, operation?: OperationPayload): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function pause(this: Manager, operation?: OperationPayload): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function togglePlay(this: Manager, operation?: OperationPayload): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function seek(this: Manager, time: number, operation?: OperationPayload): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function forward(this: Manager, seconds: number, operation?: OperationPayload): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function replay(this: Manager, seconds: number, operation?: OperationPayload): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function changeRate(this: Manager, rate: number, operation?: OperationPayload): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function changeVolume(this: Manager, volume: number, operation?: OperationPayload): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function mute(this: Manager, muted: boolean, operation?: OperationPayload): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function toggleFullscreen(this: Manager, player: PlayerState): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+    isFullscreen?: undefined;
+} | {
+    type: string;
+    isFullscreen: boolean;
+    operation?: undefined;
+};
+export declare function togglePictureInPicture(): {
+    type: string;
+    isPictureInPicture: boolean;
+};
+export declare function changeQuality(this: Manager, quality: string): {
+    type: string;
+    quality: string;
+};
+export declare function takeScreenshot(): {
+    type: string;
+    operation: {
+        action: string;
+        source: string;
+    };
+};
+export declare function toggleTheaterMode(this: Manager, isTheater: boolean): {
+    type: string;
+    isTheater: boolean;
+};
+export {};
+//# sourceMappingURL=player.d.ts.map

package/dist/actions/video.d.ts

@@ -0,0 +1,161 @@
+/**
+
+ * Copyright (c) 2016 Video-React contributors
+ * Copyright (c) 2025 ZingMe.Vn
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare const LOAD_START = "video-react-player/LOAD_START";
+export declare const CAN_PLAY = "video-react-player/CAN_PLAY";
+export declare const WAITING = "video-react-player/WAITING";
+export declare const CAN_PLAY_THROUGH = "video-react-player/CAN_PLAY_THROUGH";
+export declare const PLAYING = "video-react-player/PLAYING";
+export declare const PLAY = "video-react-player/PLAY";
+export declare const PAUSE = "video-react-player/PAUSE";
+export declare const END = "video-react-player/END";
+export declare const SEEKING = "video-react-player/SEEKING";
+export declare const SEEKED = "video-react-player/SEEKED";
+export declare const SEEKING_TIME = "video-react-player/SEEKING_TIME";
+export declare const END_SEEKING = "video-react-player/END_SEEKING";
+export declare const DURATION_CHANGE = "video-react-player/DURATION_CHANGE";
+export declare const TIME_UPDATE = "video-react-player/TIME_UPDATE";
+export declare const VOLUME_CHANGE = "video-react-player/VOLUME_CHANGE";
+export declare const PROGRESS_CHANGE = "video-react-player/PROGRESS_CHANGE";
+export declare const RATE_CHANGE = "video-react-player/RATE_CHANGE";
+export declare const SUSPEND = "video-react-player/SUSPEND";
+export declare const ABORT = "video-react-player/ABORT";
+export declare const EMPTIED = "video-react-player/EMPTIED";
+export declare const STALLED = "video-react-player/STALLED";
+export declare const LOADED_META_DATA = "video-react-player/LOADED_META_DATA";
+export declare const LOADED_DATA = "video-react-player/LOADED_DATA";
+export declare const RESIZE = "video-react-player/RESIZE";
+export declare const ERROR = "video-react-player/ERROR";
+export declare const ACTIVATE_TEXT_TRACK = "video-react-player/ACTIVATE_TEXT_TRACK";
+export declare const PICTURE_IN_PICTURE_CHANGE = "video-react-player/PICTURE_IN_PICTURE_CHANGE";
+export declare const LOOP_CHANGE = "video-react-player/LOOP_CHANGE";
+export declare const THEATER_MODE_CHANGE = "video-react-player/THEATER_MODE_CHANGE";
+export declare const QUALITY_CHANGE = "video-react-player/QUALITY_CHANGE";
+type VideoProps = Record<string, unknown>;
+export declare function handleLoadStart(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleCanPlay(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleWaiting(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleCanPlayThrough(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handlePlaying(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handlePlay(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handlePause(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleEnd(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleSeeking(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleSeeked(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleDurationChange(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleTimeUpdate(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleVolumeChange(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleProgressChange(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleRateChange(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleSuspend(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleAbort(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleEmptied(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleStalled(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleLoadedMetaData(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleLoadedData(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleResize(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleError(videoProps: VideoProps): {
+    type: string;
+    videoProps: VideoProps;
+};
+export declare function handleSeekingTime(time: number): {
+    type: string;
+    time: number;
+};
+export declare function handleEndSeeking(time: number): {
+    type: string;
+    time: number;
+};
+export declare function activateTextTrack(textTrack: TextTrack | null): {
+    type: string;
+    textTrack: TextTrack;
+};
+export declare function handlePictureInPictureChange(isPictureInPicture: boolean): {
+    type: string;
+    isPictureInPicture: boolean;
+};
+export declare function handleLoopChange(loop: boolean): {
+    type: string;
+    loop: boolean;
+};
+export declare function handleTheaterModeChange(isTheater: boolean): {
+    type: string;
+    isTheater: boolean;
+};
+export declare function handleQualityChange(quality: string): {
+    type: string;
+    quality: string;
+};
+export {};
+//# sourceMappingURL=video.d.ts.map

package/dist/components/Bezel.d.ts

@@ -0,0 +1,22 @@
+import { Component } from 'react';
+import type Manager from '../Manager';
+import type { OperationState } from '../reducers/operation';
+interface BezelProps {
+    manager: Manager;
+    className?: string;
+    order?: number;
+}
+interface BezelState {
+    hidden: boolean;
+    operation: OperationState['operation'];
+    count: number;
+}
+export default class Bezel extends Component<BezelProps, BezelState> {
+    static displayName: string;
+    private timer;
+    constructor(props: BezelProps, context: unknown);
+    handleStateChange(state: OperationState, prevState: OperationState): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};
+//# sourceMappingURL=Bezel.d.ts.map

package/dist/components/BigPlayButton.d.ts

@@ -0,0 +1,20 @@
+import React, { Component } from 'react';
+import type { ActionCreators } from '../Manager';
+import type { PlayerState } from '../reducers/player';
+export interface BigPlayButtonProps {
+    actions?: ActionCreators;
+    player?: PlayerState;
+    className?: string;
+    order?: number;
+    disabled?: boolean;
+    position?: 'left' | 'center';
+}
+export default class BigPlayButton extends Component<BigPlayButtonProps> {
+    static defaultProps: Required<Pick<BigPlayButtonProps, 'position'>>;
+    static displayName: string;
+    constructor(props: BigPlayButtonProps, context: unknown);
+    componentDidMount(): void;
+    handleClick(event: React.MouseEvent<HTMLButtonElement>): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+//# sourceMappingURL=BigPlayButton.d.ts.map

package/dist/components/ClickableComponent.d.ts

@@ -0,0 +1,24 @@
+import React, { Component } from 'react';
+type ClickableTagName = keyof HTMLElementTagNameMap;
+interface ClickableComponentProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onClick' | 'onFocus' | 'onBlur'> {
+    tagName?: ClickableTagName;
+    onClick: (event: React.MouseEvent<HTMLElement> | KeyboardEvent) => void;
+    onFocus?: (event: React.FocusEvent<HTMLElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLElement>) => void;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare class ClickableComponent extends Component<ClickableComponentProps> {
+    static defaultProps: {
+        tagName: "div";
+    };
+    static displayName: string;
+    componentWillUnmount(): void;
+    handleKeypress: (event: KeyboardEvent) => void;
+    handleClick: (event: React.MouseEvent<HTMLElement> | KeyboardEvent) => void;
+    handleFocus: (event: React.FocusEvent<HTMLElement>) => void;
+    handleBlur: (event?: React.FocusEvent<HTMLElement>) => void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export default ClickableComponent;
+//# sourceMappingURL=ClickableComponent.d.ts.map

package/dist/components/LoadingSpinner.d.ts

@@ -0,0 +1,11 @@
+import type { PlayerComponentProps } from '../types/component';
+export interface LoadingSpinnerProps extends PlayerComponentProps {
+    className?: string;
+    order?: number;
+}
+declare function LoadingSpinner({ player, className, }: LoadingSpinnerProps): import("react/jsx-runtime").JSX.Element;
+declare namespace LoadingSpinner {
+    var displayName: string;
+}
+export default LoadingSpinner;
+//# sourceMappingURL=LoadingSpinner.d.ts.map

package/dist/components/Player.d.ts

@@ -0,0 +1,82 @@
+/**
+
+ * Copyright (c) 2016 Video-React contributors
+ * Copyright (c) 2025 ZingMe.Vn
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import React, { ReactNode } from 'react';
+import { Store } from 'redux';
+import Manager, { VideoAPI } from '../Manager';
+import { VideoProps } from './Video';
+import type { RootState } from '../reducers';
+export interface PlayerProps {
+    children?: ReactNode;
+    width?: string | number;
+    height?: string | number;
+    fluid?: boolean;
+    /** Position for the default BigPlayButton ('left' | 'center'). */
+    bigPlayButtonPosition?: 'left' | 'center';
+    /** Force hide the default BigPlayButton (useful when supplying your own). */
+    hideDefaultBigPlayButton?: boolean;
+    muted?: boolean;
+    playsInline?: boolean;
+    aspectRatio?: string;
+    className?: string;
+    videoId?: string;
+    startTime?: number;
+    loop?: boolean;
+    autoPlay?: boolean;
+    src?: string;
+    poster?: string;
+    preload?: 'auto' | 'metadata' | 'none';
+    onLoadStart?: PlayerEventHandler;
+    onWaiting?: PlayerEventHandler;
+    onCanPlay?: PlayerEventHandler;
+    onCanPlayThrough?: PlayerEventHandler;
+    onPlaying?: PlayerEventHandler;
+    onEnded?: PlayerEventHandler;
+    onSeeking?: PlayerEventHandler;
+    onSeeked?: PlayerEventHandler;
+    onPlay?: PlayerEventHandler;
+    onPause?: PlayerEventHandler;
+    onProgress?: PlayerEventHandler;
+    onDurationChange?: PlayerEventHandler;
+    onError?: PlayerEventHandler;
+    onSuspend?: PlayerEventHandler;
+    onAbort?: PlayerEventHandler;
+    onEmptied?: PlayerEventHandler;
+    onStalled?: PlayerEventHandler;
+    onLoadedMetadata?: PlayerEventHandler;
+    onLoadedData?: PlayerEventHandler;
+    onTimeUpdate?: PlayerEventHandler;
+    onRateChange?: PlayerEventHandler;
+    onVolumeChange?: PlayerEventHandler;
+    store?: Store<RootState>;
+}
+type PlayerEventHandler = VideoProps['onLoadStart'];
+export interface PlayerHandle {
+    readonly manager: Manager;
+    readonly actions: ReturnType<Manager['getActions']>;
+    readonly video: VideoAPI | null;
+    getState: () => RootState;
+    playbackRate: number;
+    muted: boolean;
+    volume: number;
+    videoWidth: number;
+    videoHeight: number;
+    play: () => void;
+    pause: () => void;
+    load: () => void;
+    addTextTrack: VideoAPI['addTextTrack'];
+    canPlayType: VideoAPI['canPlayType'];
+    seek: (time: number) => void;
+    forward: (seconds: number) => void;
+    replay: (seconds: number) => void;
+    toggleFullscreen: () => void;
+    subscribeToStateChange: (listener: Parameters<Manager['subscribeToPlayerStateChange']>[0]) => ReturnType<Manager['subscribeToPlayerStateChange']>;
+}
+declare const Player: React.ForwardRefExoticComponent<PlayerProps & React.RefAttributes<PlayerHandle>>;
+export default Player;
+//# sourceMappingURL=Player.d.ts.map

package/dist/components/PosterImage.d.ts

@@ -0,0 +1,12 @@
+import type { PlayerComponentProps } from '../types/component';
+export interface PosterImageProps extends PlayerComponentProps {
+    poster?: string;
+    className?: string;
+    order?: number;
+}
+declare function PosterImage({ poster, player, actions, className }: PosterImageProps): import("react/jsx-runtime").JSX.Element;
+declare namespace PosterImage {
+    var displayName: string;
+}
+export default PosterImage;
+//# sourceMappingURL=PosterImage.d.ts.map

package/dist/components/Shortcut.d.ts

@@ -0,0 +1,48 @@
+/**
+
+ * Copyright (c) 2016 Video-React contributors
+ * Copyright (c) 2025 ZingMe.Vn
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Component } from 'react';
+import type Manager from '../Manager';
+import type { ActionCreators } from '../Manager';
+import type { PlayerState } from '../reducers/player';
+import type { PlayerComponentProps } from '../types/component';
+type ShortcutHandler = (player: PlayerState, actions: ActionCreators) => void;
+interface ShortcutDefinition {
+    keyCode?: number;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    handle: ShortcutHandler;
+}
+export interface ShortcutProps extends PlayerComponentProps {
+    clickable?: boolean;
+    dblclickable?: boolean;
+    manager?: Manager;
+    shortcuts?: ShortcutDefinition[];
+    order?: number;
+}
+export default class Shortcut extends Component<ShortcutProps> {
+    static defaultProps: Required<Pick<ShortcutProps, 'clickable' | 'dblclickable'>>;
+    static displayName: string;
+    private readonly defaultShortcuts;
+    private shortcuts;
+    constructor(props: ShortcutProps, context: unknown);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: ShortcutProps): void;
+    componentWillUnmount(): void;
+    mergeShortcuts(): void;
+    togglePlay(player: PlayerState, actions: ActionCreators): void;
+    toggleFullscreen(player: PlayerState, actions: ActionCreators): void;
+    handleKeyPress(e: KeyboardEvent): void;
+    canBeClicked(player: PlayerState, e: MouseEvent): boolean;
+    handleClick(e: MouseEvent): void;
+    handleDoubleClick(e: MouseEvent): void;
+    render(): any;
+}
+export {};
+//# sourceMappingURL=Shortcut.d.ts.map

package/dist/components/Slider.d.ts

@@ -0,0 +1,49 @@
+import React, { Component } from 'react';
+type SliderMouseEvent = MouseEvent | TouchEvent | React.MouseEvent<Element> | React.TouchEvent<Element>;
+type SliderActivateEvent = SliderMouseEvent | React.FocusEvent<HTMLDivElement>;
+interface SliderProps {
+    className?: string;
+    order?: number;
+    disabled?: boolean;
+    onMouseDown?: (event: SliderMouseEvent) => void;
+    onMouseMove?: (event: SliderMouseEvent) => void;
+    stepForward?: () => void;
+    stepBack?: () => void;
+    sliderActive?: (event: SliderActivateEvent) => void;
+    sliderInactive?: (event: SliderActivateEvent) => void;
+    onMouseUp?: (event: SliderMouseEvent) => void;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    getPercent?: () => number;
+    vertical?: boolean;
+    children?: React.ReactNode;
+    label?: string;
+    valuenow?: number;
+    valuetext?: string;
+    onPercentageChange?: (percentage: string) => void;
+}
+interface SliderState {
+    active: boolean;
+}
+declare class Slider extends Component<SliderProps, SliderState> {
+    private slider;
+    static displayName: string;
+    state: SliderState;
+    componentWillUnmount(): void;
+    getProgress: () => number;
+    handleMouseDown: (event: SliderMouseEvent) => void;
+    handleMouseMove: (event: SliderMouseEvent) => void;
+    handleMouseUp: (event: SliderMouseEvent) => void;
+    handleFocus: (event: React.FocusEvent<HTMLDivElement>) => void;
+    handleBlur: (event?: React.FocusEvent<HTMLDivElement>) => void;
+    handleClick: (event: React.MouseEvent<HTMLDivElement>) => void;
+    handleKeyPress: (event: KeyboardEvent) => void;
+    stepForward: () => void;
+    stepBack: () => void;
+    calculateDistance(event: SliderMouseEvent): number;
+    renderChildren: () => (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode>)[];
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export default Slider;
+//# sourceMappingURL=Slider.d.ts.map

package/dist/components/Source.d.ts

@@ -0,0 +1,25 @@
+/**
+
+ * Copyright (c) 2016 Video-React contributors
+ * Copyright (c) 2025 ZingMe.Vn
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import PropTypes from 'prop-types';
+interface SourceProps {
+    src: string;
+    media?: string;
+    type?: string;
+}
+declare function Source({ ...props }: SourceProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Source {
+    var propTypes: {
+        src: PropTypes.Validator<string>;
+        media: PropTypes.Requireable<string>;
+        type: PropTypes.Requireable<string>;
+    };
+    var displayName: string;
+}
+export default Source;
+//# sourceMappingURL=Source.d.ts.map

package/dist/components/Video.d.ts

@@ -0,0 +1,48 @@
+import React, { ReactNode, SyntheticEvent } from 'react';
+import type Manager from '../Manager';
+import type { VideoAPI } from '../Manager';
+import type { PlayerState } from '../reducers/player';
+type VideoEventHandler = (event: SyntheticEvent<HTMLVideoElement>) => void;
+export interface VideoProps {
+    actions: ReturnType<Manager['getActions']>;
+    player: PlayerState;
+    children?: ReactNode;
+    order?: number;
+    startTime?: number;
+    loop?: boolean;
+    muted?: boolean;
+    autoPlay?: boolean;
+    playsInline?: boolean;
+    src?: string;
+    poster?: string;
+    className?: string;
+    preload?: 'auto' | 'metadata' | 'none';
+    crossOrigin?: React.VideoHTMLAttributes<HTMLVideoElement>['crossOrigin'];
+    videoId?: string;
+    onLoadStart?: VideoEventHandler;
+    onWaiting?: VideoEventHandler;
+    onCanPlay?: VideoEventHandler;
+    onCanPlayThrough?: VideoEventHandler;
+    onPlaying?: VideoEventHandler;
+    onEnded?: VideoEventHandler;
+    onSeeking?: VideoEventHandler;
+    onSeeked?: VideoEventHandler;
+    onPlay?: VideoEventHandler;
+    onPause?: VideoEventHandler;
+    onProgress?: VideoEventHandler;
+    onDurationChange?: VideoEventHandler;
+    onError?: VideoEventHandler;
+    onSuspend?: VideoEventHandler;
+    onAbort?: VideoEventHandler;
+    onEmptied?: VideoEventHandler;
+    onStalled?: VideoEventHandler;
+    onLoadedMetadata?: VideoEventHandler;
+    onLoadedData?: VideoEventHandler;
+    onTimeUpdate?: VideoEventHandler;
+    onRateChange?: VideoEventHandler;
+    onVolumeChange?: VideoEventHandler;
+    onResize?: VideoEventHandler;
+}
+declare const Video: React.ForwardRefExoticComponent<VideoProps & React.RefAttributes<VideoAPI>>;
+export default Video;
+//# sourceMappingURL=Video.d.ts.map

package/dist/components/control-bar/ClosedCaptionButton.d.ts

@@ -0,0 +1,19 @@
+/**
+
+ * Copyright (c) 2016 Video-React contributors
+ * Copyright (c) 2025 ZingMe.Vn
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import React from 'react';
+import type { PlayerButtonProps } from '../../types/component';
+interface ClosedCaptionButtonProps extends PlayerButtonProps {
+    className?: string;
+    offMenuText?: string;
+    showOffMenu?: boolean;
+    kinds?: TextTrackKind[];
+}
+declare const ClosedCaptionButton: React.FC<ClosedCaptionButtonProps>;
+export default ClosedCaptionButton;
+//# sourceMappingURL=ClosedCaptionButton.d.ts.map

package/dist/components/control-bar/ControlBar.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { ActionCreators } from '../../Manager';
+import type { PlayerState } from '../../reducers/player';
+interface ControlBarProps {
+    actions?: ActionCreators;
+    player?: PlayerState;
+    order?: number;
+    children?: React.ReactNode;
+    autoHide?: boolean;
+    autoHideTime?: number;
+    disableDefaultControls?: boolean;
+    disableCompletely?: boolean;
+    className?: string;
+}
+declare const ControlBar: React.FC<ControlBarProps>;
+export default ControlBar;
+//# sourceMappingURL=ControlBar.d.ts.map