import { default as default_2 } from 'react';
import { JSX } from 'react/jsx-runtime';
import { ReactNode } from 'react';

export declare type AnalyticsCallback = (event: AnalyticsEvent) => void;

export declare interface AnalyticsEvent {
    eventType: 'play' | 'pause' | 'seek' | 'ended' | 'complete' | 'buffering_start' | 'buffering_end' | 'stall' | 'quality_change' | 'audio_track_change' | 'volume_change' | 'speed_change' | 'subtitle_change' | 'mute' | 'fast_forward' | 'fast_backward' | 'key_moments' | 'pip_toggle' | 'fullscreen_enter' | 'fullscreen_exit' | 'cast_start' | 'cast_stop' | 'error' | 'network_error' | 'session_start' | 'video_loaded' | 'first_quartile' | 'midpoint' | 'third_quartile' | 'heartbeat' | 'watch_progress' | 'streaming_time';
    timestamp: number;
    currentTime: number;
    duration: number;
    contentTime?: number;
    contentDuration?: number;
    bitrate?: number;
    rendition?: string;
    fromRendition?: string;
    volume?: number;
    speed?: number;
    errorMessage?: string;
    errorCode?: number;
    isRecoverable?: boolean;
    sessionId?: string;
    videoId?: string;
    deviceType?: string;
    networkType?: string;
    watchPercentage?: number;
    totalWatchTime?: number;
    streamingTime?: number;
    adWatchTime?: number;
    bufferingCount?: number;
    totalBufferingTime?: number;
    seekFrom?: number;
    seekTo?: number;
    isMuted?: boolean;
    skipSeconds?: number;
    momentTitle?: string;
    momentTime?: number;
    pipState?: 'entered' | 'exited';
    audioTrack?: string;
    subtitleLanguage?: string;
    subtitleEnabled?: boolean;
    isAutoSwitch?: boolean;
}

declare interface AnalyticsSessionSnapshot {
    sessionId: string;
    sessionStartFired: boolean;
    totalWatchTime: number;
    streamingTime: number;
    adWatchTime: number;
    bufferingCount: number;
    totalBufferingTime: number;
    milestonesHit: string[];
}

export declare function BossVideoPlayer({ playerKey, src, subtitles, licenseKey, themeColor, adAccentColor: adAccentColorProp, playerThemeColor: playerThemeColorProp, chapterTitle: chapterTitleProp, enableFullscreen: enableFullscreenProp, enableThumbnailPreview: enableThumbnailPreviewProp, proxyDomains, apiBaseUrl, adTrackingUrl, overlayAdUrl, videoId: videoIdProp, title, artworkUrl, watermark, autoplay, muted, autoFullscreen, enableControls, enableSkipAd, skipAdAfterSeconds, chaptersDisplayMode, keyMoments: propKeyMoments, chapters: propChapters, keyMomentsTray, keyMomentsPosition, defaultKeyMomentsOpen, enableKeyMoments, onKeyMomentsToggle, volumeControlType, subtitleStyle, drmConfig, onAnalyticsEvent, delegate, onKeyMomentsLoaded, initialTime, onTimeUpdate, skipMarkers, introStartTime, introEndTime, hasNextEpisode, outroStartTime, nextEpisodeLabel, onNextEpisode, nextEpisodeAutoAdvanceSeconds, nextEpisodeThumbnailUrl, featureOverrides, enableQuality, enableSources, }: BossVideoPlayerProps): JSX.Element;

