import type { ActionOptions, AriaLiveLevel, AudioTrack, AuthConfig, BasePlaylistItem, BufferState, CanPlayResult, CastState, CastTarget, Chapter, CurrentAudioTrackSelection, CurrentQualitySelection, CurrentSubtitleSelection, DeviceCapabilities, ICueParser, IPlatform, IPlayer, IPreloadStrategy, IStreamFactory, ITransitionStrategy, IUrlResolver, TimeState as KitTimeState, LoadOptions, NetworkState, PlaybackMetrics, PlayerExperimental, PlayerPhase, Plugin, PluginCtorWithId, QualityLevel, ResolvedUrl, SetupState, SidecarSubtitleInput, SubtitleStyle, SubtitleTrack, Translations, UrlCategory, VisibilityState } from '@nomercy-entertainment/nomercy-player-core';
import type { IVideoBackend, VideoBackendKind } from './adapters/video-backend/IVideoBackend.js';
import type { AudioTrackState, IVideoPlayer, PlayState, QualityState, RepeatState, SegmentOptions, ShuffleState, Stretching, VideoEventMap, VideoPlayerConfig, VideoPlaylistItem, VideoRect, VolumeState } from './types.js';
import { EventEmitter } from '@nomercy-entertainment/nomercy-player-core';
import { FullscreenState, PipState, SubtitleState, TheaterState } from './types.js';
export type { IChapterSource } from './adapters/chapter-source/IChapterSource.js';
export { VttChapterSource } from './adapters/chapter-source/vtt-chapters.js';
export type { ISubtitleStyleStore } from './adapters/subtitle-style-store/ISubtitleStyleStore.js';
export { StorageBackedSubtitleStyleStore } from './adapters/subtitle-style-store/storage-backed.js';
export type { IThumbnailSource, ThumbnailFrame } from './adapters/thumbnail-source/IThumbnailSource.js';
export { VttSpriteThumbnailSource } from './adapters/thumbnail-source/vtt-sprite.js';
export { Html5VideoBackend } from './adapters/video-backend/html5.js';
export type { BackendEvent, BackendEventPayload, BackendLoaderState, BackendState, IVideoBackend, SubtitleCue, SubtitleCueChange, VideoBackendKind, } from './adapters/video-backend/IVideoBackend.js';
export { VideoPreloadStrategy } from './player/preload.js';
export { KeyHandlerPlugin } from './plugins/key-handler/index.js';
export { OctopusPlugin } from './plugins/octopus/index.js';
export { V1VideoCompatPlugin } from './plugins/v1-compat.js';
export type { AudioTrackRef, ChapterRef, FontTrackRef, HtmlPreloadMode, IVideoPlayer, SegmentBoundaryPayload, SegmentEndBehaviour, SegmentOptions, Stretching, SubtitleTrackRef, VideoBackendFactory, VideoEventMap, VideoPlayerConfig, VideoPlaylistItem, VideoRect, WatchProgress, } from './types.js';
export { containedRect } from './types.js';
export { AudioTrackState, FullscreenState, PipState, PlayState, QualityState, RepeatState, ShuffleState, SubtitleState, TheaterState, VolumeState, } from './types.js';
export type { QualityLevel } from './types.js';
export type { AudioTrack, Chapter, SidecarSubtitleInput, SubtitleTrack } from '@nomercy-entertainment/nomercy-player-core';
/**
 * Headless video player. Plugin-driven, event-driven, no UI in core.
 *
 * Shared player logic (lifecycle, transport, queue, state, volume, time,
 * plugins, i18n, cue parsers, baseUrl, audioContext, experimental override
 * surface) is composed onto the prototype from `playerCoreMethods` exported by
 * `@nomercy-entertainment/nomercy-player-core` — the LOGIC lives there, not
 * here. NMVideoPlayer adds only:
 *
 *  - The per-library registry (own `_instances` Map)
 *  - The three-form factory constructor + the `videoElement` field
 *  - Library-typed method declarations (so consumers see `PlayState`, etc.,
 *    not the kit's internal string token — runtime impl comes from the mixin)
 *  - Video-specific stubs (fullscreen, pip, theater, subtitle toggles, etc.)
 */
