/**
 * Copyright 2015 CANAL+ Group
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import type { IMediaElement } from "../../compat/browser_compatibility_types";
import type { ISegmentSinkMetrics } from "../../core/segment_sinks/segment_sinks_store";
import type { IBufferType, IAdaptationChoice, IInbandEvent } from "../../core/types";
import type { IPeriodsUpdateResult, IAdaptationMetadata, IManifestMetadata, IPeriodMetadata, IRepresentationMetadata, IDecipherabilityStatusChangedElement } from "../../manifest";
import type { IMediaElementPlaybackObserver } from "../../playback_observer";
import type { IPlayerError } from "../../public_types";
import type { IThumbnailResponse } from "../../transports";
import EventEmitter from "../../utils/event_emitter";
import type SharedReference from "../../utils/reference";
import type { IPublicNonFiniteStreamEvent, IPublicStreamEvent } from "./utils/stream_events_emitter";
/**
 * Class allowing to start playing a content on an `HTMLMediaElement`.
 *
 * The actual constructor arguments depend on the `ContentInitializer` defined,
 * but should reflect all potential configuration wanted relative to this
 * content's playback.
 *
 * Various events may be emitted by a `ContentInitializer`. However, no event
 * should be emitted before `prepare` or `start` is called and no event should
 * be emitted after `dispose` is called.
 */