export declare interface BossVideoPlayerProps {
    playerKey: string;
    src: string | SourceItem[];
    enableSources?: boolean;
    subtitles?: SubtitleTrack[];
    licenseKey?: string;
    themeColor?: string;
    adAccentColor?: string | null;
    playerThemeColor?: string | null;
    chapterTitle?: string;
    enableFullscreen?: boolean;
    enableThumbnailPreview?: boolean;
    proxyDomains?: string;
    apiBaseUrl?: string;
    adTrackingUrl?: string;
    overlayAdUrl?: string;
    videoId?: string;
    title?: string;
    artworkUrl?: string;
    watermark?: string;
    autoplay?: boolean;
    muted?: boolean;
    autoFullscreen?: boolean;
    enableControls?: boolean;
    enableSkipAd?: boolean;
    skipAdAfterSeconds?: number;
    chaptersDisplayMode?: "strip" | "panel";
    keyMoments?: KeyMoment[];
    chapters?: Chapter[];
    keyMomentsTray?: "bottom" | "right" | "strip" | "panel" | "none" | boolean;
    keyMomentsPosition?: "bottom" | "right";
    defaultKeyMomentsOpen?: boolean;
    enableKeyMoments?: boolean;
    onKeyMomentsToggle?: (isOpen: boolean) => void;
    volumeControlType?: "slider" | "button";
    subtitleStyle?: SubtitleStyle;
    drmConfig?: DRMConfig;
    onAnalyticsEvent?: (event: AnalyticsEvent) => void;
    delegate?: PlayerDelegate;
    onKeyMomentsLoaded?: (keyMoments: Chapter[]) => void;
    initialTime?: number;
    onTimeUpdate?: (currentTime: number) => void;
    skipMarkers?: SkipMarker[];
    introStartTime?: number;
    introEndTime?: number;
    hasNextEpisode?: boolean;
    outroStartTime?: number;
    nextEpisodeLabel?: string;
    onNextEpisode?: () => void;
    nextEpisodeAutoAdvanceSeconds?: number;
    nextEpisodeThumbnailUrl?: string;
    enableQuality?: boolean;
    featureOverrides?: Partial<Record<string, boolean>>;
}

declare interface CastCustomData {
    headers?: Record<string, string>;
    externalSubtitles?: Array<{
        id: string;
        label: string;
        language: string;
        src: string;
    }>;
    selectedSubtitle?: CastTrackRef | null;
    adTrackingUrl?: string;
    themeColor?: string;
    adAccentColor?: string;
}

declare interface CastTrackRef {
    id?: string;
    language?: string;
    label?: string;
}

export declare interface Chapter {
    title: string;
    startTime: number;
    endTime: number;
    thumbnail?: string;
    thumbnailUrl?: string;
    thumbnailCrop?: ThumbnailCrop;
    description?: string;
}

export declare function createPlayer(container: HTMLElement, props: PlayerProps): PlayerInstance;

export declare const DEFAULT_AD_ACCENT_COLOR = "#ead81a";

export declare const DEFAULT_CHAPTER_TITLE = "Key Moments";

export declare const DEFAULT_PLAYER_THEME_COLOR = "#ffffff";

export declare interface DRMConfig {
    widevineLicenseUrl?: string;
    playreadyLicenseUrl?: string;
    fairplayLicenseUrl?: string;
    authToken?: string;
    authHeader?: string;
    allowedDomains?: string[];
    watermarkText?: string;
}

export declare function endSession(playerKey: string, sessionId: string, currentTime?: number, duration?: number, apiBase?: string): Promise<void>;

export declare function ErrorScreen({ offline, title, subtitle, onRetry, icon, }: ErrorScreenProps): JSX.Element;

declare interface ErrorScreenProps {
    offline?: boolean;
    title?: string;
    subtitle?: string;
    onRetry: () => void;
    icon?: ReactNode;
}

export declare type FeatureFlags = {
    m3u8_playback: boolean;
    subtitle_support: boolean;
    playback_speed: boolean;
    airplay: boolean;
    chromecast: boolean;
    picture_in_picture: boolean;
    multiple_resolution: boolean;
    multiple_audio: boolean;
    key_moments: boolean;
    drm_protection: boolean;
    screen_recording_prevention: boolean;
    signal_strength: boolean;
    ad_support: boolean;
    skip_segments: boolean;
};

