playron 1.0.31 → 1.0.32

package/dist/index.d.ts

@@ -1,107 +1,1934 @@
-import { AllPlayerEvents, EventCallback } from './types/events';
-import { VanillaPlayerConfig, PlayerState } from './types/config';
-export { default as Player } from './ui/Player';
-export { default } from './ui/Player';
-export { PlayerCore } from './core/PlayerCore';
-export { PlayronEventEmitter } from './core/PlayronEventEmitter';
-export { EventBus, eventBus } from './core/EventBus';
-export { StreamDetector, streamDetector } from './core/adaptive/StreamDetector';
-export type { StreamType, StreamInfo } from './core/adaptive/StreamDetector';
-export { default as ControlBar } from './ui/Common/ControlBar';
-export { default as PlayButton } from './ui/Controls/PlayButton';
-export { default as MuteButton } from './ui/Controls/MuteButton';
-export { default as FullscreenButton } from './ui/Controls/FullscreenButton';
-export { default as PipButton } from './ui/Controls/PipButton';
-export { default as TheaterModeButton } from './ui/Controls/TheaterModeButton';
-export { default as SettingsButton } from './ui/Controls/SettingsButton';
-export { default as TimeDisplay } from './ui/Controls/TimeDisplay';
-export { default as JumpToLiveButton } from './ui/Controls/JumpToLiveButton';
-export { default as LiveLatencyDisplay } from './ui/Controls/LiveLatencyDisplay';
-export { default as SkipIntroButton } from './ui/Controls/SkipIntroButton';
-export { default as SeekBar } from './ui/Common/SeekBar';
-export { default as SkipBackwardButton } from './ui/Controls/SkipBackwardButton';
-export { default as SkipForwardButton } from './ui/Controls/SkipForwardButton';
-export { default as VolumeControl } from './ui/Controls/VolumeControl';
-export type { VolumeSliderDirection, VolumeControlTheme } from './ui/Controls/VolumeControl';
-export { default as PlaybackSpeedSelector } from './ui/Controls/PlaybackSpeedSelector';
-export { default as SettingsPanel } from './ui/Controls/SettingsPanel';
-export type { SettingsPanelTheme, SettingsPanelPosition } from './ui/Controls/SettingsPanel';
-export { ControlsVisibilityContext } from './ui/Player';
-export { default as CastButton } from './ui/Controls/CastButton';
-export { default as ChromecastButton } from './ui/Controls/ChromecastButton';
-export { ChromecastManager } from './core/cast/ChromecastManager';
-export type { CastState, ChromecastManagerOptions } from './core/cast/ChromecastManager';
-export { default as EndCard } from './ui/Overlay/EndCard';
-export { default as KeyboardShortcutsOverlay } from './ui/Overlay/KeyboardShortcutsOverlay';
-export { default as ContextMenu } from './ui/Overlay/ContextMenu';
-export type { ContextMenuAction, ContextMenuTheme } from './ui/Overlay/ContextMenu';
-export { default as GestureHintOverlay } from './ui/Overlay/GestureHintOverlay';
-export { ThumbnailManager } from './core/streaming/ThumbnailManager';
-export type { ThumbnailCue } from './core/streaming/ThumbnailManager';
-export { StallDetector } from './core/StallDetector';
-export type { StallDetectorOptions } from './core/StallDetector';
-export type { PlayerConfig } from './types/config.types';
-export type { VanillaPlayerConfig, PlayerState } from './types/config';
-export type { PlayerProps } from './types/player.types';
-export type { ControlBarProps } from './types/controlbar.types';
-export type { PlayerEvent, PlayEvent, PauseEvent, MuteEvent, VolumeChangeEvent, AllPlayerEvents, EventCallback } from './types/events';
-export type { VirtusEventMap, VirtusEventType } from './core/PlayronEventEmitter';
-export { VideoEventType, MediaErrorCode, isVideoEventType } from './types/video-events';
-export type { VideoEventType as VideoEventTypeType, MediaErrorCode as MediaErrorCodeType } from './types/video-events';
-export type { TimelineEvent } from './types/timeline.types';
-export type { Chapter, IntroOutro } from './types/chapters.types';
-export type { AdConfig, Ad, AdPosition } from './plugins/ads/types';
-export { usePlayer } from './hooks/usePlayer';
-export { usePlayerState } from './hooks/usePlayerState';
-export { usePlayerMethods } from './hooks/usePlayerMethods';
-export { useMobileGestures } from './hooks/useMobileGestures';
-export { default as ControlsContainer } from './layout/ControlsContainer';
-export { default as SeekBarContainer } from './layout/SeekBarContainer';
-export { PlayerProvider } from './context/PlayerProvider';
-declare class Playron {
-    private playerCore;
-    private videoElement;
-    private container;
-    constructor(videoElementOrConfig: HTMLVideoElement | VanillaPlayerConfig);
-    /**
-     * Mevcut video element ile başlat
-     */
-    private initWithElement;
-    /**
-     * Konfigürasyon ile kendi player'ı oluştur
-     */
-    private initWithConfig;
-    on<T extends AllPlayerEvents>(eventType: T['type'], callback: EventCallback<T>): void;
-    off<T extends AllPlayerEvents>(eventType: T['type'], callback: EventCallback<T>): void;
-    play(): Promise<void>;
-    pause(): void;
-    toggleMute(): void;
-    setVolume(volume: number): void;
-    getState(): PlayerState | null;
-    /**
-     * Video source'u değiştir (auto-detects stream type)
-     */
-    setSource(src: string): Promise<void>;
-    /**
-     * Belirli bir zamana git
-     */
-    seekTo(time: number): void;
-    /**
-     * Oynatma hızını ayarla
-     */
-    setPlaybackRate(rate: number): void;
-    /**
-     * Video poster'ını ayarla
-     */
-    setPoster(poster: string): void;
-    /**
-     * Video boyutlarını ayarla
-     */
-    setDimensions(width: number | string, height: number | string): void;
-    /**
-     * Player'ı temizle
-     */
-    destroy(): void;
-}
-export { Playron };
-//# sourceMappingURL=index.d.ts.map
+import { Context } from 'react';
+import { FunctionComponent } from 'react';
+import { JSX } from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * Parsed VAST ad data
+ */
+export declare interface Ad {
+    id: string;
+    title?: string;
+    duration: number;
+    mediaFile: string;
+    clickThrough?: string;
+    trackingEvents: {
+        impression?: string[];
+        start?: string[];
+        complete?: string[];
+        skip?: string[];
+        firstQuartile?: string[];
+        midpoint?: string[];
+        thirdQuartile?: string[];
+        pause?: string[];
+        resume?: string[];
+    };
+    errorUrls?: string[];
+    /** Companion banners to display alongside the linear ad */
+    companions?: CompanionAd[];
+    /** Whether this is a VPAID creative */
+    isVpaid?: boolean;
+    /** VPAID JavaScript URL (apiFramework=VPAID) */
+    vpaidUrl?: string;
+    /** Position within an ad pod (from sequence attribute) */
+    podSequence?: number;
+}
+
+/**
+ * Ads configuration (from user config)
+ */
+export declare interface AdConfig {
+    enabled: boolean;
+    vastUrl?: string;
+    vmapUrl?: string;
+    skipAfter?: number;
+    timeout?: number;
+    maxWrapperDepth?: number;
+    ui?: AdUIConfig;
+}
+
+/**
+ * Ad position
+ */
+export declare type AdPosition = 'preroll' | 'midroll' | 'postroll';
+
+/**
+ * Simple Ad System Types
+ */
+/**
+ * Ad UI Configuration (optional customization)
+ */
+declare interface AdUIConfig {
+    showLabel?: boolean;
+    showCountdown?: boolean;
+    showSkipButton?: boolean;
+    labelText?: string;
+    labelPosition?: 'top-left' | 'top-right';
+    countdownPosition?: 'top-left' | 'top-right';
+}
+
+export declare type AllPlayerEvents = PlayEvent | PauseEvent | MuteEvent | VolumeChangeEvent;
+
+export declare function CastButton({ label, className }: CastButtonProps): JSX.Element | null;
+
+/**
+ * AirPlay / Cast Button
+ *
+ * Renders an AirPlay button (Safari WebKit only).
+ * Invisible in non-Safari browsers; hidden when no AirPlay device is available.
+ *
+ * Uses PlayerCore.showAirPlayPicker() to trigger the system UI.
+ * Listens to `airplaychange` events to track availability and active state.
+ */
+declare interface CastButtonProps {
+    /** Tooltip label */
+    label?: string;
+    className?: string;
+}
+
+export declare interface CastState {
+    isAvailable: boolean;
+    isActive: boolean;
+    /** 'not_connected' | 'connecting' | 'connected' | 'unavailable' */
+    state: 'not_connected' | 'connecting' | 'connected' | 'unavailable';
+}
+
+export declare interface Chapter {
+    id: string;
+    title: string;
+    startTime: number;
+    endTime?: number;
+}
+
+export declare function ChromecastButton({ label, className, }: ChromecastButtonProps): JSX.Element | null;
+
+/**
+ * ChromecastButton
+ *
+ * Shows a Google Cast icon when Chromecast devices are available.
+ * Hidden when no Cast-capable devices are nearby or when the Cast SDK
+ * has not been initialised (setupChromecast() not called on PlayerCore).
+ *
+ * Listens to `castchange` events emitted by PlayerCore / ChromecastManager.
+ * Button is visually active (tinted) while a session is connected.
+ */
+declare interface ChromecastButtonProps {
+    /** Tooltip label (default: 'Cast') */
+    label?: string;
+    className?: string;
+}
+
+export declare class ChromecastManager {
+    private readonly appId;
+    private readonly onChange;
+    private isAvailable;
+    private sessionActive;
+    private sdkLoaded;
+    /** Bound Cast state-change handler (needed for removeEventListener). */
+    private castStateHandler;
+    constructor(options: ChromecastManagerOptions);
+    /**
+     * Load the Google Cast SDK and initialise the Cast context.
+     * Safe to call multiple times — idempotent.
+     */
+    setup(): void;
+    /**
+     * Open the Cast device picker dialog.
+     * Resolves when the user selects a device (or dismisses).
+     */
+    requestSession(): Promise<void>;
+    /**
+     * End the current Cast session (stop casting).
+     * @param stopCasting Whether to stop playback on the receiver (true) or leave it running.
+     */
+    endSession(stopCasting?: boolean): void;
+    /**
+     * Load a media URL on the active Cast receiver.
+     * Must be called AFTER a session is established.
+     *
+     * @param src         Fully qualified media URL
+     * @param contentType MIME type (e.g. 'application/x-mpegURL', 'video/mp4')
+     * @param startTime   Playhead position in seconds (default 0)
+     * @param isLive      Whether the stream is live (affects receiver UI)
+     */
+    loadMedia(src: string, contentType?: string, startTime?: number, isLive?: boolean): Promise<void>;
+    /**
+     * Seek the Cast receiver to the given time.
+     * No-op when cast is not active.
+     */
+    syncTime(time: number): void;
+    /**
+     * Sync volume / mute state to the Cast receiver.
+     * No-op when cast is not active.
+     */
+    syncVolume(volume: number, muted: boolean): Promise<void>;
+    /** Returns true if at least one Cast device is available. */
+    isCastAvailable(): boolean;
+    /** Returns true if a Cast session is currently active. */
+    isCastActive(): boolean;
+    /** Current cast state snapshot. */
+    getState(): CastState;
+    /** Remove all event listeners. Does NOT end the cast session. */
+    destroy(): void;
+    private getContext;
+    private initContext;
+    private syncState;
+    private emitState;
+}
+
+export declare interface ChromecastManagerOptions {
+    /**
+     * Cast receiver application ID.
+     * Defaults to `DEFAULT_MEDIA_RECEIVER_APP_ID` ('CC1AD845').
+     */
+    appId?: string;
+    /** Called whenever cast availability or session state changes. */
+    onChange: (state: CastState) => void;
+}
+
+/**
+ * Companion banner (displayed alongside the ad)
+ */
+declare interface CompanionAd {
+    id?: string;
+    width: number;
+    height: number;
+    /** Static image / SWF URL */
+    staticResource?: string;
+    /** Raw HTML snippet */
+    htmlResource?: string;
+    /** IFrame URL */
+    iFrameResource?: string;
+    /** MIME type of the staticResource */
+    type?: string;
+    /** Click-through URL */
+    clickThrough?: string;
+    /** Alt text for image companions */
+    altText?: string;
+    /** Tracking URLs to fire on companion view */
+    viewTrackingUrls?: string[];
+}
+
+declare class ConfigManager {
+    private config;
+    private defaultConfig;
+    constructor(config: VanillaPlayerConfig);
+    /**
+     * Varsayılan konfigürasyonu döndür
+     */
+    private getDefaultConfig;
+    /**
+     * Konfigürasyonları birleştir
+     */
+    private mergeConfig;
+    /**
+     * Konfigürasyonu doğrula
+     */
+    private validateConfig;
+    /**
+     * Konfigürasyonu güncelle
+     */
+    updateConfig(updates: Partial<VanillaPlayerConfig>): void;
+    /**
+     * Mevcut konfigürasyonu döndür
+     */
+    getConfig(): VanillaPlayerConfig;
+    /**
+     * Belirli bir konfigürasyon değerini al
+     */
+    get<K extends keyof VanillaPlayerConfig>(key: K): VanillaPlayerConfig[K];
+    /**
+     * Belirli bir konfigürasyon değerini ayarla
+     */
+    set<K extends keyof VanillaPlayerConfig>(key: K, value: VanillaPlayerConfig[K]): void;
+    /**
+     * Container element'ini döndür
+     */
+    getContainer(): HTMLElement | null;
+    /**
+     * Video boyutlarını döndür
+     */
+    getDimensions(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Konfigürasyonu sıfırla
+     */
+    reset(): void;
+    /**
+     * Konfigürasyonu export et
+     */
+    export(): string;
+    /**
+     * Konfigürasyonu import et
+     */
+    import(configString: string): void;
+    /**
+     * Konfigürasyon değişikliklerini dinle
+     */
+    private listeners;
+    /**
+     * Konfigürasyon değişiklik dinleyicisi ekle
+     */
+    onChange(callback: (config: VanillaPlayerConfig) => void): void;
+    /**
+     * Konfigürasyon değişiklik dinleyicisini kaldır
+     */
+    offChange(callback: (config: VanillaPlayerConfig) => void): void;
+    /**
+     * Konfigürasyon değişikliklerini bildir
+     */
+    private notifyChange;
+    /**
+     * Konfigürasyonu güncelle ve değişiklikleri bildir
+     */
+    updateConfigAndNotify(updates: Partial<VanillaPlayerConfig>): void;
+}
+
+export declare function ContextMenu({ x, y, isOpen, onClose, actions, theme }: ContextMenuProps): JSX.Element | null;
+
+export declare interface ContextMenuAction {
+    label: string;
+    icon?: React.ReactNode;
+    onClick: () => void;
+    dividerAfter?: boolean;
+    danger?: boolean;
+}
+
+declare interface ContextMenuProps {
+    x: number;
+    y: number;
+    isOpen: boolean;
+    onClose: () => void;
+    actions: ContextMenuAction[];
+    theme?: ContextMenuTheme;
+}
+
+/** Customize the visual appearance of the ContextMenu. */
+export declare interface ContextMenuTheme {
+    /** Panel background. Default: 'rgba(12, 12, 20, 0.97)' */
+    background?: string;
+    /** Panel border color. Default: 'rgba(255,255,255,0.1)' */
+    borderColor?: string;
+    /** Normal item text color. Default: '#fff' */
+    textColor?: string;
+    /** Danger item color. Default: '#f87171' */
+    dangerColor?: string;
+    /** Row hover background. Default: 'rgba(255,255,255,0.07)' */
+    hoverBackground?: string;
+    /** Icon pill background. Default: 'rgba(255,255,255,0.08)' */
+    iconBackground?: string;
+    /** Divider line color. Default: 'rgba(255,255,255,0.07)' */
+    dividerColor?: string;
+}
+
+export declare function ControlBar({ children }: ControlBarProps): JSX.Element;
+
+export declare interface ControlBarProps {
+    children?: ReactNode;
+}
+
+export declare const ControlsContainer: FunctionComponent<ControlsContainerProps>;
+
+declare interface ControlsContainerProps {
+    /** Optional override — if omitted, live/VOD is auto-detected from stream state */
+    mode?: PlayerMode;
+}
+
+export declare const ControlsVisibilityContext: Context<boolean>;
+
+export declare function EndCard({ isVisible, onNextEpisode, onDismiss, countdownSec, nextTitle, thumbnail, }: EndCardProps): JSX.Element | null;
+
+declare interface EndCardProps {
+    isVisible: boolean;
+    onNextEpisode: () => void;
+    onDismiss: () => void;
+    countdownSec?: number;
+    nextTitle?: string;
+    thumbnail?: string;
+}
+
+export declare class EventBus {
+    private listeners;
+    /**
+     * Event dinleyicisi ekle
+     * @param eventType Event tipi
+     * @param callback Event gerçekleştiğinde çağrılacak fonksiyon
+     */
+    on<T extends AllPlayerEvents>(eventType: T['type'], callback: EventCallback<T>): void;
+    /**
+     * Event dinleyicisini kaldır
+     * @param eventType Event tipi
+     * @param callback Kaldırılacak fonksiyon
+     */
+    off<T extends AllPlayerEvents>(eventType: T['type'], callback: EventCallback<T>): void;
+    /**
+     * Event gönder
+     * @param event Gönderilecek event
+     */
+    emit<T extends AllPlayerEvents>(event: T): void;
+    /**
+     * Tüm dinleyicileri temizle
+     */
+    clear(): void;
+    /**
+     * Belirli bir event tipinin dinleyici sayısını döndür
+     * @param eventType Event tipi
+     */
+    listenerCount(eventType: string): number;
+}
+
+export declare const eventBus: EventBus;
+
+export declare type EventCallback<T = any> = (event: T) => void;
+
+export declare function FullscreenButton({ className, onClick, iconSize, hoverBackground, enterIcon, exitIcon, style, ...props }: FullscreenButtonProps): JSX.Element;
+
+declare interface FullscreenButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Icon size in px. Default: 18 */
+    iconSize?: number;
+    /** Hover background color. Pass false to disable hover background. */
+    hoverBackground?: string | boolean;
+    /** Custom icon shown when not in fullscreen (enter fullscreen). */
+    enterIcon?: React.ReactNode;
+    /** Custom icon shown when in fullscreen (exit fullscreen). */
+    exitIcon?: React.ReactNode;
+}
+
+declare interface GestureHint {
+    type: 'seek-forward' | 'seek-backward';
+    value: string;
+}
+
+export declare function GestureHintOverlay({ type, value }: GestureHintOverlayProps): JSX.Element | null;
+
+/**
+ * GestureHintOverlay
+ *
+ * Transient visual feedback for mobile gestures:
+ *   - Seek forward / backward: animated ripple + text on left / right half
+ */
+declare interface GestureHintOverlayProps {
+    type: 'seek-forward' | 'seek-backward' | null;
+    value: string;
+}
+
+export declare interface IntroOutro {
+    intro?: {
+        start: number;
+        end: number;
+    };
+    outro?: {
+        start: number;
+        end: number;
+    };
+}
+
+/**
+ * Type guard for checking if an event type is a valid VideoEventType
+ */
+export declare function isVideoEventType(event: string): event is VideoEventType;
+
+export declare function JumpToLiveButton(): JSX.Element | null;
+
+export declare function KeyboardShortcutsOverlay({ isOpen, onClose }: KeyboardShortcutsOverlayProps): JSX.Element | null;
+
+declare interface KeyboardShortcutsOverlayProps {
+    isOpen: boolean;
+    onClose: () => void;
+}
+
+declare interface LicenseAcquisitionConfig {
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+    prepareLicenseRequest?: (request: ArrayBuffer) => ArrayBuffer | Promise<ArrayBuffer>;
+    parseLicenseResponse?: (response: ArrayBuffer) => ArrayBuffer | Promise<ArrayBuffer>;
+}
+
+export declare function LiveLatencyDisplay(): JSX.Element | null;
+
+/**
+ * Media Error Codes
+ *
+ * Standard HTML5 media error codes for better error handling
+ */
+declare const MediaErrorCode: {
+    MEDIA_ERR_ABORTED: number;
+    MEDIA_ERR_NETWORK: number;
+    MEDIA_ERR_DECODE: number;
+    MEDIA_ERR_SRC_NOT_SUPPORTED: number;
+};
+
+declare type MediaErrorCode = typeof MediaErrorCode[keyof typeof MediaErrorCode];
+export { MediaErrorCode }
+export { MediaErrorCode as MediaErrorCodeType }
+
+export declare function MuteButton({ className, onClick, ...props }: MuteButtonProps): JSX.Element;
+
+declare interface MuteButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+
+export declare interface MuteEvent extends PlayerEvent {
+    type: 'mute';
+    data: {
+        muted: boolean;
+        volume: number;
+    };
+}
+
+export declare interface PauseEvent extends PlayerEvent {
+    type: 'pause';
+    data: {
+        currentTime: number;
+        duration: number;
+    };
+}
+
+export declare function PipButton({ className, onClick, ...props }: PipButtonProps): JSX.Element;
+
+declare interface PipButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+
+export declare function PlaybackSpeedSelector(): JSX.Element;
+
+export declare function PlayButton({ className, onClick, iconSize, hoverBackground, pauseIcon, playIcon, style, ...props }: PlayButtonProps): JSX.Element;
+
+declare interface PlayButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Icon size in px. Default: 24 */
+    iconSize?: number;
+    /** Hover background color. Pass false to disable hover background. */
+    hoverBackground?: string | boolean;
+    /** Custom icon shown when playing (replaces default pause icon). */
+    pauseIcon?: React.ReactNode;
+    /** Custom icon shown when paused (replaces default play icon). */
+    playIcon?: React.ReactNode;
+}
+
+declare function Player({ src, defaultControls, autoplay, muted, poster, className, children, config, onAdLoading, onNextEpisode, nextEpisodeTitle, nextEpisodeThumbnail, endCardCountdown, crossOrigin, }: PlayerComponentProps): JSX.Element;
+export { Player }
+export default Player;
+
+declare interface PlayerComponentProps extends PlayerProps {
+    children?: ReactNode;
+    config?: PlayerConfig;
+    /** Called when next-episode card fires (auto or manual). If omitted the end card is not shown. */
+    onNextEpisode?: () => void;
+    /** Title of the next episode shown in the end card */
+    nextEpisodeTitle?: string;
+    /** Thumbnail URL for the next episode */
+    nextEpisodeThumbnail?: string;
+    /** Seconds to count down before auto-advancing (default 5) */
+    endCardCountdown?: number;
+}
+
+export declare interface PlayerConfig {
+    /**
+     * Player behavior configuration
+     */
+    player?: {
+        /** Default volume (0-1) */
+        defaultVolume?: number;
+        /** Default playback rate */
+        defaultPlaybackRate?: number;
+        /** Skip forward/backward duration in seconds */
+        skipSeconds?: number;
+        /** Auto-resume from last position */
+        autoResume?: boolean;
+        /** Loop video */
+        loop?: boolean;
+        /** Preload strategy */
+        preload?: 'none' | 'metadata' | 'auto';
+        /** Include credentials (cookies, auth headers) in CORS requests */
+        withCredentials?: boolean;
+    };
+    /**
+     * UI/UX configuration
+     */
+    ui?: {
+        /** Auto-hide controls delay (ms) */
+        autoHideDelay?: number;
+        /** Show player title */
+        showTitle?: boolean;
+        /** Control bar position */
+        controlBarPosition?: 'bottom' | 'overlay';
+        /** Seek bar height (px) */
+        seekBarHeight?: number;
+        /** Show time tooltip on hover */
+        showTimeTooltip?: boolean;
+        /** Show volume slider */
+        showVolumeSlider?: boolean;
+        /** Show/hide center play, pause and loading overlay icons (default: true) */
+        showOverlayIcons?: boolean;
+        /** Custom overlay icons */
+        overlayIcons?: {
+            /** Custom play icon (SVG string or image URL) */
+            playIcon?: string;
+            /** Custom pause icon (SVG string or image URL) */
+            pauseIcon?: string;
+            /** Custom loading/buffering icon (SVG string or image URL) */
+            loadingIcon?: string;
+            /** Icon size (px) */
+            iconSize?: number;
+            /** Container size (px) */
+            containerSize?: number;
+        };
+        /** Seek bar visual style overrides */
+        seekBar?: {
+            /** Track (background) color — default: rgba(255,255,255,0.3) */
+            trackColor?: string;
+            /** Playback progress bar color — default: #6366f1 (VOD) / #ff2020 (live) */
+            progressColor?: string;
+            /** Buffered range fill color — default: rgba(255,255,255,0.25) */
+            bufferedColor?: string;
+            /** Seek handle / thumb color — default: #ffffff */
+            handleColor?: string;
+            /** Track height in px — default: 4 */
+            height?: number;
+            /** Track border-radius in px — default: 2 */
+            borderRadius?: number;
+            /** Show the circular thumb/handle on the seek bar (default: true) */
+            showHandle?: boolean;
+            /** Show the time tooltip on hover (default: true) */
+            showTooltip?: boolean;
+            /** Horizontal padding of the seekbar container in px — default: 20 */
+            paddingX?: number;
+            /** Vertical padding of the seekbar container in px — default: 0 */
+            paddingY?: number;
+            /** Distance from the bottom of the player in px — default: 64 */
+            bottom?: number;
+        };
+    };
+    /**
+     * Feature toggles
+     */
+    features?: {
+        /** Enable Picture-in-Picture */
+        pip?: boolean;
+        /** Enable fullscreen */
+        fullscreen?: boolean;
+        /** Enable theater mode */
+        theaterMode?: boolean;
+        /** Enable chapters */
+        chapters?: boolean;
+        /** Enable skip intro/outro */
+        skipIntro?: boolean;
+        /** Enable subtitles */
+        subtitles?: boolean;
+        /** Enable quality selector */
+        qualitySelector?: boolean;
+        /** Enable audio track selector */
+        audioTrackSelector?: boolean;
+        /** Enable playback speed control */
+        playbackSpeed?: boolean;
+        /** Enable keyboard shortcuts */
+        keyboardShortcuts?: boolean;
+        /** Enable AirPlay button (Safari only — hidden in other browsers) */
+        airPlay?: boolean;
+    };
+    /**
+     * Branding and styling
+     */
+    branding?: {
+        /** Primary color (hex) */
+        primaryColor?: string;
+        /** Accent color (hex) */
+        accentColor?: string;
+        /** Player logo URL */
+        logo?: string;
+        /** Logo link */
+        logoLink?: string;
+        /** Custom CSS class */
+        customClass?: string;
+    };
+    /**
+     * Content metadata
+     */
+    metadata?: {
+        /** Video title */
+        title?: string;
+        /** Video description */
+        description?: string;
+        /** Thumbnail URL */
+        thumbnail?: string;
+        /** Content rating */
+        rating?: string;
+        /** Content warnings */
+        warnings?: string[];
+    };
+    /**
+     * Advanced settings
+     */
+    advanced?: {
+        /** Buffer ahead time (seconds) */
+        bufferAhead?: number;
+        /** Buffer behind time (seconds) */
+        bufferBehind?: number;
+        /** Max buffer length (seconds) */
+        maxBufferLength?: number;
+        /** Enable debug mode */
+        debug?: boolean;
+        /** Analytics enabled */
+        analytics?: boolean;
+        /** Error reporting enabled */
+        errorReporting?: boolean;
+    };
+    /**
+     * Thumbnail preview (storyboard) configuration.
+     * Provide a WebVTT file mapping time ranges to image URLs.
+     * Supports sprite sheets via #xywh media fragments.
+     */
+    thumbnails?: {
+        /** URL of the WebVTT thumbnail track */
+        vttUrl?: string;
+    };
+    /**
+     * Live stream configuration
+     */
+    live?: {
+        /**
+         * Seconds behind live edge before the player is considered "not at live edge".
+         * Used to show/hide the "Jump to Live" button. Default: 10
+         */
+        atLiveEdgeTolerance?: number;
+        /** Show the "Jump to Live" button when behind the live edge (default: true) */
+        showJumpToLiveButton?: boolean;
+        /** Show current latency badge next to the live indicator (default: false) */
+        showLatency?: boolean;
+        /** DVR window: allow seeking back in live streams (default: true when seekable range > 0) */
+        dvr?: boolean;
+    };
+    /**
+     * Playron license key.
+     * Obtain a key at https://playron.dev/license
+     * Without a valid key the player runs in trial mode (watermark shown).
+     */
+    licenseKey?: string;
+    /**
+     * Rich player mode (enables advanced features like timeline markers)
+     */
+    isRichPlayer?: boolean;
+    /**
+     * Timeline markers configuration
+     */
+    timeline?: TimelineConfig;
+    /**
+     * DRM (Digital Rights Management) configuration.
+     * Supports Widevine, FairPlay, and PlayReady.
+     * All three can be configured simultaneously — the player will select the
+     * system supported by the current browser automatically.
+     */
+    drm?: {
+        /** Enable DRM (default: false) */
+        enabled?: boolean;
+        /** Widevine — Chrome, Firefox, Android, Smart TVs */
+        widevine?: {
+            licenseUrl: string;
+            /** Extra HTTP headers sent with every license request */
+            headers?: Record<string, string>;
+            /** Include cookies in license requests */
+            withCredentials?: boolean;
+            licenseAcquisitionConfig?: LicenseAcquisitionConfig;
+        };
+        /** FairPlay Streaming — Safari, iOS, macOS */
+        fairplay?: {
+            licenseUrl: string;
+            /** URL of the FairPlay server certificate (.der / .cer) */
+            certificateUrl: string;
+            headers?: Record<string, string>;
+            withCredentials?: boolean;
+            licenseAcquisitionConfig?: LicenseAcquisitionConfig;
+        };
+        /** PlayReady — Edge, IE, Windows, Xbox */
+        playready?: {
+            licenseUrl: string;
+            headers?: Record<string, string>;
+            withCredentials?: boolean;
+            licenseAcquisitionConfig?: LicenseAcquisitionConfig;
+        };
+        /**
+         * Force a specific DRM system instead of auto-detecting.
+         * Useful when testing or when a specific system should take precedence.
+         */
+        preferredSystem?: 'widevine' | 'fairplay' | 'playready';
+    };
+    /**
+     * Ads configuration (VAST/VMAP)
+     */
+    ads?: {
+        /** Enable ads */
+        enabled?: boolean;
+        /** VAST URL (for pre-roll ad, if vmapUrl is not provided) */
+        vastUrl?: string;
+        /** VMAP URL (alternative to vastUrl - supports pre-roll, mid-roll, post-roll) */
+        vmapUrl?: string;
+        /** Skip button after X seconds (default: 5, 0 = no skip) */
+        skipAfter?: number;
+        /** VAST/VMAP request timeout in ms (default: 5000) */
+        timeout?: number;
+        /** Max VAST wrapper depth (default: 5) */
+        maxWrapperDepth?: number;
+    };
+}
+
+export declare class PlayerCore {
+    private videoEngine;
+    private configManager;
+    private stateManager;
+    private videoElement;
+    private container;
+    events: PlayronEventEmitter;
+    private streamType;
+    private streamInfo;
+    private hlsEngine;
+    private dashEngine;
+    private airPlayAvailable;
+    private airPlayActive;
+    private onAirPlayAvailabilityChanged;
+    private onAirPlayTargetChanged;
+    private stallDetector;
+    private liveLatencyTimer;
+    /** Seconds within which the playhead is considered "at live edge" */
+    private atLiveEdgeTolerance;
+    private drmConfig;
+    private drmManager;
+    private castManager;
+    constructor(videoElement: HTMLVideoElement);
+    /**
+     * PlayerCore'u başlat
+     */
+    private initialize;
+    /**
+     * State değişikliklerini dinle
+     */
+    private setupStateListeners;
+    /**
+     * Konfigürasyon ile PlayerCore'u başlat
+     */
+    static createWithConfig(config: VanillaPlayerConfig): PlayerCore;
+    /**
+     * DRM konfigürasyonunu ayarla. setSource() çağrısından ÖNCE çağrılmalı.
+     * Widevine (Chrome/Firefox) ve PlayReady (Edge) desteklenir.
+     */
+    setupDrm(config: PlayerConfig['drm']): void;
+    /**
+     * Video'yu oynat
+     */
+    play(): Promise<void>;
+    /**
+     * Video'yu duraklat
+     */
+    pause(): void;
+    /**
+     * Video'yu sessize al/aç
+     */
+    toggleMute(): void;
+    /**
+     * Ses seviyesini ayarla
+     */
+    setVolume(volume: number): void;
+    /**
+     * Buffered time ranges from the video element.
+     */
+    getBufferedRanges(): Array<{
+        start: number;
+        end: number;
+    }>;
+    /**
+     * Real-time playback statistics (Stats for Nerds).
+     */
+    getPlayerStats(): {
+        bandwidth: number;
+        bufferHealth: number;
+        droppedFrames: number;
+        totalFrames: number;
+        codec: string;
+        resolution: string;
+        segmentUrl: string;
+        streamType: string;
+    };
+    private persistVolume;
+    private loadPersistedVolume;
+    /**
+     * Belirli bir zamana git
+     */
+    seekTo(time: number): void;
+    /**
+     * Oynatma hızını ayarla
+     */
+    setPlaybackRate(rate: number): void;
+    /**
+     * Video source'unu değiştir.
+     * HLS (.m3u8) → HlsEngine (hls.js)
+     * DASH (.mpd) → Faz 2'de dash.js
+     * Diğerleri → native <video>
+     */
+    setSource(src: string): Promise<void>;
+    /**
+     * Aktif streaming engine'i temizle
+     */
+    private destroyStreamingEngines;
+    /**
+     * Native video element fallback
+     */
+    private fallbackToNative;
+    getStreamType(): StreamType;
+    getStreamInfo(): StreamInfo | null;
+    isLive(): boolean;
+    getLiveEdgeTime(): number;
+    getCurrentLatency(): number;
+    isAtLiveEdge(tolerance?: number): boolean;
+    seekToLiveEdge(): void;
+    getDVRRange(): {
+        start: number;
+        end: number;
+    } | null;
+    private startLiveLatencyTracking;
+    private stopLiveLatencyTracking;
+    private startStallDetector;
+    setPoster(poster: string): void;
+    setDimensions(width: number | string, height: number | string): void;
+    getState(): PlayerState | null;
+    getVideoEngine(): VideoEngine | null;
+    getConfigManager(): ConfigManager | null;
+    getStateManager(): StateManager | null;
+    getVideoElement(): HTMLVideoElement | null;
+    toggleFullscreen(): void;
+    togglePip(): Promise<void>;
+    skipBackward(seconds?: number): void;
+    skipForward(seconds?: number): void;
+    setLoop(loop: boolean): void;
+    getLoop(): boolean;
+    /**
+     * Kalite değiştir. 'auto' → ABR, diğerleri → level index.
+     */
+    setQuality(qualityId: string): void;
+    getQuality(): QualityLevel | null;
+    getAvailableQualities(): QualityLevel[];
+    /**
+     * Ses izini değiştir (dublaj seçimi).
+     */
+    setAudioTrack(trackId: string): void;
+    getAudioTrack(): string;
+    getAvailableAudioTracks(): Array<{
+        id: string;
+        label: string;
+        language: string;
+    }>;
+    getSubtitleTracks(): Array<{
+        language: string;
+        label: string;
+        url: string;
+    }>;
+    setSubtitleTrack(language: string | null): Promise<void>;
+    getActiveSubtitleLanguage(): string | null;
+    private setupAirPlay;
+    showAirPlayPicker(): void;
+    isAirPlayAvailable(): boolean;
+    isAirPlayActive(): boolean;
+    private destroyAirPlay;
+    /**
+     * Load the Google Cast SDK and set up the Cast context.
+     * Call once — idempotent. Cast device picker becomes available after this.
+     *
+     * @param appId Cast receiver app ID (defaults to DEFAULT_MEDIA_RECEIVER_APP_ID)
+     */
+    setupChromecast(appId?: string): void;
+    /** Open the Chromecast device picker. */
+    showCastPicker(): Promise<void>;
+    /** Stop casting and end the session. */
+    stopCasting(): void;
+    /** Returns true when at least one Cast device is nearby. */
+    isCastAvailable(): boolean;
+    /** Returns true when a Cast session is currently active. */
+    isCastActive(): boolean;
+    private destroyChromecast;
+    toggleTheaterMode(): void;
+    isTheaterMode(): boolean;
+    /**
+     * PlayerCore'u tamamen temizle.
+     */
+    destroy(): void;
+}
+
+export declare interface PlayerEvent {
+    type: string;
+    data?: any;
+    timestamp: number;
+}
+
+declare interface PlayerMethods {
+    play: () => Promise<void>;
+    pause: () => void;
+    togglePlay: () => Promise<void>;
+    toggleMute: () => void;
+    setVolume: (volume: number) => void;
+    seekTo: (time: number) => void;
+    setPlaybackRate: (rate: number) => void;
+    toggleFullscreen: () => void;
+    togglePip: () => Promise<void>;
+    skipBackward: (seconds?: number) => void;
+    skipForward: (seconds?: number) => void;
+    setLoop: (loop: boolean) => void;
+    getLoop: () => boolean;
+    setQuality: (quality: string) => void;
+    getQuality: () => QualityLevel | null;
+    getAvailableQualities: () => QualityLevel[];
+    setAudioTrack: (trackId: string) => void;
+    getAudioTrack: () => string;
+    getAvailableAudioTracks: () => Array<{
+        id: string;
+        label: string;
+        language: string;
+    }>;
+    toggleTheaterMode: () => void;
+    isTheaterMode: () => boolean;
+    getPlayer: () => any;
+    onNextEpisode?: () => void;
+    getStreamType: () => 'vod' | 'live' | 'unknown';
+    getStreamInfo: () => any;
+    isLive: () => boolean;
+    getBufferedRanges: () => Array<{
+        start: number;
+        end: number;
+    }>;
+    seekToLiveEdge: () => void;
+    getCurrentLatency: () => number;
+    isAtLiveEdge: (tolerance?: number) => boolean;
+    getDVRRange: () => {
+        start: number;
+        end: number;
+    } | null;
+    getSubtitleTracks: () => Array<{
+        language: string;
+        label: string;
+        url: string;
+    }>;
+    setSubtitleTrack: (language: string | null) => Promise<void>;
+    getActiveSubtitleLanguage: () => string | null;
+    getPlayerStats: () => {
+        bandwidth: number;
+        bufferHealth: number;
+        droppedFrames: number;
+        totalFrames: number;
+        codec: string;
+        resolution: string;
+        segmentUrl: string;
+        streamType: string;
+    };
+}
+
+declare type PlayerMode = 'vod' | 'live';
+
+export declare interface PlayerProps {
+    src?: string;
+    width?: string | number;
+    height?: string | number;
+    defaultControls?: boolean;
+    autoplay?: boolean;
+    muted?: boolean;
+    poster?: string;
+    className?: string;
+    onAdLoading?: (isLoading: boolean) => void;
+    /**
+     * Sets the crossOrigin attribute on the underlying <video> element.
+     * Default: undefined (no crossOrigin attribute).
+     * Set to 'anonymous' only if your video CDN sends proper CORS headers
+     * AND you need canvas/screenshot access. On iOS, setting this without
+     * proper CORS headers will break playback.
+     */
+    crossOrigin?: 'anonymous' | 'use-credentials';
+}
+
+export declare function PlayerProvider({ children, playerInstance }: PlayerProviderProps): JSX.Element;
+
+declare interface PlayerProviderProps {
+    children: ReactNode;
+    playerInstance: PlayerCore | null;
+}
+
+export declare interface PlayerState {
+    isPlaying: boolean;
+    isMuted: boolean;
+    volume: number;
+    currentTime: number;
+    duration: number;
+    playbackRate?: number;
+    isLive?: boolean;
+    isAtLiveEdge?: boolean;
+    liveLatency?: number;
+}
+
+export declare interface PlayEvent extends PlayerEvent {
+    type: 'play';
+    data: {
+        currentTime: number;
+        duration: number;
+    };
+}
+
+export declare class Playron {
+    private playerCore;
+    private videoElement;
+    private container;
+    constructor(videoElementOrConfig: HTMLVideoElement | VanillaPlayerConfig);
+    /**
+     * Mevcut video element ile başlat
+     */
+    private initWithElement;
+    /**
+     * Konfigürasyon ile kendi player'ı oluştur
+     */
+    private initWithConfig;
+    on<T extends AllPlayerEvents>(eventType: T['type'], callback: EventCallback<T>): void;
+    off<T extends AllPlayerEvents>(eventType: T['type'], callback: EventCallback<T>): void;
+    play(): Promise<void>;
+    pause(): void;
+    toggleMute(): void;
+    setVolume(volume: number): void;
+    getState(): PlayerState | null;
+    /**
+     * Video source'u değiştir (auto-detects stream type)
+     */
+    setSource(src: string): Promise<void>;
+    /**
+     * Belirli bir zamana git
+     */
+    seekTo(time: number): void;
+    /**
+     * Oynatma hızını ayarla
+     */
+    setPlaybackRate(rate: number): void;
+    /**
+     * Video poster'ını ayarla
+     */
+    setPoster(poster: string): void;
+    /**
+     * Video boyutlarını ayarla
+     */
+    setDimensions(width: number | string, height: number | string): void;
+    /**
+     * Player'ı temizle
+     */
+    destroy(): void;
+}
+
+/**
+ * Unified event emitter for Playron
+ */
+export declare class PlayronEventEmitter {
+    private listeners;
+    private onceListeners;
+    /**
+     * Subscribe to an event
+     */
+    on<T extends VirtusEventType>(event: T, callback: VirtusEventCallback<T>): void;
+    /**
+     * Subscribe to an event (fires only once)
+     */
+    once<T extends VirtusEventType>(event: T, callback: VirtusEventCallback<T>): void;
+    /**
+     * Unsubscribe from an event
+     */
+    off<T extends VirtusEventType>(event: T, callback: VirtusEventCallback<T>): void;
+    /**
+     * Emit an event
+     */
+    emit<T extends VirtusEventType>(event: T, data: VirtusEventMap[T]): void;
+    /**
+     * Remove all listeners for a specific event or all events
+     */
+    removeAllListeners(event?: VirtusEventType): void;
+    /**
+     * Get listener count for an event
+     */
+    listenerCount(event: VirtusEventType): number;
+    /**
+     * Get all registered event types
+     */
+    eventNames(): VirtusEventType[];
+}
+
+/**
+ * Quality level (bitrate/resolution)
+ */
+declare interface QualityLevel {
+    id: string;
+    label: string;
+    width: number;
+    height: number;
+    bandwidth: number;
+    codecs: string;
+    frameRate?: number;
+    uri: string;
+}
+
+export declare function SeekBar({ mode, chapters, timelineEvents, showTimelineMarkers, markerSize, thumbnailsVttUrl, seekBarStyle, }: SeekBarProps): JSX.Element;
+
+export declare const SeekBarContainer: FunctionComponent<SeekBarContainerProps>;
+
+declare interface SeekBarContainerProps {
+    mode?: PlayerMode;
+    chapters?: Chapter[];
+    timelineEvents?: TimelineEvent[];
+    showTimelineMarkers?: boolean;
+    markerSize?: number;
+    config?: PlayerConfig;
+}
+
+declare interface SeekBarProps {
+    mode?: PlayerMode;
+    chapters?: Chapter[];
+    timelineEvents?: TimelineEvent[];
+    showTimelineMarkers?: boolean;
+    markerSize?: number;
+    /** WebVTT storyboard URL for hover thumbnail preview */
+    thumbnailsVttUrl?: string;
+    /** Custom seek bar visual style */
+    seekBarStyle?: SeekBarStyle;
+}
+
+declare interface SeekBarStyle {
+    /** Track (background) color */
+    trackColor?: string;
+    /** Playback progress bar color (overrides the default VOD/live color) */
+    progressColor?: string;
+    /** Buffered range fill color */
+    bufferedColor?: string;
+    /** Seek handle / thumb color */
+    handleColor?: string;
+    /** Track height in px */
+    height?: number;
+    /** Track border-radius in px */
+    borderRadius?: number;
+    /** Show circular thumb/handle */
+    showHandle?: boolean;
+    /** Show time tooltip on hover */
+    showTooltip?: boolean;
+    /** Horizontal padding of the seekbar container in px (default: 20) */
+    paddingX?: number;
+    /** Vertical padding of the seekbar container in px (default: 0) */
+    paddingY?: number;
+    /** Distance from the bottom of the player in px (default: 64) */
+    bottom?: number;
+}
+
+export declare function SettingsButton(): JSX.Element;
+
+export declare function SettingsPanel({ theme, panelPosition, iconSize, hoverBackground, gearIcon, }?: {
+    theme?: SettingsPanelTheme;
+    panelPosition?: SettingsPanelPosition;
+    /** Gear icon size in px. Default: 20 */
+    iconSize?: number;
+    /** Hover background color for the gear button. Pass false to disable hover background. */
+    hoverBackground?: string | boolean;
+    /** Custom icon replacing the default gear SVG. */
+    gearIcon?: React.ReactNode;
+}): JSX.Element;
+
+/** Where the panel opens relative to the gear button. */
+export declare interface SettingsPanelPosition {
+    /** 'top' = panel opens above the button (default). 'bottom' = opens below. */
+    vertical?: 'top' | 'bottom';
+    /** 'right' = right-aligned (default). 'left' = left-aligned. */
+    horizontal?: 'left' | 'right';
+}
+
+/**
+ * SettingsPanel
+ *
+ * YouTube / Netflix-style unified settings panel.
+ * A single ⚙️ gear button opens a multi-level panel:
+ *
+ *   Root:
+ *     Quality  →  Auto / 1080p / 720p …
+ *     Speed    →  0.25× … 2×
+ *     Audio    →  English / Türkçe …  (hidden when no tracks)
+ *     Subtitles→  Off / EN / TR …    (always shown)
+ *
+ * Each row navigates to a submenu. Back arrow returns to root.
+ * Selecting an item applies the change and closes the panel.
+ */
+/** Customize the visual appearance of the SettingsPanel. */
+export declare interface SettingsPanelTheme {
+    /** Panel background. Default: 'rgba(12, 12, 20, 0.97)' */
+    background?: string;
+    /** Panel border color. Default: 'rgba(255,255,255,0.1)' */
+    borderColor?: string;
+    /** Main text color. Default: '#fff' */
+    textColor?: string;
+    /**
+     * Accent/highlight color for selected items (hex preferred).
+     * Default: '#6366f1'
+     */
+    accentColor?: string;
+    /** Row font size. Default: '13.5px' */
+    fontSize?: string;
+}
+
+export declare function SkipBackwardButton({ seconds, iconSize, hoverBackground, icon, }: SkipBackwardButtonProps): JSX.Element | null;
+
+declare interface SkipBackwardButtonProps {
+    seconds?: number;
+    /** Icon size in px. Default: 24 */
+    iconSize?: number;
+    /** Hover background color. Pass false to disable hover background. */
+    hoverBackground?: string | boolean;
+    /** Custom icon (replaces default skip backward SVG). */
+    icon?: React.ReactNode;
+}
+
+export declare function SkipForwardButton({ seconds, iconSize, hoverBackground, icon, }: SkipForwardButtonProps): JSX.Element | null;
+
+declare interface SkipForwardButtonProps {
+    seconds?: number;
+    /** Icon size in px. Default: 24 */
+    iconSize?: number;
+    /** Hover background color. Pass false to disable hover background. */
+    hoverBackground?: string | boolean;
+    /** Custom icon (replaces default skip forward SVG). */
+    icon?: React.ReactNode;
+}
+
+export declare function SkipIntroButton({ introOutro }: SkipIntroButtonProps): JSX.Element | null;
+
+declare interface SkipIntroButtonProps {
+    introOutro?: IntroOutro;
+}
+
+export declare class StallDetector {
+    private video;
+    private events;
+    private options;
+    private timer;
+    private lastTime;
+    private stallDuration;
+    private attempts;
+    private isRunning;
+    constructor(video: HTMLVideoElement, events: PlayronEventEmitter, options?: StallDetectorOptions);
+    start(): void;
+    stop(): void;
+    destroy(): void;
+    private reset;
+    private tick;
+    private recover;
+}
+
+export declare interface StallDetectorOptions {
+    /** Poll interval in ms (default: 500) */
+    pollInterval?: number;
+    /** Seconds of no-progress before first recovery attempt (default: 3) */
+    stallThreshold?: number;
+    /** Called when quality downgrade is needed (attempt 3) */
+    onQualityDowngrade?: () => void;
+}
+
+declare class StateManager {
+    private state;
+    private listeners;
+    private history;
+    private maxHistorySize;
+    constructor(initialState?: Partial<PlayerState>);
+    /**
+     * Başlangıç durumunu oluştur
+     */
+    private getInitialState;
+    /**
+     * Durumu güncelle
+     */
+    updateState(updates: Partial<PlayerState>): void;
+    /**
+     * Mevcut durumu döndür
+     */
+    getState(): PlayerState;
+    /**
+     * Belirli bir durum değerini al
+     */
+    get<K extends keyof PlayerState>(key: K): PlayerState[K];
+    /**
+     * Belirli bir durum değerini ayarla
+     */
+    set<K extends keyof PlayerState>(key: K, value: PlayerState[K]): void;
+    /**
+     * Durum değişiklik dinleyicisi ekle
+     */
+    subscribe(callback: (state: PlayerState) => void): void;
+    /**
+     * Durum değişiklik dinleyicisini kaldır
+     */
+    unsubscribe(callback: (state: PlayerState) => void): void;
+    /**
+     * Durum değişikliklerini bildir
+     */
+    private notifyListeners;
+    /**
+     * Durumu geçmişe ekle
+     */
+    private addToHistory;
+    /**
+     * Önceki duruma geri dön
+     */
+    undo(): boolean;
+    /**
+     * Durumu sıfırla
+     */
+    reset(): void;
+    /**
+     * Durumu belirli bir değere ayarla
+     */
+    setState(newState: PlayerState): void;
+    /**
+     * Durum geçmişini temizle
+     */
+    clearHistory(): void;
+    /**
+     * Durum geçmişini döndür
+     */
+    getHistory(): PlayerState[];
+    /**
+     * Belirli bir durumda olup olmadığını kontrol et
+     */
+    isInState(predicate: (state: PlayerState) => boolean): boolean;
+    /**
+     * Durum değişikliklerini filtrele
+     */
+    subscribeToChanges<K extends keyof PlayerState>(keys: K[], callback: (changes: Pick<PlayerState, K>) => void): void;
+    /**
+     * Durumu snapshot olarak al
+     */
+    createSnapshot(): PlayerState;
+    /**
+     * Snapshot'tan durumu geri yükle
+     */
+    restoreFromSnapshot(snapshot: PlayerState): void;
+    /**
+     * Durum istatistiklerini döndür
+     */
+    getStats(): {
+        totalListeners: number;
+        historySize: number;
+        maxHistorySize: number;
+        lastUpdate: Date;
+    };
+}
+
+export declare class StreamDetector {
+    /**
+     * Main detection method
+     * Fetches and analyzes manifest to determine stream type
+     */
+    detectStream(url: string): Promise<StreamInfo>;
+    /**
+     * Pre-check basic browser capability using MediaSource.isTypeSupported
+     * to quickly determine if we should fall back to an external library.
+     */
+    private preCheckCapability;
+    /**
+     * Detect protocol from URL
+     */
+    private detectProtocol;
+    /**
+     * Detect HLS stream type
+     */
+    private detectHLS;
+    /**
+     * Detect DASH stream type
+     */
+    private detectDASH;
+    /**
+     * Progressive download (MP4, WebM, etc.)
+     * Always VOD
+     */
+    private detectProgressive;
+    /**
+     * Fetch manifest from URL
+     */
+    private fetchManifest;
+    /**
+     * Extract #EXT-X-TARGETDURATION
+     */
+    private extractTargetDuration;
+    /**
+     * Extract #EXT-X-MEDIA-SEQUENCE
+     */
+    private extractMediaSequence;
+    /**
+     * Quick sync detection (without fetching)
+     * Useful for initial UI setup
+     */
+    quickDetect(url: string): {
+        type: StreamType;
+        protocol: 'hls' | 'dash' | 'progressive' | 'unknown';
+        isEngineSupported: boolean;
+    };
+}
+
+/**
+ * Singleton instance
+ */
+export declare const streamDetector: StreamDetector;
+
+export declare interface StreamInfo {
+    type: StreamType;
+    protocol: 'hls' | 'dash' | 'progressive' | 'unknown';
+    isDynamic: boolean;
+    hasDVR: boolean;
+    targetDuration?: number;
+    mediaSequence?: number;
+    /**
+     * Pre-check capability.
+     * True if basic codecs (avc1/mp4a) are supported, preventing full playback engine load if not.
+     */
+    isEngineSupported: boolean;
+}
+
+/**
+ * Stream Type Detector
+ * Automatically detects if a stream is VOD or LIVE by analyzing the manifest
+ */
+export declare type StreamType = 'vod' | 'live' | 'unknown';
+
+export declare function TheaterModeButton(): JSX.Element;
+
+/**
+ * ThumbnailManager — WebVTT storyboard thumbnail loader.
+ *
+ * Accepts a thumbnail VTT URL where each cue maps a time range to
+ * an image URL (optionally with a #xywh media fragment for sprite sheets).
+ *
+ * VTT format example:
+ *   WEBVTT
+ *
+ *   00:00:00.000 --> 00:00:05.000
+ *   https://cdn.example.com/thumbs.jpg#xywh=0,0,160,90
+ *
+ *   00:00:05.000 --> 00:00:10.000
+ *   https://cdn.example.com/thumbs.jpg#xywh=160,0,160,90
+ */
+export declare interface ThumbnailCue {
+    startTime: number;
+    endTime: number;
+    /** Full image URL (without fragment) */
+    url: string;
+    /** Sprite x offset (0 when whole image) */
+    x: number;
+    /** Sprite y offset (0 when whole image) */
+    y: number;
+    /** Sprite/image width (0 = full image width) */
+    w: number;
+    /** Sprite/image height (0 = full image height) */
+    h: number;
+}
+
+export declare class ThumbnailManager {
+    private cues;
+    private loaded;
+    /** Fetch and parse a WebVTT thumbnail track. */
+    load(vttUrl: string): Promise<void>;
+    /** Return the thumbnail cue covering the given time, or null. */
+    getThumbnailAt(time: number): ThumbnailCue | null;
+    isLoaded(): boolean;
+    destroy(): void;
+    private parseVtt;
+    private parseCueLine;
+    private resolveUrl;
+    private parseTime;
+}
+
+export declare function TimeDisplay({ className, ...props }: TimeDisplayProps): JSX.Element;
+
+declare interface TimeDisplayProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+
+/**
+ * Timeline Marker Configuration
+ */
+declare interface TimelineConfig {
+    /** Enable timeline markers */
+    enabled?: boolean;
+    /** Timeline events */
+    events?: TimelineEvent[];
+    /** Marker size in px */
+    markerSize?: number;
+    /** Show tooltip on hover */
+    showTooltip?: boolean;
+    /** Auto-parse from raw event data (e.g., sports API) */
+    parser?: (rawEvents: any[]) => TimelineEvent[];
+}
+
+/**
+ * Timeline Marker Types
+ * For rich video players with interactive event markers (sports, live events, etc.)
+ */
+export declare interface TimelineEvent {
+    /** Event timestamp in seconds */
+    time: number;
+    /** Event type (goal, yellow, red, substitution, kickoff, etc.) */
+    type: string;
+    /** Optional custom icon (emoji or SVG) */
+    icon?: string;
+    /** Optional custom color */
+    color?: string;
+    /** Label for tooltip */
+    label?: string;
+    /** Any additional metadata */
+    metadata?: Record<string, any>;
+}
+
+export declare function useMobileGestures({ player, skipSec }: UseMobileGesturesOptions): {
+    onTouchStart: (e: React.TouchEvent<HTMLDivElement>) => void;
+    onTouchMove: (_e: React.TouchEvent<HTMLDivElement>) => void;
+    onTouchEnd: () => void;
+    gestureHint: GestureHint | null;
+};
+
+declare interface UseMobileGesturesOptions {
+    player: PlayerCore | null;
+    skipSec?: number;
+}
+
+/**
+ * Get player instance
+ * Use this when you need access to the full PlayerCore instance
+ */
+export declare function usePlayer(): PlayerCore;
+
+/**
+ * Get player methods (stable reference, won't cause re-renders)
+ * Use this when you only need to call player methods
+ */
+export declare function usePlayerMethods(): PlayerMethods;
+
+/**
+ * Get player state (reactive)
+ * Component will re-render when state changes
+ *
+ * @param selector - Optional selector to get only specific state values
+ * @returns Player state or selected value
+ */
+export declare function usePlayerState(): PlayerState;
+
+export declare function usePlayerState<T>(selector: (state: PlayerState) => T): T;
+
+export declare interface VanillaPlayerConfig {
+    container: string | HTMLElement;
+    src: string;
+    width?: string | number;
+    height?: string | number;
+    autoplay?: boolean;
+    muted?: boolean;
+    poster?: string;
+    className?: string;
+    controls?: boolean;
+}
+
+declare class VideoEngine {
+    private videoElement;
+    private isPlaying;
+    private isMuted;
+    private volume;
+    private playbackRate;
+    private currentTime;
+    private duration;
+    constructor(videoElement: HTMLVideoElement);
+    /**
+     * Video element'inin native event'lerini dinle
+     */
+    private setupEventListeners;
+    /**
+     * Video'yu başlat
+     */
+    private initializeVideo;
+    /**
+     * Play event'ini gönder
+     */
+    private emitPlayEvent;
+    /**
+     * Pause event'ini gönder
+     */
+    private emitPauseEvent;
+    /**
+     * Volume change event'ini gönder
+     */
+    private emitVolumeChangeEvent;
+    /**
+     * Mute event'ini gönder
+     */
+    private emitMuteEvent;
+    /**
+     * Video'yu oynat
+     */
+    play(): Promise<void>;
+    /**
+     * Video'yu duraklat
+     */
+    pause(): void;
+    /**
+     * Video'yu sessize al/aç
+     */
+    toggleMute(): void;
+    /**
+     * Ses seviyesini ayarla
+     */
+    setVolume(volume: number): void;
+    /**
+     * Belirli bir zamana git
+     */
+    seekTo(time: number): void;
+    /**
+     * Oynatma hızını ayarla
+     */
+    setPlaybackRate(rate: number): void;
+    /**
+     * Video source'unu değiştir
+     */
+    setSource(src: string): void;
+    /**
+     * Video poster'ını ayarla
+     */
+    setPoster(poster: string): void;
+    /**
+     * Video boyutlarını ayarla
+     */
+    setDimensions(width: number | string, height: number | string): void;
+    /**
+     * Mevcut durumu döndür
+     */
+    getState(): {
+        isPlaying: boolean;
+        isMuted: boolean;
+        volume: number;
+        playbackRate: number;
+        currentTime: number;
+        duration: number;
+        src: string;
+        poster: string;
+    };
+    /**
+     * Video element'ini döndür
+     */
+    getVideoElement(): HTMLVideoElement | null;
+    /**
+     * VideoEngine'ı temizle
+     */
+    destroy(): void;
+}
+
+/**
+ * Native HTML5 Video Element Event Types
+ *
+ * This enum provides type-safe access to all native video events.
+ * Using these constants prevents typos and improves maintainability.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/video#events
+ */
+declare const VideoEventType: {
+    readonly PLAY: "play";
+    readonly PAUSE: "pause";
+    readonly PLAYING: "playing";
+    readonly ENDED: "ended";
+    readonly SEEKING: "seeking";
+    readonly SEEKED: "seeked";
+    readonly WAITING: "waiting";
+    readonly VOLUME_CHANGE: "volumechange";
+    readonly TIME_UPDATE: "timeupdate";
+    readonly DURATION_CHANGE: "durationchange";
+    readonly LOADED_METADATA: "loadedmetadata";
+    readonly LOADED_DATA: "loadeddata";
+    readonly CAN_PLAY: "canplay";
+    readonly CAN_PLAY_THROUGH: "canplaythrough";
+    readonly RATE_CHANGE: "ratechange";
+    readonly LOAD_START: "loadstart";
+    readonly PROGRESS: "progress";
+    readonly SUSPEND: "suspend";
+    readonly ABORT: "abort";
+    readonly STALLED: "stalled";
+    readonly ERROR: "error";
+    readonly EMPTIED: "emptied";
+    readonly RESIZE: "resize";
+};
+
+declare type VideoEventType = typeof VideoEventType[keyof typeof VideoEventType];
+export { VideoEventType }
+export { VideoEventType as VideoEventTypeType }
+
+declare type VirtusEventCallback<T extends VirtusEventType> = (data: VirtusEventMap[T]) => void;
+
+/**
+ * PlayronEventEmitter - Unified event system for player
+ * Provides type-safe, consistent event handling across the player
+ */
+export declare type VirtusEventMap = {
+    'play': {
+        timestamp: number;
+    };
+    'pause': {
+        timestamp: number;
+    };
+    'ended': {
+        timestamp: number;
+    };
+    'timeupdate': {
+        currentTime: number;
+        duration: number;
+    };
+    'seeking': {
+        targetTime: number;
+    };
+    'seeked': {
+        currentTime: number;
+    };
+    'volumechange': {
+        volume: number;
+        isMuted: boolean;
+    };
+    'ratechange': {
+        playbackRate: number;
+    };
+    'loadedmetadata': {
+        duration: number;
+        videoWidth: number;
+        videoHeight: number;
+    };
+    'buffering': {
+        isBuffering: boolean;
+    };
+    'qualitychange': {
+        from: string;
+        to: string;
+    };
+    'audiotrackchange': {
+        from: string;
+        to: string;
+    };
+    'fullscreenchange': {
+        isFullscreen: boolean;
+    };
+    'pipchange': {
+        isPip: boolean;
+    };
+    'theatermodechange': {
+        isTheaterMode: boolean;
+    };
+    'chapterchange': {
+        chapterId: string;
+        title: string;
+    };
+    'skipintro': {
+        skipped: boolean;
+        time: number;
+    };
+    'skipoutro': {
+        skipped: boolean;
+        time: number;
+    };
+    'streamTypeDetected': {
+        type: 'vod' | 'live' | 'unknown';
+        info: any;
+    };
+    /** Fired immediately after manifest is parsed and tracks/qualities are populated. */
+    'tracksready': {
+        hasQualities: boolean;
+        hasAudioTracks: boolean;
+        hasSubtitleTracks: boolean;
+    };
+    /** Fires when AirPlay device availability or connection state changes */
+    'airplaychange': {
+        isAvailable: boolean;
+        isActive: boolean;
+    };
+    /** Fires when Chromecast device availability or session state changes */
+    'castchange': {
+        isAvailable: boolean;
+        isActive: boolean;
+        state: 'not_connected' | 'connecting' | 'connected' | 'unavailable';
+    };
+    /** Periodic latency update — only emitted during live playback (~1s interval) */
+    'livelatencyupdate': {
+        latency: number;
+        isAtLiveEdge: boolean;
+        liveEdgeTime: number;
+    };
+    'drm:keysystem': {
+        keySystem: string;
+    };
+    'drm:ready': {
+        keySystem?: string;
+    };
+    /** Emitted when playback freezes (currentTime stops advancing) */
+    'stall': {
+        duration: number;
+        attempt: number;
+    };
+    /** Emitted when a stall is resolved by the recovery mechanism */
+    'stallrecovered': {
+        duration: number;
+        method: 'seek' | 'quality';
+    };
+    'error': {
+        code: string;
+        message: string;
+        details?: any;
+    };
+    'warning': {
+        code: string;
+        message: string;
+    };
+    'statechange': {
+        state: any;
+    };
+    'ready': {
+        player: any;
+    };
+    'destroy': {
+        timestamp: number;
+    };
+};
+
+export declare type VirtusEventType = keyof VirtusEventMap;
+
+export declare interface VolumeChangeEvent extends PlayerEvent {
+    type: 'volumechange';
+    data: {
+        volume: number;
+        muted: boolean;
+    };
+}
+
+export declare function VolumeControl({ sliderDirection, theme, iconSize, hoverBackground }: VolumeControlProps): JSX.Element;
+
+declare interface VolumeControlProps {
+    /** Direction the volume slider expands from the mute button. Default: 'right' */
+    sliderDirection?: VolumeSliderDirection;
+    /** Visual theme overrides. */
+    theme?: VolumeControlTheme;
+    /** Mute button icon size in px. Default: 20 */
+    iconSize?: number;
+    /** Hover background color for the mute button. Pass false to disable. */
+    hoverBackground?: string | boolean;
+}
+
+/** Customize the visual appearance of the VolumeControl. */
+export declare interface VolumeControlTheme {
+    /** Slider popup panel background. Default: 'rgba(10, 10, 20, 0.88)' */
+    sliderBackground?: string;
+    /** Panel border color. Default: 'rgba(255,255,255,0.1)' */
+    borderColor?: string;
+    /** Mute button background. Default: 'rgba(255,255,255,0.1)' */
+    buttonBackground?: string;
+    /** Mute button hover background. Default: 'rgba(255,255,255,0.2)' */
+    buttonHoverBackground?: string;
+    /** Icon / SVG fill color. Default: '#fff' */
+    iconColor?: string;
+    /** Track (unfilled portion) color. Default: 'rgba(255,255,255,0.3)' */
+    trackColor?: string;
+    /** Fill (volume level) color. Default: '#3b82f6' */
+    fillColor?: string;
+    /** Knob handle color. Default: '#fff' */
+    handleColor?: string;
+}
+
+export declare type VolumeSliderDirection = 'right' | 'left' | 'top' | 'bottom';
+
+export { }