export declare abstract class ContentInitializer extends EventEmitter<IContentInitializerEvents> {
    /**
     * Prepare the content linked to this `ContentInitializer` in the background,
     * without actually trying to play it.
     *
     * This method may be used for optimization reasons, for example to prepare a
     * future content without interrupting the previous one playing on a given
     * `HTMLMediaElement`.
     */
    abstract prepare(): void;
    /**
     * Actually starts playing the content linked to this `ContentInitializer` on
     * the given `mediaElement`.
     *
     * Only a single call to `start` is expected to be performed on each
     * `ContentInitializer`.
     *
     * A call to `prepare` may or may not have been performed before calling
     * `start`. If it was, it may or may not have yet finished the preparation
     * phase before `start` is called (the `ContentInitializer` should stay
     * resilient in both scenarios).
     *
     * @param {HTMLMediaElement} mediaElement - `HTMLMediaElement` on which the
     * content will play. This is given to `start` (and not sooner) to ensure
     * that no prior step influence the `HTMLMediaElement`, on which a previous
     * content could have been playing until then.
     *
     * If a content was already playing on that `HTMLMediaElement`, it will be
     * stopped.
     * @param {Object} playbackObserver - Interface allowing to poll playback
     * information on what's playing on the `HTMLMediaElement` at regular
     * intervals.
     */
    abstract start(mediaElement: IMediaElement, playbackObserver: IMediaElementPlaybackObserver): void;
    /**
     * Update URL of the content currently being played (e.g. DASH's MPD).
     * @param {Array.<string>|undefined} urls - URLs to reach that content /
     * Manifest from the most prioritized URL to the least prioritized URL.
     * @param {boolean} refreshNow - If `true` the resource in question (e.g.
     * DASH's MPD) will be refreshed immediately.
     */
    abstract updateContentUrls(urls: string[] | undefined, refreshNow: boolean): void;
    /**
     * Stop playing the content linked to this `ContentInitializer` on the
     * `HTMLMediaElement` linked to it and dispose of every resources taken while
     * trying to do so.
     * @param {string | undefined} reason - Human-inspectable reason behind the
     * disposal. Might be used for debugging matters, especially for debug log
     * inspection.
     */
    abstract dispose(reason: string | undefined): void;
}
/** Every events emitted by a `ContentInitializer`. */
export interface IContentInitializerEvents {
    /** Event sent when a minor happened. */
    warning: IPlayerError;
    /** A fatal error occured, leading to the current content being stopped. */
    error: unknown;
    /** Event sent after the Manifest has been loaded and parsed for the first time. */
    manifestReady: IManifestMetadata;
    /** Event sent after the Manifest has been updated. */
    manifestUpdate: IPeriodsUpdateResult;
    /**
     * The codecs support for some tracks may have changed.
     */
    codecSupportUpdate: null;
    /**
     * Event sent after the decipherability status of at least one Representation
     * in the Manifest has been updated.
     */
    decipherabilityUpdate: IDecipherabilityStatusChangedElement[];
    /**
     * Event sent when we're starting attach a new MediaSource to the media element
     * (after removing the previous one).
     */
    reloadingMediaSource: {
        /** The position we're reloading at, in seconds. */
        position: number;
        /**
         * If `true`, we'll play directly after finishing the reloading operation.
         * If `false`, we'll be paused after it.
         */
        autoPlay: boolean;
    };
    /** Event sent after the player stalled. */
    stalled: IStallingSituation;
    /** Event sent when the player goes out of a stalling situation. */
    unstalled: null;
    /**
     * Event sent just as the content is considered as "loaded".
     * From this point on, the user can reliably play/pause/resume the stream.
     */
    loaded: {
        getSegmentSinkMetrics: null | (() => Promise<ISegmentSinkMetrics | undefined>);
        /**
         * Fetch the thumbnail data of the given Period for the corresponding time.
         * If there's no thumbnail for that Period or if the request fails, reject
         * the Promise with a given reason.
         * @param {number} time
         */
        getThumbnailData: (periodId: string, thumbnailTrackId: string, time: number) => Promise<IThumbnailResponse>;
    };
    /** Event emitted when a stream event is encountered. */
    streamEvent: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
    streamEventSkip: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
    /** Emitted when a new `Period` is currently playing. */
    activePeriodChanged: {
        /** The Period we're now playing. */
        period: IPeriodMetadata;
    };
    /**
     * A new `PeriodStream` is ready to start but needs an Adaptation (i.e. track)
     * to be chosen first.
     */
    periodStreamReady: {
        /** The type of buffer linked to the `PeriodStream` we want to create. */
        type: IBufferType;
        /** The `Period` linked to the `PeriodStream` we have created. */
        period: IPeriodMetadata;
        /**
         * The Reference through which any Adaptation (i.e. track) choice should be
         * emitted for that `PeriodStream`.
         *
         * The `PeriodStream` will not do anything until this Reference has emitted
         * at least one to give its initial choice.
         * You can send `null` through it to tell this `PeriodStream` that you don't
         * want any `Adaptation`.
         * It is set to `undefined` by default, you SHOULD NOT set it to `undefined`
         * yourself.
         */
        adaptationRef: SharedReference<IAdaptationChoice | null | undefined>;
    };
    /**
     * A `PeriodStream` has been removed.
     * This event can be used for clean-up purposes. For example, you are free to
     * remove from scope the shared reference that you used to choose a track for
     * that `PeriodStream`.
     */
    periodStreamCleared: {
        /**
         * The type of buffer linked to the `PeriodStream` we just removed.
         *
         * The combination of this and `Period` should give you enough information
         * about which `PeriodStream` has been removed.
         */
        type: IBufferType;
        /**
         * The `id` property of the `Period` linked to the `PeriodStream` we just
         * removed.
         *
         * The combination of this and `Period` should give you enough information
         * about which `PeriodStream` has been removed.
         */
        periodId: string;
    };
    /** Emitted when a new `Adaptation` is being considered. */
    adaptationChange: IAdaptationChangeEventPayload;
    /** Emitted as new bitrate estimates are done. */
    bitrateEstimateChange: {
        /** The type of buffer for which the estimation is done. */
        type: IBufferType;
        /**
         * The bitrate estimate, in bits per seconds. `undefined` when no bitrate
         * estimate is currently available.
         */
        bitrate: number | undefined;
    };
    /** Emitted when a new `Representation` is being considered. */
    representationChange: {
        /** The type of buffer linked to that `RepresentationStream`. */
        type: IBufferType;
        /** The `Period` linked to the `RepresentationStream` we're creating. */
        period: IPeriodMetadata;
        /**
         * The `Representation` linked to the `RepresentationStream` we're creating.
         * `null` when we're choosing no Representation at all.
         */
        representation: IRepresentationMetadata | null;
    };
    /**
     * Event emitted when one or multiple inband events (i.e. events inside a
     * given segment) have been encountered.
     */
    inbandEvents: IInbandEvent[];
}
export interface IAdaptationChangeEventPayload {
    /** The type of buffer for which the Representation is changing. */
    type: IBufferType;
    /** The `Period` linked to the `RepresentationStream` we're creating. */
    period: IPeriodMetadata;
    /**
     * The `Adaptation` linked to the `AdaptationStream` we're creating.
     * `null` when we're choosing no Adaptation at all.
     */
    adaptation: IAdaptationMetadata | null;
}
export type IStallingSituation = "seeking" | "not-ready" | "internal-seek" | "buffering" | "freezing";
export type ITextDisplayerOptions = {
    textTrackMode?: "native";
} | {
    textTrackMode: "html";
    textTrackElement: HTMLElement;
};
//# sourceMappingURL=types.d.ts.map