declare interface IAnalyticsModule {
    getSessionSnapshot(): AnalyticsSessionSnapshot;
    registerCallback(callback: AnalyticsCallback): void;
    setAdBreaks(adBreaks: Array<{
        startTime: number;
        endTime: number;
    }>): void;
    track(eventType: AnalyticsEvent['eventType'], videoEl: HTMLVideoElement, extra?: Partial<AnalyticsEvent>): void;
    startHeartbeat(videoEl: HTMLVideoElement, getExtra: () => Partial<AnalyticsEvent>, watchProgressInterval?: number): void;
    stopHeartbeat(): void;
    setBuffering(isBuffering: boolean, videoEl: HTMLVideoElement, getExtra: () => Partial<AnalyticsEvent>): void;
    setAdBreak(inAdBreak: boolean, videoEl: HTMLVideoElement): void;
}

declare interface ICastingModule {
    getCastingState(): {
        isCasting: boolean;
        deviceName: string;
    };
    getRemoteState(): RemoteCastState | null;
    isSessionActive(): boolean;
    getReceiverContentId(): string | null;
    loadMedia(src: string, currentTime: number, title?: string, customData?: CastCustomData): Promise<boolean>;
    syncMedia(src: string, currentTime: number, title?: string, customData?: CastCustomData): Promise<boolean>;
    requestSession(currentSrc: string, currentTime: number, title?: string, customData?: CastCustomData): Promise<void>;
    stopCasting(): void;
    destroy(): void;
    remotePlayPause(): void;
    remoteSeek(time: number): void;
    remoteSetVolume(volume: number): void;
    remoteSetMute(muted: boolean): void;
    remoteSetPlaybackRate(rate: number): void;
    remoteSetSubtitle(track: CastTrackRef | null): void;
    remoteSetAudioTrack(track: CastTrackRef): void;
    remoteSkipAd(toTime: number): void;
    onCastStateChange(callback: (isCasting: boolean, deviceName: string) => void): void;
    onRemoteStateChange(callback: (state: RemoteCastState) => void): void;
    requestAirPlaySession(videoElement: HTMLVideoElement): void;
    stopAirPlay(videoElement: HTMLVideoElement): void;
    isAirPlayAvailable(): boolean;
    checkCastState(): void;
}

declare interface IChaptersModule extends IKeyMomentsModule {
}

declare interface IDRMModule {
    validateDomain(currentDomain: string): boolean;
    getAuthToken(): string | undefined;
    getAuthHeader(): string | undefined;
    getRequestHeaders(): Record<string, string>;
    setupWatermark(container: HTMLElement): void;
    removeWatermark(): void;
    isDRMProtected(): boolean;
    getDRMDetails(): {
        widevine: string | null;
        playready: string | null;
        fairplay: string | null;
        authTokenPresent: boolean;
        allowedDomains: string[];
    };
}

declare interface IKeyMomentsModule {
    setKeyMoments(keyMoments: KeyMoment[]): void;
    getKeyMoments(): KeyMoment[];
    getCurrentMoment(currentTime: number): {
        keyMoment: KeyMoment | null;
        index: number;
    };
    updateTime(currentTime: number): void;
    onMomentChange(callback: (keyMoment: KeyMoment | null, index: number) => void): void;
    setChapters(chapters: KeyMoment[]): void;
    getChapters(): KeyMoment[];
    getCurrentChapter(currentTime: number): {
        chapter: KeyMoment | null;
        index: number;
    };
    onChapterChange(callback: (chapter: KeyMoment | null, index: number) => void): void;
}

export declare function initSdk(playerKey: string, apiBase?: string, options?: SdkInitOptions): Promise<SdkInitResponse>;

declare interface ISubtitlesModule {
    getTracks(): SubtitleTrack[];
    getActiveTrackId(): string;
    setHlsTracks(hlsTracks: SubtitleTrack[]): void;
    addTrack(track: SubtitleTrack): void;
    onTrackSwitch(callback: (track: SubtitleTrack | null) => void): void;
    setCustomSubtitleText(text: string): void;
    setActiveTrack(trackId: string): Promise<void>;
    updateTime(currentTime: number): void;
    onSubtitleChange(callback: (text: string) => void): void;
    getAuthHeaders?: () => Record<string, string>;
}