export declare class NMVideoPlayer<T extends VideoPlaylistItem = VideoPlaylistItem> extends EventEmitter<VideoEventMap<T>> implements IPlayer<VideoEventMap<T>>, IVideoPlayer<T> {
    playerId: string;
    container: HTMLElement;
    videoElement: HTMLVideoElement | undefined;
    get id(): string;
    /**
     * Phantom brand — never assigned at runtime. Declared explicitly here so
     * `PlayerEventMap<NMVideoPlayer<T>>` resolves to `VideoEventMap<T>` without
     * TypeScript having to walk the `EventEmitter` inheritance chain (which
     * stalls in conditional-type inference for complex class hierarchies).
     */
    readonly __eventMap__: VideoEventMap<T>;
    options: VideoPlayerConfig<T>;
    private _phase;
    private _playState;
    /** Bumped only by `item(target)` navigations — distinguishes a real consumer preselection from the queue's default cursor. */
    _currentEpoch: number | undefined;
    setup: (config: VideoPlayerConfig<T>) => this;
    ready: () => Promise<void>;
    dispose: () => Promise<void>;
    setupState: () => SetupState;
    phase: () => PlayerPhase;
    dispatching: () => ReadonlyArray<string>;
    platform: () => IPlatform;
    baseUrl: {
        (): string | undefined;
        (url: string): void;
    };
    audioContext: () => AudioContext | undefined;
    experimental: PlayerExperimental;
    t: {
        (key: string, vars?: Record<string, string>): string;
        (PluginClass: PluginCtorWithId, key: string, vars?: Record<string, string>): string;
    };
    language: {
        (): string;
        (lang: string): Promise<void>;
    };
    addTranslations: (bundle: Translations) => void;
    registerTitleTokens: (tokens: Record<string, string>) => void;
    translation: {
        (lang: string, key: string): string | undefined;
        (lang: string, key: string, value: string): void;
    };
    removeTranslations: (prefix: string, lang?: string) => void;
    registerCueParser: (parser: ICueParser, prepend?: boolean) => void;
    unregisterCueParser: (id: string) => void;
    resolveCueParser: (url: string) => ICueParser | undefined;
    play: (opts?: ActionOptions) => Promise<void>;
    pause: (opts?: ActionOptions) => Promise<void>;
    stop: (opts?: ActionOptions) => Promise<void>;
    togglePlayback: (opts?: ActionOptions) => Promise<void>;
    next: (opts?: LoadOptions) => Promise<void>;
    previous: (opts?: LoadOptions) => Promise<void>;
    rewind: (seconds?: number, opts?: ActionOptions) => Promise<void>;
    forward: (seconds?: number, opts?: ActionOptions) => Promise<void>;
    restart: (opts?: ActionOptions) => Promise<void>;
    time: {
        (): number;
        (seconds: number, opts?: ActionOptions): Promise<void>;
    };
    duration: () => number;
    buffered: () => number;
    bufferedRanges: () => TimeRanges;
    seekable: () => TimeRanges;
    timeData: () => KitTimeState;
    /** Seek to a position expressed as a percentage (0–100) of total duration. */
    seekByPercentage: (pct: number, opts?: ActionOptions) => void;
    playbackRate: {
        (): number;
        (rate: number): Promise<void>;
    };
    playbackRates: () => number[];
    volume: {
        (): number;
        (level: number): Promise<void>;
    };
    mute: () => Promise<void>;
    unmute: () => Promise<void>;
    toggleMute: () => void;
    volumeUp: (step?: number) => void;
    volumeDown: (step?: number) => void;
    bumpActivity: () => void;
    activityTracking: {
        (): boolean;
        (enabled: boolean): void;
    };
    playState: () => PlayState;
    volumeState: () => VolumeState;
    repeatState: {
        (): RepeatState;
        (state: RepeatState): Promise<void>;
    };
    shuffleState: {
        (): ShuffleState;
        (state: ShuffleState | boolean): Promise<void>;
    };
    queue: {
        (): ReadonlyArray<T>;
        (items: T[], opts?: ActionOptions): void;
    };
    queueAppend: (item: T | T[], opts?: ActionOptions) => void;
    queuePrepend: (item: T | T[], opts?: ActionOptions) => void;
    queueInsert: (item: T | T[], index: number, opts?: ActionOptions) => void;
    queueRemove: (id: string | number, opts?: ActionOptions) => void;
    queueRemoveAt: (index: number, opts?: ActionOptions) => void;
    queueMove: (from: number, to: number, opts?: ActionOptions) => void;
    queueClear: (opts?: ActionOptions) => void;
    queueShuffle: (opts?: ActionOptions) => void;
    queueSort: (compare: (itemA: T, itemB: T) => number, opts?: ActionOptions) => void;
    peekNext: () => T | undefined;
    peekPrevious: () => T | undefined;
    queueLength: () => number;
    queueIndexOf: (id: string | number) => number;
    item: {
        (): T | undefined;
        (target: T | string | number, opts?: LoadOptions): void;
    };
    index: () => number;
    seekToIndex: (position: number, opts?: ActionOptions) => void;
    playItem: (target: BasePlaylistItem | string | number | ((item: BasePlaylistItem) => boolean), opts?: LoadOptions) => void;
    playNow: (items: BasePlaylistItem[], start?: BasePlaylistItem | string | number | ((item: BasePlaylistItem) => boolean), opts?: LoadOptions) => void;
    backlog: {
        (): ReadonlyArray<T>;
        (items: T[]): void;
    };
    backlogAppend: (item: T | T[]) => void;
    backlogRemove: (id: string | number) => void;
    backlogClear: () => void;
    addPlugin: <P extends Plugin<any, any, any>>(PluginClass: PluginCtorWithId & (new () => P), opts?: P['opts']) => this;
    getPlugin: <P extends object>(PluginClass: PluginCtorWithId & (new () => P)) => P | undefined;
    getPluginById: <P extends object = object>(id: string) => P | undefined;
    removePlugin: <P extends Plugin<any, any, any>>(PluginClass: PluginCtorWithId & (new () => P)) => void;
    removePluginById: (id: string) => void;
    plugins: () => ReadonlyArray<Plugin>;
    enabledPlugins: () => ReadonlyArray<Plugin>;
    constructor(id?: string | number);
    private _languageMemoryInstance;
    /**
     * Carries the viewer's chosen audio / subtitle language across items. Built
     * on first use — `options` is not assigned yet when fields initialise.
     */
    private get languageMemory();
    private _wantedPoster;
    private _defaultQualityApplied;
    /**
     * Resolve a raw image URL to an absolute poster string and apply it.
     *
     * Sync first — the poster MUST be on the `<video>` element before the
     * backend starts loading the new source, otherwise the user sees a black
     * frame between source-clear and first-frame-paint. We prepend
     * `baseImageUrl` (when set) for relative URLs immediately, then kick off
     * `resolveUrl(raw, 'poster')` to upgrade to whatever a custom resolver
     * returns — only writing the async result if it actually differs from
     * the sync guess (avoids a redundant attribute set + repaint flash).
     */
    private _applyPosterForRaw;
    private _applyPosterFromCurrentItem;
    private _applyPoster;
    /**
     * Auto-select the default subtitle and audio tracks from config options
     * `defaultSubtitleLanguage` / `defaultAudioLanguage`. Called once after
     * `mediaReady` fires so the backend's track lists are populated.
     *
     * Language matching: exact tag first, then prefix (e.g. `'en'` matches
     * `'en-US'`). No match → leave selection at off; no warning emitted.
     */
    private _applyDefaultTracks;
    /** Test-only: clear the registry. Not part of the public API. */
    static _resetRegistry(): void;
    registerStream: (factory: IStreamFactory, prepend?: boolean) => this;
    unregisterStream: (id: string) => this;
    streams: () => ReadonlyArray<string>;
    getStreamFactory: (id: string) => IStreamFactory | undefined;
    private _backend;
    backend(): IVideoBackend;
    backend(kind: VideoBackendKind): Promise<void>;
    /**
     * Construct + fully wire an `IVideoBackend` instance for `kind`, then store
     * it as the active backend. Only `'html5'` has a built-in implementation —
     * other kinds require `options.backendFactory` to supply one. Called
     * lazily by the `backend()` getter on first access, and again by the
     * `backend(kind)` setter after disposing the previous instance.
     */
    private _createBackend;
    load: (item: T, opts?: LoadOptions) => Promise<void>;
    loadQueue: (url: string, parser?: (raw: string) => T[]) => Promise<void>;
    bufferState: () => BufferState;
    networkState: () => NetworkState;
    streamState: () => string;
    visibilityState: () => VisibilityState;
    qualityMode: {
        (): QualityState;
        (target: number | 'auto'): void;
    };
    audioTrackMode: {
        (): AudioTrackState;
        (idx: number): void;
    };
    private _fullscreenActive;
    fullscreen(): FullscreenState;
    fullscreen(state: FullscreenState | boolean): void;
    private _pipActive;
    pip(): PipState;
    pip(state: PipState | boolean): void;
    private _theaterActive;
    theater(): TheaterState;
    theater(state: TheaterState | boolean): void;
    /**
     * Whether any subtitle track is currently active.
     *
     * The canonical answer comes from the kit's selection (`subtitle()`)
     * because plugin-rendered subtitles (ASS via libass / Octopus, image-based
     * VOBSUB / PGS, future formats) render to their own surfaces and never
     * appear in `videoElement.textTracks`. Falls back to scanning `textTracks`
     * for the case where a backend (HLS.js) toggled a native track without
     * routing through `subtitle()`.
     */
    subtitleState(): SubtitleState;
    toggleFullscreen(): void;
    togglePip(): void;
    toggleTheater(): void;
    cycleSubtitles(): void;
    private _aspectRatio;
    private static readonly _OBJECT_FIT_MAP;
    aspectRatio(): Stretching;
    aspectRatio(value: Stretching): void;
    cycleAspectRatio(): void;
    private _applyObjectFit;
    private _videoRectObserver;
    /**
     * The displayed video content rectangle relative to the player container,
     * computed from `object-fit: contain` geometry.
     *
     * Returns `null` when the video has no loaded metadata yet.
     * Changes are signalled by the `'videoRect'` event — fired on `mediaReady`,
     * `duration`, `fullscreen`, and a `ResizeObserver` on the container and
     * video element.
     */
    videoRect(): VideoRect | null;
    private _emitVideoRect;
    private _mountVideoRectObserver;
    private _teardownVideoRectObserver;
    private _segmentUnlisten;
    /**
     * Seek to `opts.startSec` and begin watching for `opts.endSec` on every
     * `'time'` event. When the boundary is reached:
     *
     *   - `'segmentBoundary'` is always emitted first.
     *   - `'loop'`    → seeks back to `startSec`.
     *   - `'hold'`    → pauses at `endSec`.
     *   - `'advance'` → no extra action; playback continues naturally.
     *
     * Replaces any previously active segment window immediately.
     */
    playSegment(opts: SegmentOptions): void;
    /** Stop watching the active segment window without seeking or pausing. */
    clearSegment(): void;
    private _clearSegmentInternal;
    /**
     * Built-in wire-format adapter, called by the kit's queue ingest pipeline
     * on every item. Accepts the v1 / NoMercy server playlist format (`file`,
     * ms-based `chapters`, `{time, date}` progress, `tracks[]`) and reshapes
     * to the canonical `VideoPlaylistItem` — idempotently, so canonical items
     * pass through unchanged. Consumers reshape app-specific fields with the
     * `transformPlaylistItem` config callback instead of overriding this.
     */
    normalizePlaylistItem(item: BasePlaylistItem): BasePlaylistItem;
    subtitles: () => SubtitleTrack[];
    subtitle: {
        (): CurrentSubtitleSelection | null;
        (idx: number | null): Promise<void>;
    };
    /**
     * Read or write the user's subtitle style. Read returns a copy of
     * the current `SubtitleStyle`; write merges the patch onto the
     * current style and emits `subtitleStyle` with the merged result.
     * Persistence is the responsibility of preference plugins —
     * `mediaTracksMethods` only owns the in-memory state + event.
     */
    subtitleStyle: {
        (): SubtitleStyle;
        (patch: Partial<SubtitleStyle>): void;
    };
    /**
     * Inject a sidecar subtitle track into the currently-playing item at
     * runtime — no reload required. Idempotent by `url` + normalised
     * `language`; `default: true` selects it immediately through the same
     * cancellable `beforeSubtitle` path as `subtitle(idx)`. Composed in via
     * `mediaTracksMethods` — see that mixin for the full contract.
     */
    addSubtitleTrack: (track: SidecarSubtitleInput, opts?: ActionOptions) => SubtitleTrack;
    /** Remove a sidecar subtitle track added via `addSubtitleTrack()`, by id. */
    removeSubtitleTrack: (id: string, opts?: ActionOptions) => void;
    audioTracks: () => AudioTrack[];
    audioTrack: {
        (): CurrentAudioTrackSelection | null;
        (idx: number): Promise<void>;
    };
    /** Composed in via `mediaTracksMethods` — see that mixin for the full contract. */
    cycleAudioTracks: () => void;
    qualityLevels: {
        (): QualityLevel[];
        (opts: {
            includeUnsupported: true;
        }): QualityLevel[];
    };
    quality: {
        (): CurrentQualitySelection | 'auto';
        (idx: number | 'auto'): void;
    };
    chapters: () => Chapter[];
    chapter: {
        (): Chapter | null;
        (idx: number): void;
    };
    seekToChapter: (idx: number, opts?: ActionOptions) => void;
    nextChapter: (opts?: ActionOptions) => void;
    previousChapter: (opts?: ActionOptions) => void;
    isTv: () => boolean;
    isMobile: () => boolean;
    isDesktop: () => boolean;
    device: () => DeviceCapabilities;
    canPlay: (profile: {
        contentType: string;
        width?: number;
        height?: number;
        bitrate?: number;
        framerate?: number;
    }) => Promise<CanPlayResult>;
    bandwidth: () => number;
    bandwidthEstimator: {
        (): (() => number) | undefined;
        (fn: () => number): void;
    };
    audioOutputs: () => Promise<MediaDeviceInfo[]>;
    selectAudioOutput: () => Promise<MediaDeviceInfo | null>;
    audioOutput: {
        (): Promise<string | null>;
        (deviceId: string): Promise<void>;
    };
    castState: () => CastState;
    transferTo: (target: CastTarget) => Promise<void>;
    auth: {
        (): Readonly<AuthConfig> | undefined;
        (config: AuthConfig): void;
        (partial: Partial<AuthConfig>): void;
        (clear: null): void;
    };
    refreshAuth: () => Promise<void>;
    resolveUrl: (url: string, category?: UrlCategory) => Promise<ResolvedUrl>;
    urlResolver: {
        (): IUrlResolver | undefined;
        (resolver: IUrlResolver | undefined): void;
    };
    metrics: () => PlaybackMetrics;
    recordMetric: (name: string, value: number) => void;
    now: () => number;
    announce: (text: string, level?: AriaLiveLevel) => void;
    setPreloadStrategy: (strategy: IPreloadStrategy) => void;
    setTransitionStrategy: (strategy: ITransitionStrategy) => void;
    preloadStrategy: () => IPreloadStrategy;
    transitionStrategy: () => ITransitionStrategy;
    _disposeBackend(): void;
}
/**
 * Create (or look up) a video player bound to a container element. Returns the
 * existing instance for a given id, or mounts a fresh one.
 *
 * ```ts
 * import nmplayer from './index.js';
 * nmplayer('my-div').setup({ ... });
 * ```
 */
export declare function nmplayer<T extends BasePlaylistItem = VideoPlaylistItem>(id?: string | number): NMVideoPlayer<T>;
export default nmplayer;
export { NotImplementedError } from '@nomercy-entertainment/nomercy-player-core';
export type { SubtitleStyle } from '@nomercy-entertainment/nomercy-player-core';