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;
}

export declare class AnalyticsModule implements IAnalyticsModule {
    private callback?;
    private heartbeatInterval?;
    private watchProgressTimer?;
    private isBuffering;
    private sessionId;
    private videoId;
    private deviceType;
    private networkType;
    private adBreaks;
    private isFirstPlay;
    private watchStartTime;
    private totalWatchTime;
    private streamingWindowStart;
    private streamingTime;
    private isInAdBreak;
    private adWatchWindowStart;
    private adWatchTime;
    private bufferingCount;
    private totalBufferingTime;
    private bufferingStartTime;
    private milestonesHit;
    private lastHeartbeatPosition;
    private lastHeartbeatAt;
    constructor(callback?: AnalyticsCallback, src?: string, seed?: AnalyticsSessionSnapshot, videoId?: string);
    getSessionSnapshot(): AnalyticsSessionSnapshot;
    registerCallback(callback: AnalyticsCallback): void;
    setAdBreaks(adBreaks: Array<{
        startTime: number;
        endTime: number;
    }>): void;
    private getTotalAdDuration;
    private getElapsedAdTime;
    private getContentDuration;
    private getContentTime;
    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;
    private checkMilestones;
    private checkStall;
    private getTotalWatchTime;
    private getStreamingTime;
    private getAdWatchTime;
    private dispatchRaw;
    private generateSessionId;
    private getDeviceType;
    private getNetworkType;
}

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

export declare abstract class BasePlayerPlugin implements PlayerPlugin {
    abstract id: string;
    abstract name: string;
    protected player: any;
    install(player: any): void;
    protected abstract onInstall(): void;
    destroy(): void;
    protected onDestroy(): void;
}

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 CastingConfig {
    receiverApplicationId?: string;
}

export declare class CastingModule implements ICastingModule {
    private isCasting;
    private castDeviceName;
    private onCastStateChangeCallback?;
    private onRemoteStateChangeCallback?;
    private castContext;
    private remotePlayer;
    private remotePlayerController;
    private attachedListeners;
    private castContextListeners;
    private windowFocusHandler?;
    private destroyed;
    private initialized;
    private apiReadyHook?;
    private announcedCasting?;
    private loadedSrc;
    private pendingSrc;
    private lastIdleReason;
    private receiverGoneStrikes;
    private sawMediaSession;
    private endedSession;
    private seekInFlight;
    private queuedSeek;
    private seekToken;
    private seekAckTimer;
    private receiverApplicationId;
    private receiverTracks;
    private externalSubtitleTrackIds;
    private activeAudioTrackId;
    private activeSubtitleTrackId;
    private desiredSubtitle;
    private desiredAudio;
    private trackRetryTimer;
    private trackRetriesLeft;
    private mediaRequestId;
    constructor(config?: CastingConfig);
    private initCastApi;
    private getMediaSession;
    private hasReceiverDroppedOurMedia;
    private addListener;
    private disconnectCasting;
    private announceCastState;
    private isReceiverAppLive;
    private deviceNameFor;
    checkCastState: () => void;
    getCastingState(): {
        isCasting: boolean;
        deviceName: string;
    };
    getRemoteState(): RemoteCastState | null;
    private getContentType;
    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;
    private requestSeek;
    private dispatchSeek;
    private settleSeek;
    private clearSeekAckTimer;
    private resetSeekQueue;
    private resetTrackState;
    private clearTrackRetry;
    private liveReceiverTracks;
    remoteSetVolume(volume: number): void;
    remoteSetMute(muted: boolean): void;
    remoteSetPlaybackRate(rate: number): void;
    remoteSetSubtitle(track: CastTrackRef | null): void;
    remoteSetAudioTrack(track: CastTrackRef): void;
    private resolveAndApplyTracks;
    private clearTrackRetryTimerOnly;
    private findReceiverTrack;
    private applyActiveTracks;
    remoteSkipAd(toTime: number): void;
    private sendMediaRequest;
    onCastStateChange(callback: (isCasting: boolean, deviceName: string) => void): void;
    onRemoteStateChange(callback: (state: RemoteCastState) => void): void;
    requestAirPlaySession(videoElement: HTMLVideoElement): void;
    stopAirPlay(videoElement: HTMLVideoElement): void;
    isAirPlayAvailable(): boolean;
}

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 class ChaptersModule extends KeyMomentsModule implements IChaptersModule {
}

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

export declare class DRMModule implements IDRMModule {
    private config?;
    private watermarkElement?;
    private floatInterval?;
    constructor(config?: DRMConfig);
    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 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;
}

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 class KeyMomentsModule implements IKeyMomentsModule {
    private keyMoments;
    private currentMomentIndex;
    private onMomentChangeCallback?;
    constructor(keyMoments?: KeyMoment[]);
    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 interface PlayerPlugin {
    id: string;
    name: string;
    install(player: any): void;
    destroy?(): void;
}

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 class SubtitlesModule implements ISubtitlesModule {
    private tracks;
    private activeTrackId;
    private currentCues;
    private activeText;
    private onSubtitleChangeCallback?;
    private onTrackSwitchCallback?;
    getAuthHeaders?: () => Record<string, string>;
    constructor(tracks?: SubtitleTrack[]);
    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;
    private updateActiveText;
    onSubtitleChange(callback: (text: string) => void): void;
    private parseVttOrSrt;
}

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;
}

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

export declare class ThumbnailsModule implements IThumbnailsModule {
    private config?;
    constructor(config?: ThumbnailConfig);
    getThumbnail(time: number): {
        url: string;
        x: number;
        y: number;
        width: number;
        height: number;
    } | null;
    hasThumbnails(): boolean;
    getSpriteSize(): {
        width: number;
        height: number;
    } | null;
}

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 { }