declare interface IThumbnailsModule {
    getThumbnail(time: number): {
        url: string;
        x: number;
        y: number;
        width: number;
        height: number;
    } | null;
    hasThumbnails(): boolean;
    getSpriteSize(): {
        width: number;
        height: number;
    } | null;
}

export declare type KeyMoment = Chapter;

export declare interface NormalizedSkipMarker {
    id: string;
    title?: string;
    start: number;
    end: number;
}

export declare function normalizeSkipMarkers(skipMarkers?: SkipMarker[], introStartTime?: number, introEndTime?: number): NormalizedSkipMarker[];

export declare function parseTimecode(value: number | string | null | undefined): number | null;

export declare interface PlayerDelegate {
    playerDidStartPlaying?(startTime: number, autoplay: boolean): void;
    playerDidResumePlaying?(resumedAt: number): void;
    playerDidPause?(pausedAt: number): void;
    playerDidFinishPlaying?(finishedAt: number, watchDuration: number): void;
    playerDidDismiss?(dismissedAt: number, watchDuration: number): void;
    playerDidStartSeeking?(fromTime: number): void;
    playerDidFinishSeeking?(fromTime: number, toTime: number, seekDuration: number): void;
    playerDidUpdateCurrentTime?(currentTime: number, duration: number): void;
    playerDidStartBuffering?(startedAt: number): void;
    playerDidFinishBuffering?(endedAt: number): void;
    playerDidChangeQuality?(fromQuality: string | undefined, toQuality: string, isAutoSwitch: boolean): void;
    playerDidChangeSubtitle?(fromSubtitle: string | undefined, toSubtitle: string): void;
    playerDidDisableSubtitle?(disabledSubtitle: string | undefined): void;
    playerDidChangeAudioTrack?(fromAudioTrack: string | undefined, toAudioTrack: string): void;
    playerDidChangePlaybackSpeed?(fromSpeed: number, toSpeed: number): void;
    playerDidEnterFullscreen?(orientation?: string): void;
    playerDidExitFullscreen?(orientation?: string): void;
    playerDidSelectKeyMoment?(chapterId: string | undefined, chapterTitle: string, fromTime: number, toTime: number): void;
    playerDidEnterPictureInPicture?(enteredAt?: number): void;
    playerDidExitPictureInPicture?(exitedAt?: number): void;
    playerDidEncounterPlaybackError?(errorCode: string, message: string, isRecoverable: boolean): void;
    playerDidEncounterNetworkError?(statusCode: number, message: string, isRecoverable: boolean): void;
}

export declare interface PlayerEventPayload {
    eventType: string;
    sessionId: string;
    currentTime: number;
    videoId?: string;
    videoTitle?: string;
    [key: string]: unknown;
}

export declare interface PlayerInstance {
    update(props: Partial<PlayerProps>): void;
    destroy(): void;
}

export declare interface PlayerProps extends BossVideoPlayerProps {
}

export declare interface PlayerSDKOptions {
    container: HTMLElement;
    src: string;
    autoplay?: boolean;
    muted?: boolean;
    controls?: boolean;
    chapters?: Chapter[];
    keyMoments?: KeyMoment[];
    subtitles?: SubtitleTrack[];
    thumbnails?: ThumbnailConfig;
    drm?: DRMConfig;
    analyticsCallback?: AnalyticsCallback;
    videoId?: string;
    title?: string;
    artworkUrl?: string;
    videoElement?: HTMLVideoElement;
    analyticsSessionSeed?: AnalyticsSessionSnapshot;
    watchProgressInterval?: number;
    themeColor?: string;
    watermark?: string;
    urlTransformer?: (url: string) => string;
}

