import type { PlayerState, QualityLevel, PresentationMode, ConnectionState, StreamType, PlayerError } from './state';
import type { ProviderType, PlayerSource, ProviderConfig } from '../providers/contract';
import { BPLiveService } from '../bplive/service';
import type { NetworkInterceptorController } from '../network/index';
export interface PlayerCoreEventMap {
    play: void;
    playing: void;
    pause: void;
    ended: void;
    waiting: void;
    seeking: {
        currentTime: number;
    };
    seeked: {
        currentTime: number;
    };
    timeupdate: {
        currentTime: number;
        duration: number;
    };
    emptied: void;
    loadstart: void;
    loadedmetadata: {
        duration: number;
        videoWidth: number;
        videoHeight: number;
    };
    loadeddata: void;
    canplay: void;
    canplaythrough: void;
    durationchange: {
        duration: number;
    };
    progress: {
        buffered: TimeRanges;
    };
    resize: {
        videoWidth: number;
        videoHeight: number;
    };
    volumechange: {
        volume: number;
        muted: boolean;
    };
    ratechange: {
        playbackRate: number;
    };
    qualitieschange: {
        qualities: QualityLevel[];
    };
    qualitychange: {
        quality: QualityLevel;
        auto: boolean;
    };
    targetqualitychanged: {
        quality: QualityLevel | null;
    };
    sourcechange: {
        source: string | PlayerSource | null;
    };
    fullscreenchange: {
        fullscreen: boolean;
    };
    presentationmodechange: {
        mode: PresentationMode;
    };
    connectionstatechange: {
        state: ConnectionState;
    };
    streamtypechange: {
        streamType: StreamType;
    };
    videoelementchange: {
        video: HTMLVideoElement | null;
    };
    /**
     * Fires when the inner playback <video> element changes. For HLS this
     * is the wrapper's `nativeEl` and matches `videoelementchange`. For
     * Nano and LiveKit, the wrapper exposes a placeholder `nativeEl` and
     * binds the real playback element asynchronously — this event fires
     * once that real element is available, and again when it goes away.
     * Analytics integrations (e.g. mux-embed) should listen here.
     */
    activevideoelementchange: {
        video: HTMLVideoElement | null;
    };
    error: PlayerError;
    destroy: void;
    statechange: {
        state: PlayerState;
    };
}
export type PlayerCoreEventType = keyof PlayerCoreEventMap;
type EventListener<T> = (event: T) => void;
/**
 * Custom video element interface - all video elements (HlsVideoElement, NanoVideoElement, etc.)
 * extend CustomVideoElement from custom-media-element and expose nativeEl
 */
export type CustomVideoElement = HTMLVideoElement & {
    nativeEl: HTMLVideoElement;
};
/**
 * Result returned when a source is loaded, containing metadata from the source.
 */
export interface SourceLoadResult {
    poster?: string;
    videoWidth?: number;
    videoHeight?: number;
}
export interface PlayerCore {
    readonly state: PlayerState;
    readonly videoElement: HTMLVideoElement | null;
    /**
     * The actively playing inner <video>, distinct from the wrapper. For
     * Nano/LiveKit, this is null until the provider binds its real video
     * element. Analytics integrations should monitor this.
     */
    readonly activeVideoElement: HTMLVideoElement | null;
    readonly bpLive: BPLiveService | null;
    readonly network: NetworkInterceptorController;
    /** Whether the player is ready (attached and can accept sources) */
    readonly ready: boolean;
    /** Current provider type based on loaded source */
    readonly providerType: ProviderType | null;
    addEventListener<K extends PlayerCoreEventType>(type: K | K[], listener: EventListener<PlayerCoreEventMap[K]>): void;
    removeEventListener<K extends PlayerCoreEventType>(type: K | K[], listener: EventListener<PlayerCoreEventMap[K]>): void;
    /**
     * Attach the player to a container element. Call once during initialization.
     * After attaching, you can set sources via the source property or loadSource().
     */
    attach(container: HTMLElement, config?: ProviderConfig): void;
    /**
     * Load a source. Handles provider switching automatically.
     * If source type changes (e.g., video -> nano), the player will
     * destroy the old element and create a new one.
     */
    loadSource(source: string | PlayerSource, container?: HTMLElement, config?: ProviderConfig): Promise<SourceLoadResult | void>;
    unloadSource(): void;
    play(): Promise<void>;
    pause(): void;
    seek(time: number): void;
    setVolume(volume: number): void;
    setMuted(muted: boolean): void;
    setLoop(loop: boolean): void;
    setPlaybackRate(rate: number): void;
    setTargetQuality(quality: QualityLevel | null): void;
    setQuality(quality: QualityLevel | null): void;
    setFullscreen(fullscreen: boolean): Promise<void>;
    setPresentationMode(mode: PresentationMode): void;
    destroy(): void;
}
export declare class PlayerCoreImpl implements PlayerCore {
    private _state;
    private _mediaElement;
    private _container;
    private _config;
    private _listeners;
    private _eventCleanup;
    private _destroyed;
    private _bpLive;
    private _network;
    private _currentProviderType;
    private _ready;
    private _loadGeneration;
    constructor();
    get state(): PlayerState;
    get videoElement(): HTMLVideoElement | null;
    get activeVideoElement(): HTMLVideoElement | null;
    get bpLive(): BPLiveService | null;
    get network(): NetworkInterceptorController;
    get ready(): boolean;
    get providerType(): ProviderType | null;
    addEventListener<K extends PlayerCoreEventType>(type: K | K[], listener: EventListener<PlayerCoreEventMap[K]>): void;
    removeEventListener<K extends PlayerCoreEventType>(type: K | K[], listener: EventListener<PlayerCoreEventMap[K]>): void;
    private dispatch;
    private updateState;
    /**
     * Attach the player to a container. Call once during initialization.
     */
    attach(container: HTMLElement, config?: ProviderConfig): void;
    loadSource(source: string | PlayerSource, container?: HTMLElement, config?: ProviderConfig): Promise<SourceLoadResult | void>;
    private destroyMediaElement;
    private createMediaElement;
    private attachMediaElementListeners;
    private attachActiveVideoElementForwarding;
    private handleMediaEvent;
    unloadSource(): void;
    play(): Promise<void>;
    pause(): void;
    seek(time: number): void;
    setVolume(volume: number): void;
    setMuted(muted: boolean): void;
    setLoop(loop: boolean): void;
    setPlaybackRate(rate: number): void;
    setTargetQuality(quality: QualityLevel | null): void;
    setQuality(quality: QualityLevel | null): void;
    private _getFullscreenTarget;
    setFullscreen(fullscreen: boolean): Promise<void>;
    setPresentationMode(mode: PresentationMode): void;
    destroy(): void;
}
export declare function createPlayerCore(): PlayerCore;
export {};
//# sourceMappingURL=player-core.d.ts.map