import { ReactiveController, ReactiveElement } from 'lit';
import { ContextProviderController } from '../../base/context';
import { DisposalBin } from '../../base/events';
import { FullscreenChangeEvent, FullscreenErrorEvent } from '../../base/fullscreen';
import { Logger, LogLevel, LogLevelName } from '../../base/logger';
import { RequestQueue } from '../../base/queue';
import { MediaContextProviderRecord, MediaContextRecordValues } from '../context';
import { PauseEvent, PlayErrorEvent, PlayEvent, PlayingEvent, ReplayEvent, SeekedEvent, SeekingEvent, VolumeChangeEvent, WaitingEvent } from '../events';
import { MediaProviderConnectEvent, MediaProviderElement } from '../provider/MediaProviderElement';
import { EnterFullscreenRequestEvent, ExitFullscreenRequestEvent, MuteRequestEvent, PauseRequestEvent, PendingMediaRequests, PlayRequestEvent, SeekingRequestEvent, SeekRequestEvent, UnmuteRequestEvent, VolumeChangeRequestEvent } from '../request.events';
export declare type MediaControllerHost = ReactiveElement & {
    exitFullscreen?(): Promise<void>;
};
/**
 * The media controller acts as a message bus between the media provider and all other
 * components, such as UI components and plugins. The main responsibilities are:
 *
 * - Provide the media context that is used to pass media state down to components (this
 * context is injected into and managed by the media provider).
 *
 * - Listen for media request events and fulfill them by calling the appropriate props/methods on
 * the current media provider.
 *
 * 💡 The base `MediaPlayer` acts as both a media controller and provider.
 */
export declare class MediaController implements ReactiveController {
    protected readonly _host: MediaControllerHost;
    protected readonly _disconnectDisposal: DisposalBin;
    protected readonly _logger?: Logger;
    protected readonly _logLevelProvider: ContextProviderController<LogLevel>;
    protected readonly _mediaProviderConnectedQueue: RequestQueue;
    protected readonly _mediaProviderDisconnectedDisposal: DisposalBin;
    constructor(_host: MediaControllerHost);
    hostConnected(): void;
    hostDisconnected(): void;
    protected _addEventListeners(): void;
    get logLevel(): LogLevelName;
    set logLevel(newLevel: LogLevelName);
    protected _logEvents(): void;
    protected _logErrors(): void;
    protected _mediaProvider: MediaProviderElement | undefined;
    get mediaProvider(): MediaProviderElement | undefined;
    /** @internal */
    setMediaProvider(mediaProvider?: MediaProviderElement): void;
    protected _handleMediaProviderConnect(event: MediaProviderConnectEvent): void;
    protected _handleMediaProviderDisconnect(): void;
    protected _flushMediaProviderConnectedQueue(): void;
    /**
     * Media context provider record which is injected by the media controller into the media
     * provider, so it can be managed and updated by it.
     *
     * @internal
     */
    readonly mediaCtx: MediaContextProviderRecord;
    /**
     * A snapshot of the current media state.
     */
    get mediaState(): Readonly<MediaContextRecordValues>;
    protected _attachMediaContextRecordToProvider(): void;
    /**
     * Media requests that have been made but are waiting to be satisfied. Key represents the media
     * event type the request is waiting for to be considered "satisfied".
     */
    protected _pendingMediaRequests: PendingMediaRequests;
    protected _clearPendingMediaRequests(): void;
    protected satisfyMediaRequest<T extends keyof PendingMediaRequests>(type: T, event: Event & {
        requestEvent?: Event;
    }): void;
    /**
     * Override this to allow media events to bubble up the DOM.
     *
     * @param event
     */
    protected _mediaRequestEventGateway(event: Event): boolean;
    protected _handleMuteRequest(event: MuteRequestEvent): void;
    protected _handleUnmuteRequest(event: UnmuteRequestEvent): void;
    protected _handlePlayRequest(event: PlayRequestEvent): void;
    protected _handlePauseRequest(event: PauseRequestEvent): void;
    protected _isSeekingRequestPending: boolean;
    protected _handleSeekingRequest(event: SeekingRequestEvent): void;
    protected _handleSeekRequest(event: SeekRequestEvent): void;
    protected _handleVolumeChangeRequest(event: VolumeChangeRequestEvent): void;
    protected _handleEnterFullscreenRequest(event: EnterFullscreenRequestEvent): Promise<void>;
    protected _handleExitFullscreenRequest(event: ExitFullscreenRequestEvent): Promise<void>;
    protected _handleFullscreenChange(event: FullscreenChangeEvent): void;
    protected _handleFullscreenError(event: FullscreenErrorEvent): void;
    protected _handlePlay(event: PlayEvent): void;
    protected _handlePlayError(event: PlayErrorEvent): void;
    protected _handlePlaying(event: PlayingEvent): void;
    protected _handlePause(event: PauseEvent): void;
    protected _handleVolumeChange(event: VolumeChangeEvent): void;
    protected _handleReplay(event: ReplayEvent): void;
    protected _handleSeeking(event: SeekingEvent): void;
    protected _handleSeeked(event: SeekedEvent): void;
    protected _firingWaiting: boolean;
    protected _lastWaitingEvent?: WaitingEvent;
    protected _fireWaiting: (() => void) & {
        cancel: () => void;
        flush: () => void;
    };
    protected _handleWaiting(event: WaitingEvent): void;
}