declare interface RemoteCastState {
    currentTime: number;
    duration: number;
    isPaused: boolean;
    volumeLevel: number;
    isMuted: boolean;
}

export declare function resolveThemeColor(value: string | null | undefined, fallback: string): string;

export declare type SdkInitChapterMarkersConfig = {
    title?: string | null;
    trayPosition?: string | null;
};

export declare type SdkInitConfig = {
    chapterMarkers?: SdkInitChapterMarkersConfig;
    adAccentColor?: string | null;
    playerThemeColor?: string | null;
    aspectRatio?: boolean;
    fullscreen?: boolean;
    orientation?: boolean;
    thumbnailPreview?: boolean;
};

export declare type SdkInitData = {
    tenantId: string;
    features: SdkInitFeatures;
    config?: SdkInitConfig;
    heartbeatIntervalSeconds?: number;
    expiresAt?: string;
    validForSeconds?: number;
};

export declare type SdkInitFeatures = {
    subtitles: boolean;
    ads: boolean;
    chapterMarkers: boolean;
    skipSegments?: boolean;
    playbackSpeed?: boolean;
    chromecast?: boolean;
    airplay?: boolean;
    pictureInPicture?: boolean;
    multipleResolution?: boolean;
    multipleAudio?: boolean;
    drmProtection?: boolean;
    screenRecordingPrevention?: boolean;
    signalStrength?: boolean;
    [key: string]: boolean | undefined;
};

export declare interface SdkInitOptions {
    videoUrl?: string;
}

export declare type SdkInitResponse = {
    result: {
        data: SdkInitData;
        metadata: Record<string, unknown>;
    };
};

export declare type SdkPackage = {
    package: string;
    is_active: boolean;
    features: FeatureFlags;
    limits: {
        streaming_minutes: number;
    };
};

export declare function sendEvent(playerKey: string, payload: PlayerEventPayload, apiBase?: string): Promise<void>;

export declare function sendHeartbeat(playerKey: string, sessionId: string, currentTime: number, duration: number, apiBase?: string): Promise<void>;

export declare interface SkipMarker {
    title?: string;
    start: number | string;
    end: number | string;
}

export declare interface SourceItem {
    label: string;
    url: string;
}

export declare function startSession(playerKey: string, options: StartSessionOptions, apiBase?: string): Promise<void>;

export declare interface StartSessionOptions {
    sessionId: string;
    videoId?: string;
    videoTitle?: string;
    videoUrl?: string;
    contentDurationSec?: number;
}

export declare interface SubtitleStyle {
    size?: "small" | "medium" | "large";
    background?: "none" | "dim" | "solid";
    color?: string;
}

declare interface SubtitleStyle_2 {
    size?: 'small' | 'medium' | 'large';
    background?: 'none' | 'dim' | 'solid';
    color?: string;
}

export declare interface SubtitleTrack {
    id: string;
    label: string;
    lang: string;
    src?: string;
    isDefault?: boolean;
    cues?: Array<{
        startTime: number;
        endTime: number;
        text: string;
    }>;
    isHls?: boolean;
    hlsTrackId?: number;
    isNative?: boolean;
    nativeTrackIndex?: number;
}

export declare interface ThumbnailConfig {
    spriteUrl: string;
    tileWidth: number;
    tileHeight: number;
    columns: number;
    rows: number;
    interval: number;
    totalCount: number;
}

export declare interface ThumbnailCrop {
    x: number;
    y: number;
    width: number;
    height: number;
}

