import { BehaviorSubject } from 'rxjs';
import { Config } from 'yoga-layout';
import { default as default_2 } from 'hls.js';
import { default as default_3 } from 'konva';
import { HlsConfig } from 'hls.js';
import { MediaChromeButton } from 'media-chrome';
import { MediaChromeRange } from 'media-chrome';
import { MediaController } from 'media-chrome';
import { MediaFullscreenButton } from 'media-chrome';
import { MediaKeySessionContext } from 'hls.js';
import { MediaPlayButton } from 'media-chrome';
import { MediaPlaylist } from 'hls.js';
import { MediaThemeElement } from 'media-chrome/media-theme-element';
import { MediaTimeRange } from 'media-chrome';
import { Node as Node_2 } from 'yoga-layout';
import { Observable } from 'rxjs';
import { ReplaySubject } from 'rxjs';
import { Subject } from 'rxjs';
import { Track as Track_2 } from 'hls.js';

export declare function affectsStyledElement(event: UiEvent, element: StyledElement<any>): boolean;

declare interface Alert {
    readonly id: string;
    readonly level: AlertLevel;
    readonly message: string;
    readonly timestamp: Date;
    readonly config?: AlertConfig | undefined;
    readonly state: AlertState;
}

export declare interface AlertConfig {
    /** Display duration in milliseconds. Undefined means the alert persists until dismissed. */
    duration?: number;
}

export declare type AlertEvent = {
    [K in AlertEventType]: {
        type: K;
        data: AlertEventTypeDataMap[K];
    };
}[keyof AlertEventTypeDataMap];

declare interface AlertEventData {
    alert: Alert;
}

export declare enum AlertEventType {
    ALERT_RAISED = "ALERT_RAISED",
    ALERT_DISMISSED = "ALERT_DISMISSED"
}

export declare type AlertEventTypeDataMap = {
    [AlertEventType.ALERT_RAISED]: AlertEventData;
    [AlertEventType.ALERT_DISMISSED]: AlertEventData;
};

declare enum AlertLevel {
    INFO = "INFO",
    WARN = "WARN",
    ERROR = "ERROR"
}

export declare interface AlertsApi {
    /** Emits an event whenever an alert is raised or dismissed. */
    onEvent$: Observable<AlertEvent>;
    /**
     * Raises an info alert.
     *
     * @param message - The message to display.
     * @param config - Optional display configuration (e.g. auto-dismiss duration).
     * @returns The unique ID of the created alert.
     */
    info(message: string, config?: AlertConfig): Alert['id'];
    /**
     * Raises a warning alert.
     *
     * @param message - The message to display.
     * @param config - Optional display configuration (e.g. auto-dismiss duration).
     * @returns The unique ID of the created alert.
     */
    warn(message: string, config?: AlertConfig): Alert['id'];
    /**
     * Raises an error alert.
     *
     * @param message - The message to display.
     * @param config - Optional display configuration (e.g. auto-dismiss duration).
     * @returns The unique ID of the created alert.
     */
    error(message: string, config?: AlertConfig): Alert['id'];
    /**
     * Dismisses the alert with the given ID.
     *
     * @param id - The ID of the alert to dismiss.
     */
    dismiss(id: Alert['id']): void;
    /** Dismisses all currently active alerts. */
    dismissAll(): void;
}

declare class AlertsManager implements AlertsApi, Destroyable {
    private readonly _onEvent$;
    private readonly _activeAlerts;
    constructor();
    get onEvent$(): Observable<AlertEvent>;
    info(message: string, config?: AlertConfig): string;
    warn(message: string, config?: AlertConfig): string;
    error(message: string, config?: AlertConfig): string;
    dismiss(id: string): void;
    dismissAll(): void;
    private _emit;
    private _dismiss;
    destroy(): void;
}

declare interface AlertsManagerMessageChannel {
    onEvent$: Observable<AlertEvent>;
    info(message: string, config?: AlertConfig): Observable<Alert['id']>;
    warn(message: string, config?: AlertConfig): Observable<Alert['id']>;
    error(message: string, config?: AlertConfig): Observable<Alert['id']>;
    dismiss(id: Alert['id']): Observable<void>;
    dismissAll(): Observable<void>;
}

declare class AlertsManagerProxy extends BaseMessageChannelProxy<AlertsManagerMessageChannel> implements AlertsManagerMessageChannel {
    constructor(remoteNode: RemoteNode);
    get onEvent$(): Observable<AlertEvent>;
    error(message: string, config?: AlertConfig): Observable<Alert["id"]>;
    info(message: string, config?: AlertConfig): Observable<Alert["id"]>;
    warn(message: string, config?: AlertConfig): Observable<Alert["id"]>;
    dismiss(id: AlertState['id']): Observable<void>;
    dismissAll(): Observable<void>;
}

declare interface AlertState {
    id: string;
    level: AlertLevel;
    message: string;
    timestamp: Date;
    config?: AlertConfig | undefined;
}

declare abstract class Audio_2 extends BaseTrack<AudioState, TrackEvent_2> {
    protected _trackType: TrackType;
    protected abstract _audioType: AudioType;
    protected _url: string | undefined;
    protected _duration: number | undefined;
    protected _audioCodec: string | undefined;
    protected _channels: number | undefined;
    protected constructor(args: AudioArgs);
    protected getState(): AudioState;
    get url(): string | undefined;
    get audioType(): AudioType;
    get audioCodec(): string | undefined;
    get channels(): number | undefined;
    get duration(): number | undefined;
    updateAttrs(attrs: AudioUpdateableAttrs): void;
}
export { Audio_2 as Audio }

/**
 * Construction arguments for audio track instances.
 */
export declare interface AudioArgs extends BaseTrackArgs {
    /** URL of the audio source. Overridden by `source` when a {@link UrlSource} is provided. */
    url?: string | undefined;
    /** Duration of the audio track in seconds. */
    duration?: number | undefined;
    /** Audio codec identifier (e.g. `"mp4a.40.2"`). */
    audioCodec?: string | undefined;
    /** Number of audio channels. */
    channels?: number | undefined;
}

/**
 * Implementation of {@link AudioEffectState}
 */
export declare interface AudioEffect {
    /**
     * Converts effect to effect definition
     */
    toState(): AudioEffectState;
    /**
     * Returns input audio nodes
     */
    getInputNodes(): AudioNode[];
    /**
     * Returns output audio nodes
     */
    getOutputNode(): AudioNode;
    /**
     * Returns all audio nodes
     */
    getNodes(): AudioNode[];
    /**
     * Effect's id. Unique at {@link AudioEffectGraph} level.
     */
    id: string;
    /**
     * Effect's effect type. Used for dynamic effect instantiation.
     */
    effectType: string;
    /**
     * Arbitrary values used to describe the effect
     */
    attrs: Map<string, any>;
    /**
     * Signals when effect is fully initialized.
     */
    onReady$: Observable<void>;
    /**
     * Sets effect parameter.
     *
     * @param param
     */
    setParam(param: AudioEffectParam): void;
    /**
     * Returns all effect parameters
     */
    getParams(): AudioEffectParamType[] | undefined;
    /**
     * Destroys all effect's nodes and sets up the effect to be garbage collected
     */
    destroy(): void;
}

/**
 * Connection definition to {@link AudioEffectState}
 */
export declare interface AudioEffectConnectionDef {
    /**
     * {@link OmpAudioNodeDef.id}
     */
    effectId: string;
    /**
     * Input
     */
    output?: number;
    /**
     * Output
     */
    input?: number;
}

export declare class AudioEffectDef implements AudioEffectState {
    id: string;
    effectType: string;
    attrs?: Record<string, any>;
    connections?: AudioEffectConnectionDef[];
    audioParams?: AudioEffectParamType[];
    constructor(id: string, effectType: string);
    withAttrs(attrs: Record<string, any>): AudioEffectDef;
    outputTo(...effectConnections: (string | AudioEffectConnectionDef)[]): AudioEffectDef;
    addParam(audioParam: AudioEffectParamType): this;
}

export declare class AudioEffectDelayTimeParam extends AudioEffectParam {
    protected readonly _valueParam: AudioNodeValueParam;
    constructor(delayTime?: number);
    setDelayTime(delayTime: number): void;
}

export declare type AudioEffectEvent = {
    [K in AudioEffectEventType]: {
        type: K;
        data: AudioEffectEventTypeDataMap[K];
    };
}[keyof AudioEffectEventTypeDataMap];

export declare interface AudioEffectEventParametersChangeData extends Serializable {
    connection: AudioEffectGraphConnection;
    changedParameters: AudioEffectParameterChange[];
}

export declare enum AudioEffectEventType {
    AUDIO_EFFECT_PARAMETER_CHANGE = "AUDIO_EFFECT_PARAMETER_CHANGE",
    AUDIO_EFFECT_GRAPH_ADDED = "AUDIO_EFFECT_GRAPH_ADDED",
    AUDIO_EFFECT_GRAPH_REMOVED = "AUDIO_EFFECT_GRAPH_REMOVED"
}

export declare type AudioEffectEventTypeDataMap = {
    [AudioEffectEventType.AUDIO_EFFECT_PARAMETER_CHANGE]: AudioEffectEventParametersChangeData;
    [AudioEffectEventType.AUDIO_EFFECT_GRAPH_ADDED]: AudioEffectSlotEventChangeData;
    [AudioEffectEventType.AUDIO_EFFECT_GRAPH_REMOVED]: AudioEffectSlotEventChangeData;
};

export declare type AudioEffectFactory = (effectDef: AudioEffectState) => AudioEffect;

/**
 * Filter values used for filtering {@link AudioEffect}'s
 */
export declare interface AudioEffectFilter {
    /**
     * {@link AudioEffect.id}
     */
    id?: string | undefined;
    /**
     * {@link AudioEffect.type}
     */
    effectType?: string | undefined;
    /**
     * {@link AudioEffect.attrs}
     */
    attrs?: Record<string, any> | undefined;
}

export declare class AudioEffectGainParam extends AudioEffectParam {
    protected readonly _valueParam: AudioNodeValueParam;
    constructor(gain?: number);
    setGain(gain: number): void;
}

/**
 * Audio effects graph. Implementation corresponds to definition {@link AudioEffectGraph.toDef}
 */
export declare class AudioEffectGraph {
    private def;
    protected _effects: AudioEffect[];
    protected _effectsById: Map<string, AudioEffect>;
    protected _sourceEffects: AudioEffect[];
    protected _destinationEffects: AudioEffect[];
    protected _initialized: boolean;
    get initialized(): boolean;
    constructor(def: AudioEffectGraphState);
    initialize(): Observable<void>;
    /**
     * Finds all {@link AudioEffect}'s that correspond to {@link filter}
     *
     * @param filter
     */
    findAudioEffects(filter?: AudioEffectFilter): AudioEffect[];
    /**
     * Audio effects graph input {@link AudioEffect}'s
     */
    get sourceEffects(): AudioEffect[];
    /**
     * Audio effects graph output {@link AudioEffect}'s
     */
    get destinationEffects(): AudioEffect[];
    toState(): AudioEffectGraphState;
    destroy(): void;
}

/**
 * Connection definition for audio graph.
 */
export declare type AudioEffectGraphConnection = {
    slot: Extract<AudioEffectGraphSlot, 'router'>;
    routingPath?: Partial<AudioRoutingPath>;
} | {
    slot: Extract<AudioEffectGraphSlot, 'source'>;
} | {
    slot: Extract<AudioEffectGraphSlot, 'destination'>;
};

/**
 * Audio effects graph definition. Contains {@link AudioEffectState}'s
 */
export declare class AudioEffectGraphDef implements AudioEffectGraphState {
    effectDefs: AudioEffectState[];
    sourceEffectIds: string[];
    destinationEffectIds: string[];
    private constructor();
    static create(...effects: AudioEffectState[]): AudioEffectGraphDef;
}

export declare type AudioEffectGraphSlot = 'source' | 'router' | 'destination';

export declare type AudioEffectGraphSpecificConnection = {
    slot: Extract<AudioEffectGraphSlot, 'router'>;
    routingPath: AudioRoutingPath;
} | {
    slot: Extract<AudioEffectGraphSlot, 'source'>;
} | {
    slot: Extract<AudioEffectGraphSlot, 'destination'>;
};

/**
 * Audio graph definition. Contains {@link AudioEffectState}'s
 */
export declare interface AudioEffectGraphState {
    effectDefs: AudioEffectState[];
    /**
     * Effects graph input effects ids
     */
    sourceEffectIds: string[];
    /**
     * Effects graph output effects ids
     */
    destinationEffectIds: string[];
}

export declare class AudioEffectParam extends AudioNodeParam {
}

export declare interface AudioEffectParameterChange {
    effectId: string;
    parameterName: string;
    routingPath?: AudioRoutingPath;
}

export declare interface AudioEffectParamType extends AudioNodeParamType {
}

export declare interface AudioEffectsApi {
    setEffectGraph(effectGraphState: AudioEffectGraphState, effectGraphConnection: AudioEffectGraphConnection): Observable<void>;
    removeEffectGraph(effectGraphConnection: AudioEffectGraphConnection): Observable<void>;
    setEffectsParams(param: AudioEffectParam, effectGraphConnection: AudioEffectGraphConnection, filter?: AudioEffectFilter): Observable<void>;
    getEffectStates(effectGraphConnection: AudioEffectGraphConnection, filter?: AudioEffectFilter): Observable<AudioEffectState[]>;
    getEffectGraphState(effectGraphConnection: AudioEffectGraphSpecificConnection): Observable<AudioEffectGraphState | undefined>;
    onEvent$: Observable<AudioEffectEvent>;
}

export declare class AudioEffectsGraphDefBuilder {
    protected _effectDefs: AudioEffectState[];
    protected _effectDefsMap: Map<string, AudioEffectState>;
    protected _sourceEffectDefs?: AudioEffectState[];
    protected _destinationEffectDefs?: AudioEffectState[];
    private constructor();
    static get instance(): AudioEffectsGraphDefBuilder;
    addEffects(effectDefs: AudioEffectState[]): this;
    addEffect(node: AudioEffectState): this;
    connections(connections: [{
        from: string;
        to: string;
    }]): this;
    connect(sourceNodeId: string, destinationNodeId: string): this;
    sourceEffectsIds(ids: string[]): this;
    destinationEffectsIds(ids: string[]): this;
    build(): AudioEffectGraphState;
}

export declare interface AudioEffectSlotEventChangeData extends Serializable {
    connection: AudioEffectGraphConnection;
}

declare interface AudioEffectsMessageChannel {
    setEffectGraph(effectGraphState: AudioEffectGraphState, effectGraphConnection: AudioEffectGraphConnection): Observable<void>;
    removeEffectGraph(effectGraphConnection: AudioEffectGraphConnection): Observable<void>;
    setEffectsParams(param: AudioEffectParam, effectGraphConnection: AudioEffectGraphConnection, filter?: AudioEffectFilter): Observable<void>;
    getEffectStates(effectGraphConnection: AudioEffectGraphConnection, filter?: AudioEffectFilter): Observable<AudioEffectState[]>;
    getEffectGraphState(effectGraphConnection: AudioEffectGraphSpecificConnection): Observable<AudioEffectGraphState | undefined>;
    onEvent$: Observable<AudioEffectEvent>;
}

declare class AudioEffectsProxy extends BaseMessageChannelProxy<AudioEffectsMessageChannel> implements AudioEffectsApi {
    protected _destroyBreaker: ObserverBreaker;
    constructor(messageChannel: MessageChannel_2<AudioEffectsMessageChannel>);
    get onEvent$(): Observable<AudioEffectEvent>;
    setEffectGraph(effectGraphState: AudioEffectGraphState, effectGraphConnection: AudioEffectGraphConnection): Observable<void>;
    removeEffectGraph(effectGraphConnection: AudioEffectGraphConnection): Observable<void>;
    setEffectsParams(param: AudioEffectParam, effectGraphConnection: AudioEffectGraphConnection, filter?: AudioEffectFilter): Observable<void>;
    getEffectStates(effectGraphConnection: AudioEffectGraphConnection, filter?: AudioEffectFilter): Observable<AudioEffectState[]>;
    getEffectGraphState(effectGraphConnection: AudioEffectGraphSpecificConnection): Observable<AudioEffectGraphState | undefined>;
    destroy(): void;
}

export declare class AudioEffectsRegistry implements Destroyable {
    static get instance(): AudioEffectsRegistry;
    private registry;
    constructor();
    register(name: string, effect: AudioEffectFactory): void;
    destroy(): void;
    get(name: string): AudioEffectFactory | undefined;
}

/**
 * Definition of an audio effect.
 */
export declare interface AudioEffectState {
    id: string;
    /**
     * Effect type as used in EffectsRegistry. There are no limitations to effect types
     * but they need to be dynamically added to EffectsRegistry.
     */
    effectType: string;
    /**
     * Arbitrary attributes which can be used to describe audio effect.
     */
    attrs?: Record<string, any>;
    /**
     * Connections to other {@link OmpAudioNodeDef}'s
     */
    connections?: AudioEffectConnectionDef[];
    /**
     * Audio effect params
     */
    audioParams?: AudioEffectParamType[];
}

export declare class AudioEffectsUtil {
    /**
     * Calculates crossfade gain value for {@link value} and {@link curve}
     *
     * @param value in [0, 1] range
     * @param curve
     */
    static crossfadeGain(value: number, curve?: 'linear' | 'equal-power' | 'log' | 'sigmoid'): {
        left: number;
        right: number;
    };
}

export declare class AudioFile extends Audio_2 {
    protected _audioType: AudioType;
    constructor(args: AudioArgs);
}

declare interface AudioFileMainMediaArgs extends BaseMainMediaArgs {
    source: Source;
}

declare interface AudioFileMainMediaState extends MainMediaState {
}

declare interface AudioFilePlayerControllerConfig extends PlayerControllerConfig {
}

declare interface AudioFilePlayerPlaybackEngine extends PlayerPlaybackEngine {
}

export declare interface AudioHandlerApi {
    onEvent$: Observable<AudioHandlerEvent>;
    onPeakProcessorEvent$: Observable<AudioPeakProcessorEvent>;
    enabled: boolean;
    inputAudioNode: AudioNode;
    outputAudioNode: AudioNode;
    channelCount: number;
    volume: number;
    muted: boolean;
    state: AudioHandlerState;
    effects: AudioEffectsApi;
    router: AudioRouterApi | undefined;
    mute(): Observable<void>;
    unmute(): Observable<void>;
    toggleMuted(): Observable<void>;
    setMuted(muted: boolean): Observable<void>;
    setVolume(volume: number): Observable<void>;
    setEnabled(enabled: boolean): Observable<void>;
    createPeakProcessor(): Observable<void>;
    createPeakProcessor(meterStandard?: AudioPeakProcessorMeterStandard): Observable<void>;
    createAudioRouter(inputsNumber?: number, outputsNumber?: number): Observable<AudioRouterApi>;
}

export declare type AudioHandlerEvent = {
    [K in AudioHandlerEventType]: {
        type: K;
        data: AudioHandlerEventTypeDataMap[K];
    };
}[keyof AudioHandlerEventTypeDataMap];

export declare interface AudioHandlerEventData extends Serializable {
    state: AudioHandlerState;
}

export declare enum AudioHandlerEventType {
    AUDIO_HANDLER_CHANGE = "AUDIO_HANDLER_CHANGE"
}

declare type AudioHandlerEventTypeDataMap = {
    [AudioHandlerEventType.AUDIO_HANDLER_CHANGE]: AudioHandlerEventData;
};

declare interface AudioHandlerMessageChannel {
    onEvent$: Observable<AudioHandlerEvent>;
    onPeakProcessorEvent$: Observable<AudioPeakProcessorEvent>;
    mute(): Observable<void>;
    unmute(): Observable<void>;
    toggleMuted(): Observable<void>;
    setMuted(muted: boolean): Observable<void>;
    setVolume(volume: number): Observable<void>;
    setEnabled(enabled: boolean): Observable<void>;
    state(): Observable<AudioHandlerState>;
    createPeakProcessor(meterStandard?: AudioPeakProcessorMeterStandard): Observable<void>;
    createAudioRouter(inputsNumber?: number, outputsNumber?: number): Observable<void>;
}

declare class AudioHandlerProxy extends BaseMessageChannelProxy<AudioHandlerMessageChannel> implements AudioHandlerApi {
    protected _remoteNode: RemoteNode;
    private _state?;
    protected _audioEffects: AudioEffectsProxy;
    protected _audioRouter: AudioRouterProxy | undefined;
    private readonly _onEventQueue$;
    protected _destroyBreaker: ObserverBreaker;
    constructor(messageChannel: MessageChannel_2<AudioHandlerMessageChannel>, remoteNode: RemoteNode, state: AudioHandlerState);
    private syncStateOperator;
    get router(): AudioRouterProxy | undefined;
    get effects(): AudioEffectsApi;
    private checkLateInitialization;
    updateFromState(state: AudioHandlerState): void;
    get inputAudioNode(): AudioNode;
    get outputAudioNode(): AudioNode;
    get onEvent$(): Observable<AudioHandlerEvent>;
    get onPeakProcessorEvent$(): Observable<AudioPeakProcessorEvent>;
    get enabled(): boolean;
    get channelCount(): number;
    get muted(): boolean;
    get volume(): number;
    get state(): AudioHandlerState;
    mute(): Observable<void>;
    setEnabled(enabled: boolean): Observable<void>;
    setMuted(muted: boolean): Observable<void>;
    setVolume(volume: number): Observable<void>;
    toggleMuted(): Observable<void>;
    unmute(): Observable<void>;
    createPeakProcessor(meterStandard?: AudioPeakProcessorMeterStandard): Observable<void>;
    createAudioRouter(inputsNumber?: number, outputsNumber?: number): Observable<AudioRouterApi>;
    destroy(): void;
}

declare interface AudioHandlerSlotState {
    type: AudioSlotType;
    effectGraph: AudioEffectGraphState;
}

export declare interface AudioHandlerState {
    enabled: boolean;
    channelCount: number;
    volume: number;
    muted: boolean;
    peakProcessor: AudioPeakProcessorState | undefined;
    router: AudioRouterState | undefined;
    slots: AudioHandlerSlotState[];
}

export declare type AudioLevelEvent = {
    [K in AudioLevelEventType]: {
        type: K;
        data: AudioLevelEventTypeDataMap[K];
    };
}[keyof AudioLevelEventTypeDataMap];

export declare interface AudioLevelEventData extends Serializable {
    dbValues: number[];
}

export declare enum AudioLevelEventType {
    AUDIO_LEVEL_CHANGE = "AUDIO_LEVEL_CHANGE",
    CHANNEL_COUNT_CHANGE = "CHANNEL_COUNT_CHANGE"
}

export declare type AudioLevelEventTypeDataMap = {
    [AudioLevelEventType.AUDIO_LEVEL_CHANGE]: AudioLevelEventData;
    [AudioLevelEventType.CHANNEL_COUNT_CHANGE]: ChannelCountEventData;
};

export declare abstract class AudioLevelSource implements AudioLevelSourceApi {
    protected _onEvent$: Subject<AudioLevelEvent>;
    protected _destroyBreaker: ObserverBreaker;
    get onEvent$(): Observable<AudioLevelEvent>;
    protected getBaseLog(x: number, y: number): number;
    protected dbFromFloat(floatVal: number): number;
    destroy(): void;
}

export declare interface AudioLevelSourceApi extends Destroyable {
    onEvent$: Observable<AudioLevelEvent>;
}

export declare enum AudioLevelSourceType {
    PEAK_PROCESSOR = "PEAK_PROCESSOR",
    OBSERVATION_TRACK = "OBSERVATION_TRACK"
}

declare class AudioMainMedia extends BaseMainMedia<AudioFileMainMediaState> {
    protected getState(): AudioFileMainMediaState;
    protected _mainMediaType: MainMediaType;
    protected _source: Source;
    protected readonly _destroyBreaker: ObserverBreaker;
    constructor(args: AudioFileMainMediaArgs);
    protected _state(): AudioFileMainMediaState;
}

/**
 * Wrapper for {@link AudioParam}
 */
export declare class AudioNodeParam implements AudioNodeParamType {
    name: string;
    props: AudioNodeParamPropType[];
    constructor(name: string);
    protected addProp(prop: AudioNodeParamPropType): void;
}

export declare interface AudioNodeParamFilter {
    name?: string;
    id?: string;
}

/**
 * Wrapper for {@link AudioParam} attributes
 */
export declare interface AudioNodeParamPropType {
    name: string;
    value: any;
}

/**
 * Wrapper for {@link AudioParam}
 */
export declare interface AudioNodeParamType {
    name: string;
    props: AudioNodeParamPropType[];
}

export declare class AudioNodeUtil {
    static extractAudioParamProps(audioParam: AudioParam): AudioNodeParamPropType[];
}

/**
 * Wrapper for {@link AudioParam} attributes
 */
export declare class AudioNodeValueParam implements AudioNodeParamPropType {
    name: string;
    value: any;
    constructor(value: any);
    setValue(value: any): void;
}

export declare class AudioPeakProcessor implements AudioPeakProcessorApi {
    protected readonly _onEvent$: Subject<AudioPeakProcessorEvent>;
    protected readonly _meterStandard: AudioPeakProcessorMeterStandard;
    protected readonly _loadStage: OpStage;
    protected _audioWorkletNode?: AudioWorkletNode;
    protected _audioNode?: AudioNode;
    protected _destroyBreaker: ObserverBreaker;
    constructor(meterStandard?: AudioPeakProcessorMeterStandard);
    load(audioNode: AudioNode): Observable<void>;
    protected handleAudioPeakProcessorMessage: (event: MessageEvent) => void;
    get onEvent$(): Observable<AudioPeakProcessorEvent>;
    get state(): AudioPeakProcessorState;
    destroy(): void;
}

export declare interface AudioPeakProcessorApi extends Destroyable {
    onEvent$: Observable<AudioPeakProcessorEvent>;
    state: AudioPeakProcessorState;
    load(audioNode: AudioNode): Observable<void>;
}

export declare interface AudioPeakProcessorErrorEventData extends AudioPeakProcessorEventData {
    error: string | undefined;
}

export declare type AudioPeakProcessorEvent = {
    [K in AudioPeakProcessorEventType]: {
        type: K;
        data: AudioPeakProcessorEventTypeDataMap[K];
    };
}[keyof AudioPeakProcessorEventTypeDataMap];

export declare interface AudioPeakProcessorEventData extends Serializable {
}

export declare enum AudioPeakProcessorEventType {
    AUDIO_PEAK_PROCESSOR_LOADING = "AUDIO_PEAK_PROCESSOR_LOADING",
    AUDIO_PEAK_PROCESSOR_LOADED = "AUDIO_PEAK_PROCESSOR_LOADED",
    AUDIO_PEAK_PROCESSOR_LOAD_ERROR = "AUDIO_PEAK_PROCESSOR_LOAD_ERROR",
    AUDIO_PEAK_PROCESSOR_MESSAGE = "AUDIO_PEAK_PROCESSOR_MESSAGE"
}

export declare type AudioPeakProcessorEventTypeDataMap = {
    [AudioPeakProcessorEventType.AUDIO_PEAK_PROCESSOR_LOADING]: AudioPeakProcessorEventData;
    [AudioPeakProcessorEventType.AUDIO_PEAK_PROCESSOR_LOADED]: AudioPeakProcessorEventData;
    [AudioPeakProcessorEventType.AUDIO_PEAK_PROCESSOR_LOAD_ERROR]: AudioPeakProcessorErrorEventData;
    [AudioPeakProcessorEventType.AUDIO_PEAK_PROCESSOR_MESSAGE]: AudioPeakProcessorMessage;
};

export declare type AudioPeakProcessorMessage = AudioPeakProcessorMessageMessage | AudioPeakProcessorPeaksMessage;

export declare interface AudioPeakProcessorMessageMessage {
    type: 'message';
    message: number[][];
}

export declare enum AudioPeakProcessorMeterStandard {
    PEAK_SAMPLE = "PEAK_SAMPLE",
    TRUE_PEAK = "TRUE_PEAK"
}

export declare interface AudioPeakProcessorPeaksMessage {
    type: 'peaks';
    peaks: number[];
}

export declare interface AudioPeakProcessorState {
    /**
     * Audio peak processing strategy
     */
    meterStandard: AudioPeakProcessorMeterStandard;
    loadStage: OpStageState;
}

export declare enum AudioPlayerSize {
    FULL = "FULL",
    COMPACT = "COMPACT"
}

declare interface AudioProbeMetadata {
    channelsNumber: number;
    codec: string;
}

export declare class AudioRouter implements InternalAudioRouterApi {
    protected readonly _onEvent$: Subject<AudioRouterEvent>;
    protected readonly _loadStage: OpStage;
    protected _inputsNumber: number;
    protected _outputsNumber: number;
    protected _sourceAudioNode?: AudioNode;
    protected _channelSplitterNode: ChannelSplitterNode;
    protected _channelMergerNode: ChannelMergerNode;
    protected _defaultRoutingConnections: AudioRoutingConnection[];
    protected _soloMuteStatesByInput: Map<number, AudioRouterSoloMuteState>;
    protected _suppressMuteEvents: boolean;
    protected _muteEventAllowedInputs: Set<number> | undefined;
    protected _connectionsByInputOutput: Map<number, Map<number, AudioRoutingConnection>>;
    protected _effectGraphsByInputOutput: Map<number, Map<number, AudioEffectGraph | undefined>>;
    protected _destroyBreaker: ObserverBreaker;
    constructor(audioOutputNode: AudioNode, inputsNumber: number, outputsNumberResolver?: (maxChannelCount: number) => number);
    setDefaultRoutingConnections(connections: AudioRoutingConnection[]): Observable<void>;
    resetRouter(): Observable<void>;
    get onEvent$(): Observable<AudioRouterEvent>;
    load(): Observable<void>;
    get isSourceConnected(): boolean;
    disconnectSource(): void;
    connectSource(audioNode: AudioNode): void;
    updateConnections(connections: AudioRoutingConnection[]): Observable<void>;
    protected _updateConnection(newConnection: AudioRoutingConnection, emitEvent?: boolean): void;
    protected emitChange(): void;
    protected emitSoloChange(inputNumber: number): void;
    protected emitMuteChange(inputNumber: number): void;
    getDefaultRoutingConnections(): AudioRoutingConnection[];
    protected getRoutingConnections(): AudioRoutingConnection[][];
    get state(): AudioRouterState;
    restoreState(state: AudioRouterState): Observable<void>;
    toggleSolo(routingPath: AudioRoutingInputPath): Observable<void>;
    protected _solo(inputNumber: number): void;
    private setInputSoloMuteState;
    protected _unsolo(inputNumber: number, checkMute?: boolean): void;
    toggleMute(routingPath: AudioRoutingInputPath): Observable<void>;
    protected _mute(inputNumber: number): void;
    protected _unmute(inputNumber: number): void;
    private getInitialRoutingConnectionsForInput;
    protected resetInputSoloMuteState(inputNumber: number): void;
    protected createInitialSoloMuteState(inputNumber: number): AudioRouterSoloMuteState;
    /**
     * Recomputes solo/mute states after connections change.
     * Solo/mute change events are emitted inline via {@link setInputSoloMuteState}/{@link resetInputSoloMuteState}.
     * A soloed input can only be unsoloed here (never soloed), when both mute and solo can be emitted, mute(s) are emitted.
     */
    protected _updateInputsSoloMuteState(): void;
    setAudioEffectGraphs(effectGraphState: AudioEffectGraphState, routingPath?: Partial<AudioRoutingPath>): Observable<void>;
    removeAudioEffectGraphs(routingPath?: Partial<AudioRoutingPath>): void;
    findAudioEffectGraphs(routingPath?: Partial<AudioRoutingPath>): RoutedAudioEffectGraph[];
    getEffectGraphState(routingPath: AudioRoutingPath): AudioEffectGraphState | undefined;
    protected _findRoutedAudioEffects(filter?: {
        routingPath?: Partial<AudioRoutingPath> | undefined;
    } & AudioEffectFilter): RoutedAudioEffect[];
    findAudioEffects(filter?: {
        routingPath?: Partial<AudioRoutingPath> | undefined;
    } & AudioEffectFilter): AudioEffect[];
    findAudioEffectStates(filter?: {
        routingPath?: Partial<AudioRoutingPath> | undefined;
    } & AudioEffectFilter): AudioEffectState[];
    setAudioEffectParams(param: AudioEffectParam, filter?: {
        routingPath?: Partial<AudioRoutingPath> | undefined;
    } & AudioEffectFilter): {
        id: string;
        routingPath: AudioRoutingPath;
    }[];
    private _setEffectsGraphs;
    private _checkIfEffectsGraphsCanBeChanged;
    private _setEffectGraph;
    private _getByRoutingPath;
    private connectEffectGraph;
    private disconnectEffectGraph;
    destroy(): void;
}

export declare interface AudioRouterApi {
    onEvent$: Observable<AudioRouterEvent>;
    state: AudioRouterState;
    getDefaultRoutingConnections(): AudioRoutingConnection[];
    setDefaultRoutingConnections(connections: AudioRoutingConnection[]): Observable<void>;
    toggleSolo(routingPath: AudioRoutingInputPath): Observable<void>;
    toggleMute(routingPath: AudioRoutingInputPath): Observable<void>;
    resetRouter(): Observable<void>;
    updateConnections(connections: AudioRoutingConnection[]): Observable<void>;
}

export declare interface AudioRouterErrorEventData extends AudioRouterEventData {
    error: string | undefined;
}

export declare type AudioRouterEvent = {
    [K in AudioRouterEventType]: {
        type: K;
        data: AudioRouterEventTypeDataMap[K];
    };
}[keyof AudioRouterEventTypeDataMap];

export declare interface AudioRouterEventData extends Serializable {
    state: AudioRouterState;
}

export declare enum AudioRouterEventType {
    AUDIO_ROUTER_LOADING = "AUDIO_ROUTER_LOADING",
    AUDIO_ROUTER_LOADED = "AUDIO_ROUTER_LOADED",
    AUDIO_ROUTER_LOAD_ERROR = "AUDIO_ROUTER_LOAD_ERROR",
    AUDIO_ROUTER_CHANGE = "AUDIO_ROUTER_CHANGE",
    AUDIO_ROUTER_SOLO_CHANGE = "AUDIO_ROUTER_SOLO_CHANGE",
    AUDIO_ROUTER_MUTE_CHANGE = "AUDIO_ROUTER_MUTE_CHANGE"
}

export declare type AudioRouterEventTypeDataMap = {
    [AudioRouterEventType.AUDIO_ROUTER_LOADING]: AudioRouterEventData;
    [AudioRouterEventType.AUDIO_ROUTER_LOADED]: AudioRouterEventData;
    [AudioRouterEventType.AUDIO_ROUTER_LOAD_ERROR]: AudioRouterErrorEventData;
    [AudioRouterEventType.AUDIO_ROUTER_CHANGE]: AudioRouterEventData;
    [AudioRouterEventType.AUDIO_ROUTER_SOLO_CHANGE]: AudioRouterSoloChangeEventData;
    [AudioRouterEventType.AUDIO_ROUTER_MUTE_CHANGE]: AudioRouterMuteChangeEventData;
};

declare interface AudioRouterMessageChannel {
    onEvent$: Observable<AudioRouterEvent>;
    state: Observable<AudioRouterState>;
    getDefaultRoutingConnections(): Observable<AudioRoutingConnection[]>;
    setDefaultRoutingConnections(connections: AudioRoutingConnection[]): Observable<void>;
    toggleSolo(routingPath: AudioRoutingInputPath): Observable<void>;
    toggleMute(routingPath: AudioRoutingInputPath): Observable<void>;
    resetRouter(): Observable<void>;
    updateConnections(connections: AudioRoutingConnection[]): Observable<void>;
}

export declare interface AudioRouterMuteChangeEventData extends Serializable {
    state: Omit<AudioRouterSoloMuteState, 'soloed' | 'inputSoloedConnections' | 'unsoloConnections'>;
}

declare class AudioRouterProxy extends BaseMessageChannelProxy<AudioRouterMessageChannel> implements AudioRouterApi {
    protected _destroyBreaker: ObserverBreaker;
    protected _routerState?: AudioRouterState;
    protected _audioRouterEventEmmiter$: Subject<AudioRouterEvent>;
    constructor(messageChannel: MessageChannel_2<AudioRouterMessageChannel>);
    get onEvent$(): Observable<AudioRouterEvent>;
    get state(): AudioRouterState;
    getDefaultRoutingConnections(): AudioRoutingConnection[];
    setDefaultRoutingConnections(connections: AudioRoutingConnection[]): Observable<void>;
    toggleSolo(routingPath: AudioRoutingInputPath): Observable<void>;
    toggleMute(routingPath: AudioRoutingInputPath): Observable<void>;
    resetRouter(): Observable<void>;
    updateConnections(connections: AudioRoutingConnection[]): Observable<void>;
    private checkLateInitialization;
    updateFromState(routerState: AudioRouterState): void;
    protected tryLateInitialization(): void;
    private syncStateOperator;
}

export declare interface AudioRouterSoloChangeEventData extends Serializable {
    state: Omit<AudioRouterSoloMuteState, 'muted' | 'inputMutedConnections'>;
}

export declare interface AudioRouterSoloMuteState {
    /**
     * Audio router input number
     */
    inputNumber: number;
    /**
     * Flag that tells if audio router input is soloed
     */
    soloed: boolean;
    /**
     * Flag that tells if audio router input is muted
     */
    muted: boolean;
    /**
     * Audio router soloed input connections
     */
    inputSoloedConnections: AudioRoutingConnection[];
    /**
     * Audio router muted input connections
     */
    inputMutedConnections: AudioRoutingConnection[];
    /**
     * Audio router connections before input solo action (current input connections are not included)
     */
    unsoloConnections: AudioRoutingConnection[];
}

export declare interface AudioRouterState {
    loadStage: OpStageState;
    /**
     * Number of audio inputs
     */
    inputsNumber: number;
    /**
     * Number of audio outputs
     */
    outputsNumber: number;
    /**
     * Audio routing matrix
     */
    routingConnections: AudioRoutingConnection[][];
    /**
     * Audio router initial/default connections
     */
    initialRoutingConnections: AudioRoutingConnection[];
    routingRoutes: AudioRoutingRoute[];
    /**
     * Per-input solo/mute state
     */
    soloMuteStates: AudioRouterSoloMuteState[];
}

/**
 * Describes {@ OmpAudioRoutingPoint} connection status - connected or disconnected
 */
export declare interface AudioRoutingConnection {
    /**
     * Routing path - channel splitter output and channel merger input
     */
    path: AudioRoutingPath;
    /**
     * Connected status, true = connected, false = disconnected
     */
    connected: boolean;
}

export declare type AudioRoutingInputPath = Pick<AudioRoutingPath, 'input'>;

export declare type AudioRoutingOutputPath = Pick<AudioRoutingPath, 'output'>;

/**
 * Describes routing path - channel splitter output and channel merger input
 */
export declare interface AudioRoutingPath {
    /**
     * Input - Channel splitter output
     */
    input: number;
    /**
     * Output - Channel merger input
     */
    output: number;
}

/**
 * Describes state on {@link AudioRoutingPath}
 */
export declare interface AudioRoutingRoute {
    /**
     * Routing path
     */
    path: AudioRoutingPath;
    /**
     * Connection status
     */
    connection: AudioRoutingConnection;
    /**
     * Audio effect graph state
     */
    audioEffectGraphState: AudioEffectGraphState | undefined;
}

declare type AudioSlotType = 'source' | 'router' | 'destination';

/**
 * Serializable snapshot of an audio {@link Track}.
 */
export declare interface AudioState extends TrackState {
    audioType: AudioType;
    url: string | undefined;
    duration: number | undefined;
    audioCodec: string | undefined;
    channels: number | undefined;
}

export declare interface AudioThemeConfig extends AudioThemeConfigUpdateableAttrs {
    /**
     * Specifies list of enabled floating controls
     */
    floatingControls: AudioThemeFloatingControl[];
    /**
     * Specifies list of floating controls that are shown when the video is playing
     */
    alwaysOnFloatingControls: AudioThemeFloatingControl[];
    /**
     * Sets the available playback rates in menu
     */
    playbackRates: number[];
    /**
     * Enables/disables the audio visualization
     */
    visualization: AudioVisualization;
    /**
     * Configures the audio visualization
     */
    visualizationConfig: AudioVisualizationConfig;
    /**
     * Id of the custom web component used for Player chroming
     */
    htmlTemplateId?: string;
}

export declare interface AudioThemeConfigUpdateableAttrs {
    /**
     * Specifies controls visibility
     */
    controlBarVisibility: Omit<ControlBarVisibility, ControlBarVisibility.FULLSCREEN_ONLY>;
    /**
     * Specifies list of enabled controls in control bar
     */
    controlBar: AudioThemeControl[];
    /**
     * Specifies the audio player size
     */
    playerSize: AudioPlayerSize;
    /**
     * Specifies which time format will be used in the timer control
     */
    timeFormat: ChromingTimeFormat;
    /**
     * Specifies if the time control can be used for seeking. It is activated by double clicking the time.
     */
    timeInteractive: boolean;
}

export declare enum AudioThemeControl {
    PLAY = "PLAY",
    VOLUME = "VOLUME",
    PLAYBACK_RATE = "PLAYBACK_RATE",
    TRACK_SELECTOR = "TRACK_SELECTOR",
    SCRUBBER = "SCRUBBER",
    TIME = "TIME",
    ROUTER = "ROUTER"
}

export declare enum AudioThemeFloatingControl {
    PLAYBACK_CONTROLS = "PLAYBACK_CONTROLS",
    HELP_MENU = "HELP_MENU"
}

declare interface AudioTrackController extends TrackController<TrackControllerEvent> {
    onBufferingRequired$: Observable<boolean>;
    handler: PlayerAudioHandlerApi;
}

declare type AudioTrackIdentifier = any;

/** Load options for audio tracks. */
export declare interface AudioTrackLoadOptions extends BaseTrackLoadOptions {
    args?: AudioArgs;
}

/**
 * Discriminator for the origin of an audio track.
 */
export declare enum AudioType {
    /** Standalone audio file loaded as a sidecar. */
    AUDIO_FILE = "AUDIO_FILE",
    /** Audio rendition extracted from an HLS manifest. */
    HLS_AUDIO = "HLS_AUDIO",
    /** Audio track from an MP4 container. */
    MP4_AUDIO = "MP4_AUDIO"
}

/**
 * Subset of {@link AudioState} fields that can be updated at runtime.
 */
export declare type AudioUpdateableAttrs = TrackUpdateableAttrs & Pick<AudioState, 'channels'>;

export declare enum AudioVisualization {
    DISABLED = "DISABLED",
    ENABLED = "ENABLED"
}

export declare interface AudioVisualizationConfig {
    /**
     * Hex value for the stroke color
     */
    strokeColor: string;
    /**
     * Hex values for the fill gradient colors
     */
    fillColors: string[];
}

export declare class AuthConfig {
    static _authentication?: AuthenticationData | undefined;
    static set authentication(authentication: AuthenticationData | undefined);
    static get authentication(): AuthenticationData | undefined;
    /**
     * Creates a fetch-compatible RequestInit object
     */
    static createRequestInit(url: string, authentication?: AuthenticationData): RequestInit;
}

/** Union of all supported authentication strategies. */
export declare type AuthenticationData = BasicAuthenticationData | BearerAuthenticationData | CustomAuthenticationData;

export declare class BarChartLane extends BaseObservationTrackLane<BarChartLaneConfig, BarChartLaneStyle, BarChartLaneTrackConfig> {
    protected _downsamplers: Map<ObservationTrack['id'], ObservationTrackDownsampler>;
    private _typedTrackViews;
    constructor(configAndStyle?: ConfigAndStyle<BarChartLaneConfig, BarChartLaneStyle>);
    addTrack(track: ObservationTrack, config?: BarChartLaneTrackConfig): void;
    addTrack(id: ObservationTrack['id'], config?: BarChartLaneTrackConfig): void;
    protected renderTrack(track: ObservationTrack, config: BarChartLaneTrackConfig | undefined): ObservationTrackView;
    protected onTrackRemoved(trackId: ObservationTrack['id']): void;
    protected hasVisualElements(): boolean;
    protected updatePositions(): void;
    protected createLoadingGroupContent(width: number, height: number): default_3.Animation;
    private _createDefaultLoadingAnimation;
    private _createOgLoadingAnimation;
    destroy(): void;
}

export declare interface BarChartLaneConfig extends ObservationTrackLaneConfig {
}

export declare interface BarChartLaneStyle extends ObservationTrackLaneStyle {
}

/**
 * Per-track configuration for {@link BarChartLane}.
 * Each track added via `addTrack()` can carry its own scale, baseline, interpolation
 * settings, and visual style that override lane-level defaults.
 */
export declare interface BarChartLaneTrackConfig extends ObservationTrackLaneTrackConfig {
    /** Value domain for this track. Auto-derived from data when omitted. */
    scale?: BarChartLaneTrackScale;
    /** Value that maps to the bar baseline (zero-crossing). Defaults to 0. */
    scaleBaseline?: number;
    /** Aggregation strategy used when multiple samples fall in the same interpolation bucket. */
    interpolationStrategy?: InterpolationStrategy;
    /** Width in pixels of a single interpolation bucket. Smaller = more detail */
    interpolationWidth?: number;
    style?: BarChartLaneTrackStyle;
}

/**
 * Visual style for a single measurement series within a bar-chart track.
 * Matched to data by `measurement`; unmatched measurements use defaults.
 */
export declare interface BarChartLaneTrackMeasurementStyle {
    /** Measurement this style applies to (matches {@link ObservationItem.measurement}). */
    measurement: ObservationItem['measurement'];
    /** Bar rendering mode: `'default'` draws rectangles, `'og'` draws a column of stacked circles. */
    barType: 'default' | 'og';
    /** Solid fill color. Mutually exclusive with `fillLinearGradientColorStops`. */
    fill: Color;
    /** Gradient color stops (Konva format). Used when `fill` is not set. */
    fillLinearGradientColorStops: (number | string)[];
    /** Overall bar opacity (0–1). */
    opacity: Size;
    /** Corner radius for `'default'` bars. */
    cornerRadius: Size | [Size, Size, Size, Size];
    /** Stroke color drawn around each bar. */
    strokeColor: Color;
    /** Stroke width in pixels. */
    strokeWidth: Size;
    /** Horizontal padding inside the bar's allocated width. Single value = symmetric; tuple = [left, right]. */
    paddingX: Size | [Size, Size];
}

declare type BarChartLaneTrackScale = {
    min: number;
    max: number;
};

export declare interface BarChartLaneTrackStyle {
    paddingTop?: number;
    paddingBottom?: number;
    baselineFill?: Color;
    baselineThickness?: Size;
    baselineDash?: Size[];
    measurements?: Partial<BarChartLaneTrackMeasurementStyle>[];
}

export declare type BarChartViewComponentEvent = {
    [K in BarChartViewComponentEventType]: {
        type: K;
        data: BarChartViewComponentEventTypeDataMap[K];
    };
}[keyof BarChartViewComponentEventTypeDataMap];

export declare interface BarChartViewComponentEventData {
    item: ObservationState;
    pointerPosition: Position;
}

export declare enum BarChartViewComponentEventType {
    CLICK = "CLICK",
    MOUSE_MOVE = "MOUSE_MOVE",
    MOUSE_ENTER = "MOUSE_ENTER",
    MOUSE_LEAVE = "MOUSE_LEAVE"
}

export declare type BarChartViewComponentEventTypeDataMap = {
    [BarChartViewComponentEventType.CLICK]: BarChartViewComponentEventData;
    [BarChartViewComponentEventType.MOUSE_MOVE]: BarChartViewComponentEventData;
    [BarChartViewComponentEventType.MOUSE_ENTER]: BarChartViewComponentEventData;
    [BarChartViewComponentEventType.MOUSE_LEAVE]: BarChartViewComponentEventData;
};

declare abstract class BaseChroming implements ChromingInternalApi, Destroyable {
    protected readonly _onEvent$: Subject<ChromingEvent>;
    protected _destroyBreaker: ObserverBreaker;
    protected _config: ChromingInternalConfig;
    protected _playerInternal: PlayerInternalApi | undefined;
    protected _alertDuration: number;
    private _watermark;
    private _helpMenuGroups;
    private _videoSafeZones;
    protected _thumbnailTrackId: Track['id'] | undefined;
    protected _markerTrackHandlers: {
        [ChromingTrackDestination.PROGRESS_BAR]: ChromingMarkerBarHandler | undefined;
        [ChromingTrackDestination.MARKER_BARS]: ChromingMarkerBarHandler[];
    };
    protected _domController: ChromingDomController<ChromingThemeTypes>;
    protected constructor(config: ChromingInternalConfig);
    abstract addMarkerBar(trackId: Track['id'], destination: ChromingTrackDestination, config?: Partial<ChromingMarkerBarConfig>): Observable<ChromingMarkerBarState['id']>;
    abstract setMarkerBars(markerBars: ChromingMarkerBarState[], progressBarMarkerBar?: ChromingMarkerBarState): Observable<void>;
    abstract updateMarker(markerTrack: MarkerTrackState, marker: MarkerState, attrs: MarkerUpdateableAttrs): void;
    abstract setThumbnailTrack(trackId: Track['id'] | undefined): Observable<void>;
    abstract restoreAlerts(): Observable<void>;
    protected abstract addAudioTrackObserver(trackId: Track['id'], breaker$: Observable<any>, audioType: PlayerAudioType.MAIN | PlayerAudioType.SIDECAR): void;
    protected abstract addTextTrackObserver(trackId: Track['id'], breaker$: Observable<any>): void;
    protected abstract getMarkerTrackState(trackId: Track['id']): Observable<MarkerTrackState | undefined>;
    protected handleTrackRepositoryDeleteEvent(event: TrackRepositoryEvent): void;
    protected handleMarkerTrackEvent(event: TimedItemsTrackEvent): void;
    protected handleThumbnailTrackEvent(event: TimedItemsTrackEvent, trackState: ThumbnailTrackState): void;
    setPlayerInternal(playerInternal: PlayerInternalApi): void;
    get onEvent$(): Observable<ChromingEvent>;
    restoreChromingSession(chromingSession: ChromingSession): Observable<void>;
    protected resolveTheme(): ChromingTheme;
    protected resolveThemeConfig(): Partial<DefaultThemeConfig | StampThemeConfig | ChromelessThemeConfig | AudioThemeConfig | OmakaseThemeConfig | CustomThemeConfig> | undefined;
    get state(): ChromingState;
    get chromingSession(): ChromingSession;
    emitChromingChange(): void;
    emitSafeZonesChange(): void;
    emitHelpMenuChange(): void;
    emitMarkerTrackChange(): void;
    emitThumbnailTrackChange(): void;
    emitThemeConfigChange(): void;
    emitWatermarkChange(watermark: string | undefined): void;
    setWatermark(watermark: string | undefined): Observable<void>;
    get videoSafeZones(): VideoSafeZone[];
    setSafeZones(videoSafeZones: VideoSafeZone[]): Observable<void>;
    addSafeZone(videoSafeZone: VideoSafeZoneCreate): Observable<VideoSafeZone>;
    removeSafeZone(id: string): Observable<void>;
    removeAllSafeZones(): Observable<void>;
    get helpMenuGroups(): HelpMenuGroup[];
    setHelpMenuGroups(helpMenuGroups: HelpMenuGroup[]): Observable<void>;
    addHelpMenuGroup(helpMenuGroup: HelpMenuGroup, insertPosition?: HelpMenuGroupInsertPosition): Observable<HelpMenuGroup>;
    clearHelpMenuGroups(): Observable<void>;
    setFloatingTimeVisible(visible: boolean, interactive?: boolean, openEditMode?: boolean): Observable<void>;
    setFloatingVuMeterVisible(visible: boolean): Observable<void>;
    setTimeFormat(timeFormat: ChromingTimeFormat): Observable<void>;
    setThemeConfig(themeConfig: Partial<ChromingThemeConfigTypes>): Observable<void>;
    setVuMeterConfig(vuMeterConfig: Partial<ChromingVuMeterConfig>, position?: ChromingVuMeterPosition): Observable<void>;
    toggleFullScreen(): Observable<void>;
    getPlayerChromingElement<T>(querySelector: string): T;
    getMarkerBars(): ChromingMarkerBarHandlers;
    getMarkerBar(id: string): ChromingMarkerBarHandlerApi | undefined;
    deleteMarkerBar(id: string): Observable<void>;
    protected createMarkerElementAndHandler(markerTracks: MarkerTrackState[], destination: ChromingTrackDestination, config?: Partial<ChromingMarkerBarConfig>, trackState?: ChromingMarkerBarState, ui?: Ui | UiProxy): ChromingMarkerBarHandlerApi;
    get isFloatingTimeVisible(): boolean | undefined;
    get timeFormat(): ChromingTimeFormat | undefined;
    get domController(): ChromingDomController<ChromingThemeTypes>;
    destroy(): void;
}

declare abstract class BaseFlexGroup<C extends FlexGroupConfig, T extends FlexGroupContentNode<any>> extends BaseFlexNode<C, T> {
    private _children;
    protected constructor(config: C, contentNode: T);
    protected processOptions(): void;
    addChild(flexNode: FlexNode<any>, index?: number | undefined): BaseFlexGroup<C, T>;
    addChildren(...flexNodes: FlexNode<any>[]): BaseFlexGroup<C, T>;
    addChildInternal(flexNode: FlexNode<any>, index: number, refreshLayout?: boolean): BaseFlexGroup<C, T>;
    removeChild(flexNode: FlexNode<any>, refreshLayout?: boolean): this;
    protected _removeChild(flexNode: FlexNode<any>, refreshLayout: boolean): this;
    refreshLayout(): BaseFlexGroup<C, T>;
    applyLayout(): void;
    destroy(): void;
    private setJustifyContent;
    private setAlignContent;
    private setAlignItems;
    private setFlexDirection;
    private setFlexWrap;
    getChildren(): FlexNode<any>[];
}

declare abstract class BaseFlexNode<C extends FlexNodeConfig, T extends FlexContentNode> implements FlexNode<T> {
    protected _name: string;
    protected _config: C;
    protected _parent?: FlexNode<any>;
    protected _contentNode: T;
    protected _yogaConfig: Config;
    protected _yogaNode: Node_2;
    protected constructor(config: C, contentNode: T);
    protected processOptions(): void;
    protected setWidthInternal(value: number | string | 'auto'): void;
    protected setMaxWidthInternal(value: number | string): void;
    protected setMinWidthInternal(value: number | string): void;
    protected setHeightInternal(value: number | string | 'auto'): void;
    protected setMinHeightInternal(value: number | string): void;
    protected setMaxHeightInternal(value: number | string): void;
    protected setMarginsInternal(margins: {
        value: number;
        flexEdge: FlexEdge;
    }[]): void;
    protected setPositionsInternal(positions: {
        value: number;
        flexEdge: FlexEdge;
    }[]): void;
    refreshLayout(): void;
    applyLayout(): void;
    refreshLayoutFromRoot(): T;
    setParent(parent: FlexNode<any>): void;
    setWidth(value: number | string | 'auto'): void;
    setHeight(value: number | string | 'auto'): void;
    setHeightAndMargins(value: number | string | 'auto', margins: FlexSpacing[], refreshLayout?: boolean): void;
    setDimension(width: number | string | 'auto', height: number | string | 'auto'): void;
    setMargins(margins: FlexSpacing[], refreshLayout?: boolean): void;
    setPositions(positions: FlexSpacing[]): void;
    setDimensionAndPositions(width: number | string | 'auto', height: number | string | 'auto', positions: FlexSpacing[]): void;
    getLayout(): Layout;
    destroy(): void;
    get name(): string;
    get parent(): FlexNode<any> | undefined;
    get yogaNode(): Node_2;
    get yogaConfig(): Config;
    get contentNode(): T;
    get config(): C;
}

declare abstract class BaseKonvaComponent<C extends ComponentConfig<S>, S, T extends default_3.Node> implements KonvaComponent<C, S, T> {
    protected readonly _styleAdapter: StyleAdapter<S>;
    protected _config: C;
    private _konvaNode?;
    protected _destroyBreaker: ObserverBreaker;
    protected constructor(config: C);
    protected abstract provideKonvaNode(): T;
    destroy(): void;
    get config(): C;
    get konvaNode(): T;
    get style(): S;
    set style(value: Partial<S>);
}

declare abstract class BaseKonvaComponent2<K extends default_3.Node> implements KonvaComponent2<K> {
    protected _konvaNode?: K;
    protected _destroyBreaker: ObserverBreaker;
    protected constructor();
    protected abstract provideKonvaNode(): K;
    get konvaNode(): K;
    destroy(): void;
}

export declare abstract class BaseMainMedia<S extends MainMediaState> extends BaseMediaEntity<S> implements MainMedia {
    protected readonly _onEvent$: Subject<MainMediaEvent>;
    protected readonly _mediaType = MediaEntityType.MAIN_MEDIA;
    protected abstract _mainMediaType: MainMediaType;
    protected readonly _source: Source;
    protected _sourceFileFormatType?: FileFormatType | undefined;
    protected readonly _loadOptions: MainMediaLoadOptions | undefined;
    protected readonly _loadStage: OpStage;
    protected readonly _tracks: Track[];
    protected readonly _tracksMap: Map<Track['id'], Track>;
    protected _initialDuration?: number | undefined;
    protected _duration?: number | undefined;
    protected _frameRateModel?: FrameRateModel | undefined;
    protected _ffomTimecodeModel?: TimecodeModel | undefined;
    protected _initSegmentTimeOffset?: number | undefined;
    protected _hasDrm?: boolean | undefined;
    protected _hasVideo?: boolean | undefined;
    protected _hasAudio?: boolean | undefined;
    protected constructor(args: BaseMainMediaArgs);
    loadStart(): void;
    loadSuccess(): void;
    loadError(error: string | undefined): void;
    addTrack(track: Track): void;
    addTracks(tracks: Track[]): void;
    get source(): Source;
    get mainMediaType(): MainMediaType;
    get tracks(): Track[];
    get loadStage(): OpStage;
    get hasDrm(): boolean | undefined;
    get initialDuration(): number | undefined;
    get duration(): number | undefined;
    get frameRateModel(): FrameRateModel | undefined;
    get ffomTimecodeModel(): TimecodeModel | undefined;
    get initSegmentTimeOffset(): number | undefined;
    get hasVideo(): boolean | undefined;
    get hasAudio(): boolean | undefined;
    get sourceFileFormatType(): FileFormatType | undefined;
    updateAttrs(attrs: MainMediaUpdateableAttrs): void;
    get onEvent$(): Observable<MainMediaEvent>;
    protected _getState(): MainMediaState;
}

/**
 * Construction arguments for {@link BaseMainMedia} and its subclasses.
 */
export declare interface BaseMainMediaArgs extends BaseMediaEntityArgs {
    /** The resolved media source. */
    source: Source;
    /** The resolved file format type of the source. */
    sourceFileFormatType?: FileFormatType | undefined;
    /** Load options used when the media was requested. */
    loadOptions?: MainMediaLoadOptions | undefined;
    /** Pre-existing tracks to associate with the media. */
    tracks?: Track[];
    /** Initial media duration in seconds. */
    duration?: number | undefined;
    /** Frame rate model for frame-accurate operations. */
    frameRateModel?: FrameRateModel | undefined;
    /** FFOM timecode model for time offset display. */
    ffomTimecodeModel?: TimecodeModel | undefined;
    /** Initialization segment time offset. */
    initSegmentTimeOffset?: number | undefined;
    /** Whether the media source is DRM-protected. */
    hasDrm?: boolean | undefined;
    /** Whether media has video. */
    hasVideo?: boolean | undefined;
    /** Whether media has audio. */
    hasAudio?: boolean | undefined;
}

export declare abstract class BaseMarker extends BaseTimedItem<MarkerState, MarkerUpdateableAttrs> implements Marker {
    protected _label: string | undefined;
    protected constructor(args: MarkerArgs);
    update(attrs: MarkerUpdateableAttrs): void;
    protected _getState(): MarkerState;
    get label(): string | undefined;
    get markerType(): MarkerType;
}

declare abstract class BaseMarkerViewInnerComponent extends BaseKonvaComponent2<default_3.Group> {
    protected _onHandleClick$: Subject<ClickEvent>;
    protected _onHandleMouseMove$: Subject<MouseMoveEvent>;
    protected _onHandleDragStart$: Subject<void>;
    protected _onHandleDragEnd$: Subject<void>;
    protected _editable: boolean;
    protected _style: MarkerOnMarkerTrackLaneStyle;
    protected _markerState: MarkerState;
    protected _timeline: TimelineImpl;
    protected _markerTrackLane: MarkerTrackLane;
    protected _updateHook: (attrs: MarkerUpdateableAttrs) => void;
    protected _group: default_3.Group;
    protected _renderBreaker: ObserverBreaker;
    protected constructor(args: BaseMarkerViewInnerComponentArgs);
    protected abstract render(): void;
    abstract refreshTimelinePosition(): void;
    get onHandleClick$(): Observable<ClickEvent>;
    get onHandleMouseMove$(): Observable<MouseMoveEvent>;
    get onHandleDragStart$(): Observable<void>;
    get onHandleDragEnd$(): Observable<void>;
    update(markerState: MarkerState): void;
    protected getVerticals(): MarkerViewHandleVerticals;
    protected onDragMove(newPosition: Position): Position;
    protected provideKonvaNode(): default_3.Group;
}

declare interface BaseMarkerViewInnerComponentArgs {
    editable: boolean;
    style: MarkerOnMarkerTrackLaneStyle;
    markerState: MarkerState;
    timeline: TimelineImpl;
    markerTrackLane: MarkerTrackLane;
    updateHook: (attrs: MarkerUpdateableAttrs) => void;
}

export declare abstract class BaseMediaEntity<S extends MediaEntityState> implements MediaEntity {
    protected _id: string;
    protected abstract _mediaType: MediaEntityType;
    protected constructor(args?: BaseMediaEntityArgs);
    protected abstract getState(): S;
    protected _getState(): MediaEntityState;
    get id(): string;
    get mediaType(): MediaEntityType;
    get state(): S;
}

/**
 * Construction arguments shared by all {@link BaseMediaEntity} subclasses.
 */
export declare interface BaseMediaEntityArgs extends Serializable {
    /** Optional pre-assigned UUID. When omitted a new UUID is generated automatically. */
    id?: MediaEntity['id'] | undefined;
}

/**
 * If remote method response is awaited value is always Observable. For methods that already return Observable we need to unwrap it as return type is already Observable
 */
declare abstract class BaseMessageChannel<ChannelDef extends ExtractActions<any>> extends UntypedMessageChannel {
    protected constructor(managedBroadcastChannel: ManagedBroadcastChannel, topic: string);
    send<ActionName extends ExtractActionType<ChannelDef>, RequestData extends ChannelDef[ActionName]['requestData']>(action: ActionName, arg?: RequestData): void;
    sendAndWaitForResponse<Action extends ExtractActionType<ChannelDef>, RequestData extends ChannelDef[Action]['requestData'], ResponseData extends ChannelDef[Action]['responseData']>(action: Action, arg?: RequestData, sendOptions?: Partial<SendOptions>): Observable<UnwrapObservable<ResponseData>>;
    listen<Action extends ExtractActionType<ChannelDef>, ResponseData extends ChannelDef[Action]['responseData']>(action: Action): Observable<UnwrapObservable<ResponseData>>;
    receive<Action extends ExtractActionType<ChannelDef>, RequestData extends ChannelDef[Action]['requestData']>(action: Action): Observable<RequestData>;
    receiveAndSendResponse<Action extends ExtractActionType<ChannelDef>, RequestData extends ChannelDef[Action]['requestData'], ResponseData extends ChannelDef[Action]['responseData']>(action: Action): Observable<[RequestData, (response: UnwrapObservable<ResponseData> | ResponseData) => void, (error: Error) => void]>;
}

declare abstract class BaseMessageChannelProxy<T extends MessageChannelType> implements MessageChannelProxy<T> {
    private readonly _messageChannel;
    protected _onInitialized$: BehaviorSubject<boolean>;
    constructor(messageChannel: MessageChannel_2<T>);
    get messageChannel(): MessageChannel_2<T>;
    get onInitialized$(): Observable<boolean>;
    destroy(): void;
}

export declare abstract class BaseMultiTrackLane<C extends MultiTrackLaneConfig, S extends TimelineLaneStyle, T extends Track, TC extends MultiTrackLaneTrackConfig> extends BaseTimelineLane<C, S> implements MultiTrackTimelineLane<C, S, T, TC> {
    protected _trackRepository?: TrackRepository;
    protected _tracks: T[];
    protected _tracksMap: Map<T['id'], T>;
    protected _trackConfigs: Map<T['id'], TC>;
    protected _trackBreakers: Map<T['id'], ObserverBreaker>;
    protected _canRender: boolean;
    protected constructor(config: C, style?: Partial<S>);
    protected abstract render(): void;
    protected abstract updatePositions(): void;
    protected abstract onTrackRemoved(trackId: T['id']): void;
    protected abstract hasVisualElements(): boolean;
    protected settleLayout(): void;
    protected showLoadingGroup(): void;
    protected createLoadingGroupContent(width: number, height: number): default_3.Animation;
    protected hideLoadingGroup(): void;
    protected updateLoadingVisibility(): void;
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    addTrack(track: T, config?: TC): void;
    addTrack(id: T['id'], config?: TC): void;
    removeTrack(trackId: T['id']): void;
    getTracks(): T[];
    protected trySetOnTrackDeleted(track: T, trackBreaker: ObserverBreaker): void;
    destroy(): void;
}

/**
 * Abstract base for all observation item implementations.
 */
export declare abstract class BaseObservation extends BaseTimedItem<ObservationState, ObservationUpdateableAttrs> implements Observation {
    protected _label: string | undefined;
    protected _items: ObservationItem[];
    protected constructor(args: ObservationArgs);
    update(attrs: ObservationUpdateableAttrs): void;
    protected _getState(): ObservationState;
    get label(): string | undefined;
    get items(): ObservationItem[];
}

/**
 * Abstract base for all observation track implementations.
 */
export declare abstract class BaseObservationTrack<T extends Observation, TM extends T & BaseObservation, S extends ObservationTrackState, E extends OmpEventGroup<any, any> = never> extends BaseTimedItemsTrack<T, TM, S, E> {
    protected _trackType: TrackType;
    protected abstract _observationTrackType: ObservationTrackType;
    protected constructor(args?: ObservationTrackArgs);
    protected _getState(): ObservationTrackState;
    get observationTrackType(): ObservationTrackType;
    updateAttrs(attrs: ObservationTrackUpdateableAttrs): void;
}

export declare abstract class BaseObservationTrackLane<C extends ObservationTrackLaneConfig, S extends ObservationTrackLaneStyle, TC extends ObservationTrackLaneTrackConfig> extends BaseMultiTrackLane<C, S, ObservationTrack, TC> {
    private readonly _onEvent$;
    protected readonly _trackViews: Map<ObservationTrack['id'], ObservationTrackView>;
    protected _trackViewsGroup?: default_3.Group;
    protected _eventCatcher?: default_3.Rect;
    private _timecodedClick$;
    private _timecodedMouseMove$;
    protected _onTimelineZoom$: Subject<void>;
    protected _onTimelineScroll$: Subject<void>;
    protected _onSettleLayout$: Subject<void>;
    protected constructor(config: C, style?: Partial<S>);
    protected abstract renderTrack(track: ObservationTrack, config?: TC): ObservationTrackView;
    protected render(): void;
    protected updatePositions(): void;
    protected handleTimelineZoom(): void;
    protected handleTimelineScroll(): void;
    private handleTimecodeMouseMove;
    private handleTimecodeClick;
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    addTrack(track: ObservationTrack, config?: TC): void;
    addTrack(id: ObservationTrack['id'], config?: TC): void;
    protected createStyledElement(): StyledElementWithId<S>;
    protected hasVisualElements(): boolean;
    protected settleLayout(): void;
    protected onTrackRemoved(trackId: ObservationTrack['id']): void;
    clearContent(): void;
    destroy(): void;
}

declare abstract class BaseOmakasePlayer implements Destroyable {
    protected _destroyBreaker: ObserverBreaker;
    protected constructor();
    destroy(): void;
}

export declare abstract class BasePlayerAudioTrack extends BasePlayerTrack<AudioState, PlayerAudioTrackState, PlayerAudioLoadOptions> implements PlayerAudioTrack {
    protected _active: boolean;
    protected constructor(trackState: AudioState);
    abstract get playerAudioHandler(): PlayerAudioHandlerApi;
    abstract setActive(active: boolean): Observable<void>;
    protected _getState(): PlayerAudioTrackState;
    get active(): boolean;
    destroy(): void;
}

export declare abstract class BasePlayerTextTrack extends BasePlayerTrack<TextTrackState, PlayerTextTrackState, PlayerTextTrackLoadOptions> implements PlayerTextTrack {
    protected constructor(track: TextTrackState, loadOptions?: PlayerTextTrackLoadOptions);
    abstract get handler(): PlayerTextTrackHandlerApi;
    get active(): boolean;
    protected _getState(): PlayerTextTrackState;
    destroy(): void;
}

export declare abstract class BasePlayerTextTrackHandler implements PlayerTextTrackHandlerApi {
    protected readonly _onEvent$: Subject<TextTrackHandlerEvent>;
    protected _id: string;
    protected _trackState: TextTrackState;
    protected _playerController: PlayerController;
    protected _loadOptions: PlayerTrackLoadOptions | undefined;
    protected _active: boolean;
    protected _shown: boolean;
    protected _destroyBreaker: ObserverBreaker;
    protected constructor(trackState: TextTrackState, playerController: PlayerController, loadOptions?: PlayerTrackLoadOptions);
    abstract get handlerType(): PlayerTextHandlerType;
    abstract hide(): Observable<void>;
    abstract show(): Observable<void>;
    abstract switch(active: boolean): Observable<void>;
    protected setActive(active: boolean): void;
    protected setShown(shown: boolean): void;
    restoreState(state: PlayerTextTrackHandlerState): Observable<void>;
    get id(): string;
    get onEvent$(): Observable<TextTrackHandlerEvent>;
    get active(): boolean;
    get shown(): boolean;
    toggleShowHide(): Observable<void>;
    protected emitChangeEvent(): void;
    protected getState(): PlayerTextTrackHandlerState;
    get state(): PlayerTextTrackHandlerState;
    destroy(): void;
}

declare abstract class BasePlayerTrack<T extends TrackState, S extends PlayerTrackState, L extends PlayerTrackLoadOptions> implements PlayerTrack<T, S>, Destroyable {
    protected readonly _onEvent$: Subject<PlayerTrackEvent>;
    protected readonly _loadStage: OpStage;
    protected readonly _loadOptions: L | undefined;
    protected _trackState: T;
    protected _destroyBreaker: ObserverBreaker;
    protected constructor(trackState: T, loadOptions?: L);
    protected abstract _getState(): S;
    loadStart(): void;
    loadSuccess(): void;
    loadError(error: string | undefined): void;
    setTrackState(trackState: T): void;
    get trackState(): T;
    get loadStage(): OpStage;
    get state(): S;
    get onEvent$(): Observable<PlayerTrackEvent>;
    destroy(): void;
}

export declare abstract class BaseRepository<T extends MediaEntity> implements Repository<T> {
    protected _mediaEntities: Map<T['id'], T>;
    add(mediaEntity: T): T;
    _add(mediaEntity: T): T;
    addAll(mediaEntities: T[]): T[];
    get(id: T['id']): T | undefined;
    getOrFail(id: T['id']): T;
    delete(id: T['id']): boolean;
    clear(): boolean;
    _delete(id: T['id']): boolean;
    deleteAll(ids: T['id'][]): boolean;
    find(predicate?: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
    private _find;
    findFirst(predicate?: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
    toString(): string;
}

export declare abstract class BaseSource<S extends SourceState> implements Source {
    protected abstract _type: SourceType;
    protected abstract getState(): S;
    get state(): S;
    get type(): SourceType;
}

export declare abstract class BaseTextCue extends BaseTimedItem<TextCueState, TextCueUpdateableAttrs> implements TextCue {
    protected _text: string;
    protected constructor(args: TextCueArgs);
    update(attrs: TextCueUpdateableAttrs): void;
    protected _getState(): TextCueState;
    get text(): string;
}

export declare abstract class BaseTextTrack<T extends TextCue, TM extends T & BaseTextCue, S extends TextTrackState, E extends OmpEventGroup<any, any> = never> extends BaseTimedItemsTrack<T, TM, S, E> implements TextTrack_2<S, E> {
    protected _trackType: TrackType;
    protected abstract _textTrackType: TextTrackType;
    protected _kind: TextTrackKind_2 | undefined;
    protected _srclang: string | undefined;
    protected _default: boolean;
    protected constructor(args: TextTrackArgs);
    protected _getState(): TextTrackState;
    get textTrackType(): TextTrackType;
    get kind(): TextTrackKind_2 | undefined;
    get srclang(): string | undefined;
    get default(): boolean;
    updateAttrs(attrs: TextTrackUpdateableAttrs): void;
}

export declare abstract class BaseThumbnail extends BaseTimedItem<ThumbnailState, ThumbnailUpdateableAttrs> implements Thumbnail {
    protected _label: string | undefined;
    protected _url: string;
    protected constructor(args: ThumbnailArgs);
    update(attrs: ThumbnailUpdateableAttrs): void;
    protected _getState(): ThumbnailState;
    get label(): string | undefined;
    get url(): string;
}

export declare class BaseTimedItem<S extends TimedItemState = TimedItemState, U extends TimedItemUpdateableAttrs = TimedItemUpdateableAttrs> implements MutableTimedItem<S, U> {
    protected readonly _id: string;
    protected _temporal: TimedItemTemporal;
    protected _data: Record<string, any>;
    constructor(args: TimedItemArgs);
    protected _getState(): TimedItemState;
    /* Excluded from this release type: update */
    get id(): string;
    get temporal(): TimedItemTemporal;
    get data(): Record<string, any>;
    get state(): S;
}

export declare abstract class BaseTimedItemsFetcher<T extends TimedItemsTrack> implements TimedItemsFetcher {
    protected _track: T;
    protected _loadOptions?: TrackLoadOptions | undefined;
    protected constructor(track: T, loadOptions?: TrackLoadOptions | undefined);
    abstract fetchTimedItems(): Observable<void>;
}

export declare abstract class BaseTimedItemsTrack<T extends TimedItem, TM extends T & MutableTimedItem<T['state']>, S extends TimedItemsTrackState, E extends OmpEventGroup<any, any> = never> extends BaseTrack<S, E | TimedItemsTrackEvent> implements TimedItemsTrack<T, S, InferUpdateAttrs<TM>, E | TimedItemsTrackEvent>, Destroyable {
    protected _timedItems: TM[];
    protected _timedItemsSorted: TM[];
    protected _timedItemsById: Map<TM['id'], TM>;
    protected _timedItemHooks?: TimedItemHooks | undefined;
    protected _areTimedItemsLocked: boolean;
    protected _areTimedItemsFetched: boolean;
    protected constructor(args?: TimedItemsTrackArgs);
    protected _getState(): TimedItemsTrackState<T['state']>;
    updateTimedItem(id: T['id'], attrs: InferUpdateAttrs<TM>): void;
    findTimedItemsInRange(start: number, end: number): T[];
    findNearestTimedItem(time: number): T | undefined;
    private sortTimedItemsSorted;
    private matchesTime;
    findTimedItemsAtTime(time: number): T[];
    findFirstTimedItemAtTime(time: number): T | undefined;
    get timedItems(): T[];
    get timedItemsSorted(): T[];
    get areTimedItemsLocked(): boolean;
    set areTimedItemsLocked(value: boolean);
    get areTimedItemsFetched(): boolean;
    set areTimedItemsFetched(areTimedItemsFetched: boolean);
    getTimedItem(id: T['id']): T | undefined;
    protected checkTimedItemsLocked(): void;
    addTimedItems(timedItems: TM | TM[]): void;
    deleteTimedItems(ids: T['id'] | T['id'][]): void;
}

export declare abstract class BaseTimelineLane<C extends TimelineLaneConfig, S extends TimelineLaneStyle> implements TimelineLaneApi {
    protected _config: C;
    protected _id: string;
    protected _description?: string | undefined;
    protected _leftBgRect: default_3.Rect;
    protected _rightBgRect: default_3.Rect;
    protected _timecodedGroup?: default_3.Group;
    protected _loadingGroup?: default_3.Group;
    protected _loadingAnimation?: default_3.Animation;
    protected _mainLeftFlexGroup?: KonvaFlexGroup;
    protected _mainRightFlexGroup?: KonvaFlexGroup;
    protected _mainLeftDescription?: KonvaFlexGroup;
    protected _mainLeftStartJustified?: KonvaFlexGroup;
    protected _mainLeftEndJustified?: KonvaFlexGroup;
    protected _descriptionTextLabel?: TextLabel;
    protected _styledElement?: StyledElementWithId<S>;
    protected _providedStyle?: Partial<S> | undefined;
    protected _style?: S;
    protected _initialStyle?: S;
    protected _timeline?: TimelineImpl;
    protected _player?: PlayerApi;
    protected _ui?: Ui;
    protected _prepared: BehaviorSubject<boolean>;
    protected _uiBreaker: ObserverBreaker;
    protected _destroyBreaker: ObserverBreaker;
    protected constructor(config: C, providedStyle?: Partial<S>);
    protected abstract createStyledElement(): StyledElementWithId<S>;
    protected abstract settleLayout(): void;
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    protected handleStyleUpdate(): void;
    protected handleTimelineZoom(): void;
    protected handleTimelineScroll(): void;
    protected createMainLeftFlexGroup(): KonvaFlexGroup;
    protected createDescriptionTextLabel(): void;
    protected createMainRightFlexGroup(): KonvaFlexGroup;
    onMeasurementsChange(): void;
    /* Excluded from this release type: updateLayoutDimensions */
    clearContent(): void;
    getTimecodedRect(): RectMeasurement;
    get id(): string;
    get mainLeftFlexGroup(): KonvaFlexGroup;
    get mainRightFlexGroup(): KonvaFlexGroup;
    addTimelineNode(config: TimelineLaneComponentConfig): TimelineNode;
    isMinimized(): boolean;
    /* Excluded from this release type: _minimize */
    /* Excluded from this release type: _maximize */
    minimize(args?: TimelineLaneMinimizeMaximizeArgs): void;
    maximize(args?: TimelineLaneMinimizeMaximizeArgs): void;
    protected checkIsPrepared(): void;
    private _minimizeEased;
    private _maximizeEased;
    toggleMinimizeMaximize(args?: TimelineLaneMinimizeMaximizeArgs): void;
    get style(): S;
    setStyle(style: Partial<S>): void;
    updateAttrs(attrs: TimelineLaneUpdateableAttrs): void;
    protected updateDescriptionTextLabel(description: string | undefined): void;
    destroy(): void;
}

export declare abstract class BaseTimelineNode<C extends TimelineNodeConfig<S>, S extends TimelineNodeStyle> extends BaseKonvaComponent<C, S, default_3.Group> implements TimelineNode {
    private readonly _onEvent$;
    protected _group: default_3.Group;
    protected _bgRect: default_3.Rect;
    protected constructor(config: C);
    get onEvent$(): Observable<TimelineNodeEvent>;
    onMeasurementsChange(): void;
    protected provideKonvaNode(): default_3.Group;
    protected onStyleChange(): void;
    destroy(): void;
}

export declare abstract class BaseTrack<S extends TrackState, E extends OmpEventGroup<any, any>> extends BaseMediaEntity<S> implements Track<S, E>, Destroyable {
    protected readonly _onEvent$: Subject<E | TrackEvent_2<S>>;
    protected readonly _mediaType = MediaEntityType.TRACK;
    protected abstract readonly _trackType: TrackType;
    protected readonly _source: Source | undefined;
    protected readonly _sourceFileFormatType?: FileFormatType | undefined;
    protected readonly _loadOptions: TrackLoadOptions | undefined;
    protected readonly _relations: Relation[];
    protected readonly _loadStage: OpStage;
    protected _label: string | undefined;
    protected _customAttrs: Record<string, any> | undefined;
    protected readonly _destroyBreaker: ObserverBreaker;
    protected constructor(args?: BaseTrackArgs);
    updateAttrs(attrs: TrackUpdateableAttrs): void;
    protected _updateAttrs(attrs: TrackUpdateableAttrs, emitEvent?: boolean): void;
    protected _getState(): TrackState;
    loadStart(): void;
    loadSuccess(): void;
    loadError(error: string | undefined): void;
    addRelation(relation: Relation): void;
    hasRelation(relation: Relation): boolean;
    get onEvent$(): Observable<E | TrackEvent_2<S>>;
    get trackType(): TrackType;
    get source(): Source | undefined;
    get sourceFileFormatType(): FileFormatType | undefined;
    get relations(): Relation[];
    get loadStage(): OpStage;
    get label(): string | undefined;
    get customAttrs(): Record<string, any> | undefined;
    destroy(): void;
}

/**
 * Construction arguments for {@link BaseTrack} and its subclasses.
 */
export declare interface BaseTrackArgs extends BaseMediaEntityArgs {
    /** Data source backing this track. */
    source?: Source | undefined;
    /** Initial set of inter-track relations. */
    relations?: Relation[] | undefined;
    /** The resolved file format of the source. */
    sourceFileFormatType?: FileFormatType | undefined;
    /** Load options used when the track was requested. */
    loadOptions?: TrackLoadOptions | undefined;
    /** Human-readable label for this track. */
    label?: string | undefined;
    /** Custom arbitrary attributes for this track */
    customAttrs?: Record<string, any> | undefined;
    /** Track load status **/
    loadStage?: OpStage | undefined;
}

export declare abstract class BaseTrackLane<C extends TrackLaneConfig, S extends TimelineLaneStyle, T extends Track> extends BaseTimelineLane<C, S> {
    protected _trackRepository?: TrackRepository;
    protected _track?: T | undefined;
    protected _trackSet: BehaviorSubject<boolean>;
    protected _canRender: boolean;
    protected _trackUpdateBreaker: ObserverBreaker;
    protected constructor(config: C, style?: Partial<S>);
    abstract render(): void;
    protected abstract hasVisualElements(): boolean;
    protected settleLayout(): void;
    protected showLoadingGroup(): void;
    protected createLoadingGroupContent(width: number, height: number): default_3.Animation;
    protected hideLoadingGroup(): void;
    protected updateLoadingVisibility(): void;
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    setTrack(track: T): void;
    protected tryUpdateDescription(): void;
    protected trySetOnTrackDeleted(): void;
    destroy(): void;
}

/** Base load options shared by all track types. */
export declare interface BaseTrackLoadOptions {
    fileFormatType?: FileFormatType | undefined;
}

export declare abstract class BaseUrlSource<T extends UrlSourceState> extends BaseSource<T> {
    protected _type: SourceType;
    protected _url: string;
    constructor(url: string);
    protected abstract getState(): T;
    get url(): string;
}

/** Authentication data for HTTP Basic auth. */
export declare interface BasicAuthenticationData {
    type: 'basic';
    /** Basic auth username. */
    username: string;
    /** Basic auth password. */
    password: string;
}

/** Authentication data for Bearer token auth. */
export declare interface BearerAuthenticationData {
    type: 'bearer';
    /** Bearer token included in the `Authorization` header. */
    token: string;
}

declare interface BufferedTimeRange {
    start: number;
    end: number;
}

export declare interface ChannelCountEventData extends Serializable {
    channelCount: number;
}

export declare interface ChromelessThemeConfig extends ChromelessThemeConfigUpdateableAttrs {
    /**
     * Specifies the list of enabled floating controls
     */
    floatingControls: ChromelessThemeFloatingControl[];
    /**
     * Specifies the list of floating controls that are shown when the video is playing
     */
    alwaysOnFloatingControls: ChromelessThemeFloatingControl[];
}

export declare interface ChromelessThemeConfigUpdateableAttrs {
    /**
     * Specifies which time format will be used in the timer control
     */
    timeFormat: ChromingTimeFormat;
    /**
     * Specifies if the time control can be used for seeking. It is activated by double clicking the time.
     */
    timeInteractive: boolean;
}

export declare enum ChromelessThemeFloatingControl {
    TIME = "TIME"
}

/**
 * Public API for chroming the player
 * @document ../../docs/static/chroming/README.md
 */
export declare interface ChromingApi extends ChromingCommonApi {
    /**
     * Gets the HTML element from the player chroming DOM
     * @param querySelector HTML query selector
     */
    getPlayerChromingElement<T>(querySelector: string): T;
    /**
     * Add a marker bar to the player. Marker bar will be displayed in the marker bar area above the progress bar.
     * @param url URL of the marker bar to load
     * @param source Source of the marker bar to load
     * @param destination The destination where the marker bar should be added (marker bar area or progress bar)
     * @param options Track load options
     * @param config Marker bar configuration such as marker presentation function and initial visibility
     */
    addMarkerBar(url: string, destination: ChromingTrackDestination, options?: TrackLoadOptions, config?: Partial<ChromingMarkerBarConfig>): Observable<ChromingMarkerBarHandlerApi>;
    addMarkerBar(source: Source, destination: ChromingTrackDestination, options?: TrackLoadOptions, config?: Partial<ChromingMarkerBarConfig>): Observable<ChromingMarkerBarHandlerApi>;
    /**
     * Set a thumbnail track for the player. Thumbnail track will be used to display preview thumbnails when hovering over the progress bar.
     * @param url URL of the thumbnail track to load
     * @param source Source of the thumbnail track to load
     * @param options Track load options
     */
    setThumbnailTrack(url: string, options?: TrackLoadOptions): Observable<void>;
    setThumbnailTrack(source: Source, options?: TrackLoadOptions): Observable<void>;
    setThumbnailTrack(empty: undefined): Observable<void>;
    /**
     * Get current chroming VU meter configuration
     * @param position VU meter position in chroming
     */
    getVuMeterConfig(position?: ChromingVuMeterPosition): ChromingVuMeterConfig;
}

declare interface ChromingAudioTrack extends ChromingAudioTrackUpdateAttrs {
    audioTrack: AudioState;
}

declare interface ChromingAudioTrackUpdateAttrs {
    type: PlayerAudioType;
    playerTrack: PlayerAudioTrackState;
}

export declare interface ChromingChangeEventData extends Serializable {
    chroming: ChromingState;
}

export declare interface ChromingCommonApi {
    /**
     * Observable that emits chroming events such as theme change, safe zones change, help menu change, marker track change, thumbnail track change and theme config change.
     */
    onEvent$: Observable<ChromingEvent>;
    /**
     * Current help menu groups configured in the player chroming.
     */
    helpMenuGroups: HelpMenuGroup[];
    /**
     * Current video safe zones configured in the player chroming.
     */
    videoSafeZones: VideoSafeZone[];
    /**
     * Whether the floating time display is visible in the player chroming.
     */
    isFloatingTimeVisible: boolean | undefined;
    /**
     * Current time format used in the player chroming.
     */
    timeFormat: ChromingTimeFormat | undefined;
    /**
     * Current chroming state of the player. Should not be edited externally.
     */
    state: ChromingState;
    /**
     * Current chroming session of the player. Should not be edited externally.
     */
    chromingSession: ChromingSession;
    /**
     * Adds a video safe zone to the player chroming.
     * @param videoSafeZone
     */
    addSafeZone(videoSafeZone: Partial<VideoSafeZone>): Observable<VideoSafeZone>;
    /**
     * Removes a video safe zone from the player chroming.
     * @param id Video safe zone id
     */
    removeSafeZone(id: string): Observable<void>;
    /**
     * Removes all video safe zones from the player chroming.
     */
    removeAllSafeZones(): Observable<void>;
    /**
     * Adds a help menu group to the player chroming.
     * @param helpMenuGroup Help menu group to add
     * @param insertPosition Position where the help menu group should be added in the help menu (append or prepend)
     */
    addHelpMenuGroup(helpMenuGroup: HelpMenuGroup, insertPosition: HelpMenuGroupInsertPosition): Observable<HelpMenuGroup>;
    /**
     * Removes all help menu groups from the player chroming.
     */
    clearHelpMenuGroups(): Observable<void>;
    /**
     * Shows or hides and optionally sets the interactivity of the floating time display in the player chroming.
     * @param visible is floating time shown
     * @param isInteractive sets timeInteractive property in theme config to true/false
     * @param openEditMode if true, changes the time to edit mode and focuses the input (only applicable if timeInteractive property is true)
     */
    setFloatingTimeVisible(visible: boolean, isInteractive?: boolean, openEditMode?: boolean): Observable<void>;
    /**
     * Changes the time format used in the player chroming.
     * @param timeFormat Time format to set (media time, countdown media time or timecode)
     */
    setTimeFormat(timeFormat: ChromingTimeFormat): Observable<void>;
    /**
     * Changes the theme configuration of the player chroming. Theme configuration includes settings such as control visibility, floating control configuration and action icon configuration for each theme.
     */
    setThemeConfig(themeConfig: Partial<ChromingThemeConfigTypes>): Observable<void>;
    /**
     * Updates the VU meter configuration in the player chroming
     * @param config New VU meter configuration, only attributes to update need to be sent
     * @param position Position of the VU meter to affect, if not sent all VU meters in chroming will be affected
     */
    setVuMeterConfig(config: Partial<ChromingVuMeterConfig>, position?: ChromingVuMeterPosition): Observable<void>;
    /**
     * Shows or hides the floating VU meter in the player chroming.
     */
    setFloatingVuMeterVisible(visible: boolean): Observable<void>;
    /**
     * Sets the watermark text in the player chroming. Sending undefined will remove the watermark.
     */
    setWatermark(watermark: string | undefined): Observable<void>;
    /**
     * Returns an object containing the progress bar marker bar and a list of marker bar handlers from the marker bar area in chroming
     */
    getMarkerBars(): ChromingMarkerBarHandlers;
    /**
     * Gets a marker bar handler by the marker bar id. Marker bar handler can be used to update the marker bar presentation and visibility and to add or remove marker tracks from the marker bar.
     * @param id Send id to get the marker bar from the marker bars area or progress bar
     */
    getMarkerBar(id: string): ChromingMarkerBarHandlerApi | undefined;
    /**
     * Removes a marker bar from chroming.
     * @param id Send id to remove the marker bar from the marker bars area or progress bar
     */
    deleteMarkerBar(id: string): Observable<void>;
    /**
     * Internal method. Restores the chroming state from the session.
     * @param chromingSession Chroming session to restore
     */
    restoreChromingSession(chromingSession: ChromingSession): Observable<void>;
    /**
     * Enters or exits fullscreen mode.
     */
    toggleFullScreen(): Observable<void>;
}

export declare interface ChromingConfig extends ChromingConfigLocalAndDetached {
}

declare type ChromingConfigLocalAndDetached = Omit<CommonChromingConfig, 'playerWindowPlaybackMode' | 'findThumbnailFn'>;

declare class ChromingDetached extends BaseChroming implements ChromingDetachedApi {
    private _remoteNode?;
    private _sessionStore?;
    private _trackRepository?;
    private _omakaseTrackApiProxy?;
    private _alertsManagerProxy?;
    private _mainMediaRepositoryProxy?;
    private _uiProxy?;
    constructor(config: ChromingDetachedConfig);
    setRemoteProxies(remoteNode: RemoteNode): void;
    protected handleMarkerTrackEvent(event: TimedItemsTrackEvent): void;
    addAudioTrackObserver(trackId: Track['id'], breaker$: Observable<any>, audioType: PlayerAudioType.MAIN | PlayerAudioType.SIDECAR): void;
    addTextTrackObserver(trackId: Track['id'], breaker$: Observable<any>): void;
    protected getMarkerTrackState(trackId: Track['id']): Observable<MarkerTrackState | undefined>;
    updateMarker(markerTrack: MarkerTrackState, marker: MarkerState, attrs: MarkerUpdateableAttrs): void;
    addMarkerBar(trackId: Track['id'], destination: ChromingTrackDestination, config?: Partial<ChromingMarkerBarConfig>): Observable<ChromingMarkerBarState['id']>;
    setMarkerBars(chromingMarkerBars: ChromingMarkerBarState[], progressBarMarkerBar?: ChromingMarkerBarState): Observable<void>;
    setThumbnailTrack(trackId: Track['id'] | undefined): Observable<void>;
    findThumbnailFn(trackId: string, time: number): Observable<ThumbnailState | undefined>;
    restoreAlerts(): Observable<void>;
    protected wireEvents(): void;
}

export declare interface ChromingDetachedApi extends ChromingInternalApi, Destroyable {
}

export declare interface ChromingDetachedConfig extends ChromingConfigLocalAndDetached {
}

declare interface ChromingDetachedMessageChannel extends ChromingDetachedApi {
}

declare class ChromingDetachedProxy extends BaseMessageChannelProxy<ChromingDetachedMessageChannel> implements ChromingDetachedApi, Destroyable {
    protected _sessionStore: SessionStore;
    private _state?;
    private _remoteNode;
    private _destroyBreaker;
    constructor(remoteNode: RemoteNode, ompProvider: OmpProvider);
    protected initialize(): void;
    protected updateFromState(chromingState: ChromingState): void;
    protected updateChromingMarkerBarHandlerProxies(): void;
    get onEvent$(): Observable<ChromingEvent>;
    private checkLateInitialization;
    get chromingSession(): ChromingSession;
    get state(): ChromingState;
    get helpMenuGroups(): HelpMenuGroup[];
    get isFloatingTimeVisible(): boolean | undefined;
    get timeFormat(): ChromingTimeFormat | undefined;
    get videoSafeZones(): VideoSafeZone[];
    addHelpMenuGroup(helpMenuGroup: HelpMenuGroup, insertPosition: HelpMenuGroupInsertPosition): Observable<HelpMenuGroup>;
    addSafeZone(videoSafeZone: Partial<VideoSafeZone>): Observable<VideoSafeZone>;
    clearHelpMenuGroups(): Observable<void>;
    removeAllSafeZones(): Observable<void>;
    removeSafeZone(id: string): Observable<void>;
    restoreChromingSession(chromingSession: ChromingSession): Observable<void>;
    setFloatingTimeVisible(visible: boolean, interactive?: boolean, openEditMode?: boolean): Observable<void>;
    setFloatingVuMeterVisible(visible: boolean): Observable<void>;
    setWatermark(watermark: string | undefined): Observable<void>;
    addMarkerBar(trackId: Track['id'], destination: ChromingTrackDestination, config?: Partial<ChromingMarkerBarConfig>): Observable<ChromingMarkerBarState['id']>;
    deleteMarkerBar(id: string): Observable<void>;
    getMarkerBars(): ChromingMarkerBarHandlers;
    getMarkerBar(id: string): ChromingMarkerBarHandlerApi | undefined;
    setThumbnailTrack(trackId: Track['id'] | undefined): Observable<void>;
    setTimeFormat(timeFormat: ChromingTimeFormat): Observable<void>;
    setThemeConfig(themeConfig: Partial<ChromingThemeConfigTypes>): Observable<void>;
    setVuMeterConfig(config: Partial<ChromingVuMeterConfig>, position?: ChromingVuMeterPosition): Observable<void>;
    toggleFullScreen(): Observable<void>;
    get domController(): ChromingDomController<ChromingThemeTypes>;
    setPlayerInternal(playerInternal: PlayerInternalApi): void;
    destroy(): void;
}

declare interface ChromingDomConfig<T extends ChromingTheme> extends PlayerChromingThemeConfig<T>, PlayerChromingCommonConfig {
    playerHtmlElementId: string;
    playerWindowPlaybackMode: WindowPlaybackMode;
    playerDetachable: boolean;
    requestAttachFn: () => void;
    requestDetachFn: () => void;
    findThumbnailFn: (trackId: string, time: number) => Observable<ThumbnailState | undefined>;
    mediaElement?: Partial<Pick<DomMediaElementConfig, 'crossOrigin'>>;
}

declare abstract class ChromingDomController<T extends ChromingTheme> implements PlayerDomController, Destroyable {
    protected _themeConfigChange$: Subject<void>;
    protected _config: ChromingDomConfig<T>;
    protected _playerInternal: PlayerInternalApi | undefined;
    protected _mainMediaType: MainMediaType | undefined;
    protected _themeElement: MediaThemeElement;
    protected _videoElementId: string;
    protected _htmlElement: HTMLElement;
    protected _mediaControllerElement: MediaController;
    protected _mainMediaVideoElement: HTMLVideoElement;
    protected _divButtonOverlayPlay: HTMLElement;
    protected _divButtonOverlayPause: HTMLElement;
    protected _divButtonOverlayLoading: HTMLElement;
    protected _divButtonOverlayError: HTMLElement;
    protected _divButtonOverlayReplay: HTMLElement;
    protected _divButtonOverlayAttach: HTMLElement;
    protected _divWatermark: HTMLElement;
    protected _divSafeZoneWrapper: HTMLElement;
    protected _divBackground: HTMLElement;
    protected _divPlaybackButtons: HTMLElement;
    protected _autoHidePlaybackButtons: boolean;
    protected _divActionIcons: HTMLElement;
    protected _divAlerts: HTMLElement;
    protected _divHelp?: HTMLElement;
    protected _divHelpMenu?: HTMLElement;
    protected _divHelpWrapper?: HTMLElement;
    protected _divButtonHelp?: HTMLElement;
    protected _textMediaCaptionsElement: HTMLElement;
    protected _textImscElement: HTMLElement;
    protected _markerBar?: OmakaseMarkerBar;
    protected _timeRange?: OmakaseTimeRange;
    protected _attachDetachButton?: MediaChromeButton;
    protected _vuMeterToggle?: MediaChromeButton;
    protected _audioLevelSource?: AudioLevelSource;
    protected _audioDropdownLists: {
        [PlayerAudioType.MAIN]: OmakaseDropdownList[];
        [PlayerAudioType.SIDECAR]: OmakaseDropdownList[];
    };
    protected _textDropdownLists: OmakaseDropdownList[];
    protected _vuMeters: {
        [ChromingVuMeterPosition.CONTROL_BAR]: VuMeter | undefined;
        [ChromingVuMeterPosition.FLOATING]: VuMeter | undefined;
    };
    protected _posterDisplayDelay: number;
    protected _hideBackgroundOnSetPoster: boolean;
    protected _playerPlayback?: PlayerPlayback | undefined;
    protected _seekingToTime?: number;
    protected _seekAnimationDelay: number;
    private _showTemporaryOnMouseMoveTimeoutId?;
    private _showTemporaryBackgroundTimeoutId?;
    private _showSeekLoadingAnimationTimeoutId?;
    protected _playerBreaker: ObserverBreaker;
    protected _destroyBreaker: ObserverBreaker;
    protected _alertClosed$: Subject<string>;
    protected _attachDetachButtonEnabled$: Subject<boolean>;
    private _maxAlertCount;
    private _maxStackCount;
    private _displaySpinnerInDetached;
    protected _enterPictureInPictureHandler?: () => void;
    protected _leavePictureInPictureHandler?: () => void;
    protected _fullscreenChangeHandler: () => void;
    protected _documentClickListener: ((event: MouseEvent) => void) | undefined;
    protected constructor(config: ChromingDomConfig<T>);
    abstract setThemeConfig(themeConfig: Partial<ChromingThemeConfigMap[T]>): void;
    abstract setThumbnailTrack(track: ThumbnailTrackState | undefined): void;
    abstract get theme(): T;
    abstract get themeConfig(): Partial<ChromingThemeConfigMap[T]> | undefined;
    setVideoPoster(poster: string): void;
    showLoading(): void;
    showLoaded(): void;
    private updateCssClassesAndVariables;
    showError(): void;
    isLoading(): boolean;
    prepareForAttaching(hasMainMedia: boolean): void;
    prepareForDetaching(): void;
    setAttachDetachButtonEnabled(enabled: boolean): void;
    setPlayer(playerInternal: PlayerInternalApi): void;
    setMainMediaType(type: MainMediaType): void;
    createMainMediaVideoElement(): void;
    createTemplateDom(): string;
    protected createHelpMenuDom(): void;
    getVuMeterConfig(themeConfig: DefaultThemeConfig | OmakaseThemeConfig, position?: ChromingVuMeterPosition): ChromingVuMeterConfig;
    protected applyNordicScale(config: ChromingVuMeterConfig): ChromingVuMeterConfig;
    protected createVuMeter(theme: ChromingTheme, themeConfig: DefaultThemeConfig | OmakaseThemeConfig, container: HTMLElement, position: ChromingVuMeterPosition): void;
    protected updateVuMeterConfig(themeConfig: DefaultThemeConfig | OmakaseThemeConfig, position: ChromingVuMeterPosition): void;
    protected updateFloatingVuMeterToggle(playerAudio: PlayerAudioState): void;
    protected wireVuMeters(): void;
    getShadowElement<T>(querySelector: string): T;
    getShadowElements<T>(querySelector: string): T[] | undefined;
    getShadowElementByClass<T>(className: string): T;
    getShadowElementById<T>(id: string): T;
    destroy(): void;
    protected wirePlayer(): void;
    protected wireAudioTextDropdown(audioTextDropdown: OmakaseDropdown): void;
    protected checkPlayerInternal(): void;
    setWatermark(watermark: string | undefined): void;
    clearSafeZones(): void;
    addSafeZone(videoSafeZone: VideoSafeZoneCreate, allVideoSafeZones: VideoSafeZone[]): VideoSafeZone;
    removeSafeZone(videoSafeZone: VideoSafeZone): void;
    updateHelpMenu(helpMenuGroups: HelpMenuGroup[]): void;
    toggleFullScreen(): Observable<void>;
    enablePiP(): Observable<void>;
    disablePiP(): Observable<void>;
    isPiPSupported(): boolean;
    protected togglePiP(): Observable<void>;
    protected addPiPListeners(): void;
    getPlayerChromingElement<T>(querySelector: string): T;
    clearMarkerTracks(): void;
    addMarkerTrack(destination: ChromingTrackDestination): OmakaseMarkerTrack | OmakaseTimeRange;
    deleteMarkerTrack(idOrDestination: string | ChromingTrackDestination.PROGRESS_BAR): void;
    setMarkerTrackVisible(element: OmakaseMarkerTrack | OmakaseTimeRange, visible: boolean): void;
    hideMarkerTrack(idOrDestination: string | ChromingTrackDestination.PROGRESS_BAR): void;
    addMarker(trackId: string, marker: MarkerState): void;
    updateMarker(trackId: string, marker: MarkerState): void;
    removeMarker(trackId: string, marker: MarkerState): void;
    updateMarkerTrackState(trackId: string, markerTrack: MarkerTrackState): void;
    setAudioTracks(type: PlayerAudioType.MAIN | PlayerAudioType.SIDECAR, tracks: ChromingAudioTrack[]): void;
    updateAudioTracks(type: PlayerAudioType.MAIN | PlayerAudioType.SIDECAR, tracks: ChromingAudioTrackUpdateAttrs[]): void;
    updateAudioTrackRouters(): void;
    updateAudioTrackLabel(type: PlayerAudioType.MAIN | PlayerAudioType.SIDECAR, track: AudioState): void;
    addAudioTrack(type: PlayerAudioType.MAIN | PlayerAudioType.SIDECAR, track: ChromingAudioTrack): void;
    removeAudioTrack(type: PlayerAudioType.MAIN | PlayerAudioType.SIDECAR, trackId: AudioState['id']): void;
    setTextTracks(tracks: ChromingTextTrack[]): void;
    updateTextTracks(tracks: PlayerTextTrackState[]): void;
    updateTextTrackLabel(track: TextTrackState): void;
    addTextTrack(track: ChromingTextTrack): void;
    removeTextTrack(trackId: TextTrackState['id']): void;
    protected getTextTrackIndex(track: ChromingTextTrack): number | undefined;
    private clearShowTemporaryOnMouseMoveTimeoutId;
    private clearShowTemporaryBackgroundTimeoutId;
    private clearShowSeekLoadingAnimationTimeoutId;
    protected getControlBarClass(element: string): string;
    protected includeAudioRouter(): boolean;
    protected getAudioDropdownOptionActionClass(type: PlayerAudioType, track: PlayerAudioTrackState): string;
    protected getDefaultAudioLabel(type: PlayerAudioType, index: number): string;
    protected getDefaultTextLabel(index: number): string;
    protected getAudioDropdownOption(track: ChromingAudioTrack, defaultLabel: string): OmakaseDropdownListItem;
    protected getTextDropdownOption(track: ChromingTextTrack, defaultLabel: string): OmakaseDropdownListItem;
    protected registerAudioTextDropdown(dropdown: OmakaseDropdown): void;
    protected setDropdownOptions(dropdownList: OmakaseDropdownList, options: OmakaseDropdownListItem[]): void;
    protected addDropdownOption(dropdownList: OmakaseDropdownList, option: OmakaseDropdownListItem, index?: number): void;
    protected removeDropdownOption(dropdownList: OmakaseDropdownList, value: any): void;
    protected updateDropdownOptions(dropdownList: OmakaseDropdownList, options: Partial<OmakaseDropdownListItem>[]): void;
    protected setAudioTextDropdownMaxWidth(audioTextDropdown: OmakaseDropdown): void;
    protected displayAudioRouter(trackId: string, audioType: PlayerAudioType.MAIN | PlayerAudioType.SIDECAR, audioTextDropdown: OmakaseDropdown, player: PlayerInternalApi): void;
    protected hideAudioRouter(audioTextDropdown: OmakaseDropdown): void;
    protected isAudioRouterUpdated(handler: AudioHandlerApi): boolean;
    protected isMainAudioRouterSupported(): boolean;
    resetMainMediaVideoElement(): void;
    setAlerts(alerts: AlertState[]): void;
    addAlert(alert: AlertState): void;
    removeAlert(alertId: AlertState['id']): void;
    private _stackAlertsInDom;
    private _createAlertInDom;
    extractVideoKeyframe(options?: VideoKeyframeOptions): Observable<VideoKeyframe>;
    get mainMediaVideoElement(): HTMLVideoElement;
    get textMediaCaptionsElement(): HTMLElement;
    get textImscElement(): HTMLElement;
    get alertClosed$(): Observable<Alert['id']>;
    get themeConfigChange$(): Observable<void>;
}

export declare type ChromingEvent = {
    [K in ChromingEventType]: {
        type: K;
        data: ChromingEventTypeDataMap[K];
    };
}[keyof ChromingEventTypeDataMap];

export declare enum ChromingEventType {
    CHROMING_SESSION_RESTORED = "CHROMING_SESSION_RESTORED",
    CHROMING_CHANGE = "CHROMING_CHANGE",
    CHROMING_WATERMARK_UPDATE = "CHROMING_WATERMARK_UPDATE",
    CHROMING_SAFE_ZONES_CHANGE = "CHROMING_SAFE_ZONES_CHANGE",
    CHROMING_HELP_MENU_CHANGE = "CHROMING_HELP_MENU_CHANGE",
    CHROMING_MARKER_BAR_CHANGE = "CHROMING_MARKER_BAR_CHANGE",
    CHROMING_THUMBNAIL_TRACK_CHANGE = "CHROMING_THUMBNAIL_TRACK_CHANGE",
    CHROMING_THEME_CONFIG_CHANGE = "CHROMING_THEME_CONFIG_CHANGE"
}

export declare type ChromingEventTypeDataMap = {
    [ChromingEventType.CHROMING_CHANGE]: ChromingChangeEventData;
    [ChromingEventType.CHROMING_SESSION_RESTORED]: ChromingSessionRestoredEventData;
    [ChromingEventType.CHROMING_WATERMARK_UPDATE]: ChromingWatermarkUpdateEventData;
    [ChromingEventType.CHROMING_SAFE_ZONES_CHANGE]: ChromingSafeZoneChangeEventData;
    [ChromingEventType.CHROMING_HELP_MENU_CHANGE]: ChromingHelpMenuChangeEventData;
    [ChromingEventType.CHROMING_MARKER_BAR_CHANGE]: ChromingMarkerBarChangeEventData;
    [ChromingEventType.CHROMING_THUMBNAIL_TRACK_CHANGE]: ChromingThumbnailTrackChangeEventData;
    [ChromingEventType.CHROMING_THEME_CONFIG_CHANGE]: ChromingThemeConfigChangeEventData;
};

export declare interface ChromingHelpMenuChangeEventData extends Serializable {
    helpMenuGroups: HelpMenuGroup[];
}

export declare interface ChromingInternalApi extends ChromingCommonApi {
    domController: ChromingDomController<ChromingThemeTypes>;
    setPlayerInternal(playerInternal: PlayerInternalApi): void;
    addMarkerBar(id: Track['id'], destination: ChromingTrackDestination, config?: Partial<ChromingMarkerBarConfig>): Observable<ChromingMarkerBarState['id']>;
    setThumbnailTrack(id: Track['id'] | undefined): Observable<void>;
}

export declare interface ChromingInternalConfig extends CommonChromingConfig {
}

export declare interface ChromingLocalApi extends ChromingInternalApi, Destroyable {
    prepareDomForAttaching(isMainMediaLoaded: boolean): void;
    prepareDomForDetaching(): void;
    getPlayerChromingElement<T>(querySelector: string): T;
    loadTrack(trackType: TrackType.MARKER_TRACK, urlOrSource: string | Source, options?: TrackLoadOptions): Observable<MarkerTrack>;
    loadTrack(trackType: TrackType.THUMBNAIL_TRACK, urlOrSource: string | Source, options?: TrackLoadOptions): Observable<ThumbnailTrack>;
}

export declare interface ChromingLocalConfig extends ChromingConfigLocalAndDetached {
}

export declare interface ChromingMarkerBarAddedEventData extends Serializable {
    trackId: MarkerTrackState['id'];
}

export declare interface ChromingMarkerBarChangeEventData extends Serializable {
    progressBarMarkerBar: ChromingMarkerBarState | undefined;
    markerBars: ChromingMarkerBarState[];
}

/**
 * Configuration for a marker track in the player chroming.
 */
export declare interface ChromingMarkerBarConfig {
    /**
     * Unique identifier for the marker track. If not provided, a random id will be generated. The id is used to identify the marker track when updating or deleting it.
     */
    id: string;
    /**
     * Initial visibility of the marker track. If not provided, the marker track will be visible by default.
     */
    visible: boolean;
}

export declare interface ChromingMarkerBarElementApi {
    onEvent$: Observable<ChromingMarkerBarElementEvent>;
    destroy$: Observable<void>;
    get config(): ChromingMarkerBarConfig;
    set config(config: Partial<ChromingMarkerBarConfig>);
    get markerTracks(): MarkerTrackState[] | undefined;
    set markerTracks(markerTracks: MarkerTrackState[]);
    show(): void;
    hide(): void;
    addTrack(track: MarkerTrackState): void;
    removeTrack(track: MarkerTrackState): void;
    updateTrack(track: MarkerTrackState): void;
    hasTrack(trackId: string): boolean;
    addMarker(marker: MarkerState, trackId: MarkerTrackState['id']): void;
    updateMarker(marker: MarkerState): void;
    removeMarker(markerId: MarkerState['id']): void;
    removeAllMarkers(): void;
}

export declare type ChromingMarkerBarElementEvent = {
    [K in ChromingMarkerBarElementEventType]: {
        type: K;
        data: ChromingMarkerBarElementEventTypeDataMap[K];
    };
}[keyof ChromingMarkerBarElementEventTypeDataMap];

export declare enum ChromingMarkerBarElementEventType {
    CHROMING_MARKER_UPDATE = "CHROMING_MARKER_UPDATE",
    CHROMING_MARKER_CLICK = "CHROMING_MARKER_CLICK",
    CHROMING_MARKER_FOCUS = "CHROMING_MARKER_FOCUS",
    CHROMING_MARKER_UNFOCUS = "CHROMING_MARKER_UNFOCUS"
}

export declare type ChromingMarkerBarElementEventTypeDataMap = {
    [ChromingMarkerBarElementEventType.CHROMING_MARKER_UPDATE]: ChromingMarkerUpdateData;
    [ChromingMarkerBarElementEventType.CHROMING_MARKER_CLICK]: ChromingMarkerBarItemEventData;
    [ChromingMarkerBarElementEventType.CHROMING_MARKER_FOCUS]: ChromingMarkerBarItemEventData;
    [ChromingMarkerBarElementEventType.CHROMING_MARKER_UNFOCUS]: ChromingMarkerBarItemEventData;
};

export declare type ChromingMarkerBarEvent = {
    [K in ChromingMarkerBarEventType]: {
        type: K;
        data: ChromingMarkerBarEventTypeDataMap[K];
    };
}[keyof ChromingMarkerBarEventTypeDataMap];

export declare enum ChromingMarkerBarEventType {
    CHROMING_MARKER_BAR_CHANGE = "CHROMING_MARKER_BAR_CHANGE",
    CHROMING_MARKER_BAR_ITEM_CLICK = "CHROMING_MARKER_BAR_ITEM_CLICK",
    CHROMING_MARKER_BAR_ITEM_MOUSE_ENTER = "CHROMING_MARKER_BAR_ITEM_MOUSE_ENTER",
    CHROMING_MARKER_BAR_ITEM_MOUSE_LEAVE = "CHROMING_MARKER_BAR_ITEM_MOUSE_LEAVE",
    CHROMING_MARKER_BAR_TRACK_ADDED = "CHROMING_MARKER_BAR_TRACK_ADDED",
    CHROMING_MARKER_BAR_TRACK_REMOVED = "CHROMING_MARKER_BAR_TRACK_REMOVED"
}

export declare type ChromingMarkerBarEventTypeDataMap = {
    [ChromingMarkerBarEventType.CHROMING_MARKER_BAR_CHANGE]: ChromingMarkerBarStateChangeEventData;
    [ChromingMarkerBarEventType.CHROMING_MARKER_BAR_TRACK_ADDED]: ChromingMarkerBarAddedEventData;
    [ChromingMarkerBarEventType.CHROMING_MARKER_BAR_TRACK_REMOVED]: ChromingMarkerBarRemovedEventData;
    [ChromingMarkerBarEventType.CHROMING_MARKER_BAR_ITEM_CLICK]: ChromingMarkerBarItemEventData;
    [ChromingMarkerBarEventType.CHROMING_MARKER_BAR_ITEM_MOUSE_ENTER]: ChromingMarkerBarItemEventData;
    [ChromingMarkerBarEventType.CHROMING_MARKER_BAR_ITEM_MOUSE_LEAVE]: ChromingMarkerBarItemEventData;
};

export declare class ChromingMarkerBarHandler implements ChromingMarkerBarHandlerApi, Destroyable {
    protected readonly _onEvent$: Subject<ChromingMarkerBarEvent>;
    private _id;
    private _tracks;
    private _visible;
    private _destroyBreaker;
    private _elementBreaker;
    constructor(id: string, tracks: string[], visible: boolean);
    wireElement(markerBarElement: ChromingMarkerBarElementApi): void;
    setVisibility(visible: boolean): Observable<void>;
    addTrack(track: MarkerTrack | MarkerTrack['id']): Observable<void>;
    removeTrack(trackId: string): Observable<void>;
    getTrackIds(): string[];
    restoreState(state: ChromingMarkerBarState): Observable<void>;
    protected emitChangeEvent(): void;
    destroy(): void;
    get id(): string;
    get onEvent$(): Observable<ChromingMarkerBarEvent>;
    get state(): ChromingMarkerBarState;
}

export declare interface ChromingMarkerBarHandlerApi {
    onEvent$: Observable<ChromingMarkerBarEvent>;
    id: string;
    /**
     * Current state of the marker bar.
     */
    state: ChromingMarkerBarState;
    /**
     * Hide or show the marker bar.
     * @param visible Marker bar visibility
     */
    setVisibility(visible: boolean): Observable<void>;
    /**
     * Add another marker track.
     * @param track Marker track or marker track id
     */
    addTrack(track: MarkerTrack | MarkerTrack['id']): Observable<void>;
    /**
     * Remove marker track.
     * @param trackId Marker track id
     */
    removeTrack(trackId: string): Observable<void>;
    /**
     * Returns a list of track ids associated with the marker bar
     */
    getTrackIds(): string[];
    /**
     * Internal method. Restores the state of the marker track from the session.
     * @param state Marker track state
     */
    restoreState(state: ChromingMarkerBarState): Observable<void>;
}

declare interface ChromingMarkerBarHandlerMessageChannel {
    onEvent$: Observable<ChromingMarkerBarEvent>;
    state(): Observable<ChromingMarkerBarState>;
    setVisibility(visible: boolean): Observable<void>;
    addTrack(trackId: string): Observable<void>;
    removeTrack(trackId: string): Observable<void>;
}

declare class ChromingMarkerBarHandlerProxy extends BaseMessageChannelProxy<ChromingMarkerBarHandlerMessageChannel> implements ChromingMarkerBarHandlerApi {
    protected _remoteNode: RemoteNode;
    private _chromingMarkerTrackHandlerState?;
    protected _destroyBreaker: ObserverBreaker;
    constructor(messageChannel: MessageChannel_2<AudioHandlerMessageChannel>, remoteNode: RemoteNode, state: ChromingMarkerBarState);
    protected _router: AudioRouterProxy | undefined;
    get router(): AudioRouterProxy | undefined;
    updateFromState(markerTrackHandlerState: ChromingMarkerBarState): void;
    private checkLateInitialization;
    get onEvent$(): Observable<ChromingMarkerBarEvent>;
    get state(): ChromingMarkerBarState;
    get id(): string;
    setVisibility(visible: boolean): Observable<void>;
    getTrackIds(): string[];
    addTrack(track: MarkerTrack | MarkerTrack['id']): Observable<void>;
    removeTrack(trackId: string): Observable<void>;
    restoreState(state: ChromingMarkerBarState): Observable<void>;
    destroy(): void;
}

export declare type ChromingMarkerBarHandlers = {
    [ChromingTrackDestination.PROGRESS_BAR]: ChromingMarkerBarHandlerApi | undefined;
    [ChromingTrackDestination.MARKER_BARS]: ChromingMarkerBarHandlerApi[];
};

export declare interface ChromingMarkerBarItemEventData extends Serializable {
    item: MarkerState;
}

export declare interface ChromingMarkerBarRemovedEventData extends Serializable {
    trackId: MarkerTrackState['id'];
}

export declare interface ChromingMarkerBarState {
    id: string;
    tracks: string[];
    visible: boolean;
}

export declare interface ChromingMarkerBarStateChangeEventData extends Serializable {
    state: ChromingMarkerBarState;
}

export declare interface ChromingMarkerUpdateData extends Serializable {
    track: MarkerTrackState;
    item: MarkerState;
    attrs: MarkerUpdateableAttrs;
}

export declare interface ChromingSafeZoneChangeEventData extends Serializable {
    safeZones: VideoSafeZone[];
}

export declare type ChromingSession = ChromingState;

export declare interface ChromingSessionRestoredEventData extends Serializable {
    chromingSession: ChromingSession;
}

export declare interface ChromingState {
    theme: ChromingTheme;
    themeConfig: Partial<ChromingThemeConfigTypes> | undefined;
    watermark: string | undefined;
    safeZones: VideoSafeZone[];
    helpMenuGroups: HelpMenuGroup[];
    progressBarMarkerBar: ChromingMarkerBarState | undefined;
    markerBars: ChromingMarkerBarState[];
    thumbnailTrackId: Track['id'] | undefined;
}

declare interface ChromingTextTrack {
    playerTrack: PlayerTextTrackState;
    textTrack: TextTrackState;
}

export declare enum ChromingTheme {
    DEFAULT = "DEFAULT",
    STAMP = "STAMP",
    CHROMELESS = "CHROMELESS",
    CUSTOM = "CUSTOM",
    AUDIO = "AUDIO",
    OMAKASE = "OMAKASE"
}

export declare interface ChromingThemeConfigChangeEventData extends Serializable {
    theme: ChromingTheme;
    themeConfig: Partial<ChromingThemeConfigTypes> | undefined;
}

export declare type ChromingThemeConfigMap = {
    [ChromingTheme.DEFAULT]: DefaultThemeConfig;
    [ChromingTheme.AUDIO]: AudioThemeConfig;
    [ChromingTheme.CHROMELESS]: ChromelessThemeConfig;
    [ChromingTheme.OMAKASE]: OmakaseThemeConfig;
    [ChromingTheme.STAMP]: StampThemeConfig;
    [ChromingTheme.CUSTOM]: CustomThemeConfig;
};

export declare type ChromingThemeConfigTypes = DefaultThemeConfig | StampThemeConfig | ChromelessThemeConfig | AudioThemeConfig | OmakaseThemeConfig | CustomThemeConfig;

export declare type ChromingThemeTypes = ChromingTheme.DEFAULT | ChromingTheme.AUDIO | ChromingTheme.CHROMELESS | ChromingTheme.STAMP | ChromingTheme.OMAKASE | ChromingTheme.CUSTOM;

export declare interface ChromingThumbnailTrackChangeEventData extends Serializable {
    thumbnailTrackId: Track['id'] | undefined;
}

export declare enum ChromingTimeFormat {
    TIMECODE = "TIMECODE",
    COUNTDOWN_MEDIA_TIME = "COUNTDOWN_MEDIA_TIME",
    MEDIA_TIME = "MEDIA_TIME"
}

export declare enum ChromingTrackDestination {
    MARKER_BARS = "MARKER_BARS",
    PROGRESS_BAR = "PROGRESS_BAR"
}

export declare type ChromingVuMeterConfig = Pick<VuMeterConfig, 'theme' | 'scale' | 'rangeMinDb' | 'scaleStepDb' | 'scaleOffsetDb' | 'levelHoldDuration' | 'channels' | 'labels' | 'style'>;

export declare enum ChromingVuMeterPosition {
    CONTROL_BAR = "CONTROL_BAR",
    FLOATING = "FLOATING"
}

export declare type ChromingVuMeterStyle = Pick<VuMeterStyle, 'levelColors' | 'levelBackground'>;

export declare interface ChromingWatermarkUpdateEventData extends Serializable {
    watermark: string | undefined;
}

export declare interface ClassStyleRule<S = {}> {
    className: string;
    style: Partial<S>;
}

declare interface ClickEvent extends OmpMouseEvent {
}

export declare type Color = `#${string}` | `rgb(${string})` | `rgba(${string})` | `hsl(${string})` | (string & {});

/**
 * Default player configuration values.
 */
export declare const COMMON_PLAYER_CONFIG_DEFAULT: PlayerCommonConfig;

declare interface CommonChromingConfig extends ChromingDomConfig<ChromingThemeTypes> {
}

declare interface Comparable<T> {
    compareTo(o: T): number;
}

declare interface ComponentConfig<S> {
    style: S;
}

export declare type ConfigAndStyle<C, S> = Partial<C> & {
    style?: Partial<S>;
};

/**
 * Intended to be used in component constructors. 'style' property is made optional, style type 'S' type is made Partial
 */
declare type ConfigWithOptionalStyle<T extends ComponentConfig<any>> = WithOptionalPartial<T, 'style'>;

export declare enum ControlBarVisibility {
    ENABLED = "ENABLED",
    DISABLED = "DISABLED",
    FULLSCREEN_ONLY = "FULLSCREEN_ONLY"
}

export declare type Cursor = 'default' | 'pointer' | 'grab' | 'grabbing' | 'ew-resize' | 'col-resize';

/** Authentication data with a custom header factory. */
export declare interface CustomAuthenticationData {
    type: 'custom';
    /** Returns request headers to apply for the given URL. */
    headers: (url: string) => {
        headers: Record<string, string>;
    };
}

export declare interface CustomThemeConfig extends CustomThemeConfigUpdateableAttrs {
    /**
     * Id of the custom web component used for Player chroming
     */
    htmlTemplateId: string;
}

export declare interface CustomThemeConfigUpdateableAttrs {
}

declare interface DataMessage<DataType> extends Message {
    action: string;
    data: DataType;
}

declare type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

export declare const DEFAULT_AUDIO_PLAYER_CHROMING_CONFIG: AudioThemeConfig;

export declare const DEFAULT_CHROMELESS_PLAYER_CHROMING_CONFIG: ChromelessThemeConfig;

export declare const DEFAULT_CHROMING_VU_METER_CONFIG: ChromingVuMeterConfig;

export declare const DEFAULT_CHROMING_VU_METER_STYLE: Omit<ChromingVuMeterStyle, 'levelColors'>;

export declare const DEFAULT_DOWNSAMPLE_OPTIONS: Required<DownsampleOptions>;

export declare const DEFAULT_ELEMENT_STYLES: {
    [K in ElementStyleName]: ElementStyleByName[K];
};

export declare const DEFAULT_INTERPOLATION_OPTIONS: Required<Omit<InterpolationOptions, 'timeRange'>>;

export declare const DEFAULT_OMAKASE_PLAYER_CHROMING_CONFIG: OmakaseThemeConfig;

export declare const DEFAULT_PLAYER_CHROMING: PlayerChromingConfig;

export declare const DEFAULT_PLAYER_CHROMING_CONFIG: DefaultThemeConfig;

export declare const DEFAULT_STAMP_PLAYER_CHROMING_CONFIG: StampThemeConfig;

export declare const DEFAULT_VU_METER_CONFIG: VuMeterConfig;

export declare const DEFAULT_VU_METER_DEFAULT_THEME_COLORS: {
    maxValueDb: number;
    color: string;
    holdColor: string;
}[];

export declare const DEFAULT_VU_METER_LED_THEME_COLORS: {
    maxValueDb: number;
    color: string;
    holdColor: string;
}[];

export declare const DEFAULT_VU_METER_STYLE: Omit<VuMeterStyle, 'levelColors'>;

export declare class DefaultMarker extends BaseMarker implements Marker {
    constructor(args: MarkerArgs);
}

export declare class DefaultObservation extends BaseObservation implements Observation {
    constructor(args: ObservationArgs);
}

export declare class DefaultTextCue extends BaseTextCue implements TextCue {
    constructor(args: TextCueArgs);
}

export declare interface DefaultTextCueState extends TextCueState {
}

export declare enum DefaultThemeActionIcon {
    TRACK_SELECTOR = "TRACK_SELECTOR",
    HELP_MENU = "HELP_MENU",
    ROUTER = "ROUTER"
}

export declare interface DefaultThemeConfig extends DefaultThemeConfigUpdateableAttrs {
    /**
     * Specifies list of enabled floating controls
     */
    floatingControls: DefaultThemeFloatingControl[];
    /**
     * Specifies list of enabled floating controls
     */
    alwaysOnFloatingControls: DefaultThemeFloatingControl[];
    /**
     * Specifies list of enabled action icons
     */
    actionIcons: DefaultThemeActionIcon[];
    /**
     * Sets the available playback rates in menu
     */
    playbackRates: number[];
    /**
     * If false, track selection menu will keep open until explicitly closed.
     * If true it will close on track selection or when clicking outside of the menu
     */
    trackSelectorAutoClose: boolean;
    /**
     * Id of the custom web component used for Player chroming
     */
    htmlTemplateId?: string;
}

export declare interface DefaultThemeConfigUpdateableAttrs {
    /**
     * Specifies controls visibility
     */
    controlBarVisibility: ControlBarVisibility;
    /**
     * Specifies list of enabled controls in control bar
     */
    controlBar: DefaultThemeControl[];
    /**
     * Specifies which time format will be used in the timer control
     */
    timeFormat: ChromingTimeFormat;
    /**
     * Specifies if the time control can be used for seeking. It is activated by double clicking the time.
     */
    timeInteractive: boolean;
    /**
     * Shared configuration for floating and control bar VU meters
     */
    vuMeterConfig: Partial<ChromingVuMeterConfig>;
    /**
     * Specifies if the floating VU meter is displayed
     */
    isFloatingVuMeterVisible: boolean;
    /**
     * Override values for the floating VU meter configuration
     */
    floatingVuMeterConfig?: Partial<ChromingVuMeterConfig> | undefined;
    /**
     * Override values for the control bar VU meter configuration
     */
    controlBarVuMeterConfig?: Partial<ChromingVuMeterConfig> | undefined;
}

export declare enum DefaultThemeControl {
    PLAY = "PLAY",
    FRAME_FORWARD = "FRAME_FORWARD",
    TEN_FRAMES_FORWARD = "TEN_FRAMES_FORWARD",
    FRAME_BACKWARD = "FRAME_BACKWARD",
    TEN_FRAMES_BACKWARD = "TEN_FRAMES_BACKWARD",
    TIME_TOGGLE = "TIME_TOGGLE",
    FULLSCREEN = "FULLSCREEN",
    TEXT_TOGGLE = "TEXT_TOGGLE",
    VOLUME = "VOLUME",
    SCRUBBER = "SCRUBBER",
    TRACK_SELECTOR = "TRACK_SELECTOR",
    PLAYBACK_RATE = "PLAYBACK_RATE",
    DETACH_TOGGLE = "DETACH_TOGGLE",
    ROUTER = "ROUTER",
    VU_METER = "VU_METER",
    VU_METER_TOGGLE = "VU_METER_TOGGLE"
}

export declare enum DefaultThemeFloatingControl {
    PLAYBACK_CONTROLS = "PLAYBACK_CONTROLS",
    TIME = "TIME",
    ACTION_ICONS = "ACTION_ICONS",
    VU_METER = "VU_METER"
}

export declare class DefaultThumbnail extends BaseThumbnail implements Thumbnail {
    constructor(args: ThumbnailArgs);
}

/**
 * Serializable snapshot of a default thumbnail with a URL and time range.
 */
export declare interface DefaultThumbnailState extends ThumbnailState {
}

/**
 * Delay effect
 */
export declare class DelayEffect implements AudioEffect {
    private _delayNode;
    private _def;
    readonly id: string;
    readonly effectType: string;
    attrs: Map<string, any>;
    onReady$: ReplaySubject<void>;
    constructor(def: AudioEffectState);
    private extractDelayTimeParamFromDef;
    getInputNodes(): AudioNode[];
    getOutputNode(): AudioNode;
    getNodes(): AudioNode[];
    getParams(): AudioEffectParamType[] | undefined;
    toState(): AudioEffectState;
    setParam(param: AudioEffectParam): void;
    private updateDefParam;
    destroy(): void;
    static createDef(id: string, delayTime: number): AudioEffectDef;
}

declare interface Destroyable {
    destroy(): void;
}

export declare type Dimension = {
    width: number;
    height: number;
};

declare interface DomMediaElementConfig {
    crossOrigin?: string | undefined;
    loop?: boolean;
    preload?: 'none' | 'metadata' | 'auto';
}

export declare interface DownsampleOptions {
    /**
     * Period for downsampling in milliseconds
     */
    downsamplePeriod?: number;
    /**
     * Strategy for downsampling (supported values: none, drop, min, max, avg, max_abs, and min_abs)
     */
    downsampleStrategy?: DownsampleStrategy;
}

export declare type DownsampleStrategy = 'none' | 'drop' | 'max' | 'min' | 'avg' | 'max_abs' | 'min_abs';

declare interface DragConditions {
    positionBeforeDrag: Position | undefined;
    playbackState: MediaElementPlaybackState | undefined;
    isPlayheadDrag: boolean;
}

export declare type ElementStyleByName = {
    Marker: MarkerStyle;
    MarkerTrack: Omit<MarkerTrackStyle, keyof MarkerStyle>;
    Timeline: TimelineStyle;
    TimelineLane: TimelineLaneStyle;
    ScrubberLane: ScrubberLaneStyle;
    ThumbnailTrackLane: ThumbnailTrackLaneStyle;
    MarkerTrackLane: Omit<MarkerTrackLaneStyle, keyof TimelineLaneStyle>;
    TextTrackLane: TextTrackLaneStyle;
    LabelLane: Omit<LabelLaneStyle, keyof TimelineLaneStyle>;
    ScrollbarLane: Omit<ScrollbarLaneStyle, keyof TimelineLaneStyle>;
    ObservationTrackLane: Omit<ObservationTrackLaneStyle, keyof TimelineLaneStyle>;
    MarkerTrackOnMarkerTrackLane: Omit<MarkerTrackStyle, keyof MarkerTrackStyle>;
    MarkerOnMarkerTrackLane: Omit<MarkerOnMarkerTrackLaneStyle, keyof MarkerTrackStyle>;
    Scrollbar: ScrollbarStyle;
    MarkerOnChroming: Omit<MarkerOnChromingStyle, keyof MarkerTrackStyle>;
    MarkerOnMarkerList: Omit<MarkerOnMarkerListStyle, keyof MarkerTrackStyle>;
};

export declare type ElementStyleName = keyof ElementStyleByName;

declare type ExtractActions<T> = {
    [K in keyof T]: T[K] extends (...args: any[]) => any ? ExtractMethodTypes<T, K> : ExtractPropertyTypes<T, K>;
};

declare type ExtractActionType<T extends ExtractActions<any>> = Extract<keyof T, string>;

declare type ExtractMethodTypes<T, K extends keyof T> = {
    requestData: ExtractParameterTypes<T, K>;
    responseData: ExtractReturnType<T, K>;
};

declare type ExtractParameterTypes<T, K extends keyof T> = T[K] extends (...args: infer A) => any ? A : never;

declare type ExtractPropertyTypes<T, K extends keyof T> = {
    requestData: UnwrapObservable<T[K]>;
    responseData: T[K];
};

declare type ExtractReturnType<T, K extends keyof T> = T[K] extends (...args: any[]) => infer R ? R : never;

export declare enum FallbackFormat {
    NONE = "NONE",
    VTT = "VTT",
    SRT = "SRT",
    TTML = "TTML"
}

export declare class FileFormat {
    readonly type: FileFormatType;
    readonly mimeTypes: readonly string[];
    readonly extensions: readonly string[];
    constructor(type: FileFormatType, mimeTypes: readonly string[], extensions: readonly string[]);
    static readonly HLS: FileFormat;
    static readonly DASH: FileFormat;
    static readonly MP4: FileFormat;
    static readonly MKV: FileFormat;
    static readonly WEBM: FileFormat;
    static readonly AVI: FileFormat;
    static readonly MOV: FileFormat;
    static readonly MP4_AUDIO: FileFormat;
    static readonly MP3: FileFormat;
    static readonly AAC: FileFormat;
    static readonly OGG: FileFormat;
    static readonly OPUS: FileFormat;
    static readonly WAV: FileFormat;
    static readonly FLAC: FileFormat;
    static readonly VTT: FileFormat;
    static readonly SRT: FileFormat;
    static readonly SSA: FileFormat;
    static readonly ASS: FileFormat;
    static readonly TTML: FileFormat;
    static readonly SCC: FileFormat;
    static readonly STL: FileFormat;
    /** All supported streaming formats (HLS, DASH). */
    static readonly STREAMING: readonly FileFormat[];
    /** All supported video file formats (MP4, MKV, WEBM, AVI, MOV). */
    static readonly VIDEO: readonly FileFormat[];
    /** All supported audio file formats (MP4_AUDIO, MP3, AAC, OGG, OPUS, WAV, FLAC). */
    static readonly AUDIO: readonly FileFormat[];
    /** All supported text/subtitle formats (VTT, SRT, SSA, ASS, TTML, SCC, STL). */
    static readonly TEXT: readonly FileFormat[];
    /** All supported input formats across all categories. */
    static readonly ALL: readonly FileFormat[];
    private static _typeIndex;
    private static _extensionIndex;
    private static _mimeIndex;
    static fromType(type: FileFormatType): FileFormat | undefined;
    static fromExtension(ext: string): FileFormat | undefined;
    static fromMimeType(mime: string): FileFormat | undefined;
}

export declare enum FileFormatType {
    HLS = "HLS",
    DASH = "DASH",
    MP4 = "MP4",
    MKV = "MKV",
    WEBM = "WEBM",
    AVI = "AVI",
    MOV = "MOV",
    MP4_AUDIO = "MP4_AUDIO",
    MP3 = "MP3",
    AAC = "AAC",
    OGG = "OGG",
    OPUS = "OPUS",
    WAV = "WAV",
    FLAC = "FLAC",
    VTT = "VTT",
    SRT = "SRT",
    SSA = "SSA",
    ASS = "ASS",
    TTML = "TTML",
    SCC = "SCC",
    STL = "STL"
}

declare type FlexAlign = 'ALIGN_AUTO' | 'ALIGN_BASELINE' | 'ALIGN_CENTER' | 'ALIGN_FLEX_END' | 'ALIGN_FLEX_START' | 'ALIGN_SPACE_AROUND' | 'ALIGN_SPACE_BETWEEN' | 'ALIGN_STRETCH';

declare interface FlexContentNode extends Destroyable {
    updateLayout(layout: Layout): void;
}

declare type FlexDirection = 'FLEX_DIRECTION_COLUMN' | 'FLEX_DIRECTION_COLUMN_REVERSE' | 'FLEX_DIRECTION_ROW' | 'FLEX_DIRECTION_ROW_REVERSE';

declare type FlexEdge = 'EDGE_LEFT' | 'EDGE_TOP' | 'EDGE_RIGHT' | 'EDGE_BOTTOM' | 'EDGE_START' | 'EDGE_END' | 'EDGE_HORIZONTAL' | 'EDGE_VERTICAL' | 'EDGE_ALL';

declare interface FlexGroupConfig extends FlexNodeConfig {
    flexWrap?: FlexWrap;
    flexDirection?: FlexDirection;
    justifyContent?: FlexJustifyContent;
    alignItems?: FlexAlign;
    alignContent?: FlexAlign;
}

declare interface FlexGroupContentNode<T extends FlexContentNode> extends FlexContentNode {
    addContentChild(flexContentNode: T, index: number): void;
    removeContentChild(flexContentNode: T): void;
}

declare type FlexJustifyContent = 'JUSTIFY_CENTER' | 'JUSTIFY_FLEX_END' | 'JUSTIFY_FLEX_START' | 'JUSTIFY_SPACE_AROUND' | 'JUSTIFY_SPACE_BETWEEN' | 'JUSTIFY_SPACE_EVENLY';

declare interface FlexNode<T extends FlexContentNode> extends Destroyable {
    setWidth(value: number | string | 'auto'): void;
    setHeight(value: number | string | 'auto'): void;
    setHeightAndMargins(value: number | string | 'auto', margins: FlexSpacing[], refreshLayout: boolean): void;
    setDimension(width: number | string | 'auto', height: number | string | 'auto'): void;
    setPositions(positions: FlexSpacing[]): void;
    setDimensionAndPositions(width: number | string | 'auto', height: number | string | 'auto', positions: FlexSpacing[]): void;
    setMargins(margins: FlexSpacing[]): void;
    getLayout(): Layout;
    refreshLayout(): void;
    applyLayout(): void;
    refreshLayoutFromRoot(): void;
    setParent(parent: FlexNode<any>): void;
    get name(): string;
    get parent(): FlexNode<any> | undefined;
    get yogaNode(): Node_2;
    get yogaConfig(): Config;
    get contentNode(): T;
}

declare interface FlexNodeConfig {
    name?: string | undefined;
    flexGrow?: number | undefined;
    flexShrink?: number | undefined;
    positionType?: PositionType | undefined;
    overflow?: FlexOverflow | undefined;
    margins?: {
        value: number;
        flexEdge: FlexEdge;
    }[] | undefined;
    paddings?: {
        value: number;
        flexEdge: FlexEdge;
    }[] | undefined;
    width?: number | string | 'auto' | undefined;
    height?: number | string | 'auto' | undefined;
    minWidth?: number | string | undefined;
    minHeight?: number | string | undefined;
    maxWidth?: number | string | undefined;
    maxHeight?: number | string | undefined;
}

declare type FlexOverflow = 'OVERFLOW_VISIBLE' | 'OVERFLOW_HIDDEN' | 'OVERFLOW_SCROLL';

declare interface FlexSpacing {
    value: number;
    flexEdge: FlexEdge;
}

declare type FlexWrap = 'WRAP_NO_WRAP' | 'WRAP_WRAP' | 'WRAP_WRAP_REVERSE';

export declare type FontWeight = number & {};

declare interface FrameRateModel extends Serializable {
    value: number;
    fraction: {
        numerator: number;
        denominator: number;
    };
    frameDuration: number;
    /**
     * Indicates number of frames to drop on minute mark
     */
    dropFrames?: number;
}

export declare enum FullscreenChroming {
    ENABLED = "ENABLED",
    DISABLED = "DISABLED"
}

/**
 * Gain effect
 */
export declare class GainEffect implements AudioEffect {
    private _gainNode;
    private _def;
    readonly id: string;
    readonly effectType: string;
    attrs: Map<string, any>;
    onReady$: ReplaySubject<void>;
    constructor(def: AudioEffectState);
    private extractGainParamFromDef;
    getInputNodes(): AudioNode[];
    getOutputNode(): AudioNode;
    getNodes(): AudioNode[];
    getParams(): AudioEffectParamType[] | undefined;
    toState(): AudioEffectState;
    setParam(param: AudioEffectParam): void;
    private updateDefParam;
    destroy(): void;
    static createDef(id: string, gain: number): AudioEffectDef;
}

declare const getMessageChannelProxyMap: () => {
    Ui: typeof UiProxy;
    MainMediaRepository: typeof MainMediaRepositoryProxy;
    TrackRepository: typeof TrackRepositoryProxy;
    SessionStore: typeof SessionStoreProxy;
    OmakaseTrackApi: typeof OmakaseTrackApiProxy;
    TrackUtils: typeof TrackUtilsProxy;
    MainMedia: typeof MainMediaProxy;
    Track: typeof TrackProxy;
    MarkerTrack: typeof MarkerTrackProxy;
    ThumbnailTrack: typeof ThumbnailTrackProxy;
    PlayerDetached: typeof PlayerDetachedProxy;
    PlayerAudioInternal: typeof PlayerAudioInternalProxy;
    PlayerTextInternal: typeof PlayerTextInternalProxy;
    ChromingDetached: typeof ChromingDetachedProxy;
    ChromingMarkerBarHandler: typeof ChromingMarkerBarHandlerProxy;
    TextTrackHandler: typeof TextTrackHandlerProxy;
    AudioHandler: typeof AudioHandlerProxy;
    AudioEffects: typeof AudioEffectsProxy;
    AudioRouter: typeof AudioRouterProxy;
    AlertsManager: typeof AlertsManagerProxy;
};

declare function getSlotTemplateHTML(_attrs: Record<string, string>): string;

declare function getTooltipContentHTML(): string;

declare interface HasRectMeasurement {
    getRect(): RectMeasurement;
}

/**
 * Help menu group represents a group of help menu items in the player chroming help menu.
 */
export declare interface HelpMenuGroup {
    /**
     * Name of the help menu group. Will be displayed as the header of the group in the help menu.
     */
    name: string;
    /**
     * Array of help menu items in the help menu group. Each item represents a feature or functionality of the player and should have a name and description that will be displayed in the help menu.
     */
    items: HelpMenuItem[];
}

export declare enum HelpMenuGroupInsertPosition {
    APPEND = "APPEND",
    PREPEND = "PREPEND"
}

/**
 * Help menu item represents a feature or functionality of the player that will be displayed in the help menu.
 */
export declare interface HelpMenuItem {
    /**
     * Text to display on the right side of the help menu item. (i.e. functionality name))
     */
    name: string;
    /**
     * Text to display on the left side of the help menu item. (i.e. Keyboard shortcut)
     */
    description: string;
}

declare class HlsAudio extends Audio_2 {
    protected _audioType: AudioType;
    protected _mediaPlaylist: HlsMediaPlaylistArgs;
    constructor(args: HlsAudioArgs);
    protected getState(): HlsAudioState;
    get mediaPlaylist(): HlsAudioArgs['mediaPlaylist'];
}

declare interface HlsAudioArgs extends Omit<AudioArgs, 'url'> {
    mediaPlaylist: HlsMediaPlaylistArgs;
}

declare interface HlsAudioState extends AudioState {
    mediaPlaylist: HlsMediaPlaylistArgs;
}

declare type HlsLicenseXhrSetupFn = (xhr: XMLHttpRequest, url: string, keyContext: MediaKeySessionContext, licenseChallenge: Uint8Array) => void | Uint8Array | Promise<Uint8Array | void>;

declare class HlsMainMedia extends BaseMainMedia<HlsMainMediaState> {
    protected _mainMediaType: MainMediaType;
    protected readonly _destroyBreaker: ObserverBreaker;
    constructor(args: HlsMainMediaArgs);
    protected getState(): HlsMainMediaState;
}

declare interface HlsMainMediaArgs extends BaseMainMediaArgs {
}

declare interface HlsMainMediaState extends MainMediaState {
}

declare type HlsMediaPlaylistArgs = {
    type: MediaPlaylist['type'];
    id: MediaPlaylist['id'];
    url: MediaPlaylist['url'];
    audioCodec: MediaPlaylist['audioCodec'];
    channels: MediaPlaylist['channels'];
    name: MediaPlaylist['name'];
    default: MediaPlaylist['default'];
    autoselect: MediaPlaylist['autoselect'];
    lang: MediaPlaylist['lang'];
    forced: MediaPlaylist['forced'];
    instreamId: MediaPlaylist['instreamId'];
    characteristics: MediaPlaylist['characteristics'];
};

declare interface HlsPlayerControllerConfig extends PlayerControllerConfig {
    /**
     * HLS config
     */
    hlsConfig: Partial<HlsConfig>;
    /**
     * Function that creates hls.js pre-processor function {@link HlsConfig.licenseXhrSetup} for modifying license requests (https://github.com/video-dev/hls.js/blob/master/docs/API.md#licensexhrsetup)
     * If set, created function takes precedence over {@link licenseXhrSetup}
     *
     * @param sourceUrl
     * @param options
     */
    loadVideoLicenseXhrSetup?: (sourceUrl: string, loadOptions?: MainMediaLoadOptions | undefined) => HlsLicenseXhrSetupFn;
}

declare interface HlsPlayerPlaybackEngine extends PlayerPlaybackEngine {
    get hls(): default_2 | undefined;
}

declare class HlsTextTrack extends BaseTextTrack<TextCue, BaseTextCue, HlsTextTrackState, TextTrackEvent> {
    protected _textTrackType: TextTrackType;
    protected _mediaPlaylist: HlsMediaPlaylistArgs;
    constructor(args: HlsTextTrackArgs);
    get mediaPlaylist(): HlsMediaPlaylistArgs;
    static resolveKind(playlistType: HlsMediaPlaylistArgs['type']): TextTrackKind_2;
    protected getState(): HlsTextTrackState;
}

declare interface HlsTextTrackArgs extends Omit<TextTrackArgs, 'url'> {
    mediaPlaylist: HlsMediaPlaylistArgs;
}

declare interface HlsTextTrackState extends TextTrackState {
    mediaPlaylist: HlsMediaPlaylistArgs;
}

export declare type Horizontals = {
    x: number;
    width: number;
};

export declare interface IdStyleRule<S = {}> {
    id: string;
    style: Partial<S>;
}

/**
 * Timeline image button. Can be added  to timeline lane. {@link TimelineLaneApi}
 */
export declare class ImageButton extends BaseTimelineNode<ImageButtonConfig, ImageButtonStyle> {
    protected _konvaImage?: default_3.Image;
    protected _loadImageQueue: Subject<ImageButtonImageConfig>;
    protected _currentImageConfig?: ImageButtonImageConfig | undefined;
    constructor(config: ConfigWithOptionalStyle<ImageButtonConfig>);
    private loadImage;
    /**
     * Sets new image to display
     * @param config
     */
    setImage(config: ImageButtonImageConfig): void;
    /**
     * Gets current image config
     * @returns ImageButtonImageConfig
     */
    getImage(): {
        /**
         * Image source
         */
        src: string;
        /**
         * Image width
         */
        width?: number;
        /**
         * Image height
         */
        height?: number;
    } | undefined;
}

export declare interface ImageButtonConfig extends TimelineNodeConfig<ImageButtonStyle>, ImageButtonImageConfig {
    /**
     * Image source
     */
    src: string;
    /**
     * Image width
     */
    width?: number;
    /**
     * Image height
     */
    height?: number;
}

export declare type ImageButtonImageConfig = {
    /**
     * Image source
     */
    src: string;
    /**
     * Image width
     */
    width?: number;
    /**
     * Image height
     */
    height?: number;
};

export declare interface ImageButtonStyle extends TimelineNodeStyle {
}

export declare type InferUpdateAttrs<T> = T extends MutableTimedItem<any, infer U> ? U : TimedItemUpdateableAttrs;

export declare interface InternalAudioRouterApi extends AudioRouterApi, Destroyable {
    onEvent$: Observable<AudioRouterEvent>;
    load(): Observable<void>;
    connectSource(audioNode: AudioNode): void;
    disconnectSource(): void;
    destroy(): void;
}

export declare interface InterpolationOptions {
    /**
     * Period for interpolation in milliseconds
     */
    interpolationPeriod?: number;
    /**
     * Strategy for interpolation
     */
    interpolationStrategy?: InterpolationStrategy;
    /**
     * Optional time range (in seconds) to restrict which source items are included.
     * Items whose start time falls outside [start, end] are ignored.
     */
    timeRange?: {
        start?: number;
        end?: number;
    };
}

export declare type InterpolationStrategy = 'max' | 'min' | 'avg' | 'max_abs' | 'min_abs';

declare interface KonvaComponent<C extends ComponentConfig<S>, S, T extends default_3.Node> extends Destroyable {
    get konvaNode(): T;
    get config(): C;
    get style(): S;
    set style(value: Partial<S>);
}

declare interface KonvaComponent2<K extends default_3.Node> extends Destroyable {
    konvaNode: K;
}

/**
 * Used as content node in flex layouting
 */
declare class KonvaComponentFlexContentNode2<T extends KonvaComponent2<any> & OnMeasurementsChange> extends KonvaFlexContentNode {
    protected _component: T;
    constructor(component: T);
    updateLayout(layout: Layout): void;
    destroy(): void;
    get component(): T;
}

declare class KonvaFlexContentNode implements FlexContentNode {
    private _konvaNode;
    constructor(konvaNode: default_3.Group | default_3.Shape);
    updateLayout(layout: Layout): void;
    destroy(): void;
    get konvaNode(): default_3.Group | default_3.Shape;
}

declare class KonvaFlexGroup extends BaseFlexGroup<FlexGroupConfig, KonvaFlexGroupContentNode> {
    constructor(config: FlexGroupConfig, contentNode: KonvaFlexGroupContentNode);
    static of(config: KonvaFlexGroupConfig): KonvaFlexGroup;
}

declare interface KonvaFlexGroupConfig extends FlexGroupConfig, KonvaFlexGroupContentNodeConfig {
}

declare class KonvaFlexGroupContentNode implements FlexGroupContentNode<KonvaFlexContentNode> {
    private _config;
    private _konvaNode;
    private _konvaBgNode?;
    constructor(config: KonvaFlexGroupContentNodeConfig);
    updateLayout(layout: Layout): void;
    addContentChild(flexContentNode: KonvaFlexContentNode, index: number): void;
    removeContentChild(flexContentNode: KonvaFlexContentNode): void;
    destroy(): void;
    get konvaNode(): default_3.Group;
    get konvaBgNode(): default_3.Rect | undefined;
}

declare interface KonvaFlexGroupContentNodeConfig {
    konvaNode: default_3.Group;
    konvaBgNode?: default_3.Rect;
    clip?: boolean;
}

declare class KonvaFlexItem<T extends KonvaFlexContentNode> extends BaseFlexNode<FlexNodeConfig, T> {
    constructor(config: FlexNodeConfig, contentNode: T);
    static of(config: FlexNodeConfig, konvaNode: default_3.Group | default_3.Shape): KonvaFlexItem<KonvaFlexContentNode>;
}

export declare const LABEL_LANE_STYLE_DEFAULT: LabelLaneStyle;

export declare class LabelLane extends BaseTimelineLane<LabelLaneConfig, LabelLaneStyle> {
    protected _contentFlexGroup?: KonvaFlexGroup;
    protected _textLabel?: TextLabel;
    constructor(configAndStyle: ConfigAndStyle<LabelLaneConfig, LabelLaneStyle> & Pick<LabelLaneConfig, 'text'>);
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    protected createStyledElement(): StyledElementWithId<LabelLaneStyle>;
    protected settleLayout(): void;
    destroy(): void;
    clearContent(): void;
}

export declare interface LabelLaneConfig extends TimelineLaneConfig {
    text: string;
}

export declare interface LabelLaneStyle extends TimelineLaneStyle {
    textFill: string;
    textFontSize: number;
    textFontStyle?: string;
    textAreaStretch?: boolean;
}

declare interface Layout {
    readonly left: number;
    readonly right: number;
    readonly top: number;
    readonly bottom: number;
    readonly width: number;
    readonly height: number;
}

export declare class LineChartLane extends BaseObservationTrackLane<LineChartLaneConfig, LineChartLaneLaneStyle, LineChartLaneTrackConfig> {
    protected _downsamplers: Map<ObservationTrack['id'], ObservationTrackDownsampler>;
    private _typedTrackViews;
    constructor(configAndStyle?: ConfigAndStyle<LineChartLaneConfig, LineChartLaneLaneStyle>);
    addTrack(track: ObservationTrack, config?: LineChartLaneTrackConfig): void;
    addTrack(id: ObservationTrack['id'], config?: LineChartLaneTrackConfig): void;
    protected renderTrack(track: ObservationTrack, config: LineChartLaneTrackConfig | undefined): ObservationTrackView;
    protected onTrackRemoved(trackId: ObservationTrack['id']): void;
    protected hasVisualElements(): boolean;
    protected createLoadingGroupContent(width: number, height: number): default_3.Animation;
    destroy(): void;
}

export declare interface LineChartLaneConfig extends ObservationTrackLaneConfig {
}

export declare interface LineChartLaneLaneStyle extends ObservationTrackLaneStyle {
}

/**
 * Per-track configuration for {@link LineChartLane}.
 * Each track added via `addTrack()` can carry its own scale, baseline, interpolation
 * settings, and visual style that override lane-level defaults.
 */
export declare interface LineChartLaneTrackConfig extends ObservationTrackLaneTrackConfig {
    /** Value domain for this track. Auto-derived from data when omitted. */
    scale?: LineChartLaneTrackScale;
    /** Value that maps to the line baseline (zero-crossing). Defaults to 0. */
    scaleBaseline?: number;
    /** Aggregation strategy used when multiple samples fall in the same interpolation bucket. */
    interpolationStrategy?: InterpolationStrategy;
    /** Width in pixels of a single interpolation bucket. Smaller = more detail */
    interpolationWidth?: number;
    style?: LineChartLaneTrackStyle;
}

/**
 * Visual style for a single measurement series within a line-chart track.
 * Matched to data by `measurement`; unmatched measurements use defaults.
 */
export declare interface LineChartLaneTrackMeasurementStyle {
    /** Measurement this style applies to (matches {@link ObservationItem.measurement}). When omitted, acts as a wildcard fallback for any measurement that has no specific entry. */
    measurement?: ObservationItem['measurement'];
    /** Radius of each data-point circle in pixels. */
    pointRadius: Size;
    /** Fill color of data-point circles. */
    pointFill: Color;
    /** Opacity of data-point circles (0–1). */
    pointOpacity: Size;
    /** Stroke color of data-point circles. */
    pointStroke: Color;
    /** Stroke width of data-point circles in pixels. */
    pointStrokeWidth: Size;
    /** Color of the connecting polyline. */
    lineStroke: Color;
    /** Width of the connecting polyline in pixels. */
    lineStrokeWidth: Size;
    /** Dash pattern for the connecting polyline (Konva format). */
    lineDash: Size[];
    /** Opacity of the connecting polyline (0–1). */
    lineOpacity: Size;
    /** Solid fill color for the area below the line. Mutually exclusive with `fillBelowLinearGradientColorStops`. */
    fillBelow: Color;
    /** Gradient color stops (Konva format, top→bottom) for the area below the line. */
    fillBelowLinearGradientColorStops: (number | string)[];
    /** Solid fill color for the area above the line. Mutually exclusive with `fillAboveLinearGradientColorStops`. */
    fillAbove: Color;
    /** Gradient color stops (Konva format, bottom→top) for the area above the line. */
    fillAboveLinearGradientColorStops: (number | string)[];
}

declare type LineChartLaneTrackScale = {
    min: number;
    max: number;
};

export declare interface LineChartLaneTrackStyle {
    paddingTop?: number;
    paddingBottom?: number;
    baselineFill?: Color;
    baselineThickness?: Size;
    baselineDash?: Size[];
    measurements?: Partial<LineChartLaneTrackMeasurementStyle>[];
}

export declare type LineChartViewComponentEvent = {
    [K in LineChartViewComponentEventType]: {
        type: K;
        data: LineChartViewComponentEventTypeDataMap[K];
    };
}[keyof LineChartViewComponentEventTypeDataMap];

export declare interface LineChartViewComponentEventData {
    item: ObservationState;
    pointerPosition: Position;
}

export declare enum LineChartViewComponentEventType {
    CLICK = "CLICK",
    MOUSE_MOVE = "MOUSE_MOVE",
    MOUSE_ENTER = "MOUSE_ENTER",
    MOUSE_LEAVE = "MOUSE_LEAVE"
}

export declare type LineChartViewComponentEventTypeDataMap = {
    [LineChartViewComponentEventType.CLICK]: LineChartViewComponentEventData;
    [LineChartViewComponentEventType.MOUSE_MOVE]: LineChartViewComponentEventData;
    [LineChartViewComponentEventType.MOUSE_ENTER]: LineChartViewComponentEventData;
    [LineChartViewComponentEventType.MOUSE_LEAVE]: LineChartViewComponentEventData;
};

export declare type LoadMainMediaArgsType = {
    url: string;
    loadOptions?: MainMediaLoadOptions | undefined;
    mainMediaEssentialArgsHook: MainMediaEssentialArgsHookType;
    tracksCreatedHook: (tracks: Track[]) => Observable<void>;
    /**
     * If provided it will be used to identify possible known properties which we can take automatically instead of resolving them (ie. initSegmentTimeOffset etc.)
     */
    providedMainMedia?: MainMediaState;
};

/**
 * Primary media entity representing the loaded video or audio source.
 *
 * A `MainMedia` holds the media source, its associated tracks, load lifecycle
 * state, and runtime attributes (DRM, duration, frame rate, timecode model).
 * Extends {@link MediaEntity} with `mediaType` always set to {@link MediaEntityType.MAIN_MEDIA}.
 */
export declare interface MainMedia extends MediaEntity {
    /** Observable stream of lifecycle events (loading, loaded, error, updated). */
    onEvent$: Observable<MainMediaEvent>;
    /** The format of the media source (HLS, MP4, or AUDIO_FILE). */
    mainMediaType: MainMediaType;
    /** Serializable state snapshot. */
    state: MainMediaState;
    /** The resolved media source. */
    source: Source;
    /** The resolved file format type of the source. */
    sourceFileFormatType: FileFormatType | undefined;
    /** Tracks associated with this media (video, audio, text, markers, etc.). */
    tracks: Track[];
    /** Current load lifecycle stage (idle → loading → success / failure). */
    loadStage: OpStage;
    /** Transition the load stage to "loading" and emit a {@link MainMediaEventType.MAIN_MEDIA_LOADING} event. */
    loadStart(): void;
    /** Transition the load stage to "success" and emit a {@link MainMediaEventType.MAIN_MEDIA_LOADED} event. */
    loadSuccess(): void;
    /** Transition the load stage to "failure" and emit a {@link MainMediaEventType.MAIN_MEDIA_LOAD_ERROR} event. */
    loadError(error: string | undefined): void;
    /** Register a single track with this media. */
    addTrack(track: Track): void;
    /** Register multiple tracks with this media. */
    addTracks(tracks: Track[]): void;
    /** The duration originally reported at load time, before any runtime updates. */
    get initialDuration(): number | undefined;
    /** Current media duration in seconds. May be updated at runtime. */
    get duration(): number | undefined;
    /** Frame rate model derived from load options or the media source. */
    get frameRateModel(): FrameRateModel | undefined;
    /** FFOM (First Frame of Media) timecode model derived from load options. */
    get ffomTimecodeModel(): TimecodeModel | undefined;
    /** Time offset of the initialization segment, if applicable. */
    get initSegmentTimeOffset(): number | undefined;
    /** Whether the media source is DRM-protected. */
    get hasDrm(): boolean | undefined;
    /** Indicates whether media has video tracks. */
    get hasVideo(): boolean | undefined;
    /** Indicates whether media has audio tracks. */
    get hasAudio(): boolean | undefined;
    /**
     * Partially update mutable media attributes and emit a
     * {@link MainMediaEventType.MAIN_MEDIA_UPDATED} event.
     */
    updateAttrs(attrs: MainMediaUpdateableAttrs): void;
}

/**
 * Payload carried by the {@link MainMediaEventType.MAIN_MEDIA_LOAD_ERROR} event.
 */
export declare interface MainMediaErrorEventData extends MainMediaEventData {
    error: string | undefined;
}

export declare type MainMediaEssentialArgsHookType = (args: MainMediaUpdateableAttrs) => Observable<void>;

/**
 * Discriminated union of all main media lifecycle events.
 * Subscribe via {@link MainMedia.onEvent$}.
 */
export declare type MainMediaEvent = {
    [K in MainMediaEventType]: {
        type: K;
        data: MainMediaEventTypeDataMap[K];
    };
}[keyof MainMediaEventTypeDataMap];

/**
 * Payload carried by {@link MainMediaEvent} for non-error lifecycle events.
 */
export declare interface MainMediaEventData extends Serializable {
    mainMediaState: MainMediaState;
}

/**
 * Lifecycle event types emitted by a {@link MainMedia} instance.
 */
export declare enum MainMediaEventType {
    MAIN_MEDIA_LOADING = "MAIN_MEDIA_LOADING",
    MAIN_MEDIA_LOADED = "MAIN_MEDIA_LOADED",
    MAIN_MEDIA_LOAD_ERROR = "MAIN_MEDIA_LOAD_ERROR",
    MAIN_MEDIA_UPDATED = "MAIN_MEDIA_UPDATED"
}

/**
 * Maps each {@link MainMediaEventType} to its corresponding event data type.
 */
export declare type MainMediaEventTypeDataMap = {
    [MainMediaEventType.MAIN_MEDIA_LOADING]: MainMediaEventData;
    [MainMediaEventType.MAIN_MEDIA_LOADED]: MainMediaEventData;
    [MainMediaEventType.MAIN_MEDIA_LOAD_ERROR]: MainMediaErrorEventData;
    [MainMediaEventType.MAIN_MEDIA_UPDATED]: MainMediaEventData;
};

/**
 * Configuration provided when loading a main media source via
 * {@link OmakasePlayerApi.loadMainMedia} or {@link PlayerApi.loadMainMedia}.
 */
export declare interface MainMediaLoadOptions extends Serializable {
    /**
     * Media frame rate. Can be a numeric value or a fraction string in the form `"numerator/denominator"`.
     */
    frameRate?: number | string;
    /**
     * Whether the frame rate uses drop-frame counting.
     */
    dropFrame?: boolean;
    /**
     * Explicit media duration in seconds. Overrides the duration reported by the source.
     */
    duration?: number;
    /**
     * FFOM (First Frame of Media) timecode string used to offset time display.
     */
    ffom?: string;
    /**
     * Arbitrary key-value data provided on media load. Can be used to store values such as DRM tokens.
     */
    data?: Record<string, any>;
    /**
     * Explicitly set the media type instead of auto-detecting from the source URL.
     */
    mainMediaType?: MainMediaType;
    /**
     * Explicitly set the file format instead of auto-detecting from the source URL.
     * Takes precedence over {@link mainMediaType} for resolving both format and media type.
     */
    fileFormatType?: FileFormatType;
    /**
     * URL for a poster image displayed before the video starts playing.
     */
    poster?: string;
}

declare interface MainMediaMessageChannel {
    loadStart(): Observable<boolean>;
    loadSuccess(): Observable<boolean>;
    loadError(error: string | undefined): Observable<boolean>;
    addTrack(trackState: TrackState): Observable<boolean>;
    addTracks(trackStates: TrackState[]): Observable<boolean>;
    updateAttributes(attrs: MainMediaUpdateableAttrs): Observable<boolean>;
    state(): Observable<MainMediaState>;
}

declare class MainMediaProxy extends BaseMessageChannelProxy<MainMediaMessageChannel> implements MainMediaMessageChannel {
    constructor(messageChannel: MessageChannel_2<MainMediaMessageChannel>);
    loadStart(): Observable<boolean>;
    loadSuccess(): Observable<boolean>;
    loadError(error: string | undefined): Observable<boolean>;
    addTrack(trackState: TrackState): Observable<boolean>;
    addTracks(trackStates: TrackState[]): Observable<boolean>;
    updateAttributes(attrs: MainMediaUpdateableAttrs): Observable<boolean>;
    state(): Observable<MainMediaState>;
}

export declare class MainMediaRepository extends BaseRepository<MainMedia> implements Destroyable {
    private readonly _trackRepository;
    private readonly _onEvent$;
    private readonly _onMainMediaEvent$;
    constructor(trackRepository: TrackRepository);
    get onEvent$(): Observable<MainMediaRepositoryEvent>;
    get onMainMediaEvent$(): Observable<MainMediaEvent>;
    onMainMediaDeleted$(mainMediaId: MainMedia['id']): Observable<MainMediaRepositoryEvent<MainMediaRepositoryEventType.MAIN_MEDIA_DELETED>>;
    add(mainMedia: MainMedia): MainMedia;
    _add(mediaEntity: MainMedia): MainMedia;
    getFirstOrFail(): MainMedia;
    addAll(entities: MainMedia[]): MainMedia[];
    delete(id: MainMedia['id']): boolean;
    deleteAll(ids: MainMedia['id'][]): boolean;
    destroy(): void;
}

export declare interface MainMediaRepositoryEvent<T extends MainMediaRepositoryEventType = MainMediaRepositoryEventType> extends Serializable {
    type: T;
    data: MainMediaRepositoryEventTypeDataMap[T];
}

export declare interface MainMediaRepositoryEventData extends Serializable {
    mainMediaState: MainMediaState;
}

export declare enum MainMediaRepositoryEventType {
    MAIN_MEDIA_ADDED = "MAIN_MEDIA_ADDED",
    MAIN_MEDIA_DELETED = "MAIN_MEDIA_DELETED"
}

export declare type MainMediaRepositoryEventTypeDataMap = {
    [MainMediaRepositoryEventType.MAIN_MEDIA_ADDED]: MainMediaRepositoryEventData;
    [MainMediaRepositoryEventType.MAIN_MEDIA_DELETED]: MainMediaRepositoryEventData;
};

declare interface MainMediaRepositoryMessageChannel {
    /**
     * {@link MainMediaRepository.onEvent$}
     */
    onEvent$: Observable<MainMediaRepositoryEvent>;
    /**
     * {@link MainMediaRepository.onMainMediaEvent$}
     */
    onMainMediaEvent$: Observable<MainMediaEvent>;
    /**
     * {@link MainMediaRepository.get}
     */
    get(id: MainMediaState['id']): Observable<MainMediaState | undefined>;
    /**
     * {@link MainMediaRepository.getOrFail}
     */
    getOrFail(id: MainMediaState['id']): Observable<MainMediaState>;
    getFirstOrFail(): Observable<MainMediaState>;
    /**
     * {@link MainMediaRepository.findFirst}
     */
    findFirst(): Observable<MainMediaState | undefined>;
    /**
     * {@link MainMediaRepository.add}
     */
    add(mainMedia: MainMediaState): Observable<MainMediaState>;
    /**
     * {@link MainMediaRepository.delete}
     */
    delete(id: MainMediaState['id']): Observable<boolean>;
    /**
     * {@link MainMediaRepository.clear}
     */
    clear(): Observable<boolean>;
}

declare class MainMediaRepositoryProxy extends BaseMessageChannelProxy<MainMediaRepositoryMessageChannel> implements MainMediaRepositoryMessageChannel {
    constructor(remoteNode: RemoteNode);
    get onEvent$(): Observable<MainMediaRepositoryEvent>;
    get onMainMediaEvent$(): Observable<MainMediaEvent>;
    get(id: MainMediaState['id']): Observable<MainMediaState | undefined>;
    getOrFail(id: MainMediaState['id']): Observable<MainMediaState>;
    getFirstOrFail(): Observable<MainMediaState>;
    findFirst(): Observable<MainMediaState | undefined>;
    add(mainMedia: MainMediaState): Observable<MainMediaState>;
    delete(id: MainMediaState['id']): Observable<boolean>;
    clear(): Observable<boolean>;
}

/**
 * Serializable snapshot of a {@link MainMedia} instance.
 *
 * Extends {@link MediaEntityState} with media-specific fields such as source,
 * tracks, DRM flag, duration, frame rate, FFOM timecode, and init segment offset.
 * Used for cross-boundary transfer (e.g. attached ↔ detached mode) and session persistence.
 */
export declare interface MainMediaState extends MediaEntityState {
    mainMediaType: MainMedia['mainMediaType'];
    source: SourceState;
    sourceFileFormatType?: FileFormatType | undefined;
    loadOptions: MainMediaLoadOptions | undefined;
    loadStage: OpStageState;
    tracks: TrackState[];
    duration?: number | undefined;
    initialDuration?: number | undefined;
    frameRateModel?: FrameRateModel | undefined;
    ffomTimecodeModel?: TimecodeModel | undefined;
    initSegmentTimeOffset?: number | undefined;
    hasDrm?: boolean | undefined;
    hasVideo?: boolean | undefined;
    hasAudio?: boolean | undefined;
}

/**
 * Supported main media source types.
 */
export declare enum MainMediaType {
    HLS = "HLS",
    MP4 = "MP4",
    AUDIO_FILE = "AUDIO_FILE"
}

/**
 * Subset of {@link MainMediaState} fields that can be updated at runtime
 * via {@link MainMedia.updateAttrs}.
 */
export declare type MainMediaUpdateableAttrs = Pick<MainMediaState, 'duration' | 'frameRateModel' | 'ffomTimecodeModel' | 'initSegmentTimeOffset' | 'hasDrm' | 'hasVideo' | 'hasAudio'>;

/**
 * Functions without internal controller (only PlayerController)
 */
export declare class MainTextTrackHandler extends BasePlayerTextTrackHandler {
    constructor(trackState: TextTrackState, playerController: PlayerController);
    get handlerType(): PlayerTextHandlerType;
    switch(active: boolean): Observable<void>;
    show(): Observable<void>;
    hide(): Observable<void>;
}

declare class ManagedBroadcastChannel implements Destroyable {
    readonly onMessage$: Subject<Message>;
    protected _channelId: string;
    protected _broadcastChannel: BroadcastChannel;
    protected _messageListener: (messageEvent: MessageEvent) => void;
    protected _messageerrorListener: (error: any) => void;
    protected _destroyBreaker: ObserverBreaker;
    constructor(channelId: string);
    postMessage(message: Message): void;
    get channelId(): string;
    get broadcastChannel(): BroadcastChannel;
    destroy(): void;
}

export declare interface Marker extends TimedItem<MarkerState> {
    /** Whether this is a moment or period marker. */
    markerType: MarkerType;
    label?: string | undefined;
}

export declare const MARKER_ON_MARKER_TRACK_LANE_STYLE_DEFAULT: MarkerOnMarkerTrackLaneStyle;

export declare const MARKER_STYLE_DEFAULT: MarkerStyle;

export declare const MARKER_TRACK_LANE_STYLE_DEFAULT: MarkerTrackLaneStyle;

export declare const MARKER_TRACK_STYLE_DEFAULT: MarkerTrackStyle;

/**
 * Construction arguments shared by all marker types.
 */
export declare interface MarkerArgs extends TimedItemArgs {
    label?: string | undefined;
}

/**
 * Payload carried by marker-specific events (added, deleted, updating, updated).
 */
export declare interface MarkerEventData {
    trackId: Track['id'];
    markerState: MarkerState;
}

export declare class MarkerList implements Destroyable, MarkerListApi {
    protected _onEvent$: Subject<MarkerListEvent>;
    private _markerListDomController;
    private _markerListComponent;
    private _config;
    private _markerTracks;
    private _thumbnailTrack?;
    private _player;
    private readonly _destroyBreaker;
    private readonly _thumbnailBreaker;
    private _trackRemove$;
    private _markerRemove$;
    constructor(config: MarkerListConfig, player: OmakasePlayerApi);
    get onEvent$(): Observable<MarkerListEvent>;
    get markers(): MarkerState[];
    get config(): MarkerListConfig;
    get thumbnailTrack(): ThumbnailTrack | undefined;
    set thumbnailTrack(thumbnailTrack: ThumbnailTrack | undefined);
    addTrack(trackOrId: MarkerTrack | MarkerTrack['id']): void;
    removeTrack(trackId: MarkerTrack['id']): void;
    getTracks(): MarkerTrack[];
    reorderMarker(id: string, index: number): void;
    destroy(): void;
    protected removeMarkerFromDom(markerId: string): void;
    private resolveTrackSource;
    private wireMarkerTrack;
    private addMarkerToComponent;
    private resolveThumbnail;
    private resolveThumbnails;
}

export declare interface MarkerListActionEventData extends Serializable {
    action: string;
    item: MarkerState;
}

export declare interface MarkerListApi extends Destroyable {
    onEvent$: Observable<MarkerListEvent>;
    /**
     * Links another Marker Track to the Marker List
     * @param track Marker Track or Marker Track id
     */
    addTrack(track: MarkerTrack | MarkerTrack['id']): void;
    /**
     * Unlinks a Marker Track from the Marker List
     * @param trackId Marker Track id
     */
    removeTrack(trackId: MarkerTrack['id']): void;
    /**
     * @returns all linked Marker Tracks
     */
    getTracks(): MarkerTrack[];
}

export declare interface MarkerListConfig {
    markerListHTMLElementId: string;
    templateHTMLElementId?: string;
    headerHTMLElementId?: string;
    emptyHTMLElementId?: string;
    loadingHTMLElementId?: string;
    styleUrl?: string | string[];
    timeEditable?: boolean;
    labelEditable?: boolean;
    labelOptions?: string[];
    labelValidationFn?: (name: string | undefined) => boolean;
    markerTrack?: MarkerListSource | MarkerListSource[] | undefined;
    thumbnailTrack?: MarkerListSource | undefined;
    mode?: MarkerListMode;
}

export declare interface MarkerListDeleteEventData extends Serializable {
    item: MarkerState;
    source?: MarkerTrack | undefined;
}

export declare type MarkerListEvent = {
    [K in MarkerListEventType]: {
        type: K;
        data: MarkerListEventTypeDataMap[K];
    };
}[keyof MarkerListEventTypeDataMap];

export declare enum MarkerListEventType {
    MARKER_LIST_ITEM_ACTION = "MARKER_LIST_ITEM_ACTION",
    MARKER_LIST_ITEM_CLICK = "MARKER_LIST_ITEM_CLICK",
    MARKER_LIST_ITEM_MOUSE_ENTER = "MARKER_LIST_ITEM_MOUSE_ENTER",
    MARKER_LIST_ITEM_MOUSE_LEAVE = "MARKER_LIST_ITEM_MOUSE_LEAVE",
    MARKER_LIST_ITEM_DELETE = "MARKER_LIST_ITEM_DELETE",
    MARKER_LIST_TRACKS_LOADED = "MARKER_LIST_TRACKS_LOADED"
}

export declare type MarkerListEventTypeDataMap = {
    [MarkerListEventType.MARKER_LIST_ITEM_ACTION]: MarkerListActionEventData;
    [MarkerListEventType.MARKER_LIST_ITEM_CLICK]: MarkerListMouseEventData;
    [MarkerListEventType.MARKER_LIST_ITEM_MOUSE_ENTER]: MarkerListMouseEventData;
    [MarkerListEventType.MARKER_LIST_ITEM_MOUSE_LEAVE]: MarkerListMouseEventData;
    [MarkerListEventType.MARKER_LIST_ITEM_DELETE]: MarkerListDeleteEventData;
    [MarkerListEventType.MARKER_LIST_TRACKS_LOADED]: MarkerListTracksLoadedEventData;
};

export declare class MarkerListItem {
    private readonly _markerId;
    private _label;
    private _thumbnailUrl?;
    private _start?;
    private _end?;
    private _data?;
    private _track;
    private _markerType;
    private _styledElement;
    private _ui;
    constructor(marker: MarkerState, track: MarkerTrack, ui: UiApi);
    get markerId(): string;
    get track(): MarkerTrack;
    get label(): string | undefined;
    set label(label: string | undefined);
    get data(): Record<string, any> | undefined;
    set data(data: Record<string, any> | undefined);
    get thumbnailUrl(): string | undefined;
    set thumbnailUrl(thumbnail: string | undefined);
    get start(): string | undefined;
    get numStart(): number | undefined;
    set start(start: string | undefined);
    get end(): string | undefined;
    get numEnd(): number | undefined;
    set end(end: number | undefined);
    get duration(): number | undefined;
    get markerType(): MarkerType;
    get styledElement(): StyledElement;
    get style(): MarkerOnMarkerListStyle;
    get state(): MarkerState;
}

declare enum MarkerListMode {
    TIMELINE = "TIMELINE",
    CUTLIST = "CUTLIST"
}

export declare interface MarkerListMouseEventData extends Serializable {
    item: MarkerState;
    trackId: MarkerTrack['id'];
}

export declare interface MarkerListSource {
    url?: string;
    source?: Source;
    loadOptions?: TrackLoadOptions | undefined;
}

export declare interface MarkerListTracksLoadedEventData extends Serializable {
    tracks: MarkerTrack[];
}

declare interface MarkerMouseEvent {
    markerId: MarkerState['id'];
}

export declare interface MarkerOnChromingStyle extends MarkerTrackStyle {
    active: boolean;
}

export declare interface MarkerOnMarkerListStyle extends MarkerStyle {
    highlightMarker: boolean;
    canDeleteMarker: boolean;
}

export declare interface MarkerOnMarkerTrackLaneStyle extends MarkerTrackStyle {
    markerSymbol: 'none' | 'circle' | 'square' | 'triangle';
    markerRenderType: 'default' | 'spanning-over-all-lanes';
    markerSymbolSize: Size;
    markerLineStrokeWidth: Size;
    markerLineOpacity: Size;
    markerAreaOpacity: Size;
    markerHandleAreaOpacity: Size;
    markerHandleMouseOverScale: Size;
    markerHandleMouseOverCursor: Cursor | undefined;
    markerHandleMouseLeaveCursor: Cursor | undefined;
}

/**
 * Serializable snapshot of a {@link Marker}.
 */
export declare interface MarkerState extends TimedItemState {
    markerType: MarkerType;
    label?: string | undefined;
}

export declare interface MarkerStyle {
    markerColor: Color;
}

export declare class MarkerTrack extends BaseTimedItemsTrack<Marker, BaseMarker, MarkerTrackState, MarkerTrackEvent> {
    protected _trackType: TrackType;
    constructor(args?: MarkerTrackArgs);
    protected getState(): MarkerTrackState;
    updateAttrs(attrs: MarkerTrackUpdateableAttrs): void;
    addTimedItems(timedItems: BaseMarker | BaseMarker[]): void;
    addTimedItems(timedItems: MarkerArgs | MarkerArgs[]): void;
}

/**
 * Construction arguments for marker track instances.
 */
export declare interface MarkerTrackArgs extends TimedItemsTrackArgs {
}

/**
 * Union of base {@link TrackEventType} and marker-specific {@link MarkerTrackEventType}.
 */
export declare type MarkerTrackCommonEventTypes = TrackEventType | MarkerTrackEventType;

/**
 * Discriminated union of all events emitted by a marker track.
 */
export declare type MarkerTrackEvent = OmpEventGroup<MarkerTrackEventType, MarkerTrackEventTypeDataMap>;

/**
 * Event types specific to marker operations within a {@link MarkerTrack}.
 */
export declare enum MarkerTrackEventType {
    MARKER_SPECIFIC_EVENT_PLACEHOLDER = "MARKER_SPECIFIC_EVENT_PLACEHOLDER"
}

/**
 * Maps each marker track event type to its corresponding data payload.
 */
export declare type MarkerTrackEventTypeDataMap = TrackEventTypeDataMap<MarkerTrackState> & {
    [MarkerTrackEventType.MARKER_SPECIFIC_EVENT_PLACEHOLDER]: MarkerEventData;
};

export declare class MarkerTrackLane extends BaseMultiTrackLane<MarkerTrackLaneConfig, MarkerTrackLaneStyle, MarkerTrack, MarkerTrackLaneTrackConfig> {
    private readonly _onEvent$;
    protected readonly _visibleTimedItems: Set<Marker['id']>;
    protected readonly _markerViewComponents: Map<Marker['id'], MarkerViewComponent>;
    protected readonly _markerToTrack: Map<Marker['id'], MarkerTrack>;
    private _itemInForeground;
    protected _timecodedSpanningGroup?: default_3.Group;
    protected _markerViewComponentsGroup?: default_3.Group;
    protected _eventCatcher?: default_3.Rect;
    private _timecodedClick$;
    private _timecodedMouseMove$;
    protected _hoveredTimedItems: Set<Marker>;
    protected _handleTimelineZoom$: Subject<void>;
    protected _handleTimelineScroll$: Subject<void>;
    constructor(configAndStyle?: ConfigAndStyle<MarkerTrackLaneConfig, MarkerTrackLaneStyle>);
    get onEvent$(): Observable<MarkerTrackLaneEvent>;
    protected createStyledElement(): StyledElementWithId<MarkerTrackLaneStyle>;
    addTrack(track: MarkerTrack, config?: MarkerTrackLaneTrackConfig): void;
    addTrack(id: MarkerTrack['id'], config?: MarkerTrackLaneTrackConfig): void;
    protected render(): void;
    protected updatePositions(): void;
    protected onTrackRemoved(trackId: MarkerTrack['id']): void;
    protected handleTimelineZoom(): void;
    protected handleTimelineScroll(): void;
    clearContent(): void;
    setMarkerViewStyle(style: Partial<MarkerOnMarkerTrackLaneStyle>, ids?: TimedItem['id'][]): void;
    moveToForeground(id?: Marker['id']): void;
    private createMarkerViewComponents;
    static formatTrackOnLaneStyleId(markerTrackLane: MarkerTrackLane, trackId: MarkerTrack['id']): string;
    private updateVisibleTimedItems;
    private refreshMarkerViewComponentsPosition;
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    private handleTimecodeMouseMove;
    private setHoveredItems;
    private appendHoveredItems;
    private handleTimecodeClick;
    private handleTimedItemsUpdated;
    private handleTimedItemsDeleted;
    protected hasVisualElements(): boolean;
    protected settleLayout(): void;
    destroy(): void;
}

export declare interface MarkerTrackLaneConfig extends MultiTrackLaneConfig {
}

export declare type MarkerTrackLaneEvent = {
    [K in MarkerTrackLaneEventType]: {
        type: K;
        data: MarkerTrackLaneEventTypeDataMap[K];
    };
}[keyof MarkerTrackLaneEventTypeDataMap];

export declare interface MarkerTrackLaneEventData {
    item: MarkerState;
}

export declare enum MarkerTrackLaneEventType {
    TIMELINE_MARKER_TRACK_LANE_ITEM_CLICK = "TIMELINE_MARKER_TRACK_LANE_ITEM_CLICK",
    TIMELINE_MARKER_TRACK_LANE_ITEM_MOUSE_ENTER = "TIMELINE_MARKER_TRACK_LANE_ITEM_MOUSE_ENTER",
    TIMELINE_MARKER_TRACK_LANE_ITEM_MOUSE_LEAVE = "TIMELINE_MARKER_TRACK_LANE_ITEM_MOUSE_LEAVE",
    TIMELINE_MARKER_TRACK_LANE_ITEM_HANDLE_CLICK = "TIMELINE_MARKER_TRACK_LANE_ITEM_HANDLE_CLICK",
    TIMELINE_MARKER_TRACK_LANE_ITEM_HANDLE_MOUSE_ENTER = "TIMELINE_MARKER_TRACK_LANE_ITEM_HANDLE_MOUSE_ENTER",
    TIMELINE_MARKER_TRACK_LANE_ITEM_HANDLE_MOUSE_LEAVE = "TIMELINE_MARKER_TRACK_LANE_ITEM_HANDLE_MOUSE_LEAVE",
    TIMELINE_MARKER_TRACK_LANE_ITEM_IN_FOREGROUND_CHANGE = "TIMELINE_MARKER_TRACK_LANE_ITEM_IN_FOREGROUND_CHANGE"
}

export declare type MarkerTrackLaneEventTypeDataMap = {
    [MarkerTrackLaneEventType.TIMELINE_MARKER_TRACK_LANE_ITEM_CLICK]: MarkerTrackLaneMarkerEventData;
    [MarkerTrackLaneEventType.TIMELINE_MARKER_TRACK_LANE_ITEM_MOUSE_ENTER]: MarkerTrackLaneMarkerEventData;
    [MarkerTrackLaneEventType.TIMELINE_MARKER_TRACK_LANE_ITEM_MOUSE_LEAVE]: MarkerTrackLaneMarkerEventData;
    [MarkerTrackLaneEventType.TIMELINE_MARKER_TRACK_LANE_ITEM_HANDLE_CLICK]: MarkerTrackLaneEventData;
    [MarkerTrackLaneEventType.TIMELINE_MARKER_TRACK_LANE_ITEM_HANDLE_MOUSE_ENTER]: MarkerTrackLaneEventData;
    [MarkerTrackLaneEventType.TIMELINE_MARKER_TRACK_LANE_ITEM_HANDLE_MOUSE_LEAVE]: MarkerTrackLaneEventData;
    [MarkerTrackLaneEventType.TIMELINE_MARKER_TRACK_LANE_ITEM_IN_FOREGROUND_CHANGE]: {
        itemInForeground: MarkerState | undefined;
    };
};

export declare interface MarkerTrackLaneMarkerEventData {
    item: MarkerState;
    itemInForeground: MarkerState | undefined;
}

export declare interface MarkerTrackLaneStyle extends TimelineLaneStyle, MarkerOnMarkerTrackLaneStyle {
}

export declare interface MarkerTrackLaneTrackConfig extends MultiTrackLaneTrackConfig {
    style?: Partial<MarkerOnMarkerTrackLaneStyle> | undefined;
}

/** Load options for marker tracks. */
export declare interface MarkerTrackLoadOptions extends BaseTrackLoadOptions {
    args?: MarkerTrackArgs;
}

declare interface MarkerTrackMessageChannel extends TrackMessageChannel {
    updateTimedItem(id: MarkerState['id'], attrs: MarkerUpdateableAttrs): Observable<MarkerTrackState>;
}

declare class MarkerTrackProxy extends BaseMessageChannelProxy<MarkerTrackMessageChannel> implements MarkerTrackMessageChannel {
    constructor(messageChannel: MessageChannel_2<MarkerTrackMessageChannel>);
    get onEvent$(): Observable<TrackEvent_2>;
    loadStart(): Observable<boolean>;
    loadSuccess(): Observable<boolean>;
    loadError(error: string | undefined): Observable<boolean>;
    updateAttrs(attrs: TrackUpdateableAttrs): Observable<TrackState>;
    updateTimedItem(id: MarkerState['id'], attrs: MarkerUpdateableAttrs): Observable<MarkerTrackState>;
}

/**
 * Serializable snapshot of a marker {@link Track}.
 */
export declare interface MarkerTrackState extends TimedItemsTrackState<MarkerState> {
}

export declare interface MarkerTrackStyle extends MarkerStyle {
    /**
     * Threshold in seconds for considering a marker to render as a MOMENT_MARKER instead of SPANNING_MARKER.
     */
    momentToSpanningThreshold?: number | undefined;
}

/**
 * Subset of marker track fields that can be updated at runtime.
 */
export declare type MarkerTrackUpdateableAttrs = TrackUpdateableAttrs;

export declare class MarkerTrackVttFetcher extends VttTimedItemsFetcher<MarkerTrack> {
    map(index: number, cue: ParsedVttCue): TimedItemOf<MarkerTrack>;
}

/**
 * Discriminator for marker variants.
 */
export declare enum MarkerType {
    /** A marker that references a single point in time. */
    MOMENT_MARKER = "MOMENT_MARKER",
    /** A marker that spans a time range (start and/or end). */
    SPANNING_MARKER = "SPANNING_MARKER"
}

/**
 * Fields that can be updated on any {@link Marker} at runtime.
 */
export declare interface MarkerUpdateableAttrs extends TimedItemUpdateableAttrs {
    label?: string | undefined;
}

declare class MarkerViewComponent extends BaseKonvaComponent2<default_3.Group> {
    private readonly _onEvent$;
    protected _ui: Ui;
    protected _editable: boolean;
    protected _styledElement: StyledElement<MarkerOnMarkerTrackLaneStyle>;
    protected _style: MarkerOnMarkerTrackLaneStyle;
    protected _markerState: MarkerState;
    protected _timeline: TimelineImpl;
    protected _markerTrackLane: MarkerTrackLane;
    protected _updateHook: (attrs: MarkerUpdateableAttrs) => void;
    protected _innerComponent?: BaseMarkerViewInnerComponent;
    protected _group: default_3.Group;
    protected _innerGroup: default_3.Group;
    protected _renderBreaker: ObserverBreaker;
    constructor(args: {
        editable: boolean;
        markerState: MarkerState;
        markerTrackId: MarkerTrack['id'];
        timeline: TimelineImpl;
        ui: Ui;
        markerTrackLane: MarkerTrackLane;
        updateHook: (attrs: MarkerUpdateableAttrs) => void;
    });
    get onEvent$(): Observable<MarkerViewComponentEvent>;
    get style(): MarkerOnMarkerTrackLaneStyle;
    private getRelativePointerPosition;
    setStyle(style: Partial<MarkerOnMarkerTrackLaneStyle>): void;
    update(markerState: MarkerState): void;
    refreshTimelinePosition(): void;
    get editable(): boolean;
    protected styleChanged(): void;
    protected render(): void;
    protected provideKonvaNode(): default_3.Group;
    destroy(): void;
}

declare interface MarkerViewComponentDragEventData {
    item: MarkerState;
}

declare type MarkerViewComponentEvent = {
    [K in MarkerViewComponentEventType]: {
        type: K;
        data: MarkerViewComponentEventTypeDataMap[K];
    };
}[keyof MarkerViewComponentEventTypeDataMap];

declare interface MarkerViewComponentEventData {
    item: MarkerState;
    pointerPosition: Position;
}

declare enum MarkerViewComponentEventType {
    HANDLE_CLICK = "HANDLE_CLICK",
    HANDLE_MOUSE_MOVE = "HANDLE_MOUSE_MOVE",
    HANDLE_MOUSE_ENTER = "HANDLE_MOUSE_ENTER",
    HANDLE_MOUSE_LEAVE = "HANDLE_MOUSE_LEAVE",
    HANDLE_DRAG_START = "HANDLE_DRAG_START",
    HANDLE_DRAG_END = "HANDLE_DRAG_END"
}

declare type MarkerViewComponentEventTypeDataMap = {
    [MarkerViewComponentEventType.HANDLE_CLICK]: MarkerViewComponentEventData;
    [MarkerViewComponentEventType.HANDLE_MOUSE_MOVE]: MarkerViewComponentEventData;
    [MarkerViewComponentEventType.HANDLE_MOUSE_ENTER]: MarkerViewComponentEventData;
    [MarkerViewComponentEventType.HANDLE_MOUSE_LEAVE]: MarkerViewComponentEventData;
    [MarkerViewComponentEventType.HANDLE_DRAG_START]: MarkerViewComponentDragEventData;
    [MarkerViewComponentEventType.HANDLE_DRAG_END]: MarkerViewComponentDragEventData;
};

declare interface MarkerViewHandleVerticals {
    area: Verticals;
    handle: Verticals;
}

declare class MediaDeserializer implements Destroyable {
    constructor();
    static createMainMedia(state: MainMediaState): MainMedia;
    protected static createAudioFileMainMedia(state: MainMediaState): AudioMainMedia;
    protected static createHlsMainMedia(state: HlsMainMediaState): HlsMainMedia;
    protected static createMp4MainMedia(state: MainMediaState): Mp4MainMedia;
    protected static createBaseMainMediaArgs(state: MainMediaState): BaseMainMediaArgs;
    static createTrack(state: TrackState): Track;
    protected static createVideo(state: VideoState): Video;
    protected static createAudio(state: AudioState): Audio_2;
    protected static createMarkerTrack(state: MarkerTrackState): MarkerTrack;
    protected static createTextTrack(state: TextTrackState): TextTrackFile | HlsTextTrack;
    protected static createThumbnailTrack(state: ThumbnailTrackState): ThumbnailTrack;
    protected static createBaseMediaEntityArgs(state: MediaEntityState): BaseMediaEntityArgs;
    protected static createBaseTrackArgs(state: TrackState): BaseTrackArgs;
    protected static createAudioArgs(state: AudioState): AudioArgs;
    protected static createVideoArgs(state: VideoState): VideoArgs;
    protected static createTextTrackArgs(state: TextTrackState): TextTrackArgs;
    protected static createBaseMarkerTrackArgs(state: MarkerTrackState): MarkerTrackArgs;
    protected static createBaseTimedItemsTrackArgs(state: TimedItemsTrackState): TimedItemsTrackArgs;
    static createSource(state: SourceState): Source;
    static createLoadStage(state: OpStageState): OpStage;
    destroy(): void;
}

declare class MediaElementPlayback implements Destroyable {
    private readonly _onChange$;
    private _state;
    constructor();
    private updateState;
    private compare;
    get onChange$(): Observable<MediaElementPlaybackState>;
    get state(): MediaElementPlaybackState;
    setPlaying(): void;
    setPaused(): void;
    get pausing(): boolean;
    setPausing(value: boolean): void;
    setEnded(): void;
    get waiting(): boolean;
    set waiting(value: boolean);
    get seeking(): boolean;
    get playing(): boolean;
    get paused(): boolean;
    get ended(): boolean;
    set seeking(value: boolean);
    get buffering(): boolean;
    set buffering(value: boolean);
    get waitingSyncedMedia(): boolean;
    set waitingSyncedMedia(value: boolean);
    destroy(): void;
}

declare interface MediaElementPlaybackState {
    playing: boolean;
    pausing: boolean;
    paused: boolean;
    waiting: boolean;
    seeking: boolean;
    buffering: boolean;
    ended: boolean;
    waitingSyncedMedia: boolean;
}

/**
 * Base contract shared by all media entities ({@link MainMedia}, {@link Track}).
 *
 * Every entity carries a unique identifier, a discriminated {@link MediaEntityType},
 * and can produce a serializable {@link MediaEntityState} snapshot via {@link state}.
 */
export declare interface MediaEntity {
    /** Unique identifier (UUID). */
    id: string;
    /** Discriminator indicating whether this entity is a main media or a track. */
    mediaType: MediaEntityType;
    /** Serializable state snapshot of this entity. */
    state: MediaEntityState;
}

/**
 * Serializable snapshot of a {@link MediaEntity}, suitable for transfer across
 * worker boundaries or persistence in session storage.
 */
export declare interface MediaEntityState extends Serializable {
    id: MediaEntity['id'];
    mediaType: MediaEntity['mediaType'];
}

/**
 * Discriminator for the two kinds of media entities managed by the player.
 */
export declare enum MediaEntityType {
    MAIN_MEDIA = "MAIN_MEDIA",
    TRACK = "TRACK"
}

export declare interface MediaLoadRequest {
    id: string;
    mediaId: MediaEntityState['id'] | undefined;
    playerMainMediaId: MainMediaState['id'] | undefined;
}

declare interface MediaMetadata_2 {
    mimeType?: string | undefined;
    videoTracks?: {
        id: number;
    }[] | undefined;
    audioTracks?: {
        id: number;
    }[] | undefined;
    firstVideoTrackFrameRate?: number | undefined;
    firstVideoTrackInitSegmentTime?: number | undefined;
    firstAudioTrackChannelsNumber?: number | undefined;
    firstAudioTrackAudioCodec?: string | undefined;
}

export declare class MediaMetadataResolver {
    static getMediaMetadata<K extends keyof MediaMetadata_2>(src: string, keys: K[]): Observable<Pick<MediaMetadata_2, K>>;
    private static getMediaMetadataWithMediabunny;
}

declare interface MediaProbeMetadata {
    contentType: string;
    contentLength: number;
    video: Partial<VideoProbeMetadata>;
    audio: Partial<AudioProbeMetadata>;
}

export declare interface MediaProbeResult {
    fileFormat: FileFormat;
    metadata: Partial<MediaProbeMetadata>;
}

/**
 * Identifies the strategy used to probe a media URL.
 *
 * - `EXTENSION_PROBE`: Infers the format from the URL file extension. Returns candidates for ambiguous extensions (e.g. `.mp4`).
 * - `HEAD_REQUEST_PROBE`: Sends an HTTP HEAD request and reads the `Content-Type` header.
 * - `MEDIA_METADATA_RESOLVER_PROBE`: Partially downloads the file to resolve its actual MIME type via mediabunny.
 *   Use this to disambiguate formats the server's `Content-Type` header misreports (e.g. audio-only MP4 served as `video/mp4`).
 */
export declare enum MediaProbeToolType {
    EXTENSION_PROBE = "EXTENSION_PROBE",
    HEAD_REQUEST_PROBE = "HEAD_REQUEST_PROBE",
    MEDIA_METADATA_RESOLVER_PROBE = "MEDIA_METADATA_RESOLVER_PROBE"
}

/**
 * Discriminated union of all `{ format, value }` temporal representations.
 */
export declare type MediaTemporal = MediaTemporalByFormat[MediaTemporalFormat];

/**
 * Discriminated map that pairs each {@link MediaTemporalFormat} with a
 * `{ format, value }` object carrying the correctly-typed value.
 */
export declare type MediaTemporalByFormat = {
    [K in MediaTemporalFormat]: {
        format: K;
        value: MediaTemporalFormatValueMap[K];
    };
};

export declare class MediaTemporalConverter {
    protected _duration?: number | undefined;
    protected _frameRateModel?: FrameRateModel | undefined;
    protected _ffomTimecodeModel?: TimecodeModel | undefined;
    protected _initSegmentTimeOffset?: number | undefined;
    protected _hasVideo?: boolean | undefined;
    protected _hasAudio?: boolean | undefined;
    private constructor();
    static create(args?: MediaTemporalConverterArgs): MediaTemporalConverter;
    convert<S extends MediaTemporalFormat>(sourceValue: MediaTemporalFormatValueMap[S], sourceFormat: S, destinationFormat: MediaTemporalFormat.SECONDS): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    convert<S extends MediaTemporalFormat>(sourceValue: MediaTemporalFormatValueMap[S], sourceFormat: S, destinationFormat: MediaTemporalFormat.FRAME_COUNT): MediaTemporalFormatValueMap[MediaTemporalFormat.FRAME_COUNT];
    convert<S extends MediaTemporalFormat>(sourceValue: MediaTemporalFormatValueMap[S], sourceFormat: S, destinationFormat: MediaTemporalFormat.PERCENT): MediaTemporalFormatValueMap[MediaTemporalFormat.PERCENT];
    convert<S extends MediaTemporalFormat>(sourceValue: MediaTemporalFormatValueMap[S], sourceFormat: S, destinationFormat: MediaTemporalFormat.TIMECODE): MediaTemporalFormatValueMap[MediaTemporalFormat.TIMECODE];
    convert<S extends MediaTemporalFormat>(sourceValue: MediaTemporalFormatValueMap[S], sourceFormat: S, destinationFormat: MediaTemporalFormat.MEDIA_TIME): MediaTemporalFormatValueMap[MediaTemporalFormat.MEDIA_TIME];
    convert<S extends MediaTemporalFormat>(sourceValue: MediaTemporalFormatValueMap[S], sourceFormat: S, destinationFormat: MediaTemporalFormat.COUNTDOWN_MEDIA_TIME): MediaTemporalFormatValueMap[MediaTemporalFormat.COUNTDOWN_MEDIA_TIME];
    convert<S extends MediaTemporalFormat>(sourceValue: MediaTemporalFormatValueMap[S], sourceFormat: S, destinationFormat: MediaTemporalFormat): MediaTemporalFormatValueMap[MediaTemporalFormat];
    convertMediaTemporal(sourceTemporal: MediaTemporal, destinationFormat: MediaTemporalFormat): MediaTemporal;
    private convertToSecondsTemporal;
    private convertToFrameTemporal;
    private frameToTime;
    private timeToFrame;
    private constrainTime;
    private constrainFrame;
    private timecodeToFrame;
    private _framesPerDay;
}

/**
 * Construction arguments for {@link MediaTemporalConverter}.
 * All fields are optional; omitting a field disables conversions that depend on it.
 */
export declare interface MediaTemporalConverterArgs {
    /** Total media duration in seconds. Required for {@link MediaTemporalFormat.PERCENT} and {@link MediaTemporalFormat.COUNTDOWN_MEDIA_TIME} conversions. */
    duration?: number | undefined;
    /** Frame-rate model (rational fps + drop-frame flag). Required for {@link MediaTemporalFormat.FRAME_COUNT} and {@link MediaTemporalFormat.TIMECODE} conversions. */
    frameRateModel?: FrameRateModel | undefined;
    /** First-frame-of-media (FFOM) timecode model. When present, timecode output is offset so that `0 s` maps to this timecode value instead of `00:00:00:00`. */
    ffomTimecodeModel?: TimecodeModel | undefined;
    /** HLS init-segment time offset in seconds. Applied as a base offset when converting absolute media time to presentation time. */
    initSegmentTimeOffset?: number | undefined;
    /** Indicates if main media has video. **/
    hasVideo?: boolean | undefined;
    /** Indicates if main media has audio. **/
    hasAudio?: boolean | undefined;
}

/**
 * Supported temporal formats for expressing media time values.
 */
export declare enum MediaTemporalFormat {
    /** Absolute time in seconds (number). */
    SECONDS = "SECONDS",
    /** Zero-based frame index (number). Requires a known frame rate. */
    FRAME_COUNT = "FRAME_COUNT",
    /** Percentage of total duration, 0–100 (number). Requires a known duration. */
    PERCENT = "PERCENT",
    /** SMPTE-style timecode string (e.g. `"01:00:00:00"`). Requires a known frame rate. */
    TIMECODE = "TIMECODE",
    /** ISO 8601 time-of-day string without date, milliseconds to 3 decimal places (string). */
    MEDIA_TIME = "MEDIA_TIME",
    /** Countdown variant of {@link MEDIA_TIME}, counting down from the end of the media (string). Requires a known duration. */
    COUNTDOWN_MEDIA_TIME = "COUNTDOWN_MEDIA_TIME"
}

/**
 * Maps each {@link MediaTemporalFormat} to its TypeScript value type
 * (`number` for numeric formats, `string` for textual formats).
 */
export declare type MediaTemporalFormatValueMap = {
    [MediaTemporalFormat.SECONDS]: number;
    [MediaTemporalFormat.FRAME_COUNT]: number;
    [MediaTemporalFormat.PERCENT]: number;
    [MediaTemporalFormat.TIMECODE]: string;
    [MediaTemporalFormat.MEDIA_TIME]: string;
    [MediaTemporalFormat.COUNTDOWN_MEDIA_TIME]: string;
};

/** Shorthand for a frame-count-typed `{ format, value }` pair. */
export declare type MediaTemporalFrame = MediaTemporalByFormat[MediaTemporalFormat.FRAME_COUNT];

/** Shorthand for a seconds-typed `{ format, value }` pair. */
export declare type MediaTemporalSeconds = MediaTemporalByFormat[MediaTemporalFormat.SECONDS];

/**
 * Extracts the `{ format, value }` pair for a specific {@link MediaTemporalFormat}.
 */
export declare type MediaTemporalValueByFormat<F extends MediaTemporalFormat> = MediaTemporalByFormat[F];

declare interface Message {
    topic: string;
    type: MessageType;
    messageId: string;
}

declare class MessageChannel_2<T> extends BaseMessageChannel<ExtractActions<T>> {
    constructor(managedBroadcastChannel: ManagedBroadcastChannel, topic?: string);
    get topic(): string;
    get managedBroadcastChannel(): ManagedBroadcastChannel;
}

export declare class MessageChannelClosedError extends OmpError {
    constructor(topic: string);
}

declare type MessageChannelFactoryMap = {
    [K in keyof MessageChannelProxyFactoryArgs]: (...args: MessageChannelProxyFactoryArgs[K]) => MessageChannelProxyInstance<K & MessageChannelName>;
};

declare type MessageChannelName = keyof MessageChannelTypeMap;

declare interface MessageChannelProxy<T extends MessageChannelType> extends Destroyable {
    onInitialized$: Observable<boolean>;
    messageChannel: MessageChannel_2<T>;
}

declare type MessageChannelProxyFactoryArgs = {
    AudioHandler: [mainMediaId: MainMedia['id'], playerAudioType: PlayerAudioType, trackId: Audio_2['id'] | undefined, state: AudioHandlerState];
    TextTrackHandler: [mainMediaId: MainMedia['id'], trackId: Track['id'], state: TextTrackHandlerState];
    AudioEffects: [topic: string];
    AudioRouter: [topic: string, state: AudioRouterState];
    MainMedia: [mainMediaId: MainMedia['id']];
    Track: [trackId: Track['id']];
    MarkerTrack: [trackId: MarkerTrack['id']];
    ThumbnailTrack: [trackId: ThumbnailTrack['id']];
    ChromingMarkerBarHandler: [state: ChromingMarkerBarState];
};

declare type MessageChannelProxyInstance<K extends MessageChannelName> = MessageChannelProxyInstanceMap[K];

declare type MessageChannelProxyInstanceMap = {
    [K in MessageChannelName]: InstanceType<MessageChannelProxyMapType[K]>;
};

declare type MessageChannelProxyMapType = ReturnType<typeof getMessageChannelProxyMap>;

declare type MessageChannelType = MessageChannelTypeMap[MessageChannelName];

/**
 * Name - Type mappings for supported message channels
 */
declare type MessageChannelTypeMap = {
    Ui: UiMessageChannel;
    MainMediaRepository: MainMediaRepositoryMessageChannel;
    TrackRepository: TrackRepositoryMessageChannel;
    SessionStore: SessionStoreMessageChannel;
    OmakaseTrackApi: OmakaseTrackApiMessageChannel;
    TrackUtils: TrackUtilsMessageChannel;
    MainMedia: MainMediaMessageChannel;
    Track: TrackMessageChannel;
    MarkerTrack: MarkerTrackMessageChannel;
    ThumbnailTrack: ThumbnailTrackMessageChannel;
    PlayerDetached: PlayerDetachedMessageChannel;
    PlayerAudioInternal: PlayerAudioInternalMessageChannel;
    PlayerTextInternal: PlayerTextInternalMessageChannel;
    ChromingDetached: ChromingDetachedMessageChannel;
    ChromingMarkerBarHandler: ChromingMarkerBarHandlerMessageChannel;
    TextTrackHandler: TextTrackHandlerMessageChannel;
    AudioHandler: AudioHandlerMessageChannel;
    AudioEffects: AudioEffectsMessageChannel;
    AudioRouter: AudioRouterMessageChannel;
    AlertsManager: AlertsManagerMessageChannel;
};

declare enum MessageType {
    REQUEST = "REQUEST",
    RESPONSE = "RESPONSE"
}

export declare interface MomentTemporal {
    type: TimedItemTemporalType.MOMENT;
    time: string;
}

declare interface MouseEnterEvent extends OmpMouseEvent {
}

declare interface MouseLeaveEvent extends OmpMouseEvent {
}

declare interface MouseMoveEvent extends OmpMouseEvent {
}

declare interface MouseOutEvent extends OmpMouseEvent {
}

declare interface MouseOverEvent extends OmpMouseEvent {
}

declare class Mp4MainMedia extends BaseMainMedia<Mp4MainMediaState> {
    protected getState(): Mp4MainMediaState;
    protected _mainMediaType: MainMediaType;
    protected _source: Source;
    protected readonly _destroyBreaker: ObserverBreaker;
    constructor(args: Mp4MainMediaArgs);
    protected _state(): Mp4MainMediaState;
}

declare interface Mp4MainMediaArgs extends BaseMainMediaArgs {
}

declare interface Mp4MainMediaState extends MainMediaState {
}

declare interface Mp4PlayerControllerConfig extends PlayerControllerConfig {
}

declare interface Mp4PlayerPlaybackEngine extends PlayerPlaybackEngine {
}

export declare interface MultiTrackLaneConfig extends TimelineLaneConfig {
}

export declare interface MultiTrackLaneTrackConfig {
    /** Zero-based index at which to insert the track into the lane's track list. When omitted, the track is appended at the end. */
    trackOrderIndex?: number | undefined;
}

/**
 * Marks a timeline lane that manages multiple tracks.
 * Use this type when you need to accept any multi-track lane without caring about its concrete type.
 */
export declare interface MultiTrackTimelineLane<C extends MultiTrackLaneConfig = MultiTrackLaneConfig, S extends TimelineLaneStyle = TimelineLaneStyle, T extends Track = Track, TC extends MultiTrackLaneTrackConfig = MultiTrackLaneTrackConfig> extends TimelineLaneApi<S> {
    /**
     * Adds a track to this lane. Accepts either the track object itself or its ID, in which case
     * the track is resolved from the track repository.
     *
     * @param trackOrId - The track to add, or the ID of a track already registered in the track repository.
     * @param config - Optional per-track configuration (insertion index, style overrides, etc.).
     * @throws If a track with the same ID has already been added to this lane.
     * @throws If an ID is provided but no matching track exists in the track repository.
     */
    addTrack(track: T, config?: TC): void;
    addTrack(id: T['id'], config?: TC): void;
    /** Returns a shallow copy of all tracks currently added to this lane, in insertion order. */
    getTracks(): T[];
}

export declare interface MutableTimedItem<S extends TimedItemState = TimedItemState, U extends TimedItemUpdateableAttrs = TimedItemUpdateableAttrs> extends TimedItem<S> {
    update(attrs: U): void;
}

/**
 * A single observation entry within an {@link ObservationTrack}.
 */
export declare interface Observation extends TimedItem<ObservationState> {
    label: string | undefined;
    items: ObservationItem[];
}

export declare const OBSERVATION_TRACK_LANE_STYLE_DEFAULT: ObservationTrackLaneStyle;

/**
 * Construction arguments for {@link Observation} instances.
 */
export declare interface ObservationArgs extends TimedItemArgs {
    label?: string | undefined;
    items: ObservationItem[];
}

export declare interface ObservationItem {
    value?: string | undefined;
    measurement?: string | undefined;
    comment?: string | undefined;
}

/**
 * Serializable snapshot of an {@link Observation}.
 */
export declare interface ObservationState extends TimedItemState {
    label: string | undefined;
    items: ObservationItem[];
}

/**
 * An observation track — a timed-items track carrying {@link Observation} entries.
 */
export declare interface ObservationTrack<S extends ObservationTrackState = ObservationTrackState, E extends OmpEventGroup<any, any> = never> extends TimedItemsTrack<Observation, S, ObservationUpdateableAttrs, E> {
    observationTrackType: ObservationTrackType;
}

/**
 * Construction arguments for observation track instances.
 */
export declare interface ObservationTrackArgs extends TimedItemsTrackArgs {
}

export declare class ObservationTrackAudioLevelSource extends AudioLevelSource {
    protected _track?: ObservationTrack | undefined;
    protected _playerBreaker: ObserverBreaker;
    protected _trackBreaker: ObserverBreaker;
    protected _eventEmitter?: TimedItemsTrackEventEmitter;
    protected _timeProvider$: Subject<number>;
    private _exactObservations;
    private _nearObservations;
    private _channelTracks;
    private _channelEventEmitters;
    private _channelExactObservations;
    private _channelNearObservations;
    private _sampleTime;
    private _eventEmitterTreshold;
    constructor(player: OmakasePlayerApi, track: ObservationTrack | ObservationTrack[]);
    wirePlayer(player: OmakasePlayerApi): void;
    setTrack(track: ObservationTrack | ObservationTrack[]): void;
    destroy(): void;
    private _subscribeChannelEmitter;
    private getDbValuesAtTime;
    private getChannelMaxValueAtTime;
    private extractDbValues;
    private isObservationValid;
}

export declare class ObservationTrackDownsampler extends TimedItemsTrackDownsampler<ObservationTrack<ObservationTrackState, ObservationTrackEvent>> {
    constructor(sourceTrack: ObservationTrack, options: DownsampleOptions);
    protected createDownsampledTrack(): ObservationTrack<ObservationTrackState, ObservationTrackEvent>;
    protected resolveDownsampledTimedItem(_index: number, start: number, end: number, timedItems: TrackTimedItem<ObservationTrack<ObservationTrackState, ObservationTrackEvent>>[]): TrackTimedItem<ObservationTrack<ObservationTrackState, ObservationTrackEvent>>;
    private _getAggregateValue;
}

export declare type ObservationTrackEvent = OmpEventGroup<ObservationTrackEventType, ObservationTrackEventTypeDataMap>;

export declare interface ObservationTrackEventData {
}

export declare enum ObservationTrackEventType {
    OBSERVATION_TRACK_SPECIFIC_EVENT_PLACEHOLDER = "OBSERVATION_TRACK_SPECIFIC_EVENT_PLACEHOLDER"
}

export declare type ObservationTrackEventTypeDataMap = {
    [ObservationTrackEventType.OBSERVATION_TRACK_SPECIFIC_EVENT_PLACEHOLDER]: ObservationTrackEventData;
};

export declare class ObservationTrackFile extends BaseObservationTrack<Observation, BaseObservation, ObservationTrackState, ObservationTrackEvent> {
    protected _observationTrackType: ObservationTrackType;
    constructor(args?: ObservationTrackArgs);
    protected getState(): ObservationTrackState;
}

export declare class ObservationTrackInterpolator extends TimedItemsInterpolator<ObservationTrack<ObservationTrackState, ObservationTrackEvent>> {
    constructor(sourceTrack: ObservationTrack<ObservationTrackState, ObservationTrackEvent>, options: InterpolationOptions);
    protected createInterpolatedTrack(): ObservationTrack<ObservationTrackState, ObservationTrackEvent>;
    protected resolveInterpolatedTimedItem(_index: number, start: number, end: number, timedItems: TrackTimedItem<ObservationTrack<ObservationTrackState, ObservationTrackEvent>>[]): TrackTimedItem<ObservationTrack<ObservationTrackState, ObservationTrackEvent>>;
    private _getAggregateValue;
}

export declare interface ObservationTrackLaneConfig extends TrackLaneConfig {
    downsampleOptions?: DownsampleOptions;
}

export declare type ObservationTrackLaneEvent = {
    [K in ObservationTrackLaneEventType]: {
        type: K;
        data: ObservationTrackLaneEventTypeDataMap[K];
    };
}[keyof ObservationTrackLaneEventTypeDataMap];

export declare enum ObservationTrackLaneEventType {
    TIMELINE_OBSERVATION_TRACK_LANE_ITEM_CLICK = "TIMELINE_OBSERVATION_TRACK_LANE_ITEM_CLICK"
}

export declare type ObservationTrackLaneEventTypeDataMap = {
    [ObservationTrackLaneEventType.TIMELINE_OBSERVATION_TRACK_LANE_ITEM_CLICK]: ObservationTrackLaneObservationEventData;
};

export declare interface ObservationTrackLaneObservationEventData {
    item: ObservationState;
}

export declare interface ObservationTrackLaneStyle extends TimelineLaneStyle {
}

/** Per-track configuration for lanes that render observation data (bar charts, line charts, etc.). */
export declare interface ObservationTrackLaneTrackConfig extends MultiTrackLaneTrackConfig {
}

/**
 * Load options for an observation track.
 */
export declare interface ObservationTrackLoadOptions extends BaseTrackLoadOptions {
    args?: ObservationTrackArgs;
}

/**
 * Serializable snapshot of an observation {@link Track}.
 */
export declare interface ObservationTrackState extends TimedItemsTrackState<ObservationState> {
    observationTrackType: ObservationTrackType;
}

/**
 * Discriminator for the origin of an observation track.
 */
export declare enum ObservationTrackType {
    /** Standalone observation track file loaded as a sidecar. */
    OBSERVATION_TRACK_FILE = "OBSERVATION_TRACK_FILE"
}

/**
 * Subset of observation track fields that can be updated at runtime.
 */
export declare type ObservationTrackUpdateableAttrs = TrackUpdateableAttrs;

declare interface ObservationTrackView extends KonvaComponent2<default_3.Group> {
    render(timeRange: {
        start: number;
        end: number;
    }): void;
    updatePositions(timeRange: {
        start: number;
        end: number;
    }): void;
    clearContent(): void;
}

export declare class ObservationTrackVttFetcher extends VttTimedItemsFetcher<ObservationTrack> {
    map(index: number, cue: ParsedVttCue): TimedItemOf<ObservationTrack>;
    private fetchItems;
    private fetchLabel;
}

/**
 * Fields that can be updated on an {@link Observation} at runtime.
 */
export declare interface ObservationUpdateableAttrs extends TimedItemUpdateableAttrs {
    label?: string | undefined;
}

declare class ObserverBreaker implements Destroyable {
    private _observer;
    break(): void;
    error(error: any): void;
    get observer(): Observable<void>;
    destroy(): void;
}

declare const OMAKASE_VTT_CUE_DATA_KEY_MAPPING: {
    readonly OMAKASE_VTT_VERSION_1_0: "ompVttV1CueRows";
};

export declare class OmakaseAudioVisualization extends HTMLElement {
    private _peakArray;
    private _historyArray;
    private _barElements;
    protected _destroyBreaker: ObserverBreaker;
    private _silenceBreaker$;
    protected _viewboxWidth: number;
    protected _viewboxHeight: number;
    protected _barCount: number;
    protected _initialBars: number[];
    protected _maxHistoryCount: number;
    protected _sampleTime: number;
    protected _maxHeight: number;
    protected _smoothingFactor: number;
    protected _dbRangeMin: number;
    protected _dbRangeMax: number;
    protected _fillColors: string[];
    protected _strokeColor: string;
    connectedCallback(): void;
    showInitialSvg(): void;
    disconnectedCallback(): void;
    wirePlayer(player: PlayerInternalApi): void;
    private addPeakValue;
    private draw;
    private getScaledValue;
}

export declare enum OmakaseControlBarVisibility {
    ENABLED = "ENABLED",
    DISABLED = "DISABLED",
    ALWAYS_ON = "ALWAYS_ON"
}

export declare class OmakaseDropdown extends HTMLElement {
    private _toggle;
    private _displayLabel;
    private _subscriptions;
    private _documentClickListener;
    private _onClose$;
    constructor();
    get width(): number;
    get toggle(): OmakaseDropdownToggle | undefined;
    set toggle(toggle: OmakaseDropdownToggle | undefined);
    get displayLabel(): string | undefined;
    set displayLabel(displayLabel: string | undefined);
    get isFloating(): boolean;
    set isFloating(isFloating: boolean);
    get position(): OmakaseDropdownPosition;
    set position(position: OmakaseDropdownPosition);
    get alignment(): OmakaseDropdownAlignment;
    set alignment(alignment: OmakaseDropdownAlignment);
    get onClose$(): Observable<void>;
    connectedCallback(): void;
    disconnectedCallback(): void;
    closeDropdown(): void;
}

declare type OmakaseDropdownAlignment = 'left' | 'center' | 'right';

export declare class OmakaseDropdownList extends HTMLElement implements OmakaseDropdownListApi {
    private _title?;
    private _list?;
    private _options;
    private _optionElements;
    private _selectedOption$;
    private _selectedAction$;
    private _selectedOptionSubscription;
    constructor();
    set width(width: number);
    get width(): number;
    set maxWidth(width: number | undefined);
    get maxWidth(): number | undefined;
    get selectedOption$(): BehaviorSubject<OmakaseDropdownListItem | undefined>;
    get selectedAction$(): Observable<OmakaseDropdownListItem>;
    set type(type: OmakaseDropdownListType);
    get type(): OmakaseDropdownListType;
    get options(): OmakaseDropdownListItem[];
    setTitle(title: string): void;
    setOptions(options: OmakaseDropdownListItem[]): void;
    updateOptions(options: Partial<OmakaseDropdownListItem>[]): void;
    addOption(option: OmakaseDropdownListItem, insertAtIndex?: number): void;
    removeOption(value: any): void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    private _selectOption;
    private _updateDropdownLabel;
    private _getDropdown;
}

/**
 * Omakase dropdown component API
 */
export declare interface OmakaseDropdownListApi {
    /**
     * Width of the dropdown list in pixels. If the width is not set, the dropdown list will have a default width defined in CSS.
     */
    get width(): number;
    set width(width: number);
    /**
     * Type of icons displayed next to each dropdown list item. Can be 'radio' for radio button icons, 'checkbox' for checkbox icons, or 'default' for no icons. Default value is 'default'.
     */
    get type(): OmakaseDropdownListType;
    set type(type: OmakaseDropdownListType);
    /**
     * Observable that emits the currently selected dropdown list item whenever the selection changes. Emits undefined if no item is selected.
     */
    selectedOption$: BehaviorSubject<OmakaseDropdownListItem | undefined>;
    /**
     * Observable that emits the dropdown list item whenever the action icon on the right side of the dropdown list item is clicked.
     */
    selectedAction$: Observable<OmakaseDropdownListItem>;
    /**
     * Sets the dropdown list items and their configuration. The configuration includes the label to display for each item, the internal value of each item, and whether the item is active (selected) or not. The internal value can be used to determine which item is selected when subscribing to the selectedOption$ observable.
     * @param options Array of dropdown list items and their configuration
     */
    setOptions(options: OmakaseDropdownListItem[]): void;
}

/**
 * Single item in the dropdown list.
 */
export declare interface OmakaseDropdownListItem extends Record<string, any> {
    /**
     * Internal value of the dropdown list item that can be used to determine which item is selected. Can be of any type and is not displayed in the UI.
     */
    value: any;
    /**
     * Label of the dropdown list item that will be displayed in the UI.
     */
    label: string;
    /**
     * If true, the dropdown list item will be displayed as selected in the UI.
     */
    active?: boolean;
    /**
     * Class(es) to add to the element displayed after the label text
     */
    actionClass?: string;
}

declare type OmakaseDropdownListType = 'radio' | 'checkbox' | 'default';

export declare class OmakaseDropdownOption extends HTMLElement {
    value?: any;
    private _textElement?;
    private _iconElement?;
    private _actionElement?;
    onSelect$: Subject<void>;
    onAction$: Subject<void>;
    constructor();
    setActionClass(classNames: string): void;
    setLabel(label: string): void;
    connectedCallback(): void;
}

declare type OmakaseDropdownPosition = 'above' | 'below';

export declare class OmakaseDropdownToggle extends HTMLElement {
    static get observedAttributes(): string[];
    private _dropdown?;
    private _span?;
    get span(): HTMLSpanElement | undefined;
    get isDisabled(): boolean;
    set isDisabled(isDisabled: boolean);
    constructor();
    connectedCallback(): void;
    private _bindDropdown;
}

export declare class OmakaseFullscreenButton extends MediaFullscreenButton {
    private _player;
    get player(): PlayerInternalApi | undefined;
    set player(player: PlayerInternalApi | undefined);
    handleClick(e: Event): void;
}

export declare class OmakaseMarkerBar extends HTMLElement {
    private _markerBars;
    private _mediaDuration?;
    private _containerSize?;
    set mediaDuration(mediaDuration: number);
    set containerSize(containerSize: number);
    get markerBars(): OmakaseMarkerTrack[];
    get isOmakase(): boolean;
    set isOmakase(isOmakase: boolean);
    addMarkerBar(): OmakaseMarkerTrack;
    deleteMarkerBar(barId: string): void;
    addMarker(trackId: string, marker: MarkerState): void;
    updateMarker(trackId: string, marker: MarkerState): void;
    removeMarker(trackId: string, markerId: string): void;
    updateMarkerTrackState(trackId: string, markerTrackState: MarkerTrackState): void;
    clearMarkerTracks(): void;
    protected findAffectedMarkerTracks(trackId: string): OmakaseMarkerTrack[];
}

export declare class OmakaseMarkerTrack extends HTMLElement implements ChromingMarkerBarElementApi {
    protected readonly _onEvent$: Subject<ChromingMarkerBarElementEvent>;
    private _markers;
    private _tracks;
    private _config;
    private _containerSize?;
    private _container?;
    private _draggingPointMarker?;
    private _draggingPeriodMarker?;
    private _draggingPeriodMarkerEnd?;
    private _markerMoved;
    private _markerDragStartTime?;
    private _markerDragDelay;
    private _mouseupListener?;
    private _mousemoveListener?;
    private _resizeObserver;
    private _uiOrUiProxy?;
    private _destroyBreaker;
    get config(): ChromingMarkerBarConfig;
    set config(config: Partial<ChromingMarkerBarConfig>);
    get markerTracks(): MarkerTrackState[] | undefined;
    set markerTracks(markerTracks: MarkerTrackState[]);
    get mediaDuration(): number;
    set mediaDuration(duration: number);
    set containerSize(containerSize: number | undefined);
    get destroy$(): Observable<void>;
    get onEvent$(): Observable<ChromingMarkerBarElementEvent>;
    get isOmakase(): boolean;
    set isOmakase(isOmakase: boolean);
    protected get _ui(): Ui | UiProxy;
    setUiOrUiProxy(ui: UiProxy | Ui): void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    hide(): void;
    show(): void;
    addTrack(track: MarkerTrackState): void;
    removeTrack(track: MarkerTrackState): void;
    updateTrack(trackState: MarkerTrackState): void;
    hasTrack(trackId: string): boolean;
    addMarker(marker: MarkerState, trackId: MarkerTrackState['id']): void;
    updateMarker(markerState: MarkerState): void;
    private loadMarkers;
    private updateMarkers;
    private addMomentMarker;
    private addPeriodMarker;
    private focusMarker;
    private unfocusMarkers;
    private clearDraggingMarker;
    private moveDraggingMarker;
    private getDraggingPointMarkerTime;
    private getDraggingPeriodMarkerTime;
    isMarkerTemporalChanged(id: MarkerState['id'], temporal: TimedItemTemporal): boolean;
    private updateMomentMarker;
    private updatePeriodMarker;
    private updateMarkerStyle;
    private updateMarkerActive;
    private updateMarkerEditable;
    private updateMarkerSize;
    removeMarker(id: Marker['id']): void;
    removeAllMarkers(): void;
    private getMarkerElement;
    private toObservable;
    private getMarkerStateOrFail;
}

export declare class OmakaseMuteButton extends MediaChromeButton {
    static getSlotTemplateHTML: typeof getSlotTemplateHTML;
    static getTooltipContentHTML: typeof getTooltipContentHTML;
    private _player;
    protected _destroyBreaker: ObserverBreaker;
    get player(): PlayerInternalApi | undefined;
    set player(player: PlayerInternalApi | undefined);
    /**
     * @type {string | undefined}
     */
    get volumeLevel(): string | undefined;
    set volumeLevel(value: string | undefined);
    setVolumeLevel(isMuted: boolean, volume: number): void;
    handleClick(): void;
    disconnectedCallback(): void;
    private updateAriaLabel;
}

export declare class OmakasePlayButton extends MediaPlayButton {
    private _player;
    get player(): PlayerInternalApi | undefined;
    set player(player: PlayerInternalApi | undefined);
    handleClick(): void;
}

export declare class OmakasePlayer extends BaseOmakasePlayer implements OmakasePlayerApi {
    private _config;
    private readonly _ompProvider;
    private readonly _session;
    private _player;
    private _playerDetached?;
    private _chroming;
    private _chromingDetached?;
    private _omakaseTrack;
    private _remoteNode;
    private _playerDetachedWindow;
    private _timelines;
    private _detachingBreaker;
    private _detachedBreaker;
    private _attachingBreaker;
    constructor(config?: Partial<OmakasePlayerConfig>);
    loadMainMedia(url: string, loadOptions?: MainMediaLoadOptions): Observable<MainMedia>;
    detachPlayer(): Observable<void>;
    protected tryDisconnectDetached(): void;
    protected openPlayerDetachedWindow(mainMedia: MainMedia): void;
    protected tryClosePlayerDetachedWindow(): Observable<void>;
    attachPlayer(): Observable<void>;
    protected restoreSession(sessionState: SessionState, player: PlayerInternalApi, chroming: ChromingInternalApi): Observable<void>;
    protected isAttached(): boolean;
    protected isDetached(): boolean;
    protected isFailure(): boolean;
    setAuthentication(authentication: AuthenticationData): Observable<void>;
    get player(): PlayerApi;
    get chroming(): ChromingApi;
    get session(): SessionApi;
    get track(): OmakaseTrackApi;
    get tools(): OmakaseToolsApi;
    get alerts(): AlertsApi;
    get timeline(): TimelineApi | undefined;
    get ui(): UiApi;
    createTimeline(configAndStyle?: ConfigAndStyle<TimelineConfig, TimelineStyle>): Observable<TimelineApi>;
    getTimeline(id?: TimelineApi['id']): TimelineApi | undefined;
    destroy(): void;
}

/**
 * Primary API for the Omakase Player
 */
export declare interface OmakasePlayerApi extends OmakasePlayerCommonApi {
    /**
     * Track management API for adding, removing, loading, and querying marker and thumbnail tracks.
     */
    track: OmakaseTrackApi;
    /**
     * Session API for observing session state changes and accessing the current session snapshot
     */
    session: SessionApi;
    /**
     * Player control API.
     */
    player: PlayerApi;
    /**
     * Chroming (UI) API.
     */
    chroming: ChromingApi;
    /**
     * Tools API.
     */
    tools: OmakaseToolsApi;
    /**
     * Alerts API.
     */
    alerts: AlertsApi;
    /**
     * Timeline API.
     */
    timeline: TimelineApi | undefined;
    /**
     * UI API.
     */
    ui: UiApi;
    /**
     * Loads the primary media source (HLS, MP4, or audio file).
     *
     * @param url - URL of the media source.
     * @param loadOptions - Optional load configuration (frame rate, DRM data, poster, etc.).
     * @returns Observable that emits the loaded {@link MainMedia} instance.
     */
    loadMainMedia(url: string, loadOptions?: MainMediaLoadOptions | undefined): Observable<MainMedia>;
    /**
     * Detaches the player, transitioning it into a remote playback mode.
     */
    detachPlayer(): Observable<void>;
    /**
     * Re-attaches a previously detached player.
     */
    attachPlayer(): Observable<void>;
    createTimeline(configAndStyle?: ConfigAndStyle<TimelineConfig, TimelineStyle>): Observable<TimelineApi>;
}

/**
 * Shared API surface for both attached and detached player modes.
 */
declare interface OmakasePlayerCommonApi {
    /**
     * Configures authentication for media requests. Supports basic, bearer, and custom header strategies.
     *
     * @param authentication - Authentication configuration (basic, bearer, or custom headers).
     */
    setAuthentication(authentication: AuthenticationData): Observable<void>;
}

export declare type OmakasePlayerConfig = {
    authentication?: AuthenticationData | undefined;
    detachedBroadcastChannelId?: string | undefined;
    detachWindowUrlFn?: (mainMedia: MainMedia) => string;
    detachWindowFeatures?: string | undefined;
} & PrefixKeys<PlayerConfig, 'player'> & PrefixKeys<PlayerChromingConfig, 'chroming'>;

export declare class OmakasePlayerDetached extends BaseOmakasePlayer implements OmakasePlayerDetachedApi {
    protected _config: OmakasePlayerDetachedConfig;
    private readonly _ompProvider;
    private _remoteNode;
    private _sessionStore?;
    protected _playerDetached: PlayerDetached;
    protected _chroming: ChromingDetached;
    protected _destroyBreaker: ObserverBreaker;
    constructor(config?: Partial<OmakasePlayerDetachedConfig>);
    setAuthentication(authentication: AuthenticationData): Observable<void>;
    get player(): PlayerDetachedApi;
    destroy(): void;
}

/**
 * API for the Omakase Player in detached (remote) mode.
 */
export declare interface OmakasePlayerDetachedApi extends OmakasePlayerCommonApi {
    /**
     * Reduced player control API available in detached mode.
     */
    get player(): PlayerDetachedApi;
}

export declare type OmakasePlayerDetachedConfig = OmakasePlayerDetachedConfigApi & PrefixKeys<PlayerDetachedConfig, 'player'> & PrefixKeys<PlayerChromingConfig, 'chroming'>;

export declare interface OmakasePlayerDetachedConfigApi {
    detachedBroadcastChannelId: string;
    authentication?: AuthenticationData;
}

export declare class OmakasePreviewThumbnail extends HTMLElement {
    private _timeRange?;
    private _thumbnailTrack?;
    private _thumbnailFn?;
    protected _destroyBreaker: ObserverBreaker;
    constructor();
    set thumbnailTrack(thumbnailTrack: ThumbnailTrackState | undefined);
    set thumbnailFn(thumbnailFn: (trackId: string, time: number) => Observable<ThumbnailState | undefined>);
    set timeRange(timeRange: OmakaseTimeRange);
    connectedCallback(): void;
    disconnectedCallback(): void;
}

export declare enum OmakaseProgressBarPosition {
    OVER_VIDEO = "OVER_VIDEO",
    UNDER_VIDEO = "UNDER_VIDEO"
}

export declare enum OmakaseThemeActionIcon {
    HELP_MENU = "HELP_MENU",
    FULLSCREEN = "FULLSCREEN",
    AUDIO_TOGGLE = "AUDIO_TOGGLE",
    VOLUME = "VOLUME",
    CONTROL_BAR_TOGGLE = "CONTROL_BAR_TOGGLE"
}

export declare interface OmakaseThemeConfig extends OmakaseThemeConfigUpdateableAttrs {
    /**
     * Specifies the list of enabled floating controls
     */
    floatingControls: OmakaseThemeFloatingControl[];
    /**
     * Specifies the list of floating controls that are shown when the video is playing
     */
    alwaysOnFloatingControls: OmakaseThemeFloatingControl[];
    /**
     * Specifies the list of enabled action icons
     */
    actionIcons: OmakaseThemeActionIcon[];
    /**
     * Sets the available playback rates in menu
     */
    playbackRates: number[];
    /**
     * Id of the custom web component used for Player chroming
     */
    htmlTemplateId?: string;
}

export declare interface OmakaseThemeConfigUpdateableAttrs {
    /**
     * Specifies which time format will be used in the timer control
     */
    timeFormat: ChromingTimeFormat;
    /**
     * Specifies if the time control can be used for seeking. It is activated by double clicking the time.
     */
    timeInteractive: boolean;
    /**
     * Specifies control bar visibility
     */
    controlBarVisibility: OmakaseControlBarVisibility;
    /**
     * Specifies controls visibility
     */
    controlBar: OmakaseThemeControl[];
    /**
     * Specifies control bar position
     */
    progressBarPosition: OmakaseProgressBarPosition;
    /**
     * Specifies if the floating VU meter is displayed
     */
    isFloatingVuMeterVisible: boolean;
    /**
     * Shared configuration for control bar and floating VU meters
     */
    vuMeterConfig: Partial<ChromingVuMeterConfig>;
    /**
     * Override values for the floating VU meter configuration
     */
    floatingVuMeterConfig?: Partial<ChromingVuMeterConfig> | undefined;
    /**
     * Override values for the control bar VU meter configuration
     */
    controlBarVuMeterConfig?: Partial<ChromingVuMeterConfig> | undefined;
}

export declare enum OmakaseThemeControl {
    PLAY = "PLAY",
    FRAME_FORWARD = "FRAME_FORWARD",
    TEN_FRAMES_FORWARD = "TEN_FRAMES_FORWARD",
    FRAME_BACKWARD = "FRAME_BACKWARD",
    TEN_FRAMES_BACKWARD = "TEN_FRAMES_BACKWARD",
    FULLSCREEN = "FULLSCREEN",
    VOLUME = "VOLUME",
    TRACK_SELECTOR = "TRACK_SELECTOR",
    PLAYBACK_RATE = "PLAYBACK_RATE",
    DETACH_TOGGLE = "DETACH_TOGGLE",
    TIME_TOGGLE = "TIME_TOGGLE",
    CLOSE = "CLOSE",
    ROUTER = "ROUTER",
    VU_METER = "VU_METER",
    VU_METER_TOGGLE = "VU_METER_TOGGLE"
}

export declare enum OmakaseThemeFloatingControl {
    PROGRESS_BAR = "PROGRESS_BAR",
    TIME = "TIME",
    PLAYBACK_CONTROLS = "PLAYBACK_CONTROLS",
    ACTION_ICONS = "ACTION_ICONS",
    VU_METER = "VU_METER"
}

export declare class OmakaseTimeDisplay extends HTMLElement {
    static get observedAttributes(): string[];
    private _player;
    private _timeRange?;
    private _mediaDuration;
    protected _destroyBreaker: ObserverBreaker;
    protected _playerBreaker: ObserverBreaker;
    protected _timeRangeBreaker: ObserverBreaker;
    private _editBreaker;
    private _innerSpan;
    private _inlineEdit;
    private _isEditingTime;
    constructor();
    get displayFormat(): OmakaseTimeDisplayFormat;
    set displayFormat(format: OmakaseTimeDisplayFormat);
    get temporalFormat(): MediaTemporalFormat.TIMECODE | MediaTemporalFormat.MEDIA_TIME | MediaTemporalFormat.COUNTDOWN_MEDIA_TIME;
    get isCountdown(): boolean;
    set isCountdown(isCountdown: boolean);
    get isAudio(): boolean;
    set isAudio(isAudio: boolean);
    get includeDuration(): boolean;
    set includeDuration(includeDuration: boolean);
    set player(player: PlayerInternalApi | undefined);
    set timeRange(timeRange: OmakaseTimeRange);
    updateTime(): void;
    enableEditMode(): void;
    disableEditMode(): void;
    private getTimeString;
    private displayTime;
    private setupInlineEditTimecode;
    private formatMediaTime;
    connectedCallback(): void;
    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
    private _setupDOM;
    private _teardownDOM;
    disconnectedCallback(): void;
}

declare type OmakaseTimeDisplayFormat = 'timecode' | 'standard';

export declare class OmakaseTimeEdit extends HTMLElement {
    static get observedAttributes(): string[];
    private _timeString;
    private _container;
    private _input;
    private _minValue;
    private _maxValue;
    private _player?;
    private _submitHandlerFn?;
    private _blurHandlerFn?;
    private _isValid$;
    constructor();
    connectedCallback(): void;
    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
    get player(): PlayerCommonApi | undefined;
    set player(player: PlayerCommonApi);
    get value(): string | undefined;
    set value(timecodeText: string);
    get minValue(): string | undefined;
    set minValue(minValue: string | undefined);
    get maxValue(): string | undefined;
    set maxValue(maxValue: string | undefined);
    get isValid$(): BehaviorSubject<boolean>;
    set submitHandler(submitHandlerFn: (timeString: string) => void);
    set blurHandler(blurHandlerFn: () => void);
    focus(options?: FocusOptions): void;
    private get _format();
    private get _isNumericFormat();
    private get _maxLength();
    private handleKeyUp;
    private handleKeyDown;
    private stepTime;
    private setTime;
    private validate;
    isTimeValid(): boolean;
}

export declare class OmakaseTimeRange extends MediaTimeRange implements ChromingMarkerBarElementApi {
    protected readonly _onEvent$: Subject<ChromingMarkerBarElementEvent>;
    protected readonly _onSeek$: Subject<number>;
    protected readonly _onMouseOver$: Subject<number>;
    protected readonly _onMarkerMouseEnter$: Subject<MarkerMouseEvent>;
    protected readonly _onMarkerMouseLeave$: Subject<MarkerMouseEvent>;
    protected readonly _onMarkerClick$: Subject<MarkerMouseEvent>;
    destroy$: Subject<void>;
    private _player?;
    private _markerDisplayContainer;
    private _markerAreaContainer;
    private _rangeElement;
    private _lastPreviewTime?;
    protected _destroyBreaker: ObserverBreaker;
    private _markers;
    private _tracks;
    private _focusedMarkers;
    private _config;
    private _uiOrUiProxy?;
    constructor();
    get onEvent$(): Observable<ChromingMarkerBarElementEvent>;
    get onMouseOver$(): Observable<number>;
    get onSeek$(): Observable<number>;
    get onMarkerMouseEnter$(): Observable<MarkerMouseEvent>;
    get onMarkerMouseLeave$(): Observable<MarkerMouseEvent>;
    get onMarkerClick(): Observable<MarkerMouseEvent>;
    get config(): ChromingMarkerBarConfig;
    set config(config: Partial<ChromingMarkerBarConfig>);
    get markerTracks(): MarkerTrackState[] | undefined;
    set markerTracks(markerTracks: MarkerTrackState[]);
    get name(): string;
    get rangeWidth(): number;
    get isOmakase(): boolean;
    set isOmakase(isOmakase: boolean);
    get player(): PlayerInternalApi | undefined;
    set player(player: PlayerInternalApi);
    protected get _ui(): UiProxy | Ui;
    setUiOrUiProxy(ui: UiProxy | Ui): void;
    show(): void;
    hide(): void;
    addTrack(track: MarkerTrackState): void;
    removeTrack(track: MarkerTrackState): void;
    updateTrack(track: MarkerTrackState): void;
    hasTrack(trackId: string): boolean;
    addMarker(marker: MarkerState, trackId: MarkerTrackState['id']): void;
    updateMarker(marker: MarkerState): void;
    removeMarker(markerId: Marker['id']): void;
    removeAllMarkers(): void;
    private loadMarkers;
    handleEvent(evt: Event | MouseEvent): void;
    attributeChangedCallback(attrName: string, oldValue: string | null, newValue: string | null): void;
    destroy(): void;
    private getMarkerStart;
    private getMarkerEnd;
    private createMarkerDisplayElement;
    private createMarkerAreaElement;
    private updateFocusedMarkers;
    private unfocusAllMarkers;
    private updateMarkerPosition;
    private updateMarkerStyle;
    private updateClasses;
    private toObservable;
    private getRangeValueFromMouseEvent;
    private getTimeFromRangeValue;
}

export declare interface OmakaseToolsApi {
    /**
     * Probes a media URL to retrieve metadata such as MIME type, codec, and container information.
     *
     * Uses the default tool types ({@link MediaProbeToolType.EXTENSION_PROBE} and
     * {@link MediaProbeToolType.HEAD_REQUEST_PROBE}) when no `toolTypes` are specified.
     *
     * @param url - The URL of the media resource to probe.
     * @param toolTypes - Optional list of probe strategies to use. Defaults to extension and HEAD request probes.
     * @returns An Observable that emits the {@link MediaProbeResult} or `undefined` if probing was unsuccessful.
     */
    probe(url: string, toolTypes?: MediaProbeToolType[]): Observable<MediaProbeResult | undefined>;
}

export declare interface OmakaseTrackApi extends OmakaseTrackCommonApi {
    /** Utility helpers for working with tracks. */
    utils: TrackUtilsApi;
    /**
     * Returns the track with the given ID, or `undefined` if not found.
     *
     * @param id - The unique identifier of the track.
     */
    get(id: Track['id']): Track | undefined;
    /**
     * Registers a pre-constructed track instance.
     *
     * @param track - The track to add.
     * @returns The added track.
     */
    add(track: Track): Track;
    /**
     * Removes the track with the given ID.
     *
     * @param id - The unique identifier of the track to remove.
     * @returns `true` if the track was found and removed, `false` otherwise.
     */
    delete(id: Track['id']): boolean;
    /**
     * Returns all tracks that satisfy the predicate, or all tracks if no predicate is provided.
     *
     * @param predicate - Optional filter function applied to each track.
     */
    find(predicate?: (value: Track, index: number, array: Track[]) => unknown): Track[];
    findFirst(predicate?: (value: Track, index: number, array: Track[]) => unknown): Track | undefined;
    /**
     * Loads a track from a {@link Source} object or a URL string.
     *
     * @param source - A {@link Source} descriptor or a URL string pointing to the track resource.
     * @param loadOptions - Optional type-specific load options (e.g. marker or thumbnail track options).
     * @returns An Observable that emits the loaded {@link Track}.
     */
    load(source: Source, loadOptions?: TrackLoadOptions | undefined): Observable<Track>;
    load(url: string, loadOptions?: TrackLoadOptions | undefined): Observable<Track>;
}

declare class OmakaseTrackApiImpl implements OmakaseTrackApi, Destroyable {
    protected _trackRepository: TrackRepository;
    protected _trackUtils: TrackUtils;
    protected _playerInternal: PlayerInternalApi | undefined;
    protected _destroyBreaker: ObserverBreaker;
    constructor(trackRepository: TrackRepository, trackUtils: TrackUtils);
    /* Excluded from this release type: setPlayerInternal */
    get utils(): TrackUtils;
    get(id: Track['id']): Track | undefined;
    delete(id: Track['id']): boolean;
    find(predicate?: (value: Track, index: number, array: Track[]) => unknown): Track[];
    findFirst(predicate?: (value: Track, index: number, array: Track[]) => unknown): Track | undefined;
    add(track: Track): Track;
    load(source: Source, loadOptions?: TrackLoadOptions | undefined): Observable<Track>;
    load(url: string, loadOptions?: TrackLoadOptions | undefined): Observable<Track>;
    loadMarkerTrack(track: MarkerTrack, loadOptions?: MarkerTrackLoadOptions): Observable<MarkerTrack>;
    loadThumbnailTrack(track: ThumbnailTrack, loadOptions?: ThumbnailTrackLoadOptions): Observable<ThumbnailTrack>;
    loadTextTrack(track: TextTrack_2, loadOptions?: TextTrackLoadOptions): Observable<TextTrack_2>;
    loadObservationTrack(track: ObservationTrack, loadOptions?: ObservationTrackLoadOptions): Observable<ObservationTrack>;
    destroy(): void;
}

declare interface OmakaseTrackApiMessageChannel {
    get(id: TrackState['id']): Observable<TrackState | undefined>;
    delete(id: Track['id']): Observable<boolean>;
    add(track: TrackState): Observable<TrackState>;
    find(): Observable<TrackState[]>;
    load(sourceOrUrl: SourceState | string, loadOptions?: TrackLoadOptions | undefined): Observable<TrackState>;
}

declare class OmakaseTrackApiProxy extends BaseMessageChannelProxy<OmakaseTrackApiMessageChannel> implements OmakaseTrackApiMessageChannel {
    constructor(remoteNode: RemoteNode);
    add(track: TrackState): Observable<TrackState>;
    delete(id: Track['id']): Observable<boolean>;
    find(): Observable<TrackState[]>;
    get(id: TrackState['id']): Observable<TrackState | undefined>;
    load(sourceOrUrl: SourceState | string, loadOptions?: TrackLoadOptions | undefined): Observable<TrackState>;
}

declare interface OmakaseTrackCommonApi {
}

export declare class OmakaseVolumeRange extends MediaChromeRange {
    private _player;
    protected _destroyBreaker: ObserverBreaker;
    get player(): PlayerInternalApi | undefined;
    set player(player: PlayerInternalApi | undefined);
    constructor();
    setVolume(value: number): void;
    connectedCallback(): void;
    disconnectedCallback(): void;
}

declare type OmakaseVttCueData = {
    [V in OmakaseVttVersion as (typeof OMAKASE_VTT_CUE_DATA_KEY_MAPPING)[V]]?: OmakaseVttCueDataTypeMap[V];
};

declare type OmakaseVttCueDataTypeMap = {
    [OmakaseVttVersion.OMAKASE_VTT_VERSION_1_0]: {
        value?: string | undefined;
        measurement?: string | undefined;
        comment?: string | undefined;
    }[];
};

declare enum OmakaseVttVersion {
    OMAKASE_VTT_VERSION_1_0 = "OMAKASE_VTT_VERSION_1_0"
}

declare interface OmpCancelableEvent {
    cancelableEvent: {
        cancelBubble: boolean;
    };
}

export declare class OmpError extends Error {
    constructor(message: string, name?: string);
}

export declare type OmpEvent<T extends string, D extends {}> = {
    type: T;
    data: D;
};

export declare type OmpEventGroup<ET extends string, DM extends Record<ET, {}>> = {
    [K in ET]: OmpEvent<K, DM[K]>;
}[ET];

declare interface OmpMouseEvent extends OmpCancelableEvent {
    mouseEvent: MouseEvent;
}

export declare class OmpProvider implements Destroyable {
    readonly alertsManager: AlertsManager;
    readonly sessionStore: SessionStore;
    readonly trackRepository: TrackRepository;
    readonly mainMediaRepository: MainMediaRepository;
    readonly trackUtils: TrackUtils;
    readonly omakaseTrack: OmakaseTrackApiImpl;
    readonly ui: Ui;
    readonly audioEffectsRegistry: AudioEffectsRegistry;
    readonly mediaDeserializer: MediaDeserializer;
    readonly slateProvider: SlateProvider;
    constructor();
    destroy(): void;
}

declare interface OnMeasurementsChange {
    /* Excluded from this release type: onMeasurementsChange */
}

declare class OpStage {
    protected _status: OpStageStatus;
    protected _error: string | undefined;
    constructor(args?: {
        status: OpStageStatus;
        error: string | undefined;
    });
    static of(status: OpStageStatus, error?: string): OpStage;
    start(): void;
    success(): void;
    failure(error: string | undefined): void;
    get status(): OpStageStatus;
    get error(): string | undefined;
    get state(): OpStageState;
}

declare interface OpStageState extends Serializable {
    status: OpStageStatus;
    error: string | undefined;
}

declare enum OpStageStatus {
    NOT_STARTED = "NOT_STARTED",
    IN_PROGRESS = "IN_PROGRESS",
    SUCCESS = "SUCCESS",
    FAILURE = "FAILURE"
}

export declare type OutputTextFileFormatType = FileFormatType.VTT | FileFormatType.SRT | FileFormatType.TTML;

declare interface ParsedVttCue {
    identifier: string;
    start: number;
    end: number;
    text: string;
    styles: string;
    data?: OmakaseVttCueData | undefined;
}

export declare class PeakProcessorAudioLevelSource extends AudioLevelSource {
    protected _handlerBreaker: ObserverBreaker;
    protected _player?: OmakasePlayerApi | undefined;
    protected _audioType?: PlayerAudioType | undefined;
    protected _trackId?: Track['id'] | undefined;
    constructor(player?: OmakasePlayerApi, audioType?: PlayerAudioType, trackId?: Track['id']);
    setHandler(handler: AudioHandlerApi): void;
    destroy(): void;
    private resetHandler;
    private wireEvents;
}

export declare class Player implements PlayerApi, Destroyable {
    protected readonly _alertsManager: AlertsManager;
    protected readonly _onEvent$: Subject<PlayerEvent>;
    protected _config: PlayerConfig;
    protected _sessionStore: SessionStore;
    protected _mainMediaRepository: MainMediaRepository;
    protected _trackRepository: TrackRepository;
    protected _trackUtils: TrackUtils;
    protected _slateProvider: SlateProvider;
    private _playerLocal;
    private _playerDetached?;
    protected _playerAudio: PlayerAudio;
    protected _playerText: PlayerText;
    protected _playerInternalSwitchBreaker: ObserverBreaker;
    protected _destroyBreaker: ObserverBreaker;
    constructor(ompProvider: OmpProvider, config?: Partial<PlayerConfig>);
    setChromingInternal(chromingInternal: ChromingInternalApi): void;
    wireLocal(): void;
    wireDetached(playerDetached: PlayerDetachedApi): void;
    protected wirePlayerInternal(playerInternal: PlayerInternalApi): void;
    protected isAttached(): boolean;
    protected isAttaching(): boolean;
    protected isDetached(): boolean;
    protected isDetaching(): boolean;
    get playerLocal(): PlayerLocalApi;
    get playerDetached(): PlayerDetachedApi | undefined;
    protected getPlayerInternalOrFail(): PlayerInternalApi;
    clearPlayerSession(): void;
    getCurrentTime(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    getCurrentTime<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    getDuration(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    getDuration<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    get isMainMediaLoaded(): boolean;
    loadMainMedia(url: string, loadOptions?: MainMediaLoadOptions | undefined): Observable<MainMedia>;
    protected _loadMainMedia(mainMedia: MainMedia): Observable<MainMedia>;
    protected checkIsMediaLoaded(): void;
    protected checkIsStableWindowPlayback(): void;
    loadSidecarTrack(source: Source, loadOptions?: TrackLoadOptions | undefined): Observable<Track>;
    loadSidecarTrack(url: string, loadOptions?: TrackLoadOptions | undefined): Observable<Track>;
    loadSlate(slateType: SlateType): Observable<MainMedia>;
    removeSidecarTrack(id: Track['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    restorePlayerSession(playerSession: PlayerSession): Observable<void>;
    pause(): Observable<void>;
    play(): Observable<void>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat], format?: MediaTemporalFormat): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat], format?: MediaTemporalFormat): Observable<boolean>;
    convertTime<S extends MediaTemporalFormat, D extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: D): MediaTemporalFormatValueMap[D];
    setPlaybackRate(playbackRate: number): Observable<void>;
    unloadMainMedia(): Observable<void>;
    getPlaybackEngine(mainMediaType: MainMediaType.HLS): PlayerPlaybackEngineMapping[MainMediaType.HLS];
    getPlaybackEngine(mainMediaType: MainMediaType.MP4): PlayerPlaybackEngineMapping[MainMediaType.MP4];
    getPlaybackEngine(mainMediaType: MainMediaType.AUDIO_FILE): PlayerPlaybackEngineMapping[MainMediaType.AUDIO_FILE];
    toggleFullScreen(): Observable<void>;
    isFullScreen(): boolean;
    extractVideoKeyframe(options?: VideoKeyframeOptions): Observable<VideoKeyframe>;
    get playerSession(): PlayerSession;
    get mainMedia(): MainMedia | undefined;
    get htmlMediaElement(): HTMLMediaElement | undefined;
    get onEvent$(): Observable<PlayerEvent>;
    get audio(): PlayerAudioApi;
    get text(): PlayerTextApi;
    destroy(): void;
}

export declare const PLAYER_CONFIG_DEFAULT: PlayerConfig;

/**
 * Player API.
 */
export declare interface PlayerApi extends PlayerCommonApi {
    /**
     * Audio API.
     */
    audio: PlayerAudioApi;
    /**
     * Text API.
     */
    text: PlayerTextApi;
    /**
     * The currently loaded main media, or `undefined` if nothing is loaded.
     */
    mainMedia: MainMedia | undefined;
    /**
     * The underlying HTML element, or `undefined` if not yet created.
     */
    htmlMediaElement: HTMLMediaElement | undefined;
    /**
     * Loads the primary media source.
     *
     * @param url - URL of the media source.
     * @param loadOptions - Optional load configuration (frame rate, DRM data, poster, etc.).
     * @returns Observable that emits the {@link MainMedia} once its load stage reaches success.
     */
    loadMainMedia(url: string, loadOptions?: MainMediaLoadOptions | undefined): Observable<MainMedia>;
    /**
     * Loads a sidecar track (audio or text) from a {@link Source} object or URL string.
     *
     * @param source - A {@link Source} object or URL string pointing to the sidecar data.
     * @param loadOptions - Optional configuration specifying track type, text, or audio options.
     * @returns Observable that emits the loaded {@link Track}.
     */
    loadSidecarTrack(source: Source, loadOptions?: TrackLoadOptions | undefined): Observable<Track>;
    loadSidecarTrack(url: string, loadOptions?: TrackLoadOptions | undefined): Observable<Track>;
    /**
     * Replaces the current media with a slate (e.g. a black frame placeholder).
     *
     * @param slateType - The type of slate to load.
     * @returns Observable that emits the slate as a {@link MainMedia} instance.
     */
    loadSlate(slateType: SlateType): Observable<MainMedia>;
    /** Removes a single sidecar track by its id. */
    removeSidecarTrack(id: Track['id']): Observable<void>;
    /** Removes all sidecar tracks. */
    removeAllSidecarTracks(): Observable<void>;
    /**
     * Restores a previously persisted player session (playback position, audio/text state, etc.).
     */
    restorePlayerSession(playerSession: PlayerSession): Observable<void>;
    /** @ignore */
    getPlaybackEngine(mainMediaType: MainMediaType.HLS): PlayerPlaybackEngineMapping[MainMediaType.HLS];
    /** @ignore */
    getPlaybackEngine(mainMediaType: MainMediaType.MP4): PlayerPlaybackEngineMapping[MainMediaType.MP4];
    /** @ignore */
    getPlaybackEngine(mainMediaType: MainMediaType.AUDIO_FILE): PlayerPlaybackEngineMapping[MainMediaType.AUDIO_FILE];
    /**
     * Returns the playback engine instance for the given media type, providing
     * access to engine-specific configuration (e.g. HLS.js internals).
     */
    getPlaybackEngine<T extends MainMediaType>(mainMediaType: T): PlayerPlaybackEngineMapping[T];
    /** Whether the player is currently in fullscreen mode. */
    isFullScreen(): boolean;
    /**
     * Extracts video frame from current playhead position
     * @param options
     */
    extractVideoKeyframe(options?: VideoKeyframeOptions): Observable<VideoKeyframe>;
}

export declare class PlayerAudio implements PlayerAudioApi, Destroyable {
    protected readonly _onEvent$: Subject<PlayerAudioEvent>;
    protected _sessionStore: SessionStore;
    protected _trackRepository: TrackRepository;
    protected _audioEffectsRegistry: AudioEffectsRegistry;
    protected _player: PlayerInternalApi;
    protected _playerBreaker: ObserverBreaker;
    protected _destroyBreaker: ObserverBreaker;
    constructor(ompProvider: OmpProvider, player: PlayerInternalApi);
    get audioEffects(): AudioEffectsRegistry;
    wirePlayer(player: PlayerInternalApi): void;
    protected isAttached(): boolean;
    protected isDetached(): boolean;
    get audioContext(): AudioContext;
    get onEvent$(): Observable<PlayerAudioEvent>;
    get state(): PlayerAudioState;
    getHandler(playerAudioType: PlayerAudioType, id?: Audio_2['id']): AudioHandlerApi | undefined;
    getTracks(): Audio_2[];
    switchTrack(trackId: Audio_2['id'], activate?: boolean): Observable<void>;
    private getOutputHandlerOrFail;
    get muted(): boolean;
    get volume(): number;
    mute(): Observable<void>;
    setMuted(muted: boolean): Observable<void>;
    setVolume(volume: number): Observable<void>;
    toggleMuted(): Observable<void>;
    unmute(): Observable<void>;
    destroy(): void;
}

export declare interface PlayerAudioApi extends PlayerAudioCommonApi {
    /**
     * Returns tracks loaded by player
     */
    getTracks(): Audio_2[];
    getTracks(playerAudioType: PlayerAudioType.MAIN): Audio_2[];
    getTracks(playerAudioType: PlayerAudioType.SIDECAR): Audio_2[];
    audioContext: AudioContext;
    /**
     * Audio effects registry — use to register custom audio effect implementations.
     */
    audioEffects: AudioEffectsRegistry;
}

export declare interface PlayerAudioChangeEventData extends Serializable {
    playerAudio: PlayerAudioState;
}

export declare interface PlayerAudioCommonApi {
    /**
     * Observable that emits audio events as they occur.
     */
    onEvent$: Observable<PlayerAudioEvent>;
    /**
     * Current audio state snapshot.
     */
    state: PlayerAudioState;
    /**
     * Switches the active audio track.
     * @param trackId - ID of the track to switch to.
     * @param activate - Whether to immediately activate the track. Defaults to `true`.
     */
    switchTrack(trackId: Audio_2['id'], activate?: boolean): Observable<void>;
    /**
     * Returns the audio handler for the given OUTPUT or MAIN audio type.
     * @param playerAudioType - The audio type (`OUTPUT` or `MAIN`).
     */
    getHandler(playerAudioType: PlayerAudioType.OUTPUT | PlayerAudioType.MAIN): AudioHandlerApi | undefined;
    /**
     * Returns the audio handler for a specific SIDECAR track.
     * @param playerAudioType - Must be `SIDECAR`.
     * @param id - ID of the sidecar audio track.
     */
    getHandler(playerAudioType: PlayerAudioType.SIDECAR, id: Audio_2['id']): AudioHandlerApi | undefined;
    /**
     * Current volume level, in the range `[0, 1]`.
     */
    volume: number;
    /**
     * Whether audio is currently muted.
     */
    muted: boolean;
    /**
     * Mutes audio output.
     */
    mute(): Observable<void>;
    /**
     * Unmutes audio output.
     */
    unmute(): Observable<void>;
    /**
     * Toggles mute and unmute.
     */
    toggleMuted(): Observable<void>;
    /**
     * Mutes or unmutes audio output.
     * @param muted - `true` to mute, `false` to unmute.
     */
    setMuted(muted: boolean): Observable<void>;
    /**
     * Sets the volume level.
     * @param volume - A value in the range `[0, 1]`.
     */
    setVolume(volume: number): Observable<void>;
}

export declare interface PlayerAudioConfig {
    audioMode: PlayerAudioMode;
}

export declare interface PlayerAudioErrorEventData extends PlayerAudioEventData {
    error: string | undefined;
}

export declare type PlayerAudioEvent = {
    [K in PlayerAudioEventType]: {
        type: K;
        data: PlayerAudioEventTypeDataMap[K];
    };
}[keyof PlayerAudioEventTypeDataMap];

export declare interface PlayerAudioEventData extends Serializable {
    playerAudio: PlayerAudioState;
}

export declare enum PlayerAudioEventType {
    /** Audio sub-system is initializing for the current media (start of setup). */
    PLAYER_AUDIO_LOADING = "PLAYER_AUDIO_LOADING",
    /** Audio sub-system is ready; all embedded tracks have been registered. */
    PLAYER_AUDIO_LOADED = "PLAYER_AUDIO_LOADED",
    /** Audio sub-system failed to initialize. */
    PLAYER_AUDIO_LOAD_ERROR = "PLAYER_AUDIO_LOAD_ERROR",
    /** Audio sub-system has been torn down and all tracks removed. */
    PLAYER_AUDIO_UNLOADED = "PLAYER_AUDIO_UNLOADED",
    /** Fired after any change in audio sub-system (catch-all change notification). */
    PLAYER_AUDIO_CHANGE = "PLAYER_AUDIO_CHANGE",
    /** The active audio track has changed. */
    PLAYER_AUDIO_TRACK_SWITCHED = "PLAYER_AUDIO_TRACK_SWITCHED",
    /** An individual sidecar audio track has started loading. */
    PLAYER_AUDIO_TRACK_LOADING = "PLAYER_AUDIO_TRACK_LOADING",
    /** An individual sidecar audio track finished loading successfully. */
    PLAYER_AUDIO_TRACK_LOADED = "PLAYER_AUDIO_TRACK_LOADED",
    /** An individual sidecar audio track failed to load. */
    PLAYER_AUDIO_TRACK_LOAD_ERROR = "PLAYER_AUDIO_TRACK_LOAD_ERROR",
    /** An individual sidecar audio track has been unloaded. */
    PLAYER_AUDIO_TRACK_UNLOADED = "PLAYER_AUDIO_TRACK_UNLOADED",
    /** The set of tracks requesting media buffering has changed (a track started or stopped requesting buffering). */
    PLAYER_AUDIO_TRACKS_REQUESTING_BUFFERING_CHANGE = "PLAYER_AUDIO_TRACKS_REQUESTING_BUFFERING_CHANGE"
}

export declare type PlayerAudioEventTypeDataMap = {
    [PlayerAudioEventType.PLAYER_AUDIO_CHANGE]: PlayerAudioEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_LOADING]: PlayerAudioEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_LOADED]: PlayerAudioEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_LOAD_ERROR]: PlayerAudioErrorEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_UNLOADED]: PlayerAudioEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_TRACK_SWITCHED]: PlayerAudioTrackSwitchedEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_TRACK_LOADING]: PlayerAudioTrackEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_TRACK_LOADED]: PlayerAudioTrackEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_TRACK_LOAD_ERROR]: PlayerAudioTrackErrorEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_TRACK_UNLOADED]: PlayerAudioTrackEventData;
    [PlayerAudioEventType.PLAYER_AUDIO_TRACKS_REQUESTING_BUFFERING_CHANGE]: {
        playerAudioTracks: PlayerAudioTrackState[];
    };
};

declare interface PlayerAudioHandlerApi extends AudioHandlerApi, Destroyable {
    id: string;
    state: PlayerAudioHandlerState;
    setChannelCount(channelCount: number): Observable<void>;
    restoreState(state: PlayerAudioHandlerState): Observable<void>;
}

declare interface PlayerAudioHandlerState extends AudioHandlerState {
    id: string;
}

export declare class PlayerAudioInternal implements PlayerAudioInternalApi, Destroyable {
    private readonly _onEvent$;
    private readonly _onEventQueue$;
    private _config;
    private _playerController;
    private _audioMode;
    private _playerTracks;
    private _handlers;
    private _playerTracksRequestingBuffering;
    private _eventBreaker;
    private _destroyBreaker;
    constructor(config: PlayerAudioConfig);
    teardown(): void;
    protected checkIsSetup(): void;
    setup(playerController: PlayerController, mainMediaState: MainMediaState): void;
    protected emitPlayerAudioChange(): void;
    switchTrack(trackId: Audio_2['id'], activate?: boolean): Observable<void>;
    protected switchTrackPrepare(track: PlayerAudioTrack, activate: boolean): Observable<boolean>;
    private _getPlayerTracks;
    updateTrack(trackState: AudioState): void;
    getTracks(): AudioState[];
    getTracks(playerAudioType: PlayerAudioType.MAIN): AudioState[];
    getTracks(playerAudioType: PlayerAudioType.SIDECAR): AudioState[];
    getHandler(playerAudioType: PlayerAudioType.OUTPUT | PlayerAudioType.MAIN): AudioHandlerApi | undefined;
    getHandler(playerAudioType: PlayerAudioType.SIDECAR, id: Audio_2['id']): AudioHandlerApi | undefined;
    loadSidecarTrack(trackState: AudioState, trackUpdater: (attrs: AudioUpdateableAttrs) => Observable<AudioState>, loadOptions?: PlayerAudioLoadOptions | undefined): Observable<AudioState>;
    removeSidecarTrack(id: TrackState['id']): Observable<void>;
    protected _removeSidecarTrack(id: TrackState['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    _removeAllSidecarTracks(): Observable<void>;
    get state(): PlayerAudioState;
    restoreState(state: PlayerAudioState): Observable<void>;
    get onEvent$(): Observable<PlayerAudioEvent>;
    private getOutputHandlerOrFail;
    get muted(): boolean;
    get volume(): number;
    mute(): Observable<void>;
    setMuted(muted: boolean): Observable<void>;
    setVolume(volume: number): Observable<void>;
    toggleMuted(): Observable<void>;
    unmute(): Observable<void>;
    destroy(): void;
}

export declare interface PlayerAudioInternalApi extends PlayerAudioCommonApi {
    loadSidecarTrack(audioState: AudioState, trackUpdater: (attrs: AudioUpdateableAttrs) => Observable<AudioState>, loadOptions?: PlayerAudioLoadOptions | undefined): Observable<AudioState>;
    removeSidecarTrack(id: TrackState['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    updateTrack(trackState: AudioState): void;
    getTracks(): AudioState[];
    getTracks(playerAudioType: PlayerAudioType.MAIN): AudioState[];
    getTracks(playerAudioType: PlayerAudioType.SIDECAR): AudioState[];
}

declare interface PlayerAudioInternalMessageChannel {
    onEvent$: Observable<PlayerAudioEvent>;
    switchTrack(trackId: Audio_2['id'], activate?: boolean): Observable<void>;
    loadSidecarTrack(audioState: AudioState): Observable<AudioState>;
    removeSidecarTrack(trackId: Audio_2['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    mute(): Observable<void>;
    unmute(): Observable<void>;
    toggleMuted(): Observable<void>;
    setMuted(muted: boolean): Observable<void>;
    setVolume(volume: number): Observable<void>;
    state(): Observable<PlayerAudioState>;
}

declare class PlayerAudioInternalProxy extends BaseMessageChannelProxy<PlayerAudioInternalMessageChannel> implements PlayerAudioInternalApi, Destroyable {
    private readonly _trackRepository;
    private readonly _session;
    protected _remoteNode: RemoteNode;
    private _tracks;
    private _state?;
    private readonly _onEventQueue$;
    private _handlers;
    private _destroyBreaker;
    constructor(remoteNode: RemoteNode, ompProvider: OmpProvider);
    private syncStateOperator;
    protected initialize(): void;
    protected updateFromState(playerAudioState: PlayerAudioState): void;
    private updateAudioHandlerProxies;
    protected resolveHandlerState(playerAudioType: PlayerAudioType, trackId?: Audio_2['id']): AudioHandlerState | undefined;
    get onEvent$(): Observable<PlayerAudioEvent>;
    private checkLateInitialization;
    get state(): PlayerAudioState;
    switchTrack(trackId: Audio_2['id'], activate?: boolean): Observable<void>;
    loadSidecarTrack(audioState: AudioState): Observable<AudioState>;
    removeSidecarTrack(id: TrackState['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    getHandler(playerAudioType: PlayerAudioType.OUTPUT | PlayerAudioType.MAIN): AudioHandlerApi | undefined;
    getHandler(playerAudioType: PlayerAudioType.SIDECAR, id: Audio_2['id']): AudioHandlerApi | undefined;
    updateTrack(trackState: AudioState): void;
    private _getTracks;
    getTracks(): AudioState[];
    getTracks(playerAudioType: PlayerAudioType.MAIN): AudioState[];
    getTracks(playerAudioType: PlayerAudioType.SIDECAR): AudioState[];
    private getOutputHandlerOrFail;
    get muted(): boolean;
    get volume(): number;
    mute(): Observable<void>;
    setMuted(muted: boolean): Observable<void>;
    setVolume(volume: number): Observable<void>;
    toggleMuted(): Observable<void>;
    unmute(): Observable<void>;
    destroy(): void;
}

/** Load options for audio tracks. */
export declare interface PlayerAudioLoadOptions extends PlayerTrackLoadOptions {
}

/**
 * Defines the audio playback mode for the player.
 *
 * - `SINGLE`: Only one audio track can be active at a time.
 * - `MULTIPLE`: Multiple audio tracks can play simultaneously.
 */
export declare enum PlayerAudioMode {
    SINGLE = "SINGLE",
    MULTIPLE = "MULTIPLE"
}

export declare interface PlayerAudioState {
    audioMode: PlayerAudioMode;
    tracks: {
        [PlayerAudioType.MAIN]: PlayerAudioTrackState[];
        [PlayerAudioType.SIDECAR]: PlayerAudioTrackState[];
    };
    handlers: {
        [PlayerAudioType.OUTPUT]: PlayerAudioHandlerState | undefined;
        [PlayerAudioType.MAIN]: PlayerAudioHandlerState | undefined;
        [PlayerAudioType.SIDECAR]: PlayerAudioHandlerState[];
    };
}

export declare interface PlayerAudioTrack extends PlayerTrack<AudioState, PlayerAudioTrackState>, Destroyable {
    playerAudioHandler: PlayerAudioHandlerApi;
    active: boolean;
    setActive(active: boolean): Observable<void>;
}

export declare interface PlayerAudioTrackErrorEventData extends PlayerAudioTrackEventData {
    error: string | undefined;
}

export declare interface PlayerAudioTrackEventData extends Serializable {
    playerAudioTrack: PlayerAudioTrackState;
}

export declare interface PlayerAudioTrackState extends PlayerTrackState {
    handlerId: PlayerAudioHandlerState['id'];
    active: boolean;
}

export declare interface PlayerAudioTrackSwitchedEventData extends Serializable {
    playerAudio: PlayerAudioState;
    playerAudioTrack: PlayerAudioTrackState;
}

export declare enum PlayerAudioType {
    OUTPUT = "OUTPUT",
    MAIN = "MAIN",
    SIDECAR = "SIDECAR"
}

export declare interface PlayerBufferingEventData extends PlayerControllerBufferingEventData {
}

export declare interface PlayerChromingChangeEventData extends Serializable {
    chroming: ChromingState;
}

export declare interface PlayerChromingCommonConfig {
    /**
     * Watermark text or svg
     */
    watermark?: string | undefined;
    /**
     * Specifies if watermark is shown when the video is playing
     */
    watermarkVisibility?: WatermarkVisibility | undefined;
    /**
     * Specifies if chroming is enabled in fullscreen
     */
    fullscreenChroming?: FullscreenChroming | undefined;
    /**
     * CSS file url(s) for player chroming styling
     */
    styleUrl?: string | string[] | undefined;
}

export declare type PlayerChromingConfig = {
    [K in ChromingTheme]: PlayerChromingThemeConfig<K>;
}[keyof ChromingThemeConfigMap] & PlayerChromingCommonConfig;

export declare interface PlayerChromingThemeConfig<T extends ChromingTheme> {
    /**
     * Chroming theme determines how the player will be chromed.
     */
    readonly theme: T;
    /**
     * Chroming theme configuration
     */
    themeConfig?: Partial<ChromingThemeConfigMap[T]> | undefined;
}

/**
 * Shared API surface inherited by all player variants ({@link PlayerApi},
 * {@link PlayerInternalApi}, {@link PlayerLocalApi}, {@link PlayerDetachedApi}).
 *
 * Provides playback control, seeking (supporting multiple temporal formats),
 * time conversion, playback rate, and fullscreen toggling.
 */
export declare interface PlayerCommonApi {
    /**
     * Observable stream of player lifecycle and playback events.
     */
    onEvent$: Observable<PlayerEvent>;
    /**
     * Current player session state (playback position, audio/text selection, etc.).
     */
    playerSession: PlayerSession;
    /**
     * Whether a main media source is currently loaded and ready.
     */
    isMainMediaLoaded: boolean;
    /**
     * Unloads the current main media and releases associated resources.
     */
    unloadMainMedia(): Observable<void>;
    /**
     * Starts or resumes playback.
     */
    play(): Observable<void>;
    /**
     * Pauses playback.
     */
    pause(): Observable<void>;
    /** @ignore */
    getCurrentTime(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    /**
     * Returns the current playback time. Defaults to seconds; pass a {@link MediaTemporalFormat}
     * to get the value in another format (frame count, percent, timecode, media time, countdown).
     */
    getCurrentTime<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    /** @ignore */
    getDuration(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    /**
     * Returns the media duration. Defaults to seconds; pass a {@link MediaTemporalFormat}
     * to get the value in another format.
     */
    getDuration<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    /** @ignore */
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS]): Observable<boolean>;
    /** @ignore */
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS], format: MediaTemporalFormat.SECONDS): Observable<boolean>;
    /** @ignore */
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.FRAME_COUNT], format: MediaTemporalFormat.FRAME_COUNT): Observable<boolean>;
    /** @ignore */
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.PERCENT], format: MediaTemporalFormat.PERCENT): Observable<boolean>;
    /** @ignore */
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.TIMECODE], format: MediaTemporalFormat.TIMECODE): Observable<boolean>;
    /** @ignore */
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.MEDIA_TIME], format: MediaTemporalFormat.MEDIA_TIME): Observable<boolean>;
    /** @ignore */
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.COUNTDOWN_MEDIA_TIME], format: MediaTemporalFormat.COUNTDOWN_MEDIA_TIME): Observable<boolean>;
    /**
     * Seeks to an absolute position. The value is interpreted according to the given
     * {@link MediaTemporalFormat} (defaults to seconds).
     *
     * @returns Observable that emits `true` if the seek succeeded.
     */
    seekTo<F extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[F], format: F): Observable<boolean>;
    /** @ignore */
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS]): Observable<boolean>;
    /** @ignore */
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS], format: MediaTemporalFormat.SECONDS): Observable<boolean>;
    /** @ignore */
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.FRAME_COUNT], format: MediaTemporalFormat.FRAME_COUNT): Observable<boolean>;
    /** @ignore */
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.PERCENT], format: MediaTemporalFormat.PERCENT): Observable<boolean>;
    /** @ignore */
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.TIMECODE], format: MediaTemporalFormat.TIMECODE): Observable<boolean>;
    /** @ignore */
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.MEDIA_TIME], format: MediaTemporalFormat.MEDIA_TIME): Observable<boolean>;
    /** @ignore */
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.COUNTDOWN_MEDIA_TIME], format: MediaTemporalFormat.COUNTDOWN_MEDIA_TIME): Observable<boolean>;
    /**
     * Seeks by a relative offset from the current playback position. The value is
     * interpreted according to the given {@link MediaTemporalFormat} (defaults to seconds).
     *
     * @returns Observable that emits `true` if the seek succeeded.
     */
    seekFromCurrentTime<F extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[F], format: F): Observable<boolean>;
    /** @ignore */
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.SECONDS): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    /** @ignore */
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.FRAME_COUNT): MediaTemporalFormatValueMap[MediaTemporalFormat.FRAME_COUNT];
    /** @ignore */
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.PERCENT): MediaTemporalFormatValueMap[MediaTemporalFormat.PERCENT];
    /** @ignore */
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.TIMECODE): MediaTemporalFormatValueMap[MediaTemporalFormat.TIMECODE];
    /** @ignore */
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.MEDIA_TIME): MediaTemporalFormatValueMap[MediaTemporalFormat.MEDIA_TIME];
    /** @ignore */
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.COUNTDOWN_MEDIA_TIME): MediaTemporalFormatValueMap[MediaTemporalFormat.COUNTDOWN_MEDIA_TIME];
    /**
     * Converts a time value from one {@link MediaTemporalFormat} to another
     * (e.g. seconds → timecode, frame count → percent).
     *
     * @param value - The time value to convert.
     * @param valueFormat - The format of the input value.
     * @param destinationFormat - The desired output format.
     */
    convertTime<S extends MediaTemporalFormat, D extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: D): MediaTemporalFormatValueMap[D];
    /**
     * Sets the playback rate.
     * @param playbackRate - Decimal value in the range [0.1, 16]. For example, `2` plays at 2x speed.
     */
    setPlaybackRate(playbackRate: number): Observable<void>;
    /**
     * Toggles between fullscreen and windowed display.
     */
    toggleFullScreen(): Observable<void>;
}

/**
 * Shared configuration options for all player variants.
 */
declare interface PlayerCommonConfig {
    /** DOM element id of the container that hosts the `<video>` element. */
    htmlElementId: string;
    /** Audio track handling mode (single vs. multiple simultaneous tracks). */
    audioMode: PlayerAudioMode;
    /** Text track handling mode (single vs. multiple simultaneous tracks). */
    textMode: PlayerTextMode;
    /**
     * List of handlers used to render {@link PlayerTextType.MAIN} text tracks in the player:
     * - {@link PlayerTextHandlerType.EMBEDDED}: text tracks rendered natively through hls.js text handler
     * - {@link PlayerTextHandlerType.NATIVE}: text tracks rendered natively via the browser's native track element
     * - {@link PlayerTextHandlerType.MEDIA_CAPTIONS}: text tracks rendered natively with the media-captions handler
     *
     * An empty array disables in-player rendering of {@link PlayerTextType.MAIN} text tracks.
     */
    textMainTracksHandler: Exclude<PlayerTextHandlerType, PlayerTextHandlerType.IMSC>[];
    /**
     * Optional per-media-type player controller configuration.
     * Each key corresponds to a {@link MainMediaType} and its value is a partial config
     * for the matching controller (e.g. HLS, MP4, AudioFile).
     */
    controllerConfig?: {
        [T in MainMediaType]?: Partial<PlayerControllerConfigMap[T]>;
    } | undefined;
}

/**
 * Configuration for the player.
 */
export declare interface PlayerConfig extends PlayerCommonConfig {
}

export declare interface PlayerController extends Destroyable {
    onEvent$: Observable<PlayerControllerEvent>;
    mediaElementPlayback: MediaElementPlayback | undefined;
    mediaTemporalConverter: MediaTemporalConverter | undefined;
    videoElement: HTMLVideoElement;
    textMediaCaptionsElement: HTMLElement;
    textImscElement: HTMLElement;
    loadMainMedia(args: LoadMainMediaArgsType): Observable<boolean>;
    /**
     * Sets up media time converters and wires {@link onEvent$} events
     * @param mainMediaState
     */
    wireEvents(mainMediaState: MainMediaState): void;
    unwireEvents(): void;
    restoreMainMediaSession(args: RestoreMainMediaSessionArgsType): Observable<void>;
    play(): Observable<void>;
    pause(): Observable<void>;
    getCurrentTime(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    getCurrentTime<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    getDuration(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    getDuration<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS]): Observable<boolean>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS], format: MediaTemporalFormat.SECONDS): Observable<boolean>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.FRAME_COUNT], format: MediaTemporalFormat.FRAME_COUNT): Observable<boolean>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.PERCENT], format: MediaTemporalFormat.PERCENT): Observable<boolean>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.TIMECODE], format: MediaTemporalFormat.TIMECODE): Observable<boolean>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.MEDIA_TIME], format: MediaTemporalFormat.MEDIA_TIME): Observable<boolean>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat.COUNTDOWN_MEDIA_TIME], format: MediaTemporalFormat.COUNTDOWN_MEDIA_TIME): Observable<boolean>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat], format: MediaTemporalFormat): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS]): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS], format: MediaTemporalFormat.SECONDS): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.FRAME_COUNT], format: MediaTemporalFormat.FRAME_COUNT): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.PERCENT], format: MediaTemporalFormat.PERCENT): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.TIMECODE], format: MediaTemporalFormat.TIMECODE): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.MEDIA_TIME], format: MediaTemporalFormat.MEDIA_TIME): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat.COUNTDOWN_MEDIA_TIME], format: MediaTemporalFormat.COUNTDOWN_MEDIA_TIME): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat], format: MediaTemporalFormat): Observable<boolean>;
    extractVideoKeyframe(options?: VideoKeyframeOptions): Observable<VideoKeyframe>;
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.SECONDS): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.FRAME_COUNT): MediaTemporalFormatValueMap[MediaTemporalFormat.FRAME_COUNT];
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.PERCENT): MediaTemporalFormatValueMap[MediaTemporalFormat.PERCENT];
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.TIMECODE): MediaTemporalFormatValueMap[MediaTemporalFormat.TIMECODE];
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.MEDIA_TIME): MediaTemporalFormatValueMap[MediaTemporalFormat.MEDIA_TIME];
    convertTime<S extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: MediaTemporalFormat.COUNTDOWN_MEDIA_TIME): MediaTemporalFormatValueMap[MediaTemporalFormat.COUNTDOWN_MEDIA_TIME];
    convertTime<S extends MediaTemporalFormat, D extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: D): MediaTemporalFormatValueMap[D];
    playbackRate: number;
    setPlaybackRate(playbackRate: number): Observable<void>;
    createMediaElementSourceEnabled: boolean;
    resolveAudioTrackIdentifier(track: AudioState): AudioTrackIdentifier;
    resolveActiveAudioTracks(tracks: AudioState[]): AudioState[];
    isAudioTrackActive(track: AudioState): boolean;
    switchAudioTrack(track: AudioState, activate: boolean): Observable<void>;
    setWaitingForSyncedMedia(syncedMediaWaiting: boolean): void;
    textTracksDisplayed: boolean;
    setTextTracksDisplayed(textTracksDisplayed: boolean): void;
    resolveTextTrackIdentifier(track: TextTrackState): TextTrackIdentifier;
    resolveActiveTextTracks(track: TextTrackState[]): TextTrackState[];
    isTextTrackActive(track: TextTrackState): boolean;
    switchTextTrack(track: TextTrackState, activate: boolean): Observable<void>;
}

export declare interface PlayerControllerAudioSwitchedEventData {
    activeAudioIdentifiers: AudioTrackIdentifier[];
}

export declare interface PlayerControllerBufferingEventData {
    bufferedTimeRanges: BufferedTimeRange[];
}

declare interface PlayerControllerConfig {
}

/**
 * Maps each {@link MainMediaType} to its corresponding player controller config type.
 */
export declare type PlayerControllerConfigMap = {
    [MainMediaType.HLS]: HlsPlayerControllerConfig;
    [MainMediaType.MP4]: Mp4PlayerControllerConfig;
    [MainMediaType.AUDIO_FILE]: AudioFilePlayerControllerConfig;
};

export declare interface PlayerControllerDurationUpdateEventData {
    /**
     * Duration
     */
    duration: number;
}

export declare type PlayerControllerEvent = {
    [K in PlayerControllerEventType]: {
        type: K;
        data: PlayerControllerEventTypeDataMap[K];
    };
}[keyof PlayerControllerEventTypeDataMap];

export declare enum PlayerControllerEventType {
    PLAYER_CONTROLLER_MEDIA_ELEMENT_PLAYBACK_CHANGE = "PLAYER_CONTROLLER_MEDIA_ELEMENT_PLAYBACK_CHANGE",
    PLAYER_CONTROLLER_PLAYBACK_PROGRESS = "PLAYER_CONTROLLER_PLAYBACK_PROGRESS",
    PLAYER_CONTROLLER_PLAY = "PLAYER_CONTROLLER_PLAY",
    PLAYER_CONTROLLER_PAUSE = "PLAYER_CONTROLLER_PAUSE",
    PLAYER_CONTROLLER_ENDED = "PLAYER_CONTROLLER_ENDED",
    PLAYER_CONTROLLER_BUFFERING = "PLAYER_CONTROLLER_BUFFERING",
    PLAYER_CONTROLLER_SEEKING = "PLAYER_CONTROLLER_SEEKING",
    PLAYER_CONTROLLER_SEEKED = "PLAYER_CONTROLLER_SEEKED",
    PLAYER_CONTROLLER_PLAYBACK_RATE_UPDATE = "PLAYER_CONTROLLER_PLAYBACK_RATE_UPDATE",
    PLAYER_CONTROLLER_DURATION_UPDATE = "PLAYER_CONTROLLER_DURATION_UPDATE",
    PLAYER_CONTROLLER_AUDIO_SWITCHED = "PLAYER_CONTROLLER_AUDIO_SWITCHED",
    PLAYER_CONTROLLER_TEXT_TRACK_SWITCHED = "PLAYER_CONTROLLER_TEXT_TRACK_SWITCHED"
}

export declare type PlayerControllerEventTypeDataMap = {
    [PlayerControllerEventType.PLAYER_CONTROLLER_PLAYBACK_RATE_UPDATE]: PlayerControllerPlaybackRateUpdateEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_DURATION_UPDATE]: PlayerControllerDurationUpdateEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_MEDIA_ELEMENT_PLAYBACK_CHANGE]: PlayerControllerMediaElementPlaybackChangeEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_PLAYBACK_PROGRESS]: PlayerControllerPlaybackProgressEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_PLAY]: PlayerControllerPlaybackProgressEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_PAUSE]: PlayerControllerPlaybackProgressEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_ENDED]: PlayerControllerPlaybackProgressEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_BUFFERING]: PlayerControllerBufferingEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_SEEKING]: PlayerControllerSeekingEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_SEEKED]: PlayerControllerSeekedEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_AUDIO_SWITCHED]: PlayerControllerAudioSwitchedEventData;
    [PlayerControllerEventType.PLAYER_CONTROLLER_TEXT_TRACK_SWITCHED]: PlayerControllerTextTrackSwitchedEventData;
};

export declare interface PlayerControllerMediaElementPlaybackChangeEventData {
    mediaElementPlaybackState: MediaElementPlaybackState;
    currentTime: MediaTemporalSeconds['value'];
}

export declare interface PlayerControllerPlaybackProgressEventData {
    currentTime: MediaTemporalSeconds['value'];
}

export declare interface PlayerControllerPlaybackRateUpdateEventData {
    /**
     * Playback rate
     */
    playbackRate: number;
}

export declare interface PlayerControllerSeekedEventData {
    /**
     * Current time
     */
    currentTime: MediaTemporalSeconds['value'];
    /**
     * Previous time
     */
    previousTime: MediaTemporalSeconds['value'];
}

export declare interface PlayerControllerSeekingEventData {
    /**
     * Seek from
     */
    fromTime: MediaTemporalSeconds['value'];
    /**
     * Seek to
     */
    toTime: MediaTemporalSeconds['value'];
}

export declare interface PlayerControllerTextTrackSwitchedEventData {
    activeTextTrackIdentifiers: TextTrackIdentifier[];
    textTracksDisplayed: boolean;
}

declare class PlayerDetached implements PlayerDetachedApi, Destroyable {
    private readonly _onEvent$;
    private _remoteNode?;
    private _sessionStore?;
    private _mainMediaRepository?;
    private _trackRepository?;
    private _trackUtils?;
    private _alertsManager?;
    private _config;
    private _mainMediaState;
    private _playerPlayback;
    private _playerAudioInternal;
    private _playerTextInternal;
    private _playerController;
    private _chromingInternal;
    private _loadMainMediaBreaker;
    private _wiredEventsBreaker;
    private _destroyBreaker;
    constructor(config?: Partial<PlayerDetachedConfig>);
    setChromingInternal(chromingInternal: ChromingInternalApi): void;
    setRemoteProxies(remoteNode: RemoteNode): void;
    get onEvent$(): Observable<PlayerEvent>;
    restorePlayerSession(playerSession: PlayerSession): Observable<void>;
    loadMainMedia(mainMediaId: MainMedia['id']): Observable<MainMediaState>;
    /**
     * Preloads all text tracks from the main media state as sidecar tracks.
     */
    protected loadMainTextTracksAsSidecars(mainMediaState: MainMediaState): void;
    protected wireEvents(): Observable<void>;
    protected wirePlayerEvents(): Observable<void>;
    protected wirePlayerAudioEvents(): Observable<void>;
    protected wirePlayerTextEvents(): Observable<void>;
    protected wireChromingEvents(): Observable<void>;
    clearPlayerSession(): void;
    unloadMainMedia(): Observable<void>;
    protected checkIsMediaLoaded(): void;
    get isMainMediaLoaded(): boolean;
    play(): Observable<void>;
    pause(): Observable<void>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat], format?: MediaTemporalFormat): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat], format?: MediaTemporalFormat): Observable<boolean>;
    convertTime<S extends MediaTemporalFormat, D extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: D): MediaTemporalFormatValueMap[D];
    setPlaybackRate(playbackRate: number): Observable<void>;
    getCurrentTime(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    getCurrentTime<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    getDuration(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    getDuration<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    loadSidecarTrack(trackId: Track['id'], loadOptions?: TrackLoadOptions | undefined): Observable<void>;
    protected loadSidecarAudio(trackState: AudioState, loadOptions?: PlayerAudioLoadOptions | undefined): Observable<void>;
    protected restoreLoadSidecarAudios(trackStates: AudioState[]): Observable<void>;
    protected restoreLoadSidecarTextTracks(trackStates: TextTrackState[], playerTextState: PlayerTextState | undefined): Observable<void>;
    protected loadSidecarTextTrack(trackState: TextTrackState, loadOptions?: PlayerTextTrackLoadOptions | undefined): Observable<void>;
    removeSidecarTrack(trackId: Track['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    toggleFullScreen(): Observable<void>;
    extractVideoKeyframe(options?: VideoKeyframeOptions): Observable<VideoKeyframe>;
    destroy(): void;
    get audioInternal(): PlayerAudioInternalApi;
    get textInternal(): PlayerTextInternalApi;
    get playerSession(): PlayerSession;
}

export declare interface PlayerDetachedApi extends PlayerInternalApi, Destroyable {
    loadMainMedia(mainMediaId: MainMedia['id']): Observable<MainMediaState>;
}

export declare interface PlayerDetachedConfig extends PlayerInternalConfig {
}

declare interface PlayerDetachedMessageChannel extends PlayerDetachedApi {
}

declare class PlayerDetachedProxy extends BaseMessageChannelProxy<PlayerDetachedMessageChannel> implements PlayerDetachedApi, Destroyable {
    private readonly _playerAudioInternal;
    private readonly _playerTextInternal;
    protected _mainMedia: MainMedia | undefined;
    protected _mediaTemporalConverter: MediaTemporalConverter | undefined;
    protected _sessionStore: SessionStore;
    protected _mainMediaRepository: MainMediaRepository;
    protected _remoteNode: RemoteNode;
    protected _utilsBreaker: ObserverBreaker;
    protected _destroyBreaker: ObserverBreaker;
    constructor(remoteNode: RemoteNode, ompProvider: OmpProvider);
    get onEvent$(): Observable<PlayerEvent>;
    unloadMainMedia(): Observable<void>;
    loadMainMedia(mainMediaId: MainMedia['id']): Observable<MainMediaState>;
    loadSidecarTrack(trackId: Track_2['id']): Observable<void>;
    removeSidecarTrack(trackId: Track_2['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    restorePlayerSession(playerSession: PlayerSession): Observable<void>;
    private initMainMedia;
    private initUtils;
    play(): Observable<void>;
    pause(): Observable<void>;
    seekTo(value: MediaTemporalFormatValueMap[MediaTemporalFormat], format?: MediaTemporalFormat): Observable<boolean>;
    seekFromCurrentTime(value: MediaTemporalFormatValueMap[MediaTemporalFormat], format?: MediaTemporalFormat): Observable<boolean>;
    setPlaybackRate(playbackRate: number): Observable<void>;
    toggleFullScreen(): Observable<void>;
    getCurrentTime(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    getCurrentTime<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    getDuration(): MediaTemporalFormatValueMap[MediaTemporalFormat.SECONDS];
    getDuration<F extends MediaTemporalFormat>(format: F): MediaTemporalFormatValueMap[F];
    convertTime<S extends MediaTemporalFormat, D extends MediaTemporalFormat>(value: MediaTemporalFormatValueMap[S], valueFormat: S, destinationFormat: D): MediaTemporalFormatValueMap[D];
    extractVideoKeyframe(options?: VideoKeyframeOptions): Observable<VideoKeyframe>;
    protected checkIsMediaLoaded(): void;
    get isMainMediaLoaded(): boolean;
    get playerSession(): PlayerSession;
    get audioInternal(): PlayerAudioInternalApi;
    get textInternal(): PlayerTextInternalApi;
    destroy(): void;
}

export declare interface PlayerDomController {
    mainMediaVideoElement: HTMLVideoElement;
    textMediaCaptionsElement: HTMLElement;
    textImscElement: HTMLElement;
    resetMainMediaVideoElement(): void;
    prepareForAttaching(hasMainMedia: boolean): void;
    prepareForDetaching(): void;
    setAttachDetachButtonEnabled(enabled: true): void;
    setVideoPoster(poster: string): void;
    addAlert(alert: Alert): void;
    removeAlert(alertId: Alert['id']): void;
    extractVideoKeyframe(options?: VideoKeyframeOptions): Observable<VideoKeyframe>;
}

export declare interface PlayerEndedEventData extends PlayerPlayEventData {
}

export declare type PlayerEvent = {
    [K in PlayerEventType]: {
        type: K;
        data: PlayerEventTypeDataMap[K];
    };
}[keyof PlayerEventTypeDataMap];

export declare enum PlayerEventType {
    PLAYER_SESSION_RESTORED = "PLAYER_SESSION_RESTORED",
    PLAYER_MAIN_MEDIA_LOADING = "PLAYER_MAIN_MEDIA_LOADING",
    PLAYER_MAIN_MEDIA_LOADED = "PLAYER_MAIN_MEDIA_LOADED",
    PLAYER_MAIN_MEDIA_LOAD_ERROR = "PLAYER_MAIN_MEDIA_LOAD_ERROR",
    PLAYER_MAIN_MEDIA_UNLOADING = "PLAYER_MAIN_MEDIA_UNLOADING",
    PLAYER_MAIN_MEDIA_UNLOADED = "PLAYER_MAIN_MEDIA_UNLOADED",
    PLAYER_MAIN_MEDIA_UPDATED = "PLAYER_MAIN_MEDIA_UPDATED",
    PLAYER_AUDIO_CHANGE = "PLAYER_AUDIO_CHANGE",
    PLAYER_CHROMING_CHANGE = "PLAYER_CHROMING_CHANGE",
    PLAYER_TEXT_CHANGE = "PLAYER_TEXT_CHANGE",
    PLAYER_PLAYBACK_CHANGE = "PLAYER_PLAYBACK_CHANGE",
    PLAYER_PLAY = "PLAYER_PLAY",
    PLAYER_PAUSE = "PLAYER_PAUSE",
    PLAYER_ENDED = "PLAYER_ENDED",
    PLAYER_BUFFERING = "PLAYER_BUFFERING",
    PLAYER_SEEKING = "PLAYER_SEEKING",
    PLAYER_SEEKED = "PLAYER_SEEKED",
    PLAYER_PLAYBACK_PROGRESS = "PLAYER_PLAYBACK_PROGRESS",
    PLAYER_PLAYBACK_RATE_UPDATE = "PLAYER_PLAYBACK_RATE_UPDATE"
}

export declare type PlayerEventTypeDataMap = {
    [PlayerEventType.PLAYER_SESSION_RESTORED]: PlayerSessionRestoredEventData;
    [PlayerEventType.PLAYER_MAIN_MEDIA_LOADING]: PlayerMainMediaEventData;
    [PlayerEventType.PLAYER_MAIN_MEDIA_LOADED]: PlayerMainMediaEventData;
    [PlayerEventType.PLAYER_MAIN_MEDIA_LOAD_ERROR]: PlayerMainMediaErrorEventData;
    [PlayerEventType.PLAYER_MAIN_MEDIA_UNLOADING]: PlayerMainMediaUnloadedEventData;
    [PlayerEventType.PLAYER_MAIN_MEDIA_UNLOADED]: PlayerMainMediaUnloadedEventData;
    [PlayerEventType.PLAYER_MAIN_MEDIA_UPDATED]: PlayerMainMediaEventData;
    [PlayerEventType.PLAYER_AUDIO_CHANGE]: PlayerAudioChangeEventData;
    [PlayerEventType.PLAYER_CHROMING_CHANGE]: PlayerChromingChangeEventData;
    [PlayerEventType.PLAYER_TEXT_CHANGE]: PlayerTextChangeEventData;
    [PlayerEventType.PLAYER_PLAYBACK_CHANGE]: PlayerPlaybackChangeEventData;
    [PlayerEventType.PLAYER_PLAYBACK_PROGRESS]: PlayerPlaybackProgressEventData;
    [PlayerEventType.PLAYER_PLAY]: PlayerPlayEventData;
    [PlayerEventType.PLAYER_PAUSE]: PlayerPauseEventData;
    [PlayerEventType.PLAYER_ENDED]: PlayerEndedEventData;
    [PlayerEventType.PLAYER_BUFFERING]: PlayerBufferingEventData;
    [PlayerEventType.PLAYER_SEEKING]: PlayerSeekingEventData;
    [PlayerEventType.PLAYER_SEEKED]: PlayerSeekedEventData;
    [PlayerEventType.PLAYER_PLAYBACK_RATE_UPDATE]: PlayerPlaybackRateUpdateEventData;
};

export declare interface PlayerInternalApi extends PlayerCommonApi {
    audioInternal: PlayerAudioInternalApi;
    textInternal: PlayerTextInternalApi;
    restorePlayerSession(playerSession: PlayerSession): Observable<void>;
    loadSidecarTrack(trackId: Track['id'], loadOptions?: TrackLoadOptions | undefined): Observable<void>;
    removeSidecarTrack(trackId: Track['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    extractVideoKeyframe(options?: VideoKeyframeOptions): Observable<VideoKeyframe>;
}

export declare interface PlayerInternalConfig extends PlayerCommonConfig {
}

export declare interface PlayerLocalApi extends PlayerInternalApi, Destroyable {
    htmlMediaElement: HTMLMediaElement | undefined;
    setChromingInternal(chroming: ChromingInternalApi): void;
    loadMainMedia(mainMediaId: MainMedia['id']): Observable<MainMedia>;
    clearPlayerSession(): void;
    getPlaybackEngine(mainMediaType: MainMediaType.HLS): PlayerPlaybackEngineMapping[MainMediaType.HLS];
    getPlaybackEngine(mainMediaType: MainMediaType.MP4): PlayerPlaybackEngineMapping[MainMediaType.MP4];
    getPlaybackEngine(mainMediaType: MainMediaType.AUDIO_FILE): PlayerPlaybackEngineMapping[MainMediaType.AUDIO_FILE];
    getPlaybackEngine<T extends MainMediaType>(mainMediaType: T): PlayerPlaybackEngineMapping[T];
}

export declare interface PlayerLocalConfig extends PlayerInternalConfig {
}

export declare class PlayerMainAudioTrack extends BasePlayerAudioTrack {
    protected _playerAudioHandler: PlayerAudioHandlerApi;
    protected _playerController: PlayerController;
    constructor(track: AudioState, playerAudioHandler: PlayerAudioHandlerApi, playerController: PlayerController);
    get playerAudioHandler(): PlayerAudioHandlerApi;
    protected updateActive(active: boolean): void;
    setActive(active: boolean): Observable<void>;
    destroy(): void;
}

export declare interface PlayerMainMediaErrorEventData extends PlayerMainMediaEventData {
    error: string | undefined;
}

export declare interface PlayerMainMediaEventData extends Serializable {
    mainMediaState: MainMediaState;
}

export declare interface PlayerMainMediaUnloadedEventData extends Serializable {
    mainMediaId: MainMediaState['id'];
}

export declare class PlayerMainTextTrack extends BasePlayerTextTrack {
    protected _handler: PlayerTextTrackHandlerApi;
    constructor(track: TextTrackState, playerController: PlayerController);
    get handler(): PlayerTextTrackHandlerApi;
}

export declare interface PlayerPauseEventData extends PlayerPlayEventData {
}

export declare interface PlayerPlayback {
    playing: boolean;
    pausing: boolean;
    paused: boolean;
    waiting: boolean;
    seeking: boolean;
    buffering: boolean;
    ended: boolean;
    waitingSyncedMedia: boolean;
    currentTime: number;
    playbackRate: number;
    bufferedTimeRanges: BufferedTimeRange[];
}

export declare interface PlayerPlaybackChangeEventData extends Serializable {
    playerPlayback: PlayerPlayback;
}

declare interface PlayerPlaybackEngine {
}

declare type PlayerPlaybackEngineMapping = {
    [MainMediaType.HLS]: HlsPlayerPlaybackEngine;
    [MainMediaType.MP4]: Mp4PlayerPlaybackEngine;
    [MainMediaType.AUDIO_FILE]: AudioFilePlayerPlaybackEngine;
};

export declare interface PlayerPlaybackProgressEventData extends PlayerControllerPlaybackProgressEventData {
}

export declare interface PlayerPlaybackRateUpdateEventData extends PlayerControllerPlaybackRateUpdateEventData {
}

export declare interface PlayerPlayEventData extends PlayerControllerPlaybackProgressEventData {
}

export declare interface PlayerSeekedEventData extends PlayerControllerSeekedEventData {
}

export declare interface PlayerSeekingEventData extends PlayerControllerSeekingEventData {
}

export declare interface PlayerSession extends Serializable {
    /** ID of the currently loaded main media, or `undefined` if none is loaded. */
    mainMediaId: MainMediaState['id'] | undefined;
    /** Current playback state. */
    playback: PlayerPlayback;
    /** Current audio state, or `undefined` if audio is not initialized. */
    audio: PlayerAudioState | undefined;
    /** Current text track state, or `undefined` if text is not initialized. */
    text: PlayerTextState | undefined;
}

export declare interface PlayerSessionRestoredEventData extends Serializable {
    playerSession: PlayerSession;
}

export declare class PlayerSidecarAudioTrack extends BasePlayerAudioTrack {
    protected _playerAudioHandler: PlayerAudioHandlerApi;
    private _audioTrackController;
    private _outputAudioNode;
    constructor(audioState: AudioState, playerController: PlayerController, outputAudioNode: AudioNode);
    get audioTrackController(): AudioTrackController;
    loadSource(): Observable<void>;
    setActive(active: boolean): Observable<void>;
    get playerAudioHandler(): PlayerAudioHandlerApi;
    destroy(): void;
}

export declare class PlayerSidecarTextTrack extends BasePlayerTextTrack {
    protected _handler: PlayerTextTrackHandlerApi;
    protected _textTrackController: TextTrackController;
    constructor(trackState: TextTrackState, playerController: PlayerController, loadOptions?: PlayerTextTrackLoadOptions);
    loadSource(): Observable<void>;
    get handler(): PlayerTextTrackHandlerApi;
    destroy(): void;
}

export declare class PlayerText implements PlayerTextApi, Destroyable {
    protected readonly _onEvent$: Subject<PlayerTextEvent>;
    protected _sessionStore: SessionStore;
    protected _trackRepository: TrackRepository;
    protected _player: PlayerInternalApi;
    protected _playerBreaker: ObserverBreaker;
    protected _destroyBreaker: ObserverBreaker;
    constructor(ompProvider: OmpProvider, player: PlayerInternalApi);
    wirePlayer(player: PlayerInternalApi): void;
    getHandler(id: TextTrack_2['id']): TextTrackHandlerApi | undefined;
    getTracks(): TextTrack_2[];
    switchTrack(trackId: TextTrack_2['id'], activate?: boolean): Observable<void>;
    get shown(): boolean;
    show(): Observable<void>;
    hide(): Observable<void>;
    toggleShowHide(): Observable<void>;
    protected isAttached(): boolean;
    protected isDetached(): boolean;
    get onEvent$(): Observable<PlayerTextEvent>;
    get state(): PlayerTextState;
    destroy(): void;
}

export declare interface PlayerTextApi extends PlayerTextCommonApi {
    /**
     * Returns tracks loaded by player
     */
    getTracks(): TextTrack_2[];
    getTracks(playerTextTrackType: PlayerTextType.MAIN): TextTrack_2[];
    getTracks(playerTextTrackType: PlayerTextType.SIDECAR): TextTrack_2[];
}

export declare interface PlayerTextChangeEventData extends Serializable {
    playerText: PlayerTextState;
}

export declare interface PlayerTextCommonApi {
    /**
     * Observable that emits text events as they occur.
     */
    onEvent$: Observable<PlayerTextEvent>;
    /**
     * Current text state snapshot.
     */
    state: PlayerTextState;
    /**
     * Switches the active text track.
     * @param trackId - ID of the track to switch to.
     * @param show - Whether to show the track after switching. Defaults to `true`.
     */
    switchTrack(trackId: TextTrack_2['id'], show?: boolean): Observable<void>;
    /**
     * Returns the handler for a specific text track.
     * @param trackId - ID of the text track.
     */
    getHandler(trackId: TextTrack_2['id']): TextTrackHandlerApi | undefined;
    /**
     * Whether active text tracks are currently visible.
     */
    shown: boolean;
    /**
     * Shows text tracks.
     */
    show(): Observable<void>;
    /**
     * Hides text tracks.
     */
    hide(): Observable<void>;
    /**
     * Toggles show and hide.
     */
    toggleShowHide(): Observable<void>;
}

export declare interface PlayerTextConfig {
    textMode: PlayerTextMode;
}

export declare interface PlayerTextErrorEventData extends PlayerTextEventData {
    error: string | undefined;
}

export declare type PlayerTextEvent = {
    [K in PlayerTextEventType]: {
        type: K;
        data: PlayerTextEventTypeDataMap[K];
    };
}[keyof PlayerTextEventTypeDataMap];

export declare interface PlayerTextEventData extends Serializable {
    playerText: PlayerTextState;
}

export declare enum PlayerTextEventType {
    /** Text sub-system is initializing for the current media (start of setup). */
    PLAYER_TEXT_LOADING = "PLAYER_TEXT_LOADING",
    /** Text sub-system is ready; all embedded tracks have been registered. */
    PLAYER_TEXT_LOADED = "PLAYER_TEXT_LOADED",
    /** Text sub-system failed to initialize. */
    PLAYER_TEXT_LOAD_ERROR = "PLAYER_TEXT_LOAD_ERROR",
    /** Text sub-system has been torn down and all tracks removed. */
    PLAYER_TEXT_UNLOADED = "PLAYER_TEXT_UNLOADED",
    /** Fired after any change in text sub-system (catch-all change notification). */
    PLAYER_TEXT_CHANGE = "PLAYER_TEXT_CHANGE",
    /** The active text track has changed. */
    PLAYER_TEXT_TRACK_SWITCHED = "PLAYER_TEXT_TRACK_SWITCHED",
    /** An individual sidecar text track has started loading. */
    PLAYER_TEXT_TRACK_LOADING = "PLAYER_TEXT_TRACK_LOADING",
    /** An individual sidecar text track finished loading successfully. */
    PLAYER_TEXT_TRACK_LOADED = "PLAYER_TEXT_TRACK_LOADED",
    /** An individual sidecar text track failed to load. */
    PLAYER_TEXT_TRACK_LOAD_ERROR = "PLAYER_TEXT_TRACK_LOAD_ERROR",
    /** An individual sidecar text track has been unloaded. */
    PLAYER_TEXT_TRACK_UNLOADED = "PLAYER_TEXT_TRACK_UNLOADED"
}

export declare type PlayerTextEventTypeDataMap = {
    [PlayerTextEventType.PLAYER_TEXT_CHANGE]: PlayerTextEventData;
    [PlayerTextEventType.PLAYER_TEXT_LOADING]: PlayerTextEventData;
    [PlayerTextEventType.PLAYER_TEXT_LOADED]: PlayerTextEventData;
    [PlayerTextEventType.PLAYER_TEXT_LOAD_ERROR]: PlayerTextErrorEventData;
    [PlayerTextEventType.PLAYER_TEXT_UNLOADED]: PlayerTextEventData;
    [PlayerTextEventType.PLAYER_TEXT_TRACK_SWITCHED]: PlayerTextTrackSwitchedEventData;
    [PlayerTextEventType.PLAYER_TEXT_TRACK_LOADING]: PlayerTextTrackEventData;
    [PlayerTextEventType.PLAYER_TEXT_TRACK_LOADED]: PlayerTextTrackEventData;
    [PlayerTextEventType.PLAYER_TEXT_TRACK_LOAD_ERROR]: PlayerTextTrackErrorEventData;
    [PlayerTextEventType.PLAYER_TEXT_TRACK_UNLOADED]: PlayerTextTrackEventData;
};

export declare enum PlayerTextHandlerType {
    EMBEDDED = "EMBEDDED",
    NATIVE = "NATIVE",
    MEDIA_CAPTIONS = "MEDIA_CAPTIONS",
    IMSC = "IMSC"
}

export declare class PlayerTextInternal implements PlayerTextInternalApi, Destroyable {
    private readonly _onEvent$;
    private readonly _onEventQueue$;
    private _config;
    private _playerController;
    private _textMode;
    private _playerTracks;
    private _mainMediaOrderById;
    private _eventBreaker;
    private _destroyBreaker;
    constructor(config: PlayerTextConfig);
    teardown(): void;
    protected checkIsSetup(): void;
    setup(playerController: PlayerController, mainMediaState: MainMediaState, playerTextHandlerType: PlayerTextHandlerType[]): void;
    switchTrack(trackId: TextTrack_2['id'], activate?: boolean): Observable<void>;
    protected switchTrackPrepare(track: PlayerTextTrack, activate: boolean): Observable<boolean>;
    private _getPlayerTracks;
    private sortSidecarTracks;
    updateTrack(trackState: TextTrackState): void;
    getTracks(): TextTrackState[];
    getTracks(playerTextTrackType: PlayerTextType.MAIN): TextTrackState[];
    getTracks(playerTextTrackType: PlayerTextType.SIDECAR): TextTrackState[];
    getHandler(trackId: TextTrack_2['id']): TextTrackHandlerApi | undefined;
    protected getPlayerTextTrackHandler(trackId: TextTrack_2['id']): PlayerTextTrackHandlerApi | undefined;
    show(): Observable<void>;
    hide(): Observable<void>;
    protected showOrHide(show: boolean): Observable<void>;
    get shown(): boolean;
    toggleShowHide(): Observable<void>;
    loadSidecarTrack(trackState: TextTrackState, trackUpdater: (attrs: TextTrackUpdateableAttrs) => Observable<TextTrackState>, loadOptions?: PlayerTextTrackLoadOptions | undefined): Observable<TextTrackState>;
    removeSidecarTrack(id: TrackState['id']): Observable<void>;
    _removeSidecarTrack(id: TrackState['id']): void;
    removeAllSidecarTracks(): Observable<void>;
    _removeAllSidecarTracks(): void;
    get state(): PlayerTextState;
    protected emitPlayerTextChange(): void;
    restoreState(state: PlayerTextState): Observable<void>;
    get onEvent$(): Observable<PlayerTextEvent>;
    destroy(): void;
}

export declare interface PlayerTextInternalApi extends PlayerTextCommonApi {
    loadSidecarTrack(trackState: TextTrackState, trackUpdater: (attrs: TextTrackUpdateableAttrs) => Observable<TextTrackState>, loadOptions?: PlayerTextTrackLoadOptions | undefined): Observable<TextTrackState>;
    removeSidecarTrack(id: TrackState['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    updateTrack(trackState: TextTrackState): void;
    getTracks(): TextTrackState[];
    getTracks(playerTextTrackType: PlayerTextType.MAIN): TextTrackState[];
    getTracks(playerTextTrackType: PlayerTextType.SIDECAR): TextTrackState[];
}

declare interface PlayerTextInternalMessageChannel {
    onEvent$: Observable<PlayerTextEvent>;
    shown: boolean;
    switchTrack(trackId: TextTrack['id'], activate?: boolean): Observable<void>;
    show(): Observable<void>;
    hide(): Observable<void>;
    toggleShowHide(): Observable<void>;
    loadSidecarTrack(textTrackState: TextTrackState): Observable<TextTrackState>;
    removeSidecarTrack(trackId: TextTrack['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    state(): Observable<PlayerTextState>;
}

declare class PlayerTextInternalProxy extends BaseMessageChannelProxy<PlayerTextInternalMessageChannel> implements PlayerTextInternalApi, Destroyable {
    private readonly _trackRepository;
    private readonly _session;
    protected _remoteNode: RemoteNode;
    private _tracks;
    private _state?;
    private readonly _onEventQueue$;
    private _handlers;
    private _destroyBreaker;
    constructor(remoteNode: RemoteNode, ompProvider: OmpProvider);
    private syncStateOperator;
    protected initialize(): void;
    protected updateFromState(playerTextState: PlayerTextState): void;
    private updateTextTrackHandlerProxies;
    protected resolveHandlerState(id: TextTrack_2['id']): TextTrackHandlerState | undefined;
    get onEvent$(): Observable<PlayerTextEvent>;
    private checkLateInitialization;
    get state(): PlayerTextState;
    switchTrack(trackId: TextTrack_2['id'], activate?: boolean): Observable<void>;
    get shown(): boolean;
    hide(): Observable<void>;
    show(): Observable<void>;
    toggleShowHide(): Observable<void>;
    loadSidecarTrack(textTrackState: TextTrackState): Observable<TextTrackState>;
    removeSidecarTrack(id: TrackState['id']): Observable<void>;
    removeAllSidecarTracks(): Observable<void>;
    getHandler(id: TextTrack_2['id']): TextTrackHandlerApi | undefined;
    updateTrack(trackState: TextTrackState): void;
    getTracks(): TextTrackState[];
    getTracks(playerTextTrackType: PlayerTextType.MAIN): TextTrackState[];
    getTracks(playerTextTrackType: PlayerTextType.SIDECAR): TextTrackState[];
    destroy(): void;
}

/**
 * Defines the text track playback mode for the player.
 *
 * - `SINGLE`: Only one text track can be active at a time.
 */
export declare enum PlayerTextMode {
    SINGLE = "SINGLE"
}

export declare enum PlayerTextRenderingRegion {
    PLAYER = "PLAYER",
    VIDEO = "VIDEO"
}

export declare interface PlayerTextState {
    textMode: PlayerTextMode;
    tracks: {
        [PlayerTextType.MAIN]: PlayerTextTrackState[];
        [PlayerTextType.SIDECAR]: PlayerTextTrackState[];
    };
    handlers: {
        [PlayerTextType.MAIN]: PlayerTextTrackHandlerState[];
        [PlayerTextType.SIDECAR]: PlayerTextTrackHandlerState[];
    };
    shown: boolean;
}

export declare interface PlayerTextTrack extends PlayerTrack<TextTrackState, PlayerTextTrackState>, Destroyable {
    handler: PlayerTextTrackHandlerApi;
    active: boolean;
}

export declare interface PlayerTextTrackErrorEventData extends PlayerTextTrackEventData {
    error: string | undefined;
}

export declare interface PlayerTextTrackEventData extends Serializable {
    playerTextTrack: PlayerTextTrackState;
}

export declare interface PlayerTextTrackHandlerApi extends TextTrackHandlerApi, Destroyable {
    id: string;
    handlerType: PlayerTextHandlerType;
    state: PlayerTextTrackHandlerState;
    restoreState(state: PlayerTextTrackHandlerState): Observable<void>;
}

export declare interface PlayerTextTrackHandlerState extends TextTrackHandlerState {
    id: string;
}

/** Load options for text tracks. */
export declare interface PlayerTextTrackLoadOptions extends PlayerTrackLoadOptions {
    handlerType?: PlayerTextHandlerType;
    timeReference?: TimeReference;
    fallbackFormat?: FallbackFormat;
    /**
     * Not supported with NATIVE or EMBEDDED handlerType
     */
    renderingRegion?: PlayerTextRenderingRegion;
    /**
     * Not supported with NATIVE or EMBEDDED handlerType
     */
    adaptiveRendering?: boolean;
}

export declare interface PlayerTextTrackState extends PlayerTrackState {
    handlerId: PlayerTextTrackHandlerState['id'];
    active: boolean;
    shown: boolean;
}

export declare interface PlayerTextTrackSwitchedEventData extends Serializable {
    playerText: PlayerTextState;
    playerTextTrack: PlayerTextTrackState;
}

export declare enum PlayerTextType {
    MAIN = "MAIN",
    SIDECAR = "SIDECAR"
}

declare interface PlayerTrack<T extends TrackState = TrackState, S extends PlayerTrackState = PlayerTrackState> {
    onEvent$: Observable<PlayerTrackEvent>;
    trackState: T;
    loadStage: OpStage;
    state: S;
    loadStart(): void;
    loadSuccess(): void;
    loadError(error: string | undefined): void;
    setTrackState(trackState: T): void;
}

declare interface PlayerTrackErrorEventData extends PlayerTrackEventData {
    error: string | undefined;
}

declare type PlayerTrackEvent = {
    [K in PlayerTrackEventType]: {
        type: K;
        data: PlayerTrackEventTypeDataMap[K];
    };
}[keyof PlayerTrackEventTypeDataMap];

declare interface PlayerTrackEventData extends Serializable {
    playerTrackState: PlayerTrackState;
}

declare enum PlayerTrackEventType {
    PLAYER_TRACK_LOADING = "PLAYER_TRACK_LOADING",
    PLAYER_TRACK_LOADED = "PLAYER_TRACK_LOADED",
    PLAYER_TRACK_LOAD_ERROR = "PLAYER_TRACK_LOAD_ERROR",
    PLAYER_TRACK_SWITCHED = "PLAYER_TRACK_SWITCHED"
}

declare type PlayerTrackEventTypeDataMap = {
    [PlayerTrackEventType.PLAYER_TRACK_LOADING]: PlayerTrackEventData;
    [PlayerTrackEventType.PLAYER_TRACK_LOADED]: PlayerTrackEventData;
    [PlayerTrackEventType.PLAYER_TRACK_LOAD_ERROR]: PlayerTrackErrorEventData;
    [PlayerTrackEventType.PLAYER_TRACK_SWITCHED]: PlayerTrackEventData;
};

/** Base load options shared by all player track types. */
declare interface PlayerTrackLoadOptions extends BaseTrackLoadOptions {
}

declare interface PlayerTrackState {
    trackId: TrackState['id'];
    loadStage: OpStageState;
    loadOptions?: PlayerTrackLoadOptions | undefined;
}

export declare type Position = {
    x: number;
    y: number;
};

declare type PositionType = 'POSITION_TYPE_ABSOLUTE' | 'POSITION_TYPE_RELATIVE' | 'POSITION_TYPE_STATIC';

declare type PrefixKeys<T, P extends string> = {
    [K in keyof T as `${P}${Capitalize<string & K>}`]: T[K];
};

/**
 * Options controlling how a track is preloaded.
 */
declare interface PreloadTrackOptions {
    /**
     * Maximum number of segment HTTP requests issued in parallel during preloading.
     * Segments are processed in strict batches of this size — each batch must complete
     * before the next one starts. Defaults to 50 when not specified.
     */
    maxConcurrentRequests?: number | undefined;
}

export declare type RectMeasurement = Position & Dimension;

export declare class Relation {
    private readonly _relationType;
    private readonly _entityId;
    private readonly _entityType;
    protected constructor(relationType: RelationType, entityId: MediaEntity['id'], entityType: MediaEntity['mediaType']);
    static of(relationType: RelationType, entityId: MediaEntity['id'], entityType: MediaEntity['mediaType']): Relation;
    static fromEntity(relationType: RelationType, entity: MediaEntity): Relation;
    static fromState(relationState: RelationState): Relation;
    isEqualTo(relation: Relation): boolean;
    get state(): RelationState;
    get relationType(): RelationType;
    get entityId(): MediaEntity['id'];
    get entityType(): MediaEntity['mediaType'];
}

/**
 * Serializable snapshot of a {@link Relation}, referencing the related entity
 * by its id and {@link MediaEntityType}.
 */
export declare interface RelationState extends Serializable {
    relationType: RelationType;
    entityId: MediaEntityState['id'];
    entityType: MediaEntityState['mediaType'];
}

/**
 * Describes how two {@link MediaEntity} instances are related.
 */
export declare enum RelationType {
    /** The entity is a constituent part of another entity. */
    PART_OF = "PART_OF",
    /** The entity was derived from another entity. */
    DERIVED_FROM = "DERIVED_FROM"
}

declare interface RemoteNode {
    getChannelOrFail<T extends MessageChannelName>(messageChannelName: T, topic?: string): MessageChannel_2<MessageChannelTypeMap[T]>;
    getRemoteChannelOrFail<T extends MessageChannelName>(messageChannelName: T, topic?: string): MessageChannel_2<MessageChannelTypeMap[T]>;
    initRemoteProxies(): Observable<void>;
    getProxyByName<T extends MessageChannelName>(messageChannelName: T): MessageChannelProxyInstanceMap[T];
    getOrCreateProxy<K extends keyof MessageChannelFactoryMap>(name: K, ...args: Parameters<MessageChannelFactoryMap[K]>): ReturnType<MessageChannelFactoryMap[K]>;
    deleteProxy(proxy: MessageChannelProxy<any>): void;
    deleteProxies(proxy: MessageChannelProxy<any>[]): void;
}

export declare interface Repository<T extends MediaEntity> {
    add(mediaEntity: T): T;
    addAll(entities: T[]): T[];
    get(id: T['id']): T | undefined;
    getOrFail(id: T['id']): T;
    find(predicate?: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
    findFirst(predicate?: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
    /**
     * @returns true if media entity is deleted successfully
     * @param id
     */
    delete(id: T['id']): boolean;
    /**
     * @returns true if all media entities are deleted successfully
     * @param ids
     */
    deleteAll(ids: T['id'][]): boolean;
    /**
     * @returns true if all media entities are deleted successfully
     */
    clear(): boolean;
    toString(): string;
}

declare interface RequestMessage<DataType> extends DataMessage<DataType> {
    type: MessageType.REQUEST;
}

declare interface ResponseError {
    name: string;
    message?: string;
}

declare interface ResponseMessage<DataType> extends DataMessage<DataType> {
    type: MessageType.RESPONSE;
    requestMessageId: Message['messageId'];
    error?: ResponseError;
}

export declare type RestoreMainMediaSessionArgsType = {
    mainMedia: MainMediaState;
    mainMediaLoadedHook: () => Observable<void>;
};

export declare interface RoutedAudioEffect {
    effect: AudioEffect;
    routingPath: AudioRoutingPath;
}

export declare interface RoutedAudioEffectGraph {
    effectGraph: AudioEffectGraph;
    routingPath: AudioRoutingPath;
}

export declare interface RoutedAudioEffectGraphState {
    effectGraphState: AudioEffectGraphState;
    routingPath: AudioRoutingPath;
}

export declare const ROUTER_VISUALIZATION_LABELS_DEFAULT: string[];

export declare class RouterVisualization implements Destroyable, RouterVisualizationApi {
    private _config;
    private _routerVisualizationDomController;
    private _routerVisualizationComponent;
    private _omakasePlayer;
    constructor(config: RouterVisualizationConfig, player: OmakasePlayerApi);
    get config(): RouterVisualizationConfig;
    private prepareTrack;
    updateSize(size: RouterVisualizationSize): void;
    destroy(): void;
}

export declare interface RouterVisualizationApi {
    /**
     * Updates the size of the Router Visualization component
     * @param size small, medium or large
     */
    updateSize(size: RouterVisualizationSize): void;
    /**
     * Destroys Router Visualization component
     */
    destroy(): void;
}

export declare interface RouterVisualizationConfig {
    size: RouterVisualizationSize;
    routerVisualizationHTMLElementId: string;
    outputNumber?: number;
    outputLabels?: string[];
    visualizationTracks?: RouterVisualizationTrack[];
    defaultMatrix?: AudioRoutingConnection[];
}

export declare type RouterVisualizationSize = 'small' | 'medium' | 'large';

export declare interface RouterVisualizationTrack {
    name?: string | undefined;
    inputNumber?: number | undefined;
    inputLabels?: string[] | undefined;
    maxInputNumber: number;
    trackId?: string | undefined;
}

declare interface ScrollableHorizontally {
    scrollHorizontallyToPercent(percent: number): void;
    getHorizontalScrollPercent(): number;
    getScrollHandleHorizontals(scrollbarWidth: number): Horizontals;
}

declare class Scrollbar extends BaseKonvaComponent2<default_3.Group> implements OnMeasurementsChange, HasRectMeasurement {
    private readonly _onEvent$;
    protected _ui: Ui;
    protected _config: ScrollbarConfig;
    protected _providedStyle?: Partial<ScrollbarStyle> | undefined;
    protected _styledElement: StyledElementWithId<ScrollbarStyle>;
    protected _style: ScrollbarStyle;
    protected _initialStyle?: ScrollbarStyle;
    private _group;
    private _handleGroup;
    private _bgRect;
    private _handleBar;
    private _leftZoomHandle;
    private _rightZoomHandle;
    private _minHandleBarWidth;
    constructor(ompProvider: OmpProvider, configAndStyle?: ConfigAndStyle<ScrollbarConfig, ScrollbarStyle>);
    get onEvent$(): Observable<ScrollbarEvent>;
    protected provideKonvaNode(): default_3.Group;
    onMeasurementsChange(): void;
    protected handleStyleUpdate(): void;
    private getScrollHandleMaxX;
    private getConstrainedHandleBarX;
    private clickScrollTo;
    private scrollTo;
    private scrollToEased;
    private calculateHandleBarWidthFromZoomRatioPercent;
    getZoomPercent(): number;
    getScrollHandlePercent(): number;
    updateScrollHandle(scrollable: ScrollableHorizontally): void;
    private syncLeftRightHandles;
    getRect(): RectMeasurement;
    updateStyle(style: Partial<ScrollbarStyle>): void;
}

declare interface ScrollbarConfig {
    x: number;
    y: number;
    width: number;
    zoomMax: number;
    scrollStepNumberOfDivisions: number;
    scrollEasingDuration: number;
}

declare type ScrollbarEvent = {
    [K in ScrollbarEventType]: {
        type: K;
        data: ScrollbarEventTypeDataMap[K];
    };
}[keyof ScrollbarEventTypeDataMap];

declare enum ScrollbarEventType {
    SCROLLBAR_SCROLL = "SCROLLBAR_SCROLL",
    SCROLLBAR_ZOOM = "SCROLLBAR_ZOOM"
}

declare type ScrollbarEventTypeDataMap = {
    [ScrollbarEventType.SCROLLBAR_SCROLL]: {
        scrollPercent: number;
    };
    [ScrollbarEventType.SCROLLBAR_ZOOM]: {
        zoomPercent: number;
        zoomFocus: number;
    };
};

declare class ScrollbarFlexContentNode extends KonvaComponentFlexContentNode2<Scrollbar> {
    private _scrollableHorizontally;
    constructor(component: Scrollbar, scrollableHorizontally: ScrollableHorizontally);
    updateLayout(layout: Layout): void;
}

declare class ScrollbarFlexItem extends KonvaFlexItem<ScrollbarFlexContentNode> {
    constructor(config: FlexGroupConfig, scrollbar: Scrollbar, scrollableHorizontally: ScrollableHorizontally);
}

export declare class ScrollbarLane extends BaseTimelineLane<ScrollbarLaneConfig, ScrollbarLaneStyle> {
    protected _contentGroup?: default_3.Group;
    protected _contentFlexGroup?: KonvaFlexGroup;
    protected _scrollbarFlexItem?: KonvaFlexItem<KonvaComponentFlexContentNode2<Scrollbar>>;
    protected _scrollbar?: Scrollbar;
    private _timelineZoomInProgress;
    constructor(configAndStyle?: ConfigAndStyle<ScrollbarLaneConfig, ScrollbarLaneStyle>);
    protected createStyledElement(): StyledElementWithId<ScrollbarLaneStyle>;
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    protected handleStyleUpdate(): void;
    private resolveScrollbarHeight;
    protected settleLayout(): void;
    get scrollbar(): Scrollbar | undefined;
    destroy(): void;
}

export declare interface ScrollbarLaneConfig extends TimelineLaneConfig {
}

export declare interface ScrollbarLaneStyle extends TimelineLaneStyle {
    scrollbarWidth: number | string;
    scrollbarHeight: number | undefined;
    scrollbarBackgroundFill: Color;
    scrollbarBackgroundFillOpacity: number;
    scrollbarHandleBarFill: Color;
    scrollbarHandleBarOpacity: number;
    scrollbarHandleOpacity: number;
    scrollbarJustify: 'start' | 'center' | 'end';
}

declare interface ScrollbarStyle {
    height: number;
    backgroundFill: string;
    backgroundFillOpacity: number;
    handleBarFill: string;
    handleBarOpacity: number;
    handleOpacity: number;
}

export declare const SCRUBBER_LANE_STYLE_DEFAULT: ScrubberLaneStyle;

export declare class ScrubberLane extends BaseTimelineLane<ScrubberLaneConfig, ScrubberLaneStyle> implements ScrubberLaneApi {
    readonly onClick$: Subject<ClickEvent>;
    readonly onMouseEnter$: Subject<MouseEnterEvent>;
    readonly onMouseOver$: Subject<MouseOverEvent>;
    readonly onMouseMove$: Subject<MouseMoveEvent>;
    readonly onMouseOut$: Subject<MouseOutEvent>;
    readonly onMouseLeave$: Subject<MouseLeaveEvent>;
    private _tickDivisionWidth?;
    private _tickTotalDivisions?;
    private _timecodedEventCatcher?;
    private _ticksGroup?;
    constructor(configAndStyle?: ConfigAndStyle<ScrubberLaneConfig, ScrubberLaneStyle>);
    protected createStyledElement(): StyledElementWithId<ScrubberLaneStyle>;
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    protected settleLayout(): void;
    protected handleStyleUpdate(): void;
    destroy(): void;
    clearContent(): void;
    refreshTimeDivisions(forceCreate?: boolean): void;
    private resolveTimeDivisionWidth;
}

declare interface ScrubberLaneApi extends TimelineLaneApi<ScrubberLaneStyle> {
    /**
     * Fires on click
     * @readonly
     */
    onClick$: Observable<ClickEvent>;
    /**
     * Fires on mouse enter
     * @readonly
     */
    onMouseEnter$: Observable<MouseEnterEvent>;
    /**
     * Fires on mouse over
     * @readonly
     */
    onMouseOver$: Observable<MouseOverEvent>;
    /**
     * Fires on mouse move
     * @readonly
     */
    onMouseMove$: Observable<MouseMoveEvent>;
    /**
     * Fires on mouse out
     * @readonly
     */
    onMouseOut$: Observable<MouseOutEvent>;
    /**
     * Fires on mouse leave
     * @readonly
     */
    onMouseLeave$: Observable<MouseLeaveEvent>;
}

export declare interface ScrubberLaneConfig extends TimelineLaneConfig {
}

export declare interface ScrubberLaneStyle extends TimelineLaneStyle {
    tickDivisor: number;
    tickDivisionMinWidth: number;
    tickFill: string;
    tickHeight: number;
    divisionTickHeight: number;
    timecodeShowFirst: boolean;
    timecodeFontSize: number;
    timecodeFill: string;
}

export declare const selectChroming: (state: SessionState) => ChromingSession | undefined;

export declare const selectPlayer: (state: SessionState) => PlayerSession | undefined;

export declare const selectWindowPlayback: (state: SessionState) => WindowPlayback;

declare interface SendOptions {
    timeout: number;
}

/**
 * Serializable object with properties without methods
 */
declare interface Serializable {
}

export declare interface SessionApi {
    onEvent$: Observable<SessionEvent>;
    get state(): SessionState;
}

export declare type SessionEvent = {
    [K in SessionEventType]: {
        type: K;
        data: SessionEventTypeDataMap[K];
    };
}[keyof SessionEventTypeDataMap];

export declare interface SessionEventData extends Serializable {
}

export declare enum SessionEventType {
    SESSION_WINDOW_PLAYBACK_UPDATED = "SESSION_WINDOW_PLAYBACK_UPDATED",
    SESSION_WINDOW_PLAYBACK_MODE_CHANGE_REQUEST = "SESSION_WINDOW_PLAYBACK_MODE_CHANGE_REQUEST",
    SESSION_PLAYER_UPDATED = "SESSION_PLAYER_UPDATED",
    SESSION_CHROMING_UPDATED = "SESSION_CHROMING_UPDATED",
    SESSION_MEDIA_LOAD_REQUESTS_UPDATED = "SESSION_MEDIA_LOAD_REQUESTS_UPDATED",
    SESSION_ALERTS_UPDATED = "SESSION_ALERTS_UPDATED"
}

export declare type SessionEventTypeDataMap = {
    [SessionEventType.SESSION_WINDOW_PLAYBACK_UPDATED]: {
        windowPlayback: WindowPlayback;
    };
    [SessionEventType.SESSION_WINDOW_PLAYBACK_MODE_CHANGE_REQUEST]: {
        mode: WindowPlaybackMode;
    };
    [SessionEventType.SESSION_PLAYER_UPDATED]: {
        player: PlayerSession | undefined;
    };
    [SessionEventType.SESSION_CHROMING_UPDATED]: {
        chroming: ChromingSession | undefined;
    };
    [SessionEventType.SESSION_MEDIA_LOAD_REQUESTS_UPDATED]: {
        mediaLoadRequests: MediaLoadRequest[];
    };
    [SessionEventType.SESSION_ALERTS_UPDATED]: {
        alerts: AlertState[];
    };
};

export declare class SessionFactory {
    static createEmptySession(): SessionState;
    static createEmptyPlayerSession(): PlayerSession;
    static createEmptyChromingSession(): ChromingSession;
}

export declare interface SessionState extends Serializable {
    /** Whether player can be detached. */
    isDetachable: boolean;
    /** Current window playback state, including mode and detach/attach availability. */
    windowPlayback: WindowPlayback;
    /** Pending media load requests, used to track in-progress loads. */
    mediaLoadRequests: MediaLoadRequest[];
    /** Active alerts raised during the session. */
    alerts: AlertState[];
    /** Player session state, including playback, audio, and text. */
    player: PlayerSession;
    /** Chroming session state. */
    chroming: ChromingSession;
}

export declare class SessionStore implements SessionApi, Destroyable {
    private readonly _onEvent$;
    private readonly _sessionState$;
    private readonly _mediaLoadRequests;
    private readonly _destroyBreaker;
    constructor(alertsManager: AlertsManager);
    get onEvent$(): Observable<SessionEvent>;
    private patch;
    select<R>(project: (state: SessionState) => R, compare?: (a: R, b: R) => boolean): Observable<R>;
    update(patch: DeepPartial<SessionState>): void;
    setPlayer(player: PlayerSession | undefined): void;
    updatePlayer(patch: DeepPartial<PlayerSession>): void;
    updatePlayerCurrentTime(currentTime: PlayerPlayback['currentTime']): void;
    updateWindowPlaybackMode(next: WindowPlaybackMode, error?: string): void;
    private resolveCanDetach;
    private resolveCanAttach;
    requestWindowPlaybackModeChange(mode: WindowPlaybackMode): void;
    setChroming(chroming: ChromingSession | undefined): void;
    updateChroming(patch: DeepPartial<ChromingSession>): void;
    createMediaLoadRequest(media?: Track | MainMedia, playerMainMedia?: MainMedia): MediaLoadRequest;
    removeMediaLoadRequest(mediaLoadPackage: MediaLoadRequest): void;
    onDetached$(): Observable<void>;
    get state(): SessionState;
    destroy(): void;
}

declare interface SessionStoreMessageChannel {
    onEvent$: Observable<SessionEvent>;
    setPlayer(player: PlayerSession | undefined): Observable<void>;
    updatePlayer(patch: DeepPartial<PlayerSession>): Observable<void>;
    updatePlayerCurrentTime(currentTime: PlayerPlayback['currentTime']): Observable<void>;
    updateWindowPlaybackMode(next: WindowPlaybackMode, error?: string): Observable<void>;
    updateChroming(patch: DeepPartial<ChromingSession>): Observable<void>;
    /**
     * Intentionally not Observable, we want to exit method as soon as possible
     * @param mode
     */
    requestWindowPlaybackModeChange(mode: WindowPlaybackMode): void;
    state(): Observable<SessionState>;
}

declare class SessionStoreProxy extends BaseMessageChannelProxy<SessionStoreMessageChannel> implements SessionStoreMessageChannel {
    constructor(remoteNode: RemoteNode);
    get onEvent$(): Observable<SessionEvent>;
    setPlayer(playerSession: PlayerSession | undefined): Observable<void>;
    updatePlayer(patch: DeepPartial<PlayerSession>): Observable<void>;
    updateChroming(patch: DeepPartial<ChromingSession>): Observable<void>;
    updatePlayerCurrentTime(currentTime: PlayerPlayback['currentTime']): Observable<void>;
    updateWindowPlaybackMode(next: WindowPlaybackMode, error?: string): Observable<void>;
    requestWindowPlaybackModeChange(mode: WindowPlaybackMode): void;
    state(): Observable<SessionState>;
}

/**
 * Functions with internal TextTrackController
 */
export declare class SidecarTextTrackHandler extends BasePlayerTextTrackHandler {
    protected _textTrackController: TextTrackController;
    constructor(trackState: TextTrackState, playerController: PlayerController, loadOptions?: PlayerTextTrackLoadOptions);
    get handlerType(): PlayerTextHandlerType;
    switch(active: boolean): Observable<void>;
    show(): Observable<void>;
    hide(): Observable<void>;
    get textTrackController(): TextTrackController;
    destroy(): void;
}

export declare type Size = number & {};

export declare class SlateProvider implements Destroyable {
    private _slateUrls;
    constructor();
    getMainMedia(slateType: SlateType): MainMedia;
    private createSlate;
    destroy(): void;
}

export declare enum SlateType {
    BLACK = "BLACK"
}

export declare interface SlewOptions {
    timeSlew: number;
    expectedFrameRate?: number | string;
}

export declare interface Source {
    type: SourceType;
    state: SourceState;
}

export declare class SourceFactory {
    static create(sourceState: SourceState): Source;
}

export declare interface SourceState extends Serializable {
    type: SourceType;
}

export declare enum SourceType {
    URL = "URL",
    TRACK = "TRACK"
}

export declare class SourceUtil {
    static resolveUrlFromSource(source: Source): string;
    static resolveUrlFromSourceState(sourceState: SourceState): string;
}

export declare interface SpanEndTemporal {
    type: TimedItemTemporalType.SPAN_END;
    end: string;
}

export declare interface SpanStartTemporal {
    type: TimedItemTemporalType.SPAN_START;
    start: string;
}

export declare interface SpanTemporal {
    type: TimedItemTemporalType.SPAN;
    start: string;
    end: string;
}

export declare enum StampThemeActionIcon {
    AUDIO_TOGGLE = "AUDIO_TOGGLE",
    FULLSCREEN = "FULLSCREEN"
}

export declare interface StampThemeConfig extends StampThemeConfigUpdateableAttrs {
    /**
     * Specifies list of enabled floating controls
     */
    floatingControls: StampThemeFloatingControl[];
    /**
     * Specifies list of floating controls that are shown when the video is playing
     */
    alwaysOnFloatingControls: StampThemeFloatingControl[];
    /**
     * Specifies list of enabled action icons
     */
    actionIcons: StampThemeActionIcon[];
    /**
     * Id of the custom web component used for Player chroming
     */
    htmlTemplateId?: string;
}

export declare interface StampThemeConfigUpdateableAttrs {
    /**
     * Specifies how the video will fill the container
     */
    stampScale: StampThemeScale;
    /**
     * Specifies which time format will be used in the timer control
     */
    timeFormat: ChromingTimeFormat;
    /**
     * Specifies if the time control can be used for seeking. It is activated by double clicking the time.
     */
    timeInteractive: boolean;
}

export declare enum StampThemeFloatingControl {
    PROGRESS_BAR = "PROGRESS_BAR",
    TIME = "TIME",
    PLAYBACK_CONTROLS = "PLAYBACK_CONTROLS",
    ACTION_ICONS = "ACTION_ICONS"
}

export declare enum StampThemeScale {
    FILL = "FILL",
    FIT = "FIT"
}

declare class StyleAdapter<T> {
    readonly onChange$: Subject<T>;
    private _style;
    constructor(style: T);
    get style(): T;
    set style(value: Partial<T>);
}

export declare interface StyledElement<S = {}> {
    id?: string | undefined;
    classes?: string[];
    style?: Partial<S> | undefined;
    parent?: StyledElement<S> | undefined;
    description?: string | undefined;
}

export declare interface StyledElementWithId<S = {}> extends StyledElement<S> {
    id: string;
}

export declare type StyleRule<S = {}> = ClassStyleRule<S> | IdStyleRule<S>;

export declare const TEXT_RENDERING_DOM_CLASSES: {
    playerRegion: string;
    videoRegion: string;
    adaptiveRendering: string;
    noAdaptiveRendering: string;
};

export declare const TEXT_TRACK_LANE_STYLE_DEFAULT: TextTrackLaneStyle;

export declare type TextAlign = 'left' | 'right' | 'center' | 'justify';

export declare interface TextCue extends TimedItem<TextCueState> {
    text: string;
}

export declare interface TextCueArgs extends TimedItemArgs {
    text: string;
}

export declare interface TextCueState extends TimedItemState {
    text: string;
}

export declare interface TextCueUpdateableAttrs extends TimedItemUpdateableAttrs {
    text?: string;
}

declare class TextCueVisualization extends BaseKonvaComponent<TextCueVisualizationConfig, TextCueVisualizationStyle, default_3.Group> implements OnMeasurementsChange, HasRectMeasurement {
    private _group;
    private _bgRect;
    private _eventCatcherRect;
    cues: TextCue[];
    constructor(config: Partial<ConfigWithOptionalStyle<TextCueVisualization>>);
    protected provideKonvaNode(): default_3.Group;
    onMeasurementsChange(): void;
    getPosition(): Position;
    getDimension(): Dimension;
    getRect(): RectMeasurement;
}

declare interface TextCueVisualizationConfig extends ComponentConfig<TextCueVisualizationStyle> {
}

declare interface TextCueVisualizationStyle {
    x: number;
    y: number;
    width: number;
    height: number;
    fill: string;
    opacity: number;
}

/**
 * Timeline text label. Can be added  to timeline lane. {@link TimelineLaneApi}
 */
export declare class TextLabel extends BaseTimelineNode<TextLabelConfig, TextLabelStyle> {
    private _konvaText;
    constructor(config: ConfigWithOptionalStyle<TextLabelConfig>);
    onMeasurementsChange(): void;
    protected onStyleChange(): void;
    /**
     * Sets new text to display
     * @param value
     */
    set text(value: string);
    get text(): string;
}

export declare interface TextLabelConfig extends TimelineNodeConfig<TextLabelStyle> {
    /**
     * Text to display
     */
    text?: string | undefined;
}

export declare interface TextLabelStyle extends TimelineNodeStyle {
    fontSize?: number | undefined;
    fontFamily?: string | undefined;
    fontStyle?: string | undefined;
    fill?: string | undefined;
    align?: 'left' | 'right' | 'center' | undefined;
    verticalAlign?: 'top' | 'middle' | 'bottom' | undefined;
    wrap?: 'word' | 'char' | 'none' | undefined;
    padding?: number | undefined;
    offsetX?: number | undefined;
    offsetY?: number | undefined;
    opacity?: number | undefined;
    textAreaStretch?: boolean | undefined;
}

declare interface TextTrack_2<S extends TextTrackState = TextTrackState, E extends OmpEventGroup<any, any> = never> extends TimedItemsTrack<TextCue, S, TextCueUpdateableAttrs, E> {
    textTrackType: TextTrackType;
    kind?: TextTrackKind_2 | undefined;
    srclang?: string | undefined;
    default: boolean;
}
export { TextTrack_2 as TextTrack }

/**
 * Construction arguments for text track instances.
 */
export declare interface TextTrackArgs extends BaseTrackArgs {
    /** The kind of text track (subtitles, captions, etc.). */
    kind?: TextTrackKind_2 | undefined;
    /** BCP 47 language tag (e.g. `"en"`). */
    srclang?: string | undefined;
    /** Whether this track should be selected by default. */
    default?: boolean;
}

declare interface TextTrackController extends TrackController<TrackControllerEvent> {
    playerTextHandlerType: PlayerTextHandlerType;
    switch(active: boolean): Observable<void>;
    show(): Observable<void>;
    hide(): Observable<void>;
}

export declare interface TextTrackConversionOptions {
    label?: string | undefined;
    outputFormat?: OutputTextFileFormatType | undefined;
    slewOptions?: SlewOptions | undefined;
}

export declare type TextTrackEvent = OmpEventGroup<TextTrackEventType, TextTrackEventTypeDataMap>;

export declare interface TextTrackEventData {
}

export declare enum TextTrackEventType {
    TEXT_TRACK_SPECIFIC_EVENT_PLACEHOLDER = "TEXT_TRACK_SPECIFIC_EVENT_PLACEHOLDER"
}

export declare type TextTrackEventTypeDataMap = {
    [TextTrackEventType.TEXT_TRACK_SPECIFIC_EVENT_PLACEHOLDER]: TextTrackEventData;
};

export declare class TextTrackFile extends BaseTextTrack<TextCue, BaseTextCue, TextTrackState, TextTrackEvent> {
    protected _textTrackType: TextTrackType;
    constructor(args: TextTrackArgs);
    protected getState(): TextTrackState;
}

export declare interface TextTrackHandlerApi {
    onEvent$: Observable<TextTrackHandlerEvent>;
    active: boolean;
    shown: boolean;
    handlerType: PlayerTextHandlerType;
    state: TextTrackHandlerState;
    switch(active: boolean): Observable<void>;
    show(): Observable<void>;
    hide(): Observable<void>;
    toggleShowHide(): Observable<void>;
}

export declare type TextTrackHandlerEvent = {
    [K in TextTrackHandlerEventType]: {
        type: K;
        data: TextTrackHandlerEventTypeDataMap[K];
    };
}[keyof TextTrackHandlerEventTypeDataMap];

export declare interface TextTrackHandlerEventData extends Serializable {
    state: TextTrackHandlerState;
}

export declare enum TextTrackHandlerEventType {
    TEXT_TRACK_HANDLER_CHANGE = "TEXT_TRACK_HANDLER_CHANGE"
}

export declare type TextTrackHandlerEventTypeDataMap = {
    [TextTrackHandlerEventType.TEXT_TRACK_HANDLER_CHANGE]: TextTrackHandlerEventData;
};

declare interface TextTrackHandlerMessageChannel {
    onEvent$: Observable<TextTrackHandlerEvent>;
    setEnabled(enabled: boolean): Observable<void>;
    state(): Observable<TextTrackHandlerState>;
    switch(active: boolean): Observable<void>;
    show(): Observable<void>;
    hide(): Observable<void>;
    toggleShowHide(): Observable<void>;
}

declare class TextTrackHandlerProxy extends BaseMessageChannelProxy<TextTrackHandlerMessageChannel> implements TextTrackHandlerApi {
    private _state?;
    private readonly _onEventQueue$;
    protected _destroyBreaker: ObserverBreaker;
    constructor(messageChannel: MessageChannel_2<TextTrackHandlerMessageChannel>, state: TextTrackHandlerState);
    private syncStateOperator;
    updateFromState(textTrackHandlerState: TextTrackHandlerState): void;
    private checkLateInitialization;
    get onEvent$(): Observable<TextTrackHandlerEvent>;
    get state(): TextTrackHandlerState;
    get active(): boolean;
    get shown(): boolean;
    get handlerType(): PlayerTextHandlerType;
    hide(): Observable<void>;
    show(): Observable<void>;
    switch(active: boolean): Observable<void>;
    toggleShowHide(): Observable<void>;
    destroy(): void;
}

export declare interface TextTrackHandlerState {
    handlerType: PlayerTextHandlerType;
    active: boolean;
    shown: boolean;
}

declare type TextTrackIdentifier = any;

/**
 * Mirrors the HTML `<track>` element's `kind` attribute.
 */
declare type TextTrackKind_2 = 'subtitles' | 'captions' | 'descriptions' | 'chapters' | 'metadata';
export { TextTrackKind_2 as TextTrackKind }

export declare class TextTrackLane extends BaseTrackLane<TextTrackLaneConfig, TextTrackLaneStyle, TextTrack_2> {
    private readonly _onEvent$;
    protected _eventsBreaker: ObserverBreaker;
    protected _textMarkingsGroup?: default_3.Group;
    protected _textCueVisualizations: Map<number, TextCueVisualization>;
    protected _squashedCueGroups: TextCue[][];
    protected _cueSquashThreshold: number;
    constructor(configAndStyle?: ConfigAndStyle<TextTrackLaneConfig, TextTrackLaneStyle>);
    setTrack(track: TextTrack_2): void;
    protected createStyledElement(): StyledElementWithId<TextTrackLaneStyle>;
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    private handleTrackUpdated;
    render(): void;
    clearContent(): void;
    protected handleTimelineScroll(): void;
    protected createLoadingGroupContent(width: number, height: number): default_3.Animation;
    protected hasVisualElements(): boolean;
    settleLayout(): void;
    private squashCues;
    private adjustCueVisualizations;
    private attachCueListeners;
    get onEvent$(): Observable<TextTrackLaneEvent>;
    destroy(): void;
}

export declare interface TextTrackLaneConfig extends TrackLaneConfig {
}

export declare type TextTrackLaneEvent = {
    [K in TextTrackLaneEventType]: {
        type: K;
        data: TextTrackLaneEventTypeDataMap[K];
    };
}[keyof TextTrackLaneEventTypeDataMap];

export declare interface TextTrackLaneEventData {
    cues: TextCue[];
}

export declare enum TextTrackLaneEventType {
    TIMELINE_TEXT_TRACK_LANE_ITEM_CLICK = "TIMELINE_TEXT_TRACK_LANE_ITEM_CLICK",
    TIMELINE_TEXT_TRACK_LANE_ITEM_MOUSE_ENTER = "TIMELINE_TEXT_TRACK_LANE_ITEM_MOUSE_ENTER",
    TIMELINE_TEXT_TRACK_LANE_ITEM_MOUSE_LEAVE = "TIMELINE_TEXT_TRACK_LANE_ITEM_MOUSE_LEAVE"
}

export declare type TextTrackLaneEventTypeDataMap = {
    [TextTrackLaneEventType.TIMELINE_TEXT_TRACK_LANE_ITEM_CLICK]: TextTrackLaneEventData;
    [TextTrackLaneEventType.TIMELINE_TEXT_TRACK_LANE_ITEM_MOUSE_ENTER]: TextTrackLaneEventData;
    [TextTrackLaneEventType.TIMELINE_TEXT_TRACK_LANE_ITEM_MOUSE_LEAVE]: TextTrackLaneEventData;
};

export declare interface TextTrackLaneStyle extends TimelineLaneStyle {
    paddingTop: number;
    paddingBottom: number;
    textLaneItemOpacity: number;
    textLaneItemFill: string;
}

/** Load options for text tracks. */
export declare interface TextTrackLoadOptions extends BaseTrackLoadOptions {
    args?: TextTrackArgs;
}

/**
 * Serializable snapshot of a text track {@link Track}.
 */
export declare interface TextTrackState extends TimedItemsTrackState<TextCueState> {
    textTrackType: TextTrackType;
    kind: TextTrackKind_2 | undefined;
    /** BCP 47 language tag for the text track (e.g. `"en"`, `"fr"`). */
    srclang?: string | undefined;
    /** Whether this text track is selected by default. */
    default: boolean;
}

/**
 * Discriminator for the origin of a text track.
 */
export declare enum TextTrackType {
    /** Standalone text track file loaded as a sidecar (e.g. VTT, SRT). */
    TEXT_TRACK_FILE = "TEXT_TRACK_FILE",
    /** Text track rendition extracted from an HLS manifest. */
    HLS_TEXT_TRACK = "HLS_TEXT_TRACK"
}

/**
 * Subset of {@link TextTrackState} fields that can be updated at runtime.
 */
export declare type TextTrackUpdateableAttrs = TrackUpdateableAttrs;

export declare class TextTrackVttFetcher extends VttTimedItemsFetcher<TextTrack_2> {
    map(index: number, cue: ParsedVttCue): TimedItemOf<TextTrack_2>;
}

/**
 * Public interface for a thumbnail within a {@link ThumbnailTrack}.
 *
 * @typeParam S - The concrete {@link ThumbnailState} subtype.
 */
export declare interface Thumbnail extends TimedItem<ThumbnailState> {
    /** Label **/
    label?: string | undefined;
    /** URL of the thumbnail image. */
    url: string;
}

export declare const THUMBNAIL_TRACK_LANE_STYLE_DEFAULT: ThumbnailTrackLaneStyle;

/**
 * Construction arguments shared by all thumbnail types.
 */
export declare interface ThumbnailArgs extends TimedItemArgs {
    label?: string | undefined;
    /** URL of the thumbnail image. */
    url: string;
}

/**
 * Payload carried by thumbnail-specific events (added, deleted, updating, updated).
 */
export declare interface ThumbnailEventData {
    trackId: Track['id'];
    thumbnailState: ThumbnailState;
}

declare class ThumbnailHoverWrapper implements Destroyable {
    private _thumbnailImg;
    private _thumbnail?;
    constructor(thumbnailImg: ThumbnailImg);
    setPosition(position: Position): void;
    set thumbnail(value: Thumbnail);
    get thumbnail(): Thumbnail | undefined;
    get thumbnailImg(): ThumbnailImg;
    destroy(): void;
}

declare class ThumbnailHoverWrapper_2 implements Destroyable {
    private _thumbnailImg?;
    private _thumbnail?;
    constructor();
    setPosition(position: Position): void;
    set thumbnail(value: Thumbnail);
    set thumbnailImg(value: ThumbnailImg);
    get thumbnail(): Thumbnail | undefined;
    get thumbnailImg(): ThumbnailImg | undefined;
    destroy(): void;
}

declare class ThumbnailImg extends BaseKonvaComponent<ThumbnailImgConfig, ThumbnailImgStyle, default_3.Group> implements OnMeasurementsChange, HasRectMeasurement, Comparable<ThumbnailImg> {
    private readonly _onEvent$;
    private _group;
    private _bgRect;
    private _image?;
    protected _imageLoadBreaker: ObserverBreaker;
    constructor(config: Partial<ConfigWithOptionalStyle<ThumbnailImgConfig>>);
    protected provideKonvaNode(): default_3.Group;
    onMeasurementsChange(): void;
    loadImage(image: default_3.Image | Observable<default_3.Image>): Observable<default_3.Image>;
    setVisible(visible: boolean): void;
    setPosition(position: Position): void;
    setVisibleAndX(visible: boolean, x: number): void;
    getPosition(): Position;
    getDimension(): Dimension;
    getRect(): RectMeasurement;
    compareTo(o: ThumbnailImg): number;
    get image(): default_3.Image | undefined;
    get onEvent$(): Observable<ThumbnailImgEvent>;
    get state(): ThumbnailImgState;
    destroy(): void;
}

declare interface ThumbnailImgConfig extends ComponentConfig<ThumbnailImgStyle> {
    listening: boolean;
}

declare type ThumbnailImgEvent = {
    [K in ThumbnailImgEventType]: {
        type: K;
        data: ThumbnailImgEventTypeDataMap[K];
    };
}[keyof ThumbnailImgEventTypeDataMap];

declare interface ThumbnailImgEventData {
    state: ThumbnailImgState;
}

declare enum ThumbnailImgEventType {
    TIMELINE_THUMBNAIL_IMAGE_LOADING = "TIMELINE_THUMBNAIL_IMAGE_LOADING",
    TIMELINE_THUMBNAIL_IMAGE_LOADED = "TIMELINE_THUMBNAIL_IMAGE_LOADED",
    TIMELINE_THUMBNAIL_CLICK = "TIMELINE_THUMBNAIL_CLICK",
    TIMELINE_THUMBNAIL_MOUSE_ENTER = "TIMELINE_THUMBNAIL_MOUSE_ENTER",
    TIMELINE_THUMBNAIL_MOUSE_LEAVE = "TIMELINE_THUMBNAIL_MOUSE_LEAVE",
    TIMELINE_THUMBNAIL_MOUSE_MOVE = "TIMELINE_THUMBNAIL_MOUSE_MOVE"
}

declare type ThumbnailImgEventTypeDataMap = {
    [ThumbnailImgEventType.TIMELINE_THUMBNAIL_IMAGE_LOADING]: ThumbnailImgEventData;
    [ThumbnailImgEventType.TIMELINE_THUMBNAIL_IMAGE_LOADED]: ThumbnailImgEventData;
    [ThumbnailImgEventType.TIMELINE_THUMBNAIL_CLICK]: ThumbnailImgEventData;
    [ThumbnailImgEventType.TIMELINE_THUMBNAIL_MOUSE_ENTER]: ThumbnailImgEventData;
    [ThumbnailImgEventType.TIMELINE_THUMBNAIL_MOUSE_LEAVE]: ThumbnailImgEventData;
    [ThumbnailImgEventType.TIMELINE_THUMBNAIL_MOUSE_MOVE]: ThumbnailImgEventData;
};

declare interface ThumbnailImgState {
}

declare interface ThumbnailImgStyle {
    x: number;
    y: number;
    width: number;
    height: number;
    stroke: string;
    strokeWidth: number;
    visible: boolean;
}

/**
 * Serializable snapshot of a {@link Thumbnail}.
 */
export declare interface ThumbnailState extends TimedItemState {
    label?: string | undefined;
    /** URL of the thumbnail image. */
    url: string;
}

export declare class ThumbnailTrack extends BaseTimedItemsTrack<Thumbnail, BaseThumbnail, ThumbnailTrackState, ThumbnailTrackEvent> {
    protected _trackType: TrackType;
    constructor(args?: ThumbnailTrackArgs);
    protected getState(): ThumbnailTrackState;
    updateAttrs(attrs: ThumbnailTrackUpdateableAttrs): void;
    addTimedItems(timedItems: BaseThumbnail | BaseThumbnail[]): void;
    addTimedItems(timedItems: ThumbnailArgs | ThumbnailArgs[]): void;
}

/**
 * Construction arguments for thumbnail track instances.
 */
export declare interface ThumbnailTrackArgs extends BaseTrackArgs {
    /** URL of the thumbnail data source. Overridden by `source` when a {@link UrlSource} is provided. */
    url?: string | undefined;
}

export declare class ThumbnailTrackDownsampler extends TimedItemsTrackDownsampler<ThumbnailTrack> {
    constructor(sourceTrack: ThumbnailTrack, options: DownsampleOptions);
    protected createDownsampledTrack(): ThumbnailTrack;
    protected resolveDownsampledTimedItem(_index: number, start: number, end: number, timedItems: TrackTimedItem<ThumbnailTrack>[]): TrackTimedItem<ThumbnailTrack>;
}

/**
 * Discriminated union of all events emitted by a thumbnail track.
 */
export declare type ThumbnailTrackEvent = OmpEventGroup<ThumbnailTrackEventType, ThumbnailTrackEventTypeDataMap>;

/**
 * Event types specific to thumbnail operations within a {@link ThumbnailTrack}.
 */
export declare enum ThumbnailTrackEventType {
    THUMBNAIL_SPECIFIC_EVENT_PLACEHOLDER = "THUMBNAIL_SPECIFIC_EVENT_PLACEHOLDER"
}

/**
 * Maps each thumbnail track event type to its corresponding data payload.
 */
export declare type ThumbnailTrackEventTypeDataMap = {
    [ThumbnailTrackEventType.THUMBNAIL_SPECIFIC_EVENT_PLACEHOLDER]: ThumbnailEventData;
};

declare class ThumbnailTrackImg extends ThumbnailImg {
    private _thumbnail;
    constructor(config: Partial<ConfigWithOptionalStyle<ThumbnailImgConfig>>, thumbnail: Thumbnail);
    get state(): ThumbnailTrackImgState;
    get thumbnail(): Thumbnail;
    compareTo(o: ThumbnailTrackImg): number;
    destroy(): void;
}

declare interface ThumbnailTrackImgState {
    thumbnail: ThumbnailState;
}

export declare class ThumbnailTrackLane extends BaseTrackLane<ThumbnailTrackLaneConfig, ThumbnailTrackLaneStyle, ThumbnailTrack> {
    private readonly _onEvent$;
    protected _firstItemAvailable: BehaviorSubject<boolean>;
    protected _placeholderImageUrl?: string;
    protected _placeholderKonvaImage?: default_3.Image;
    protected _currentThumbnailWrapper: ThumbnailWrapper | undefined;
    protected _thumbnailHoverWrapper: ThumbnailHoverWrapper_2;
    protected _timecodedEventCatcher?: default_3.Rect;
    protected _thumbnailsGroup?: default_3.Group;
    protected _thumbnailDimension?: Dimension;
    protected readonly _visibleTimedItems: Set<TimedItem['id']>;
    protected readonly _thumbnailWrappers: Map<Thumbnail['id'], ThumbnailWrapper>;
    protected _handleTimelineZoom: Subject<void>;
    protected _handleTimelineScroll: Subject<void>;
    protected _eventsBreaker: ObserverBreaker;
    constructor(configAndStyle?: ConfigAndStyle<ThumbnailTrackLaneConfig, ThumbnailTrackLaneStyle>);
    protected createStyledElement(): StyledElementWithId<ThumbnailTrackLaneStyle>;
    private refreshFirstItemAvailable;
    setTrack(track: ThumbnailTrack): void;
    clearContent(): void;
    render(): void;
    protected handleTimelineZoom(): void;
    protected handleTimelineScroll(): void;
    protected hasVisualElements(): boolean;
    protected settleLayout(): void;
    onMeasurementsChange(): void;
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    private resolveThumbnailDimension;
    private updateVisibleTimedItems;
    private createMissingThumbnails;
    private addThumbnailWrapper;
    private adjustThumbnails;
    private handleTrackUpdated;
    private handleTimedItemsUpdated;
    private handleTimedItemsDeleted;
    private showThumbnailHover;
    private hideThumbnailHover;
    get onEvent$(): Observable<ThumbnailTrackLaneEvent>;
    destroy(): void;
}

export declare interface ThumbnailTrackLaneConfig extends TrackLaneConfig {
}

export declare type ThumbnailTrackLaneEvent = {
    [K in ThumbnailTrackLaneEventType]: {
        type: K;
        data: ThumbnailTrackLaneEventTypeDataMap[K];
    };
}[keyof ThumbnailTrackLaneEventTypeDataMap];

export declare interface ThumbnailTrackLaneEventData {
    thumbnailTrackImg: ThumbnailTrackImgState;
}

export declare enum ThumbnailTrackLaneEventType {
    TIMELINE_THUMBNAIL_TRACK_LANE_THUMBNAIL_CLICK = "TIMELINE_THUMBNAIL_TRACK_LANE_THUMBNAIL_CLICK",
    TIMELINE_THUMBNAIL_TRACK_LANE_THUMBNAIL_MOUSE_ENTER = "TIMELINE_THUMBNAIL_TRACK_LANE_THUMBNAIL_MOUSE_ENTER",
    TIMELINE_THUMBNAIL_TRACK_LANE_THUMBNAIL_MOUSE_LEAVE = "TIMELINE_THUMBNAIL_TRACK_LANE_THUMBNAIL_MOUSE_LEAVE"
}

declare type ThumbnailTrackLaneEventTypeDataMap = {
    [ThumbnailTrackLaneEventType.TIMELINE_THUMBNAIL_TRACK_LANE_THUMBNAIL_CLICK]: ThumbnailTrackLaneEventData;
    [ThumbnailTrackLaneEventType.TIMELINE_THUMBNAIL_TRACK_LANE_THUMBNAIL_MOUSE_ENTER]: ThumbnailTrackLaneEventData;
    [ThumbnailTrackLaneEventType.TIMELINE_THUMBNAIL_TRACK_LANE_THUMBNAIL_MOUSE_LEAVE]: ThumbnailTrackLaneEventData;
};

export declare interface ThumbnailTrackLaneStyle extends TimelineLaneStyle {
    thumbnailHeight: Size;
    thumbnailStroke: Color;
    thumbnailStrokeWidth: Size;
    thumbnailHoverScale: Size;
    thumbnailHoverStroke: Color;
    thumbnailHoverStrokeWidth: Size;
}

/** Load options for thumbnail tracks. */
export declare interface ThumbnailTrackLoadOptions extends BaseTrackLoadOptions {
    args?: ThumbnailTrackArgs;
}

declare interface ThumbnailTrackMessageChannel extends TrackMessageChannel {
    findNearestThumbnail(time: number): Observable<ThumbnailState | undefined>;
}

declare class ThumbnailTrackProxy extends BaseMessageChannelProxy<ThumbnailTrackMessageChannel> implements ThumbnailTrackMessageChannel {
    constructor(messageChannel: MessageChannel_2<ThumbnailTrackMessageChannel>);
    get onEvent$(): Observable<TrackEvent_2>;
    loadStart(): Observable<boolean>;
    loadSuccess(): Observable<boolean>;
    loadError(error: string | undefined): Observable<boolean>;
    updateAttrs(attrs: TrackUpdateableAttrs): Observable<TrackState>;
    findNearestThumbnail(time: number): Observable<ThumbnailState | undefined>;
}

/**
 * Serializable snapshot of a thumbnail {@link Track}.
 */
export declare interface ThumbnailTrackState extends TimedItemsTrackState<ThumbnailState> {
}

/**
 * Subset of thumbnail track fields that can be updated at runtime.
 */
export declare type ThumbnailTrackUpdateableAttrs = TrackUpdateableAttrs;

export declare class ThumbnailTrackVttFetcher extends VttTimedItemsFetcher<ThumbnailTrack> {
    map(index: number, cue: ParsedVttCue): TimedItemOf<ThumbnailTrack>;
    fetchTimedItems(): Observable<void>;
}

/**
 * Fields that can be updated on any {@link Thumbnail} at runtime.
 */
export declare interface ThumbnailUpdateableAttrs extends TimedItemUpdateableAttrs {
    label?: string | undefined;
    url?: string;
}

declare class ThumbnailWrapper implements Destroyable {
    private _thumbnail;
    private _thumbnailTrackImg;
    private _placeholderImg;
    private _placeholderAnimation;
    private _style;
    constructor(thumbnail: Thumbnail, x: number, placeholderUrl: string, style: ThumbnailTrackLaneStyle);
    private _stopPlaceholderAnimation;
    private loadThumbnailImage;
    updateThumbnail(thumbnail: Thumbnail): void;
    updateVisible(visible: boolean): void;
    updateVisibleAndX(visible: boolean, x: number): void;
    get thumbnailTrackImg(): ThumbnailTrackImg;
    get placeholderImg(): ThumbnailImg;
    get thumbnail(): Thumbnail;
    destroy(): void;
}

declare interface TimecodeModel extends Serializable {
    hours: number;
    minutes: number;
    seconds: number;
    frames: number;
    valueText: string;
    frameRateModel: FrameRateModel;
    hasVideo: boolean;
    hasAudio: boolean;
}

export declare interface TimedItem<S extends TimedItemState = TimedItemState> {
    /** Unique identifier (UUID). */
    id: string;
    temporal: TimedItemTemporal;
    /** Arbitrary data. */
    data: Record<string, any>;
    state: S;
}

export declare interface TimedItemArgs {
    temporal: TimedItemTemporal;
    data?: Record<string, any> | undefined;
}

export declare type TimedItemHooks = {
    beforeCreate?: (timedItem: TimedItem) => void | undefined;
    afterCreate?: (timedItem: TimedItem) => void | undefined;
};

declare type TimedItemOf<T> = T extends TimedItemsTrack<infer I, any> ? I : never;

export declare class TimedItemsDownsamplerFactory {
    static create(track: TimedItemsTrack, options: DownsampleOptions): TimedItemsTrackDownsampler<TimedItemsTrack>;
}

export declare interface TimedItemsFetcher {
    fetchTimedItems(): Observable<void>;
}

export declare class TimedItemsFetcherFactory {
    static createTimedItemsFetcher(track: Track, loadOptions: TrackLoadOptions | undefined): TimedItemsFetcher;
    private static createTextTrackFetcher;
    private static createThumbnailTrackFetcher;
    private static createMarkerTrackFetcher;
    private static createObservationTrackFetcher;
}

export declare abstract class TimedItemsInterpolator<T extends TimedItemsTrack> implements Destroyable {
    protected readonly _sourceTrack: T;
    protected readonly _interpolatedTrack: T;
    protected readonly _options: InterpolationOptions;
    private readonly _periodDuration;
    private readonly _periodBoundary;
    private readonly _bucketToItemId;
    private readonly _sourceItemToBucket;
    private _pendingBuckets;
    private readonly _subscription;
    protected constructor(sourceTrack: T, options: InterpolationOptions);
    protected abstract createInterpolatedTrack(): T;
    protected abstract resolveInterpolatedTimedItem(index: number, start: number, end: number, items: TrackTimedItem<T>[]): TrackTimedItem<T>;
    get interpolatedTrack(): T;
    destroy(): void;
    private isInRange;
    private bucketIndex;
    private bucketBounds;
    private initialInterpolate;
    private collectAffectedBuckets;
    private recomputeBuckets;
    get sourceTrack(): T;
}

export declare class TimedItemsInterpolatorFactory {
    static create(track: TimedItemsTrack, options: InterpolationOptions): TimedItemsInterpolator<TimedItemsTrack>;
}

export declare interface TimedItemState extends Serializable {
    id: string;
    data: Record<string, any>;
    temporal: TimedItemTemporal;
}

export declare interface TimedItemsTrack<T extends TimedItem = TimedItem, S extends TimedItemsTrackState = TimedItemsTrackState, U extends TimedItemUpdateableAttrs = TimedItemUpdateableAttrs, E extends OmpEventGroup<any, any> = any> extends Track<S, E | TimedItemsTrackEvent> {
    timedItems: T[];
    /**
     * Returns the timed items sorted by their start time.
     */
    timedItemsSorted: T[];
    areTimedItemsLocked: boolean;
    areTimedItemsFetched: boolean;
    getTimedItem(id: T['id']): T | undefined;
    addTimedItems(timedItems: T | T[]): void;
    deleteTimedItems(id: T['id'] | T['id'][]): void;
    updateTimedItem(id: T['id'], attrs: U): void;
    findTimedItemsAtTime(time: number): T[];
    findFirstTimedItemAtTime(time: number): T | undefined;
    findTimedItemsInRange(start: number, end: number): T[];
    findNearestTimedItem(time: number): T | undefined;
}

export declare interface TimedItemsTrackArgs extends BaseTrackArgs {
    timedItemsLocked?: boolean | undefined;
    timedItemHooks?: TimedItemHooks | undefined;
}

export declare abstract class TimedItemsTrackDownsampler<T extends TimedItemsTrack> implements Destroyable {
    protected readonly _sourceTrack: T;
    protected readonly _downsampledTrack: T;
    protected readonly _options: DownsampleOptions;
    private readonly _isPassthrough;
    private readonly _samplePeriodDuration;
    private readonly _periodBoundary;
    private readonly _bucketToItemId;
    private readonly _sourceItemToBucket;
    private _pendingBuckets;
    private readonly _subscription;
    protected constructor(sourceTrack: T, options: DownsampleOptions);
    protected abstract createDownsampledTrack(): T;
    protected abstract resolveDownsampledTimedItem(index: number, start: number, end: number, items: TrackTimedItem<T>[]): TrackTimedItem<T>;
    get downsampledTrack(): T;
    get sourceTrack(): T;
    destroy(): void;
    private bucketIndex;
    private bucketBounds;
    private initialDownsample;
    private collectAffectedBuckets;
    private recomputeBuckets;
    private applyPassthrough;
}

export declare type TimedItemsTrackEvent = OmpEventGroup<TimedItemsTrackEventType, TimedItemsTrackEventTypeDataMap>;

export declare interface TimedItemsTrackEventData {
    trackId: TimedItemsTrack['id'];
    updatedTimedItems: TimedItemState[];
}

export declare class TimedItemsTrackEventEmitter {
    private _track;
    private _activeItems;
    private _ineligibleItems;
    private _threshold?;
    private _thresholdType;
    private readonly _onEvent$;
    private _destroyBreaker;
    readonly onEvent$: Observable<TimedItemsTrackItemEvent>;
    constructor(track: TimedItemsTrack, timeProvider$: Observable<number>, threshold?: number | undefined, thresholdType?: TimedItemsTrackEventEmitterThresholdType | undefined);
    private _findItemsIntersectingRange;
    private _isTimedItemExited;
    private _getExitInfo;
    private _getEntryInfo;
    private _isTimedItemEntered;
    private _isTimedItemEnteredExactly;
    private _isExactEntered;
    private _isNearEntered;
    private _checkItemEligibility;
    private _createThresholdRange;
    private _moveNearEnteredToExactEntered;
    resetEnteredItems(ids?: TimedItem['id'][]): void;
    destroy(): void;
}

declare enum TimedItemsTrackEventEmitterThresholdType {
    MINIMUM = "MINIMUM",
    START = "START",
    END = "END",
    START_AND_END = "START_AND_END"
}

export declare enum TimedItemsTrackEventType {
    TIMED_ITEMS_TRACK_ITEMS_ADDED = "TIMED_ITEMS_TRACK_ITEMS_ADDED",
    TIMED_ITEMS_TRACK_ITEMS_DELETED = "TIMED_ITEMS_TRACK_ITEMS_DELETED",
    TIMED_ITEMS_TRACK_ITEMS_UPDATING = "TIMED_ITEMS_TRACK_ITEMS_UPDATING",
    TIMED_ITEMS_TRACK_ITEMS_UPDATED = "TIMED_ITEMS_TRACK_ITEMS_UPDATED"
}

export declare type TimedItemsTrackEventTypeDataMap = {
    [TimedItemsTrackEventType.TIMED_ITEMS_TRACK_ITEMS_ADDED]: TimedItemsTrackEventData;
    [TimedItemsTrackEventType.TIMED_ITEMS_TRACK_ITEMS_DELETED]: TimedItemsTrackEventData;
    [TimedItemsTrackEventType.TIMED_ITEMS_TRACK_ITEMS_UPDATING]: TimedItemsTrackEventData;
    [TimedItemsTrackEventType.TIMED_ITEMS_TRACK_ITEMS_UPDATED]: TimedItemsTrackEventData;
};

export declare interface TimedItemsTrackItemEntryEventData {
    nearItems: TimedItem[];
    exactItems: TimedItem[];
    time: number;
}

export declare type TimedItemsTrackItemEvent = {
    [K in TimedItemsTrackItemEventType]: {
        type: K;
        data: TimedItemsTrackItemEventTypeDataMap[K];
    };
}[keyof TimedItemsTrackItemEventTypeDataMap];

export declare enum TimedItemsTrackItemEventType {
    TIMED_ITEMS_TRACK_ITEM_ENTRY = "TIMED_ITEMS_TRACK_ITEM_ENTRY",
    TIMED_ITEMS_TRACK_ITEM_EXIT = "TIMED_ITEMS_TRACK_ITEM_EXIT"
}

declare type TimedItemsTrackItemEventTypeDataMap = {
    [TimedItemsTrackItemEventType.TIMED_ITEMS_TRACK_ITEM_ENTRY]: TimedItemsTrackItemEntryEventData;
    [TimedItemsTrackItemEventType.TIMED_ITEMS_TRACK_ITEM_EXIT]: TimedItemsTrackItemExitEventData;
};

export declare interface TimedItemsTrackItemExitEventData {
    items: TimedItem[];
    time: number;
}

export declare interface TimedItemsTrackLoadOptions extends BaseTrackLoadOptions {
}

export declare interface TimedItemsTrackState<T extends TimedItemState = TimedItemState> extends TrackState {
    timedItems: T[];
    timedItemsLocked: boolean;
}

export declare type TimedItemTemporal = MomentTemporal | SpanStartTemporal | SpanEndTemporal | SpanTemporal;

export declare enum TimedItemTemporalType {
    MOMENT = "MOMENT",
    SPAN = "SPAN",
    SPAN_START = "SPAN_START",
    SPAN_END = "SPAN_END"
}

export declare class TimedItemTemporalUtil {
    static extractDuration(temporal: TimedItemTemporal): number | undefined;
    static touchesTimeRange(temporal: TimedItemTemporal, start: number, end: number): boolean;
    static extractStartTime(temporal: TimedItemTemporal): number | undefined;
    static extractEndTime(temporal: TimedItemTemporal): number | undefined;
    static compareByStartTime(a: TimedItemTemporal, b: TimedItemTemporal): number;
    static validate(temporal: TimedItemTemporal): void;
    private static validateFiniteTime;
    private static validateMoment;
    private static validateSpan;
    private static validateSpanStart;
    private static validateSpanEnd;
}

export declare interface TimedItemUpdateableAttrs {
    data?: Record<string, any> | undefined;
    temporal?: TimedItemTemporal | undefined;
}

export declare const TIMELINE_LANE_STYLE_DEFAULT: TimelineLaneStyle;

export declare const TIMELINE_STYLE_DEFAULT: TimelineStyle;

export declare interface TimelineApi extends Destroyable {
    /**
     * Stream of all events emitted by this timeline instance, including lifecycle events
     * ({@link TimelineEventType.TIMELINE_READY}), viewport changes ({@link TimelineEventType.TIMELINE_SCROLL},
     * {@link TimelineEventType.TIMELINE_ZOOM}, {@link TimelineEventType.TIMELINE_RESIZE}),
     * and interaction events ({@link TimelineEventType.TIMELINE_TIMECODE_CLICK},
     * {@link TimelineEventType.TIMELINE_SCRUBBER_MOVE}, {@link TimelineEventType.TIMELINE_PLAYHEAD_MOVE}).
     */
    onEvent$: Observable<TimelineEvent>;
    /**
     * Unique identifier for this timeline instance.
     */
    id: string;
    /**
     * Current style configuration of the timeline.
     * Reflects the active visual settings such as dimensions, colours, and playhead appearance.
     * @see {@link TimelineStyle}
     */
    style: TimelineStyle;
    /**
     * Current runtime state of the timeline.
     * @see {@link TimelineState}
     */
    state: TimelineState;
    /**
     * @returns true if visible, false if not visible
     */
    descriptionPaneVisible: boolean;
    /**
     * Timeline zoom
     * @param percent number between 100 and TimelineConfig.zoomMax
     */
    zoomTo(percent: number): number;
    /**
     * Timeline zoom
     * @param percent number between 100 and {@link TimelineConfig.zoomMax}
     * @param zoomFocusPercent in range from 0 - timeline start or first timestamp, to 100 - timeline end or last timestamop
     */
    zoomTo(percent: number, zoomFocusPercent: number | undefined): number;
    /**
     * Timeline zoom
     * @param percent number between 100 and {@link TimelineConfig.zoomMax}
     */
    zoomToEased(percent: number): Observable<number>;
    /**
     * Timeline zoom
     * @param percent number between 100 and {@link TimelineConfig.zoomMax}
     * @param zoomFocusPercent in range from 0 - timeline start or first timestamp, to 100 - timeline end or last timestamop
     */
    zoomToEased(percent: number, zoomFocusPercent: number | undefined): Observable<number>;
    /**
     * Zoom in. Zoom scale in single method call is defined with TimelineConfig.zoomScale
     */
    zoomInEased(): Observable<number>;
    /**
     * Zoom out. Zoom scale in single method call is defined with {@link TimelineConfig.zoomScale}
     */
    zoomOutEased(): Observable<number>;
    /**
     * Zoom to max resolution
     */
    zoomToMaxEased(): Observable<number>;
    /**
     * @returns current zoom perent
     */
    getZoomPercent(): number;
    /**
     * Scrolls timeline
     * @param percent in range from 0 - timeline start or first timestamp, to 100 - timeline end or last timestamop
     */
    scrollToEased(percent: number): Observable<number>;
    /**
     * Scrolls timeline to playhead position
     */
    scrollToPlayheadEased(): Observable<number>;
    /**
     * Adds {@link TimelineLaneApi} instance to timeline
     * @param timelineLane
     */
    addTimelineLane(timelineLane: TimelineLaneApi): TimelineLaneApi;
    /**
     * Adds {@link TimelineLaneApi} instance to timeline
     * @param timelineLane
     * @param index
     */
    addTimelineLaneAtIndex(timelineLane: TimelineLaneApi, index: number): TimelineLaneApi;
    /**
     * Removes {@link TimelineLaneApi} instance by id
     * @param id {@link TimelineLaneApi.id}
     */
    removeTimelineLane(id: string): void;
    /**
     * Removes {@link TimelineLaneApi} instances by ids
     * @param ids {@link TimelineLaneApi.id}s
     */
    removeTimelineLanes(ids: string[]): void;
    /**
     * Removes all timeline lanes
     */
    removeAllTimelineLanes(): void;
    /**
     * Adds multiple instantiated {@link TimelineLaneApi} instances to timeline
     * @param timelineLanes
     */
    addTimelineLanes(timelineLanes: TimelineLaneApi[]): TimelineLaneApi[];
    /**
     * @returns all {@link TimelineLaneApi} instances
     */
    getTimelineLanes(): TimelineLaneApi[];
    /**
     * @returns single {@link TimelineLaneApi} instance
     * @param id {@link TimelineLaneApi.id}
     */
    getTimelineLane<T extends TimelineLaneApi>(id: string): T | undefined;
    /**
     * @returns ScrubberLane instance
     */
    getScrubberLane(): ScrubberLane;
    /**
     * Shows or hides Timeline description pane
     */
    setDescriptionPaneVisible(visible: boolean): void;
    /**
     * Toggles Timeline description pane
     */
    toggleDescriptionPaneVisible(): void;
    /**
     * Shows or hides Timeline description pane
     */
    setDescriptionPaneVisibleEased(visible: boolean): Observable<void>;
    /**
     * Toggles Timeline description pane
     */
    toggleDescriptionPaneVisibleEased(): Observable<void>;
    /**
     * Toggles the CTI between its interactive and read-only state
     */
    toggleTimecodeEdit(): void;
    setThumbnailTrack(track: ThumbnailTrack): void;
    /**
     * Minimize timeline lanes
     * @param timelineLanes
     */
    minimizeTimelineLanes(timelineLanes: TimelineLaneApi[]): void;
    /**
     * Maximize timeline lanes
     * @param timelineLanes
     */
    maximizeTimelineLanes(timelineLanes: TimelineLaneApi[]): void;
    /**
     * Recalculates and settles layout, called on window resize event
     */
    settleLayout(): void;
    /**
     * Destroys Timeline and it's dependencies
     */
    destroy(): void;
}

export declare interface TimelineCancelableEvent extends Serializable {
    cancelableEvent: {
        cancelBubble: boolean;
    };
}

export declare interface TimelineConfig {
    htmlElementId: string;
    scrubberSnapArea: number;
    playheadDragScrollMaxSpeedAfterPx: number;
    zoomWheelEnabled: boolean;
    zoomScale: number;
    zoomScaleWheel: number;
    zoomBaseline: number;
    zoomMax: number;
    layoutEasingDuration: number;
    zoomEasingDuration: number;
    scrollEasingDuration: number;
    scrubberClickSeek: boolean;
    timecodeClickEdit: boolean;
}

export declare type TimelineEvent = {
    [K in TimelineEventType]: {
        type: K;
        data: TimelineEventTypeDataMap[K];
    };
}[keyof TimelineEventTypeDataMap];

export declare interface TimelineEventData extends Serializable {
    timeline: TimelineState;
}

export declare enum TimelineEventType {
    TIMELINE_READY = "TIMELINE_READY",
    TIMELINE_STYLE_CHANGE = "TIMELINE_STYLE_CHANGE",
    TIMELINE_SCROLL = "TIMELINE_SCROLL",
    TIMELINE_ZOOM = "TIMELINE_ZOOM",
    TIMELINE_RESIZE = "TIMELINE_RESIZE",
    TIMELINE_TIMECODE_CLICK = "TIMELINE_TIMECODE_CLICK",
    TIMELINE_TIMECODE_MOUSE_MOVE = "TIMELINE_TIMECODE_MOUSE_MOVE",
    TIMELINE_SCRUBBER_MOVE = "TIMELINE_SCRUBBER_MOVE",
    TIMELINE_PLAYHEAD_MOVE = "TIMELINE_PLAYHEAD_MOVE"
}

export declare type TimelineEventTypeDataMap = {
    [TimelineEventType.TIMELINE_READY]: TimelineEventData;
    [TimelineEventType.TIMELINE_STYLE_CHANGE]: TimelineStyleChangeEventData;
    [TimelineEventType.TIMELINE_SCROLL]: TimelineScrollEventData;
    [TimelineEventType.TIMELINE_ZOOM]: TimelineZoomEventData;
    [TimelineEventType.TIMELINE_RESIZE]: TimelineResizeEventData;
    [TimelineEventType.TIMELINE_TIMECODE_CLICK]: TimelineTimecodeClickEventData;
    [TimelineEventType.TIMELINE_TIMECODE_MOUSE_MOVE]: TimelineTimecodeMouseMoveEventData;
    [TimelineEventType.TIMELINE_SCRUBBER_MOVE]: TimelineScrubberMoveEventData;
    [TimelineEventType.TIMELINE_PLAYHEAD_MOVE]: TimelinePlayheadMoveEventData;
};

export declare class TimelineImpl implements TimelineApi, Destroyable {
    protected _ui: Ui;
    private _ompProvider;
    protected readonly _onEvent$: Subject<TimelineEvent>;
    private readonly _id;
    private readonly _config;
    private readonly _styledElement;
    private readonly _style;
    private readonly _ready;
    private readonly _player;
    protected _dragBreaker: ObserverBreaker;
    protected _dragConditions?: DragConditions;
    private _rootElement;
    private _canvasElement;
    private _timelineOverlayElement;
    private _timecodeElement;
    private _timecodeEdit;
    private _timelineLanes;
    private _timelineLanesMap;
    private _konvaStage;
    private _mainLayer;
    private _timecodedContainer;
    private _timecodedFloatingGroup;
    private _timecodedFloatingBg;
    private _timecodedFloatingEventCatcher;
    private _timecodedFloatingContentGroups;
    private _surfaceLayer;
    private _surfaceLayer_timecodedContainer;
    private _surfaceLayer_timecodedFloatingGroup;
    private _surfaceLayer_timecodedFloatingContentGroups;
    private _layoutBg;
    private _headerBg;
    private _footerBg;
    private _layoutFlexGroup;
    private _headerFlexGroup;
    private _mainFlexGroup;
    private _mainLeftFlexGroup;
    private _mainRightFlexGroup;
    private _timelineLaneStaticFlexGroup;
    private _timecodedWrapperFlexGroup;
    private _timecodedContainerFlexGroup;
    private _timecodedContainerStaticFlexGroup;
    private _footerFlexGroup;
    private _scrubber;
    private _playhead;
    private _scrubberLane;
    private _scrollWithPlayhead;
    private _syncTimelineWithPlayheadInProgress;
    private _descriptionPaneVisible;
    private readonly _mediaBreaker;
    private readonly _destroyBreaker;
    constructor(player: PlayerApi, ompProvider: OmpProvider, configAndStyle?: ConfigAndStyle<TimelineConfig, TimelineStyle>);
    private createDom;
    private createCanvas;
    private resolveStageDimension;
    private handleTimecodeClick;
    private hideScrubber;
    private settleDom;
    settleLayout(): void;
    private settleTimecodedGroups;
    private layersSync;
    private onWindowResize;
    private emitScrollEvent;
    private emitZoomEvent;
    getHorizontalScrollPercent(): number;
    scrollHorizontallyToPercent(percent: number): void;
    getScrollHandleHorizontals(scrollbarWidth: number): Horizontals;
    scrollToEased(percent: number): Observable<number>;
    scrollToPlayheadEased(): Observable<number>;
    private scrollToPercent;
    private scrollToPercentEased;
    private scrollToPositionEased;
    private isPlayheadInTimecodedView;
    private refreshScrollWithPlayhead;
    /**
     * Scrolls timecoded group so that playhead is at left most position
     * @private
     */
    private syncTimelineWithPlayhead;
    scrollTimeline(x: number): void;
    private calculateTimelineXFromScrollPercent;
    getZoomPercent(): number;
    zoomTo(percent: number, zoomFocusPercent?: number | undefined): number;
    zoomToEased(percent: number, zoomFocusPercent?: number | undefined): Observable<number>;
    private resolveTimecodedFloatingPosition;
    zoomInEased(): Observable<number>;
    zoomOutEased(): Observable<number>;
    zoomToMaxEased(): Observable<number>;
    private zoomByStep;
    private zoomByPercent;
    private zoomByWidth;
    private settleTimecodedFloating;
    private zoomByStepEased;
    private zoomByPercentEased;
    private zoomByWidthEased;
    private resolveTimelineContainerZoomFocusPosition;
    private calculateTimecodedWidthFromZoomRatioPercent;
    private getConstrainedTimecodedWidth;
    private getConstrainedZoomPercent;
    private getConstrainedScrollPercent;
    private scrubberMove;
    private onMainMediaLoaded;
    private doPlaybackProgress;
    addTimelineLane(timelineLane: TimelineLaneApi): TimelineLaneApi;
    private _addTimelineLane;
    addTimelineLaneAtIndex(timelineLane: TimelineLaneApi, index: number): TimelineLaneApi;
    private _addTimelineLaneAtIndex;
    removeTimelineLane(id: string): void;
    removeTimelineLanes(ids: string[]): void;
    removeAllTimelineLanes(): void;
    private _removeTimelineLane;
    addTimelineLanes(timelineLanes: TimelineLaneApi[]): TimelineLaneApi[];
    getTimelineLanes(): TimelineLaneApi[];
    getTimelineLane<T extends TimelineLaneApi>(id: string): T | undefined;
    getScrubberLane(): ScrubberLane;
    addToTimecodedFloatingContent(node: default_3.Group | default_3.Shape, zIndex?: number): void;
    addToTimecodedStaticContent(node: default_3.Group | default_3.Shape, zIndex?: number): void;
    addToSurfaceLayerTimecodedFloatingContent(node: default_3.Group | default_3.Shape, zIndex?: number): void;
    addToFooterFlexGroup(flexNode: FlexNode<any>): void;
    constrainTimelinePosition(x: number): number;
    timelinePositionToTime(xOnTimeline: number): number;
    timelineContainerPositionToTime(xOnTimeline: number): number;
    timelinePositionToTimecode(x: number): string;
    timeToTimelinePosition(time: number | string): number;
    private convertTimeToTimelinePosition;
    private convertPositionOnTimelineToTime;
    private constrainTimecodedFloatingPosition;
    getTimecodedContainerDimension(): Dimension;
    getTimecodedFloatingDimension(): Dimension;
    getTimecodedFloatingPosition(): Position;
    getTimecodedFloatingRelativePointerPosition(): Position | undefined;
    getTimecodedFloatingRect(): RectMeasurement;
    getTimecodedFloatingHorizontals(): Horizontals;
    getVisiblePositionRange(): {
        start: number;
        end: number;
    };
    private isInVisiblePositionRange;
    private isSnappedStart;
    private isSnappedEnd;
    getVisibleTimeRange(): {
        start: number;
        end: number;
    };
    setDescriptionPaneVisible(visible: boolean): void;
    toggleDescriptionPaneVisible(): void;
    setDescriptionPaneVisibleEased(visible: boolean): Observable<void>;
    toggleDescriptionPaneVisibleEased(): Observable<void>;
    protected _minimizeTimelineLane(timelineLane: TimelineLaneApi, refreshLayout?: boolean): void;
    minimizeTimelineLanes(timelineLanes: TimelineLaneApi[]): void;
    protected _maximizeTimelineLane(timelineLane: TimelineLaneApi, refreshLayout?: boolean): void;
    maximizeTimelineLanes(timelineLanes: TimelineLaneApi[]): void;
    private clearContent;
    get config(): TimelineConfig;
    get descriptionPaneVisible(): boolean;
    toggleTimecodeEdit(): void;
    private openTimecodeEdit;
    private refreshTimecode;
    protected _trackRepository: TrackRepository;
    protected _thumbnailTrack?: ThumbnailTrack | undefined;
    protected _thumbnailHoverWrapper: ThumbnailHoverWrapper;
    protected _thumbnailTrackBreaker: ObserverBreaker;
    setThumbnailTrack(track: ThumbnailTrack): void;
    private showThumbnailHover;
    private hideThumbnailHover;
    private getElementOrFail;
    get onEvent$(): Observable<TimelineEvent>;
    get id(): string;
    get timecodedFloatingGroup(): default_3.Group;
    get ready(): boolean;
    get style(): TimelineStyle;
    get state(): TimelineState;
    destroy(): void;
}

/**
 * Timeline lane API
 */
export declare interface TimelineLaneApi<S extends TimelineLaneStyle = TimelineLaneStyle> extends Destroyable, OnMeasurementsChange {
    /**
     * Unique identifier for this lane instance.
     */
    id: string;
    /**
     * Current resolved style for this lane.
     * Reflects style defaults merged with any overrides applied via {@link setStyle}.
     */
    style: TimelineLaneStyle;
    /* Excluded from this release type: mainLeftFlexGroup */
    /* Excluded from this release type: mainRightFlexGroup */
    /**
     * Merges `style` into the lane's current style and triggers a visual refresh.
     * Only the properties present in `style` are changed; omitted properties retain their current values.
     *
     * @param style - Partial style object containing only the properties to update.
     */
    setStyle(style: Partial<S>): void;
    /**
     * Updates mutable lane attributes without removing and re-adding the lane.
     *
     * @param attrs - The attributes to change. Properties that are `undefined` are ignored.
     */
    updateAttrs(attrs: TimelineLaneUpdateableAttrs): void;
    /**
     * Removes all visual content from the lane's timecoded area without destroying the lane itself.
     * Useful for clearing stale data before reloading (e.g. when the main media changes).
     */
    clearContent(): void;
    /**
     * Adds a floating {@link TimelineNode} overlay to this lane — typically an icon button or label
     * anchored to the left or right edge of the lane's timecoded area.
     *
     * @param config - Position, size, margin, and the node instance to add.
     * @returns The created {@link TimelineNode} handle.
     */
    addTimelineNode(config: TimelineLaneComponentConfig): TimelineNode;
    /**
     * Returns `true` when the lane is currently collapsed to zero height.
     */
    isMinimized(): boolean;
    /**
     * Collapses the lane to zero height.
     *
     * Pass `args.easing: true` for an animated transition. When `args` is provided, `args.complete` is set to an
     * `Observable<void>` that completes when the operation finishes (immediately for non-eased, after the animation
     * for eased). Subscribe to `args.complete` after calling this method.
     *
     * @param args - Optional animation and completion options.
     */
    minimize(args?: TimelineLaneMinimizeMaximizeArgs): void;
    /**
     * Expands the lane back to its configured height.
     *
     * Pass `args.easing: true` for an animated transition. When `args` is provided, `args.complete` is set to an
     * `Observable<void>` that completes when the operation finishes (immediately for non-eased, after the animation
     * for eased). Subscribe to `args.complete` after calling this method.
     *
     * @param args - Optional animation and completion options.
     */
    maximize(args?: TimelineLaneMinimizeMaximizeArgs): void;
    /**
     * Collapses the lane if it is expanded, or expands it if it is collapsed.
     *
     * Pass `args.easing: true` for an animated transition. When `args` is provided, `args.complete` is set to an
     * `Observable<void>` that completes when the operation finishes. Subscribe to `args.complete` after calling
     * this method.
     *
     * @param args - Optional animation and completion options.
     */
    toggleMinimizeMaximize(args?: TimelineLaneMinimizeMaximizeArgs): void;
    /**
     * Connects this lane to the timeline engine. Called by the timeline when the lane
     * is added; do not call this directly.
     *
     * @param timeline - The owning {@link TimelineImpl} instance.
     * @param player - The active {@link PlayerApi}.
     * @param ompProvider - The OMP service provider.
     */
    prepareForTimeline(timeline: TimelineImpl, player: PlayerApi, ompProvider: OmpProvider): void;
    /* Excluded from this release type: getTimecodedRect */
}

export declare interface TimelineLaneComponentConfig {
    /**
     * {@link TimelineNode} to add
     */
    timelineNode: TimelineNode;
    /**
     * Justify to start or end
     */
    justify: 'start' | 'end';
    /**
     * Width
     */
    width: number;
    /**
     * Height
     */
    height: number;
    /**
     * Margins: [top, right, bottom, left]
     */
    margin?: number[];
}

/**
 * Base configuration for classes that extend {@link BaseTimelineLane}
 */
export declare interface TimelineLaneConfig {
    minimized: boolean;
    description?: string | undefined;
    /** Show a loading animation while the lane's track(s) are loading. Defaults to `false`. */
    loadingAnimation?: boolean | undefined;
}

export declare type TimelineLaneMinimizeMaximizeArgs = {
    easing?: boolean | undefined;
    duration?: number | undefined;
    complete?: Observable<void>;
};

export declare interface TimelineLaneStyle {
    height: number;
    marginBottom: number;
    backgroundFill: Color;
    backgroundOpacity: Size;
    descriptionTextFill: Color;
    descriptionTextFontSize: Size;
    descriptionTextFontStyle?: string;
    descriptionTextYOffset?: Size;
    leftBackgroundFill?: Color | undefined;
    leftBackgroundOpacity?: Size | undefined;
    rightBackgroundFill?: Color | undefined;
    rightBackgroundOpacity?: Size | undefined;
    loadingAnimationFill?: Color | undefined;
    loadingAnimationSpeed?: Size | undefined;
    loadingAnimationType?: 'pulse' | 'gradient' | undefined;
}

export declare interface TimelineLaneUpdateableAttrs {
    description?: string | undefined;
}

export declare interface TimelineMouseEventData extends TimelineCancelableEvent {
    mouseEvent: MouseEvent;
    pointerPosition: Position;
}

/**
 * Custom component that can be added to Timeline
 */
export declare interface TimelineNode extends KonvaComponent<TimelineNodeConfig<TimelineNodeStyle>, TimelineNodeStyle, default_3.Group>, OnMeasurementsChange {
    onEvent$: Observable<TimelineNodeEvent>;
}

export declare interface TimelineNodeConfig<S extends TimelineNodeStyle> extends ComponentConfig<S> {
    /**
     * If set to true node listens to events
     */
    listening?: boolean | undefined;
}

export declare type TimelineNodeEvent = {
    [K in TimelineNodeEventType]: {
        type: K;
        data: TimelineNodeEventTypeDataMap[K];
    };
}[keyof TimelineNodeEventTypeDataMap];

export declare interface TimelineNodeEventData {
}

export declare enum TimelineNodeEventType {
    TIMELINE_NODE_CLICK = "TIMELINE_NODE_CLICK",
    TIMELINE_NODE_MOUSE_ENTER = "TIMELINE_NODE_MOUSE_ENTER",
    TIMELINE_NODE_MOUSE_LEAVE = "TIMELINE_NODE_MOUSE_LEAVE"
}

export declare type TimelineNodeEventTypeDataMap = {
    [TimelineNodeEventType.TIMELINE_NODE_CLICK]: ClickEvent;
    [TimelineNodeEventType.TIMELINE_NODE_MOUSE_ENTER]: MouseEnterEvent;
    [TimelineNodeEventType.TIMELINE_NODE_MOUSE_LEAVE]: MouseLeaveEvent;
};

export declare interface TimelineNodeStyle {
    backgroundFill?: string;
    backgroundOpacity?: number;
    backgroundBorderRadius?: number | number[];
}

export declare interface TimelinePlayheadMoveEventData extends Serializable {
    timecode: string;
}

export declare interface TimelineResizeEventData extends TimelineEventData {
}

export declare class TimelineScrollbar extends ScrollbarFlexItem {
    private _timeline;
    private _scrollbar;
    private _timelineZoomInProgress;
    protected _destroyBreaker: ObserverBreaker;
    constructor(config: FlexGroupConfig, scrollbar: Scrollbar, timeline: TimelineImpl);
    destroy(): void;
}

export declare interface TimelineScrollEventData {
    scrollPercent: number;
}

export declare interface TimelineScrubberMoveEventData extends Serializable {
    timecode: string;
    snapped: boolean;
}

export declare interface TimelineState {
}

export declare interface TimelineStyle {
    textFontFamily: string;
    textFontStyle: string;
    stageMinWidth: number;
    stageMinHeight: number;
    backgroundFill: string;
    backgroundOpacity: number;
    headerHeight: number;
    headerMarginBottom: number;
    headerBackgroundFill: string;
    headerBackgroundOpacity: number;
    footerHeight: number;
    footerMarginTop: number;
    footerBackgroundFill: string;
    footerBackgroundOpacity: number;
    thumbnailHoverWidth: number;
    thumbnailHoverStroke: string;
    thumbnailHoverStrokeWidth: number;
    thumbnailHoverYOffset: number;
    leftPaneWidth: number;
    rightPaneMarginLeft: number;
    rightPaneMarginRight: number;
    rightPaneClipPadding: number;
    playheadVisible: boolean;
    playheadFill: string;
    playheadLineWidth: number;
    playheadSymbolHeight: number;
    playheadScrubberHeight: number;
    playheadBackgroundFill: string;
    playheadBackgroundOpacity: number;
    playheadTextFill: string;
    playheadTextYOffset: number;
    playheadTextFontSize: number;
    playheadPlayProgressFill: string;
    playheadPlayProgressOpacity: number;
    playheadBufferedFill: string;
    playheadBufferedOpacity: number;
    scrubberVisible: boolean;
    scrubberFill: string;
    scrubberSnappedFill: string;
    scrubberNorthLineWidth: number;
    scrubberNorthLineOpacity: number;
    scrubberSouthLineWidth: number;
    scrubberSouthLineOpacity: number;
    scrubberSymbolHeight: number;
    scrubberTextFill: string;
    scrubberTextYOffset: number;
    scrubberTextFontSize: number;
    scrubberHeight: number;
    scrubberMarginBottom: number;
    loadingAnimationTheme: 'light' | 'dark';
}

export declare interface TimelineStyleChangeEventData {
    style: TimelineStyle;
}

export declare interface TimelineTimecodeClickEventData extends TimelineMouseEventData {
    seconds: number;
    timecode: string;
}

export declare interface TimelineTimecodeMouseMoveEventData extends TimelineMouseEventData {
    timecode: string;
}

export declare interface TimelineZoomEventData extends Serializable {
    zoomPercent: number;
}

export declare enum TimeReference {
    FFOM = "FFOM",
    SELF = "SELF"
}

/**
 * A track associated with a {@link MainMedia} (video, audio, text, markers, thumbnails, etc.).
 *
 * Tracks carry their own source, load lifecycle, and inter-track relations.
 * Extends {@link MediaEntity} with `mediaType` always set to {@link MediaEntityType.TRACK}.
 *
 * @typeParam S - The concrete {@link TrackState} subtype.
 * @typeParam E - The concrete {@link TrackEvent} subtype.
 */
export declare interface Track<S extends TrackState = TrackState, E extends OmpEventGroup<any, any> = OmpEventGroup<any, any>> extends MediaEntity {
    /** Observable stream of track lifecycle events. */
    onEvent$: Observable<E | TrackEvent_2<S>>;
    /** The kind of track (VIDEO, AUDIO, TEXT_TRACK, MARKER_TRACK, etc.). */
    trackType: TrackType;
    /** Serializable state snapshot. */
    state: S;
    /** The data source backing this track, if any. */
    source: Source | undefined;
    /** The resolved file format type of the source. */
    sourceFileFormatType: FileFormatType | undefined;
    /** Directed relations to other {@link MediaEntity} instances (e.g. {@link RelationType.PART_OF}, {@link RelationType.DERIVED_FROM}). */
    relations: Relation[];
    /** Current load lifecycle stage (idle → loading → success / failure). */
    loadStage: OpStage;
    /** Human-readable label for this track. */
    label: string | undefined;
    /** Custom arbitrary attributes for this track */
    customAttrs: Record<string, any> | undefined;
    /** Transition the load stage to "loading" and emit a {@link TrackEventType.TRACK_LOADING} event. */
    loadStart(): void;
    /** Transition the load stage to "success" and emit a {@link TrackEventType.TRACK_LOADED} event. */
    loadSuccess(): void;
    /** Transition the load stage to "failure" and emit a {@link TrackEventType.TRACK_LOAD_ERROR} event. */
    loadError(error: string | undefined): void;
    /** Add an inter-track relation. Duplicates are silently ignored. */
    addRelation(relation: Relation): void;
    /** Check whether this track already has the given relation. */
    hasRelation(relation: Relation): boolean;
    /**
     * Partially update mutable track attributes and emit a
     * {@link TrackEventType.TRACK_UPDATED} event.
     */
    updateAttrs(attrs: TrackUpdateableAttrs): void;
}

declare interface TrackController<E extends TrackControllerEvent = TrackControllerEvent> extends Destroyable {
    onEvent$: Observable<E>;
    loadSource(): Observable<void>;
}

declare interface TrackControllerErrorEventData extends TrackControllerEventData {
    error: string | undefined;
}

declare type TrackControllerEvent = {
    [K in TrackControllerEventType]: {
        type: K;
        data: TrackControllerEventTypeDataMap[K];
    };
}[keyof TrackControllerEventTypeDataMap];

declare interface TrackControllerEventData extends Serializable {
}

declare enum TrackControllerEventType {
    TRACK_CONTROLLER_TRACK_LOADING = "TRACK_CONTROLLER_TRACK_LOADING",
    TRACK_CONTROLLER_TRACK_LOADED = "TRACK_CONTROLLER_TRACK_LOADED",
    TRACK_CONTROLLER_TRACK_LOAD_ERROR = "TRACK_CONTROLLER_TRACK_LOAD_ERROR"
}

declare type TrackControllerEventTypeDataMap = {
    [TrackControllerEventType.TRACK_CONTROLLER_TRACK_LOADING]: TrackControllerEventData;
    [TrackControllerEventType.TRACK_CONTROLLER_TRACK_LOADED]: TrackControllerEventData;
    [TrackControllerEventType.TRACK_CONTROLLER_TRACK_LOAD_ERROR]: TrackControllerErrorEventData;
};

/**
 * Payload carried by the {@link TrackEventType.TRACK_LOAD_ERROR} event.
 */
export declare interface TrackErrorEventData<S extends TrackState = TrackState> extends TrackEventData<S> {
    error: string | undefined;
}

declare type TrackEvent_2<S extends TrackState = TrackState> = OmpEventGroup<TrackEventType, TrackEventTypeDataMap<S>>;
export { TrackEvent_2 as TrackEvent }

/**
 * Payload carried by non-error {@link TrackEvent}s.
 */
export declare interface TrackEventData<S extends TrackState = TrackState> {
    trackState: S;
}

/**
 * Lifecycle event types emitted by a {@link Track} instance.
 */
export declare enum TrackEventType {
    TRACK_LOADING = "TRACK_LOADING",
    TRACK_LOADED = "TRACK_LOADED",
    TRACK_LOAD_ERROR = "TRACK_LOAD_ERROR",
    TRACK_UPDATING = "TRACK_UPDATING",
    TRACK_UPDATED = "TRACK_UPDATED"
}

/**
 * Maps each {@link TrackEventType} to its corresponding event data type.
 */
export declare type TrackEventTypeDataMap<S extends TrackState = TrackState> = {
    [TrackEventType.TRACK_LOADING]: TrackEventData<S>;
    [TrackEventType.TRACK_LOADED]: TrackEventData<S>;
    [TrackEventType.TRACK_LOAD_ERROR]: TrackErrorEventData<S>;
    [TrackEventType.TRACK_UPDATING]: {};
    [TrackEventType.TRACK_UPDATED]: TrackEventData<S>;
};

export declare interface TrackLaneConfig extends TimelineLaneConfig {
}

/**
 * Discriminated union of all track load-options types.
 * The optional `trackType` field narrows the union to the options for a specific track type.
 */
export declare type TrackLoadOptions = {
    [T in keyof TrackLoadOptionsMap]: {
        trackType?: T;
    } & TrackLoadOptionsMap[T];
}[keyof TrackLoadOptionsMap];

/** Maps each {@link TrackType} to its concrete load-options type. */
export declare type TrackLoadOptionsMap = {
    /** Load options for text (subtitle/caption) tracks. */
    [TrackType.TEXT_TRACK]: PlayerTextTrackLoadOptions & TextTrackLoadOptions;
    /** Load options for audio tracks. */
    [TrackType.AUDIO]: PlayerAudioLoadOptions & AudioTrackLoadOptions;
    /** Load options for thumbnail tracks. */
    [TrackType.THUMBNAIL_TRACK]: ThumbnailTrackLoadOptions;
    /** Load options for marker tracks. */
    [TrackType.MARKER_TRACK]: MarkerTrackLoadOptions;
    /** Load options for observation tracks. */
    [TrackType.OBSERVATION_TRACK]: ObservationTrackLoadOptions;
};

declare interface TrackMessageChannel {
    onEvent$: Observable<TrackEvent_2>;
    loadStart(): Observable<boolean>;
    loadSuccess(): Observable<boolean>;
    loadError(error: string | undefined): Observable<boolean>;
    updateAttrs(attrs: TrackUpdateableAttrs): Observable<TrackState>;
}

declare class TrackProxy extends BaseMessageChannelProxy<TrackMessageChannel> implements TrackMessageChannel {
    constructor(messageChannel: MessageChannel_2<TrackMessageChannel>);
    get onEvent$(): Observable<TrackEvent_2>;
    loadStart(): Observable<boolean>;
    loadSuccess(): Observable<boolean>;
    loadError(error: string | undefined): Observable<boolean>;
    updateAttrs(attrs: TrackUpdateableAttrs): Observable<TrackState>;
}

export declare class TrackRepository extends BaseRepository<Track> implements Destroyable {
    protected readonly _onEvent$: Subject<TrackRepositoryEvent>;
    protected readonly _onTrackEvent$: Subject<TrackEvent_2>;
    constructor();
    get onEvent$(): Observable<TrackRepositoryEvent>;
    get onTrackEvent$(): Observable<TrackEvent_2>;
    add(entity: Track): Track;
    addAll(entities: Track[]): Track[];
    _add(mediaEntity: Track): Track;
    delete(id: Track['id']): boolean;
    deleteAll(ids: Track['id'][]): boolean;
    onTrackDeleted$(trackId: Track['id']): Observable<TrackRepositoryEvent<TrackRepositoryEventType.TRACK_DELETED>>;
    destroy(): void;
}

export declare interface TrackRepositoryEvent<T extends TrackRepositoryEventType = TrackRepositoryEventType> extends Serializable {
    type: T;
    data: TrackRepositoryEventTypeDataMap[T];
}

export declare interface TrackRepositoryEventData extends Serializable {
    trackState: TrackState;
}

export declare enum TrackRepositoryEventType {
    TRACK_ADDED = "TRACK_ADDED",
    TRACK_DELETED = "TRACK_DELETED"
}

export declare type TrackRepositoryEventTypeDataMap = {
    [TrackRepositoryEventType.TRACK_ADDED]: TrackRepositoryEventData;
    [TrackRepositoryEventType.TRACK_DELETED]: TrackRepositoryEventData;
};

declare interface TrackRepositoryMessageChannel {
    onEvent$: Observable<TrackRepositoryEvent>;
    onTrackEvent$: Observable<TrackEvent_2>;
    get(id: TrackState['id']): Observable<TrackState | undefined>;
    getOrFail(id: TrackState['id']): Observable<TrackState>;
    find(): Observable<TrackState[]>;
    add(state: TrackState): Observable<TrackState>;
    addAll(states: TrackState[]): Observable<TrackState[]>;
    delete(id: TrackState['id']): Observable<boolean>;
}

declare class TrackRepositoryProxy extends BaseMessageChannelProxy<TrackRepositoryMessageChannel> implements TrackRepositoryMessageChannel {
    constructor(remoteNode: RemoteNode);
    get onEvent$(): Observable<TrackRepositoryEvent>;
    get onTrackEvent$(): Observable<TrackEvent_2>;
    get(id: TrackState['id']): Observable<TrackState | undefined>;
    getOrFail(id: TrackState['id']): Observable<TrackState>;
    find(): Observable<TrackState[]>;
    add(state: TrackState): Observable<TrackState>;
    addAll(states: TrackState[]): Observable<TrackState[]>;
    delete(id: TrackState['id']): Observable<boolean>;
}

export declare class TrackSource extends BaseSource<TrackSourceState> {
    protected _type: SourceType;
    private _trackId;
    constructor(trackId: Track['id']);
    static of(trackId: Track['id']): TrackSource;
    static fromTrack(track: Track): TrackSource;
    static fromState(state: TrackSourceState): TrackSource;
    get trackId(): Track['id'];
    protected getState(): TrackSourceState;
}

export declare interface TrackSourceState extends SourceState {
    trackId: Track['id'];
}

/**
 * Serializable snapshot of a {@link Track} instance.
 *
 * Extends {@link MediaEntityState} with track-specific fields such as track type,
 * source, load stage, relations, and label.
 */
export declare interface TrackState extends MediaEntityState {
    trackType: Track['trackType'];
    source: SourceState | undefined;
    sourceFileFormatType?: FileFormatType | undefined;
    loadOptions: TrackLoadOptions | undefined;
    loadStage: OpStageState;
    relations: RelationState[];
    label: string | undefined;
    customAttrs: Record<string, any> | undefined;
}

export declare type TrackTimedItem<T extends TimedItemsTrack> = T extends TimedItemsTrack<infer I> ? I : never;

/**
 * Discriminator for the different kinds of tracks that can be associated with a {@link MainMedia}.
 */
export declare enum TrackType {
    VIDEO = "VIDEO",
    AUDIO = "AUDIO",
    TEXT_TRACK = "TEXT_TRACK",
    MARKER_TRACK = "MARKER_TRACK",
    OBSERVATION_TRACK = "OBSERVATION_TRACK",
    THUMBNAIL_TRACK = "THUMBNAIL_TRACK"
}

/**
 * Subset of {@link BaseTrackArgs} fields that can be updated at runtime
 */
export declare type TrackUpdateableAttrs = Pick<BaseTrackArgs, 'label' | 'customAttrs'>;

declare class TrackUtils implements TrackUtilsApi {
    protected readonly _tools: OmakaseToolsApi;
    protected readonly _trackRepository: TrackRepository;
    protected _tracksWithRequestedTimedItems: Map<string, Observable<void>>;
    constructor(trackRepository: TrackRepository);
    preloadTrack(id: Track['id'], options?: PreloadTrackOptions): Observable<Track>;
    convertTextTrack(source: Source, conversionOptions: TextTrackConversionOptions, loadOptions?: TextTrackLoadOptions): Observable<Track>;
    convertTextTrack(url: string, conversionOptions: TextTrackConversionOptions, loadOptions?: TextTrackLoadOptions): Observable<Track>;
    protected createAudioFile(hlsAudio: HlsAudio, options?: PreloadTrackOptions): Observable<AudioFile>;
    protected createTextTrackFile(hlsTextTrack: HlsTextTrack, options?: PreloadTrackOptions): Observable<TextTrackFile>;
    fetchTimedItems(id: Track['id'], loadOptions?: TrackLoadOptions | undefined): Observable<void>;
    downsampleTrack(id: Track['id'], options: DownsampleOptions): Observable<Track>;
    protected convertTextTrackFile(textTrackFile: TextTrackFile, conversionOptions: TextTrackConversionOptions): Observable<Track>;
    private resolveConverter;
    private slewSubtitles;
    private convertWithTtconv;
    private convertWithSubtitleConverter;
    destroy(): void;
}

export declare interface TrackUtilsApi extends Destroyable {
    /**
     * Preloads a track by resolving its segments into a self-contained, locally accessible form.
     *
     * For HLS audio tracks, segments are fetched and merged into a single blob URL.
     * For HLS text tracks, VTT segments are concatenated and exposed as a blob URL.
     * The resulting track is registered in the repository with a `DERIVED_FROM` relation
     * pointing to the original track.
     *
     * @param id - The ID of the track to preload.
     * @param options - Optional preload configuration (e.g. segment request concurrency).
     * @returns An Observable that emits the newly created derived {@link Track} once preloading is complete.
     */
    preloadTrack(id: Track['id'], options?: PreloadTrackOptions): Observable<Track>;
    /**
     * Downsamples a timed-items track and registers the result as a new derived track in the repository.
     *
     * The downsampled track has a `DERIVED_FROM` relation pointing to the source track.
     *
     * @param id - The ID of the source {@link TimedItemsTrack} to downsample.
     * @param options - Downsampling options (period and strategy).
     * @returns An Observable that emits the newly created downsampled {@link Track} once complete.
     */
    downsampleTrack(id: Track['id'], options: DownsampleOptions): Observable<Track>;
    /**
     * Fetches and populates timed items for the given track.
     *
     * Concurrent calls for the same track ID are deduplicated — subsequent subscribers
     * receive the result of the in-flight request rather than starting a new one.
     *
     * @param id - The ID of the track whose timed items should be fetched.
     * @returns An Observable that completes once the timed items have been loaded.
     */
    fetchTimedItems(id: Track['id']): Observable<void>;
    /**
     * Converts a text track to a different subtitle format, optionally applying time slewing.
     *
     * Accepts either a {@link Source} or a plain URL string pointing to the source subtitle file.
     * The converted track is registered in the repository with a `DERIVED_FROM` relation
     * pointing to the source track.
     *
     * @param source - A {@link Source} or URL string of the subtitle file to convert.
     * @param conversionOptions - Target format and optional slew configuration.
     * @param loadOptions - Optional load-time overrides (track type, file format, etc.).
     * @returns An Observable that emits the newly created converted {@link Track} once complete.
     */
    convertTextTrack(source: Source, conversionOptions: TextTrackConversionOptions, loadOptions?: TextTrackLoadOptions): Observable<Track>;
    convertTextTrack(url: string, conversionOptions: TextTrackConversionOptions, loadOptions?: TextTrackLoadOptions): Observable<Track>;
}

declare interface TrackUtilsMessageChannel {
    preloadTrack(id: Track['id']): Observable<TrackState>;
}

declare class TrackUtilsProxy extends BaseMessageChannelProxy<TrackUtilsMessageChannel> implements TrackUtilsMessageChannel {
    constructor(remoteNode: RemoteNode);
    preloadTrack(id: Track['id']): Observable<TrackState>;
}

export declare type TypedMediaControllerEvent<T extends PlayerControllerEventType> = Extract<PlayerControllerEvent, {
    type: T;
}>;

export declare class Ui implements UiApi, Destroyable {
    private _onEvent$;
    private _styleEngine;
    private _elementPropsEngine;
    protected _destroyBreaker: ObserverBreaker;
    static readonly defaultStyles: {
        [K in ElementStyleName]: ClassStyleRule<ElementStyleByName[K]>;
    };
    static formatStyleClassName<T extends ElementStyleName>(name: T): string;
    constructor();
    get onEvent$(): Observable<UiEvent>;
    resolveStyle<S>(element: StyledElement<S>): Partial<S>;
    resolveStyleClass<T extends ElementStyleName>(name: T): string;
    updateStyleRule<S>(rule: StyleRule<S>): void;
    removeStyleRules(predicate: (rule: StyleRule<any>) => boolean): void;
    updateElement(element: UiElement): void;
    findStyleRule(predicate: (rule: StyleRule<any>) => boolean): StyleRule<any> | undefined;
    removeElements(id: UiElement['id'] | UiElement['id'][]): void;
    getElement(id: UiElement['id']): UiElement | undefined;
    get elements(): UiElement[];
    get styleRules(): StyleRule<any>[];
    destroy(): void;
}

export declare interface UiApi {
    /**
     * Emits whenever a style rule or element is updated or removed.
     *
     * Delivered asynchronously via `asyncScheduler` — subscribers always receive
     * events on the next tick, never synchronously. Switch on `event.type` to
     * handle specific event kinds:
     * - `UI_STYLE_RULE_UPDATED` — a style rule was added or merged
     * - `UI_STYLE_RULES_REMOVED` — style rules were removed
     * - `UI_ELEMENT_UPDATED` — an element's props were updated
     * - `UI_ELEMENTS_REMOVED` — one or more elements were removed
     */
    onEvent$: Observable<UiEvent>;
    /**
     * Snapshot of all currently tracked UI elements.
     *
     * An element is tracked as long as it has at least one non-undefined prop.
     * It is automatically removed (and `UI_ELEMENTS_REMOVED` emitted) once all
     * its props are cleared.
     */
    elements: UiElement[];
    /**
     * Snapshot of all registered style rules (both class-based and id-based).
     */
    styleRules: StyleRule<any>[];
    /**
     * Computes the merged style for an element using the following cascade priority
     * (later steps override earlier ones):
     * 1. Class rules — applied in `element.classes` array order; later class wins
     * 2. Inline `element.style`
     * 3. Id rule — highest priority, overrides everything else
     *
     * Any combination of `id`, `classes`, and `style` on the element is accepted.
     */
    resolveStyle<S>(element: StyledElement<S>): Partial<S>;
    /**
     * Returns the class name string for a named default element style.
     */
    resolveStyleClass<T extends ElementStyleName>(name: T): string;
    /**
     * Adds or merges a style rule into the registry.
     *
     * If a rule with the same key already exists (`id` or `className`), its style
     * is shallow-merged with the incoming rule. Otherwise the rule is appended.
     * Emits `UI_STYLE_RULE_UPDATED` after the update.
     */
    updateStyleRule<S>(rule: StyleRule<S>): void;
    /**
     * Removes all style rules for which `predicate` returns `true`.
     *
     * Iterates the rule registry and deletes every matching entry, then emits
     * `UI_STYLE_RULES_REMOVED`. Default styles registered at construction time
     * can also be removed this way.
     *
     * @example
     * // Remove all per-instance scoped rules for a specific track
     * ui.removeStyleRules((rule) => 'className' in rule && rule.className.startsWith('marker-track['));
     */
    removeStyleRules(predicate: (rule: StyleRule<any>) => boolean): void;
    /**
     * Adds or updates an element's props in the registry.
     *
     * - If the element exists, props are shallow-merged. Keys explicitly set to
     *   `undefined` are deleted from the stored props.
     * - If all props become `undefined` after the merge, the element is removed
     *   and `UI_ELEMENTS_REMOVED` is emitted instead.
     * - If the element does not exist and has at least one non-undefined prop, it
     *   is created and `UI_ELEMENT_UPDATED` is emitted.
     */
    updateElement(element: UiElement): void;
    /**
     * Gets an element by id, or `undefined` if it doesn't exist.
     * @param id Requested element's id
     */
    getElement(id: UiElement['id']): UiElement | undefined;
}

export declare interface UiAppearanceRuleEventData {
    element: UiElement;
}

export declare interface UiElement<S extends UiElementProps = UiElementProps> {
    id: string;
    props?: Partial<S> | undefined;
}

export declare interface UiElementProps {
    focused?: boolean | undefined;
}

export declare class UiElementPropsEngine {
    private readonly _elements;
    private readonly _onElementUpdated$;
    private readonly _onElementsRemoved$;
    readonly onElementUpdated$: Observable<UiElement>;
    readonly onElementsRemoved$: Observable<UiElement[]>;
    constructor();
    resolve<S extends UiElementProps = UiElementProps>(id: string): Partial<S>;
    updateElement(newElement: UiElement): void;
    removeElements(idOrIds: UiElement['id'] | UiElement['id'][]): void;
    get elements(): Map<UiElement['id'], UiElement>;
}

export declare type UiEvent = {
    [K in UiEventType]: {
        type: K;
        data: UiEventTypeDataMap[K];
    };
}[UiEventType];

export declare enum UiEventType {
    UI_STYLE_RULE_UPDATED = "UI_STYLE_RULE_UPDATED",
    UI_STYLE_RULES_REMOVED = "UI_STYLE_RULES_REMOVED",
    UI_ELEMENT_UPDATED = "UI_ELEMENT_UPDATED",
    UI_ELEMENTS_REMOVED = "UI_ELEMENTS_REMOVED"
}

export declare type UiEventTypeDataMap = {
    [UiEventType.UI_STYLE_RULE_UPDATED]: UiStyleRuleEventData;
    [UiEventType.UI_STYLE_RULES_REMOVED]: {};
    [UiEventType.UI_ELEMENT_UPDATED]: UiAppearanceRuleEventData;
    [UiEventType.UI_ELEMENTS_REMOVED]: {
        elements: UiElement[];
    };
};

declare interface UiMessageChannel {
    onEvent$: Observable<UiEvent>;
    elements: Observable<UiElement[]>;
    styleRules: Observable<StyleRule<any>[]>;
    resolveStyle<S>(element: StyledElement<S>): Observable<Partial<S>>;
    resolveStyleClass<T extends ElementStyleName>(name: T): Observable<string>;
    updateStyleRule(rule: StyleRule<any>): Observable<void>;
    updateElement(element: UiElement): Observable<void>;
}

declare class UiProxy extends BaseMessageChannelProxy<UiMessageChannel> implements UiMessageChannel {
    constructor(remoteNode: RemoteNode);
    get onEvent$(): Observable<UiEvent>;
    get elements(): Observable<UiElement[]>;
    get styleRules(): Observable<StyleRule<any>[]>;
    resolveStyle<S>(element: StyledElement<S>): Observable<Partial<S>>;
    resolveStyleClass<T extends ElementStyleName>(name: T): Observable<string>;
    updateStyleRule(rule: StyleRule<any>): Observable<void>;
    updateElement(element: UiElement): Observable<void>;
}

export declare class UiStyleEngine {
    private readonly _rules;
    private readonly _onRuleUpdated$;
    private readonly _onRulesRemoved$;
    readonly onRuleUpdated$: Observable<StyleRule<any>>;
    readonly onRulesRemoved$: Observable<void>;
    constructor();
    resolve<S>(el: StyledElement<S>): Partial<S>;
    updateRule(rule: StyleRule<any>): void;
    private _rulesMatchKey;
    findRule(predicate: (rule: StyleRule<any>) => boolean): StyleRule<any> | undefined;
    removeRules(predicate: (rule: StyleRule<any>) => boolean): void;
    get rules(): StyleRule<any>[];
}

export declare interface UiStyleRuleEventData {
    rule: StyleRule<any>;
}

export declare class UnsupportedMethodInDetachedError extends OmpError {
    constructor();
}

declare abstract class UntypedMessageChannel implements Destroyable {
    protected readonly _managedBroadcastChannel: ManagedBroadcastChannel;
    protected readonly _topic: string;
    protected _destroyBreaker: ObserverBreaker;
    protected constructor(managedBroadcastChannel: ManagedBroadcastChannel, topic: string);
    protected createResponseMessageStream<ResponseData>(): Observable<ResponseMessage<ResponseData>>;
    protected createRequestMessageStream<RequestData>(action: string): Observable<RequestMessage<RequestData>>;
    protected createRequestMessageDataStream<T>(action: string): Observable<T>;
    protected createMessageId(): string;
    protected _sendAndObserveResponse<ResponseData>(message: RequestMessage<any>, providedSendOptions?: Partial<SendOptions>): Observable<ResponseMessage<ResponseData>>;
    protected sendResponse<ResponseData>(request: RequestMessage<any>, responseValue: Observable<ResponseData> | ResponseData): void;
    protected createResponseHook<ResponseData>(request: RequestMessage<any>): (responseValue: Observable<ResponseData> | ResponseData) => void;
    protected createErrorResponseHook(request: RequestMessage<any>): (error: Error) => void;
    protected sendRequestMessage<RequestData>(message: RequestMessage<RequestData>): void;
    protected createRequestMessage<RequestData>(action: string, data: RequestData): RequestMessage<RequestData>;
    private _createResponseMessage;
    private _sendResponse;
    private _sendErrorResponse;
    destroy(): void;
}

declare type UnwrapObservable<T> = T extends Observable<infer U> ? U : T;

export declare class UrlSource extends BaseUrlSource<UrlSourceState> {
    protected _type: SourceType;
    constructor(url: string);
    protected getState(): UrlSourceState;
    static of(url: string): UrlSource;
    static fromState(state: UrlSourceState): UrlSource;
}

export declare interface UrlSourceState extends SourceState {
    url: string;
}

export declare type Verticals = {
    y: number;
    height: number;
};

export declare abstract class Video extends BaseTrack<VideoState, TrackEvent_2> {
    protected _trackType: TrackType;
    protected abstract _videoType: VideoType;
    protected _duration: number;
    protected constructor(args: VideoArgs);
    get videoType(): VideoType;
    protected getState(): VideoState;
}

/**
 * Construction arguments for video track instances.
 */
export declare interface VideoArgs extends BaseTrackArgs {
    /** Video duration in seconds. */
    duration: number;
}

declare interface VideoKeyframe {
    src: string;
}

declare interface VideoKeyframeOptions {
    type?: VideoKeyframeType;
}

declare enum VideoKeyframeType {
    PNG = "PNG",
    JPEG = "JPEG"
}

declare interface VideoProbeMetadata {
    frameRate: number;
    initSegmentTime: number;
}

/**
 * Video safe zone determines the area of the video that is considered "safe" for displaying important content.
 */
export declare interface VideoSafeZone {
    /**
     * Video safe zone id. Should be unique for each safe zone.
     */
    id: string;
    /**
     * Percentages from the top, right, bottom and left of the video that defines the safe area of the video. For example, [10, 20, 30, 40] means the safe area starts at 10% from the top, 20% from the right, 30% from the bottom and 40% from the left of the video.
     */
    topRightBottomLeftPercent: number[];
    /**
     * Video safe zone HTML element id
     */
    htmlId: string;
    /**
     * Video safe zone HTML element class for styling.
     */
    htmlClass: string;
}

export declare type VideoSafeZoneCreate = Partial<VideoSafeZone> & Pick<VideoSafeZone, 'topRightBottomLeftPercent'>;

/**
 * Serializable snapshot of a video {@link Track}.
 */
export declare interface VideoState extends TrackState {
    videoType: VideoType;
    /** Video duration in seconds. */
    duration: number;
}

/**
 * Discriminator for the origin of a video track.
 */
export declare enum VideoType {
    /** Video rendition extracted from an HLS manifest. */
    HLS_VIDEO = "HLS_VIDEO",
    /** Video track from an MP4 container. */
    MP4_VIDEO = "MP4_VIDEO"
}

export declare abstract class VttTimedItemsFetcher<T extends TimedItemsTrack> extends BaseTimedItemsFetcher<T> {
    protected _vttUrl: string | undefined;
    protected _omakaseVttVersion: OmakaseVttVersion | undefined;
    constructor(track: T, loadOptions: TrackLoadOptions | undefined);
    abstract map(index: number, cue: ParsedVttCue): TimedItemOf<T>;
    fetchTimedItems(): Observable<void>;
}

export declare class VuMeter implements Destroyable, VuMeterApi {
    private _config;
    private _container;
    private _vuMeterComponent;
    private _source?;
    private _isExternalSource;
    private _destroyBreaker;
    private _sourceBreaker;
    constructor(args: VuMeterArgs);
    get config(): VuMeterConfig;
    setConfig(config: Partial<VuMeterConfig>): void;
    setSource(source: AudioLevelSourceApi): void;
    private createDom;
    private resolveChannelCount;
    private wireSource;
    destroy(): void;
}

export declare interface VuMeterApi {
    get config(): VuMeterConfig;
    /**
     * Sets the configuration for VU Meter.
     * @param config Partial configuration for the VU Meter. Only the provided properties will be updated, and the rest will remain unchanged.
     */
    setConfig(config: Partial<VuMeterConfig>): void;
    /**
     * Sets the source for the VU Meter.
     * @param source VU Meter source.
     */
    setSource(source: AudioLevelSourceApi): void;
}

export declare interface VuMeterArgs {
    /**
     * Omakase player instance, required if source is not provided
     */
    player?: OmakasePlayerApi;
    /**
     * Audio level source
     */
    source?: AudioLevelSourceApi;
    /**
     * Audio type, required to create a PeakProcessorAudioLevelSource from PlayerAudioType.MAIN or PlayerAudioType.OUTPUT
     */
    audioType?: PlayerAudioType;
    /**
     * Track, track id, or array of tracks/track ids. A single value creates a PeakProcessorAudioLevelSource (sidecar audio) or ObservationTrackAudioLevelSource (observation track); an array creates an ObservationTrackAudioLevelSource with one ObservationTrack per channel.
     */
    tracks?: Track['id'] | Track | Track['id'][] | Track[];
    /**
     * VU Meter configuration, optional
     */
    config?: Partial<VuMeterConfig>;
}

export declare interface VuMeterColor {
    /**
     * Maximum dB value for this color. The colors will be applied in order, so the first color with a maxValueDb higher than the current dB value will be used to color the level.
     */
    maxValueDb: number;
    /**
     * Color for the level when the dB value is below the maxValueDb. Can be any valid CSS color value.
     */
    color: string;
    /**
     * Color for the hold level when the dB value is below the maxValueDb. Can be any valid CSS color value.
     */
    holdColor: string;
}

export declare class VuMeterComponent extends HTMLElement {
    private _channels;
    private _barRegion;
    private _barContainers;
    private _scaleLabelsContainer;
    private _scaleLabels;
    private _barLevels;
    private _heldLevels;
    private _barSegments?;
    private _sampleTime;
    private _maxChannelCount;
    private _defaultChannelCount;
    private _dbValues;
    private _heldDbValues;
    private _levelColors;
    private _isNewFrame;
    private _isSetUp;
    private _isConnected;
    private _destroyBreaker;
    private _sourceBreaker;
    private _resizeObserver;
    get theme(): VuMeterTheme;
    get scale(): VuMeterScale;
    get channelCount(): number;
    set channelCount(channelCount: number);
    get isVertical(): boolean;
    get showScaleMarks(): boolean;
    get showScaleLabels(): boolean;
    get showLevelLabels(): boolean;
    get rangeMinDb(): number;
    get rangeMaxDb(): number;
    get scaleStepDb(): number;
    get scaleOffsetDb(): number;
    get labels(): string[];
    get colors(): VuMeterColor[];
    set colors(colors: VuMeterColor[]);
    get levelBackground(): string;
    set levelBackground(color: string);
    get levelHoldDuration(): number;
    connectedCallback(): void;
    disconnectedCallback(): Promise<void>;
    setSource(source: AudioLevelSourceApi): void;
    private initHoldTimers;
    private handleDbValues;
    private getDbValue;
    private updateBars;
    private createDom;
    private createScaleContainer;
    private createScaleLabelsDom;
    private updateScaleLabelsDom;
    private createScaleMarksDom;
    private createChannelsDom;
    private createBarDom;
    private createBarLabelDom;
    private getBarSegmentCount;
    private getMaxSegmentSizeWithGap;
    private createBarSegment;
    private createBarSegments;
    private colorBarSegments;
    private getSegmentColor;
    private getClipPath;
    private getLinearGradient;
    private getScaleLabels;
}

export declare interface VuMeterConfig {
    /**
     * ID of the HTML element where the VU Meter will be rendered. The element must exist in the DOM before creating the VU Meter instance.
     */
    htmlElementId: string;
    /**
     * Html element where the VU Meter will be rendered. Can be used instead of htmlElementId to provide the element directly. If both htmlElementId and htmlElement are provided, htmlElement will take precedence.
     */
    htmlElement?: HTMLElement;
    /**
     * Theme for the VU Meter. The theme controls the way the levels are rendered and colored. The DEFAULT theme renders the levels as simple bars, while the LED theme renders the levels as a series of LEDs that light up based on the dB value.
     */
    theme: VuMeterTheme;
    /**
     * Orientation of the VU Meter. Can be either vertical or horizontal.
     */
    orientation: VuMeterOrientation;
    /**
     * Number of channels to display on the VU Meter. If not specified, the VU Meter will display as many channels as provided by the audio level source. If specified, the VU Meter will display the specified number of channels, and if the audio source provides fewer channels, the remaining channels will be displayed as empty.
     */
    channels?: number | undefined;
    /**
     * Scale type for the VU Meter. The scale controls the dB values displayed on the VU Meter. The DEFAULT scale displays values from rangeMinDb to 0 with steps of scaleStepDb. The NORDIC scale displays values from rangeMinDb to 0 with steps of 3 dB and an offset of 12 dB. The NONE scale does not display any dB values.
     */
    scale: VuMeterScale;
    /**
     * Minimum dB value for the VU Meter scale. The scale will display values from this minimum value to 0 dB. This value is typically a negative number, and common values are -60 dB, -54 dB or -48 dB. The default value is -54 dB.
     */
    rangeMinDb: number;
    /**
     * Step in dB between each value displayed on the scale. The default value is 6 dB. This value is ignored if the scale is set to NORDIC, which uses a fixed step of 3 dB.
     */
    scaleStepDb: number;
    /**
     * Offset in dB for the scale values. The default value is 0 dB. This value is ignored if the scale is set to NORDIC, which uses a fixed offset of 12 dB.
     */
    scaleOffsetDb: number;
    /**
     * Duration in milliseconds for which the hold level is displayed after a peak. The hold level is the maximum level reached since the last time the level was at or below the current level. A value of 0 means that the hold level is not displayed. The default value is 0 ms.
     */
    levelHoldDuration: number;
    /**
     * Labels for the levels. The labels are applied in order to the levels, so the first label corresponds to the first level, the second label to the second level, and so on. If there are more levels than labels, the remaining levels will not have labels. The default value is ['L', 'R', 'C', 'LFE', 'Ls', 'Rs'].
     */
    labels: string[];
    /**
     * Style configuration for the VU Meter. The style controls the visual appearance of the VU Meter, such as the colors.
     */
    style: Partial<VuMeterStyle>;
}

export declare class VuMeterFactory {
    static createAudioLevelSource(args: VuMeterArgs): AudioLevelSourceApi;
}

export declare enum VuMeterOrientation {
    VERTICAL = "VERTICAL",
    HORIZONTAL = "HORIZONTAL"
}

export declare enum VuMeterScale {
    DEFAULT = "DEFAULT",
    NORDIC = "NORDIC",
    NONE = "NONE"
}

export declare interface VuMeterStyle {
    /**
     * Whether to show labels for the scale values. Only applicable if the scale is not set to NONE.
     */
    showScaleLabels: boolean;
    /**
     * Whether to show ticks for the scale values. Only applicable if the scale is not set to NONE.
     */
    showScaleMarks: boolean;
    /**
     * Whether to show labels for the channels. The labels are taken from the config.labels array and are applied in order to the channels.
     */
    showChannelLabels: boolean;
    /**
     * Color configuration for the levels. The colors will be applied in order, so the first color with a maxValueDb higher than the current dB value will be used to color the level.
     */
    levelColors: VuMeterColor[];
    /**
     * Background color for the level. Can be any valid CSS color value.
     */
    levelBackground: string;
}

export declare enum VuMeterTheme {
    DEFAULT = "DEFAULT",
    LED = "LED"
}

export declare enum WatermarkVisibility {
    ALWAYS_ON = "ALWAYS_ON",
    AUTO_HIDE = "AUTO_HIDE"
}

export declare const WINDOW_PLAYBACK_MODE_TRANSITIONS: Record<WindowPlaybackMode, WindowPlaybackMode[]>;

export declare interface WindowPlayback {
    /** Current window playback mode. */
    mode: WindowPlaybackMode;
    /** Error message set when the mode transitions to `FAILURE`. */
    error?: string | undefined;
    /** Whether the player can currently be detached. */
    canDetach: boolean;
    /** Whether the player can currently be re-attached. */
    canAttach: boolean;
}

export declare enum WindowPlaybackMode {
    ATTACHED = "ATTACHED",
    DETACHING = "DETACHING",
    DETACHED = "DETACHED",
    ATTACHING = "ATTACHING",
    FAILURE = "FAILURE"
}

declare type WithOptionalPartial<T, K extends keyof T> = Omit<T, K> & {
    [P in K]?: Partial<T[P]>;
};

export { }