@byomakase/omakase-player/dist/omakase-player.es.d.ts

## Omakase Player - Open source JavaScript framework for building frame accurate video experiences

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, AudioRouterInputSoloMuteState>;
    protected _lastChangedSoloMuteStateInput: 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;
    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;
    resetInputsSoloMuteState(): void;
    protected resetInputSoloMuteState(inputNumber: number, emitEvent?: boolean): void;
    protected createInitialSoloMuteState(inputNumber: number): AudioRouterInputSoloMuteState;
    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"
}

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

export declare interface AudioRouterInputSoloMuteState {
    /**
     * 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[];
}

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

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

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

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, BarChartLaneLaneStyle, BarChartLaneTrackConfig> {
    protected _downsamplers: Map<ObservationTrack['id'], ObservationTrackDownsampler>;
    private _typedTrackViews;
    constructor(configAndStyle?: ConfigAndStyle<BarChartLaneConfig, BarChartLaneLaneStyle>);
    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 BarChartLaneLaneStyle 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, track: ThumbnailTrack): 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): 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 BaseF