export declare class VideoPlayerSDK {
    private options;
    private videoElement;
    private hlsInstance;
    private dashInstance;
    private activeQuality;
    private qualityLevels;
    private nativeMasterSrc;
    private nativeVariantUris;
    private nativeQualityGeneration;
    analytics: IAnalyticsModule;
    keyMoments: IKeyMomentsModule;
    chapters: IChaptersModule;
    subtitles: ISubtitlesModule;
    drm: IDRMModule;
    casting: ICastingModule;
    thumbnails: IThumbnailsModule;
    private hlsSubtitleCues;
    private hlsActiveSubtitleKey;
    private audioTrackList;
    private adBreaks;
    private isAdBreak;
    private adBreaksFromAvails;
    private adBreakDiscoverySettled;
    private retiredAdBreakStarts;
    private contentPlaybackRate;
    private networkErrorRetries;
    private mediaErrorRecovered;
    private static readonly MAX_NETWORK_RETRIES;
    private static readonly TERMINAL_HTTP_STATUSES;
    private static readonly STALL_TIMEOUT_MS;
    private static readonly MEDIA_ERROR_RECOVERY_TIMEOUT_MS;
    private static readonly BUFFER_RESOLVE_MIN_ADVANCE_S;
    private stallTimer;
    private mediaErrorTimer;
    private isBuffering;
    private progressTick;
    private hasFailed;
    private mediaEventsAbort;
    private keyMomentsGeneration;
    private thumbnailBlobUrls;
    private lastPlaybackPos;
    private pendingSeekAttribution;
    private eventListeners;
    private static readonly AIRPLAY_POLL_INTERVAL_MS;
    private static readonly PRE_ROLL_HEAD_TOLERANCE_S;
    private airPlayPollTimer;
    private airPlayTargetChangeHandler?;
    private airPlaySeekPin;
    private airPlaySeekPinAt;
    private static readonly AIRPLAY_SEEK_PIN_MS;
    private static readonly AIRPLAY_SEEK_PIN_TOLERANCE_S;
    constructor(options: PlayerSDKOptions);
    private initializePlayer;
    private handleTimeUpdate;
    private setupAirPlaySync;
    private startAirPlayPoll;
    private stopAirPlayPoll;
    private expireAirPlaySeekPin;
    private isAirPlayActive;
    private clearBufferingForRouteChange;
    private bindMediaEvents;
    private rewriteToProxy;
    private loadSource;
    private setupBackgroundControls;
    play(): void;
    pause(): void;
    seek(seconds: number): void;
    attributeNextSeek(eventType: 'fast_forward' | 'fast_backward' | 'key_moments', extras?: Partial<AnalyticsEvent>): void;
    setVolume(volume: number): void;
    setMute(muted: boolean): void;
    setPlaybackRate(rate: number): void;
    setQuality(qualityId: number): void;
    notifyPipToggle(entered: boolean): void;
    togglePictureInPicture(): Promise<boolean>;
    toggleFullscreen(): void;
    getVideoElement(): HTMLVideoElement;
    getCurrentTime(): number;
    getDuration(): number;
    getVolume(): number;
    isMuted(): boolean;
    getPlaybackRate(): number;
    getActiveQuality(): VideoQuality;
    getQualityLevels(): VideoQuality[];
    getBufferLength(): number;
    getBufferedRanges(): Array<{
        start: number;
        end: number;
    }>;
    private hasPlayableLevel;
    private getAnalyticsPayload;
    on(event: string, callback: (...args: any[]) => void): void;
    off(event: string, callback: (...args: any[]) => void): void;
    private emit;
    private extractNativeQualityLevelsFromManifest;
    private extractSubtitlesFromManifest;
    private findManifestThumbnailUri;
    private parseThumbnailVtt;
    private parseImageMediaPlaylist;
    private bareThumbnailFilenameBesideVtt;
    private resolveThumbnailCueBase;
    private loadManifestThumbnailCues;
    private revokeThumbnailBlobs;
    private hydrateAuthenticatedThumbnails;
    private fetchThumbnailBlobUrl;
    private thumbnailCueAtTime;
    private applyThumbnailCuesToMoments;
    private extractKeyMomentsFromManifest;
    hasAdBreakDiscoverySettled(): boolean;
    private buildManifestUrl;
    private resolveManifestUrl;
    private static readonly AD_HOST_PATTERNS;
    private static readonly AD_STITCHER_PATH_PATTERNS;
    private static readonly AD_PATH_HINT_PATTERNS;
    private parseSegmentUrl;
    private isKnownAdSegment;
    private hasAdPathHint;
    private classifyAdGroups;
    private mergeAdjacentRanges;
    private parseAdBreaksFromFragments;
    private sameAdBreaks;
    private isTimeInAdBreak;
    private refreshAdBreakState;
    private videoTimeToContentTime;
    getAdBreaks(): Array<{
        startTime: number;
        endTime: number;
    }>;
    setAdBreaks(breaks: Array<{
        startTime: number;
        endTime: number;
    }>): void;
    setRetiredAdBreaks(starts: number[]): void;
    isInAdBreak(): boolean;
    getAudioTracks(): Array<{
        id: number;
        label: string;
        lang: string;
    }>;
    setAudioTrack(id: number): void;
    private armStallWatchdog;
    private clearStallWatchdog;
    private clearMediaErrorTimer;
    private fail;
    destroy(options?: {
        releaseVideoElement?: boolean;
    }): void;
}

