/**
 * QoE (Quality of Experience) analytics — a small, versioned event stream with
 * pluggable sinks. Because movi decodes itself, it can measure things a
 * <video>-based player cannot: hardware-vs-software decode fallback and per-codec
 * decode timing, alongside the usual startup time, rebuffering and errors.
 *
 * Wire a sink (or listen to the element's `movi-qoe` CustomEvent) and forward to
 * Mux / GA4 / Amplitude / your own endpoint. Cookieless and self-host friendly.
 */
/** Bump when the event shape changes so downstream consumers can branch. */
export declare const QOE_SCHEMA_VERSION = 1;
export type QoEEvent = {
    type: "session_start";
    ts: number;
    src: string;
}
/** Time from load/play intent to the first presented frame. */
 | {
    type: "startup";
    ts: number;
    startupMs: number;
}
/** One rebuffer (stall) that has just ended. */
 | {
    type: "rebuffer";
    ts: number;
    durationMs: number;
    count: number;
}
/** Rendition/quality changed (premuxed height or HLS/DASH level). */
 | {
    type: "bitrate_switch";
    ts: number;
    height: number | null;
    label: string | null;
}
/** Decode dropped from hardware (WebCodecs) to software (FFmpeg-WASM). */
 | {
    type: "decode_fallback";
    ts: number;
    codec: string;
} | {
    type: "error";
    ts: number;
    message: string;
    fatal: boolean;
}
/** Periodic health sample while playing. */
 | {
    type: "heartbeat";
    ts: number;
    position: number;
    watchedMs: number;
    droppedFrames: number;
    decoder: string;
    rebufferRatio: number;
} | {
    type: "ended";
    ts: number;
    watchedMs: number;
};
export type QoESink = (event: QoEEvent) => void;
/** A rolled-up snapshot of the whole session. */
export interface QoESession {
    schemaVersion: number;
    src: string;
    startupMs: number | null;
    rebufferCount: number;
    rebufferMs: number;
    rebufferRatio: number;
    watchedMs: number;
    droppedFrames: number;
    bitrateSwitches: number;
    errors: number;
    decoder: string;
}
/**
 * Collects QoE signals and fans typed events out to registered sinks. Fed by
 * MoviElement from the player's existing event surface; framework-agnostic and
 * dependency-free.
 */
export declare class QoECollector {
    private sinks;
    private startAt;
    private firstFrameSent;
    private startupMsValue;
    private bufferingStart;
    private rebufferCount;
    private rebufferMs;
    private watchAccumMs;
    private lastPlayingAt;
    private isPlaying;
    private bitrateSwitches;
    private errors;
    private droppedFrames;
    private decoder;
    private src;
    private nowFn;
    constructor(now?: () => number);
    addSink(sink: QoESink): void;
    removeSink(sink: QoESink): void;
    private emit;
    private stamp;
    /** New source loaded — resets the session and starts the startup timer. */
    sessionStart(src: string): void;
    /** First presented frame — emits startup time once per session. */
    firstFrame(): void;
    playing(): void;
    paused(): void;
    bufferingStartNow(): void;
    bufferingEndNow(): void;
    bitrateSwitch(height: number | null, label: string | null): void;
    decodeFallback(codec: string): void;
    error(message: string, fatal: boolean): void;
    /** Periodic sample. `droppedFrames` and `decoder` come from the player. */
    heartbeat(position: number, droppedFrames: number, decoder: string): void;
    ended(): void;
    private watchedMs;
    private ratio;
    /** A rolled-up snapshot of the session so far. */
    getSession(): QoESession;
}
/** Built-in sink: POST each event to `url` via sendBeacon (falls back to fetch
 *  keepalive). Non-blocking and cookieless. Batching is left to the endpoint. */
export declare function beaconSink(url: string): QoESink;
//# sourceMappingURL=QoE.d.ts.map