export declare interface VideoQuality {
    id: number;
    height: number;
    width: number;
    bitrate: number;
    label: string;
}

export declare const WebVideoPlayer: default_2.FC<WebVideoPlayerProps>;

declare interface WebVideoPlayerProps {
    src: string;
    autoplay?: boolean;
    muted?: boolean;
    chapters?: Chapter[];
    keyMoments?: KeyMoment[];
    subtitles?: SubtitleTrack[];
    thumbnails?: ThumbnailConfig;
    watermark?: string;
    themeColor?: string;
    adAccentColor?: string;
    playerThemeColor?: string;
    chapterTitle?: string;
    drmConfig?: any;
    onAnalyticsEvent?: (event: AnalyticsEvent) => void;
    onAdBreakChange?: (active: boolean) => void;
    onKeyMomentsLoaded?: (keyMoments: KeyMoment[]) => void;
    enableControls?: boolean;
    enableChromecast?: boolean;
    enableKeyMoments?: boolean;
    enableSubtitles?: boolean;
    enableQuality?: boolean;
    enableSources?: boolean;
    enablePlaybackSpeed?: boolean;
    enablePiP?: boolean;
    enableFullscreen?: boolean;
    enableThumbnailPreview?: boolean;
    autoFullscreen?: boolean;
    watchProgressInterval?: number;
    subtitleStyle?: SubtitleStyle_2;
    resolvedEntitlement?: {
        package: string;
        is_active: boolean;
        features: Record<string, boolean>;
        limits: {
            streaming_minutes: number;
        };
    } | null;
    licenseKey?: string | null;
    title?: string;
    artworkUrl?: string;
    chaptersDisplayMode?: 'strip' | 'panel';
    keyMomentsTray?: 'bottom' | 'right' | 'strip' | 'panel' | 'none' | boolean;
    keyMomentsPosition?: 'bottom' | 'right';
    defaultKeyMomentsOpen?: boolean;
    onKeyMomentsToggle?: (isOpen: boolean) => void;
    volumeControlType?: 'slider' | 'button';
    urlTransformer?: (url: string) => string;
    pauseAdOnTabSwitch?: boolean;
    enableSkipAd?: boolean;
    skipAdAfterSeconds?: number;
    overlayAdUrl?: string;
    adTrackingUrl?: string;
    videoId?: string;
    sources?: SourceItem[];
    activeSourceIndex?: number;
    onSourceChange?: (index: number) => void;
    initialTime?: number;
    onTimeUpdate?: (currentTime: number) => void;
    skipMarkers?: SkipMarker[];
    introStartTime?: number;
    introEndTime?: number;
    hasNextEpisode?: boolean;
    outroStartTime?: number;
    nextEpisodeLabel?: string;
    onNextEpisode?: () => void;
    nextEpisodeAutoAdvanceSeconds?: number;
    nextEpisodeThumbnailUrl?: string;
}

export { }