/**
 * 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.
 */
/**
 * Callback allowing to retrieve an initialization segment. Each
 * `ILocalManifestInitSegmentLoader` will be associated to a single
 * `ILocalRepresentation`, so to only one possible initialization segment
 * (or to the absence of one).
 *
 * It will be called when the RxPlayer wants to download the corresponding
 * `ILocalRepresentation`'s initialization segment.
 * When called, it will have a single argument containing two properties:
 *   - `resolve`: function to call when the data has been loaded, with the
 *                data itself.
 *                If the corresponding `ILocalRepresentation` has no
 *                initialization segment, this data can be set to `null`.
 *   - `reject`: function to call when an error happened which made the
 *               retrieval of the data impossible. The error should be given
 *               to this function.
 *
 * Optionally, this callack can return a function. This function will be called
 * in the case where the RxPlayer wants to cancel this request.
 * You can thus abort every steps taken to retrieve the segment in that callback.
 * Calls to `resolve` and to `reject` won't be considered after the returned
 * callback is called.
 */
export type ILocalManifestInitSegmentLoader = (callbacks: {
    resolve: (args: {
        data: ArrayBuffer | null;
    }) => void;
    reject: (err?: Error) => void;
}) => (() => void) | void;
/**
 * Callback allowing to retrieve a media segment. Each `ILocalManifestSegmentLoader`
 * will be associated to a single `ILocalRepresentation`.
 *
 * It will be called when the RxPlayer wants to download a specific media
 * segment for that `ILocalRepresentation` with two arguments.
 *
 * The first of those arguments is the segment the player wants to fetch.
 * This coresponds to the same object than the one defined in the corresponding
 * `ILocalIndex`.
 *
 * The second argument is an object containing two callbacks, that you can call
 * either when the segment has been loaded or when an error happened while doing
 * so:
 *   - `resolve`: function to call when the data has been loaded, with the
 *                data itself.
 *   - `reject`: function to call when an error happened which made the
 *               retrieval of the data impossible. The error should be given
 *               to this function.
 *
 * Optionally, this callack can return a function. This function will be called
 * in the case where the RxPlayer wants to cancel this request.
 * You can thus abort every steps taken to retrieve the segment in that callback.
 * Calls to `resolve` and to `reject` won't be considered after the returned
 * callback is called.
 */
export type ILocalManifestSegmentLoader = (segment: ILocalIndexSegment, // Same than the segment from `segments`
callbacks: {
    resolve: (args: {
        data: ArrayBuffer;
    }) => void;
    reject: (err?: Error) => void;
}) => (() => void) | void;
/**
 * DRM information describing a "keyId" identifying a key with which a given
 * `ILocalRepresentation` is encrypted.
 */
export interface IContentProtectionKID {
    /** The corresponding "keyId", encoded as an array of bytes. */
    keyId: Uint8Array;
    /**
     * Optional "systemId" (identifying a given key system) to which the keyId
     * apply.
     * This systemId should be defined as an hexadecimal string, with optional
     * dashes in between. An example of possible systemId can be found here:
     * https://dashif.org/identifiers/content_protection/
     */
    systemId?: string;
}
/**
 * DRM information describing initialization data necessary to initialize a
 * given CDM's instance.
 * For the moment, this is limited to PSSH information.
 */
export interface IContentProtectionInitData {
    /**
     * The initialization data itself. For data coming from a pssh ISOBMFF box,
     * this includes the size and name of the box.
     */
    data: Uint8Array;
    /**
     * Id defining what key system the initialization data applies to.
     *
     * This systemId should be defined as an hexadecimal string, with optional
     * dashes in between. An example of possible systemId can be found here:
     * https://dashif.org/identifiers/content_protection/
     */
    systemId: string;
}
/**
 * Object describing DRM information for a given `ILocalRepresentation`.
 * Note that any information here is optional. A content can be encrypted
 * without these being properly defined.
 * Those information are only used for supplementary features and optimizations
 * in the RxPlayer.
 */
export interface IContentProtections {
    /** All "keyId" that applies to the `ILocalRepresentation`. */
    keyIds: IContentProtectionKID[];
    /**
     * DRM information describing initialization data necessary to initialize a
     * given CDM's instance.
     * This is an Object grouping such initialization data by "types" of data.
     * Examples of possible initialization data type can be found here:
     * https://www.w3.org/TR/eme-initdata-registry/
     */
    initData: Partial<Record<string, IContentProtectionInitData[]>>;
}
/** Object defining a single available media segment in a `ILocalIndex`. */
export interface ILocalIndexSegment {
    /** Earliest presentation time available for this segment, in seconds. */
    time: number;
    /**
     * Time difference between the maximum available presentation time in this
     * segment and the first (defined by `time`), in seconds.
     */
    duration: number;
    /**
     * If set, this is the amount of time in seconds we have to add to the
     * segment once loaded so it can be decoded at the time indicated by the
     * `time` property.
     */
    timestampOffset?: number;
}
/** "Index" of a `ILocalRepresentation`. Allow to declare available segments. */
export interface ILocalIndex {
    /** Every segments in that `ILocalIndex` has been downloaded. */
    isFinished: boolean;
    /** Callback used to retrieve the initialization segment of a `ILocalRepresentation`. */
    loadInitSegment: ILocalManifestInitSegmentLoader;
    /** Callback used to retrieve a media segment of a `ILocalRepresentation`. */
    loadSegment: ILocalManifestSegmentLoader;
    /**
     * List of available media segments, in chronological order.
     * Doesn't include the initialization segment.
     */
    segments: ILocalIndexSegment[];
    /**
     * List of not yet available time ranges, that should become available once
     * the content is fully loaded.
     */
    incomingRanges?: Array<{
        start: number;
        end: number;
    }>;
}
/** A quality for a given "local" Manifest track (`ILocalAdaptation`). */
export interface ILocalRepresentation {
    /** Maximum number of bytes per second for the segments contained in this quality. */
    bitrate: number;
    /** DRM information. */
    contentProtections?: IContentProtections;
    /** Mime-type of the corresponding quality's segment. */
    mimeType: string;
    /** Codec(s) necessary to decode this quality's segment. */
    codecs: string;
    /**
     * Width in pixels for this quality.
     * This should only be set if the corresponding "track" contains video.
     */
    width?: number;
    /**
     * Height in pixels for this quality.
     * This should only be set if the corresponding "track" contains video.
     */
    height?: number;
    /** Interface allowing to retrieve media segments for this quality. */
    index: ILocalIndex;
    /** `true` if audio has Dolby Atmos. */
    isSpatialAudio?: boolean;
}
/** A "track"" of a "local" Manifest. */
export interface ILocalAdaptation {
    /** The "type" of that track ("text" == subtitles, closed captions...). */
    type: "audio" | "video" | "text";
    /**
     * If `true`, this track contains an audio description of what is happening
     * visually on the screen.
     */
    audioDescription?: boolean;
    /** If `true`, this track contains closed captions. */
    closedCaption?: boolean;
    /** If `true`, this track contains "forced subtitles". */
    forcedSubtitles?: boolean;
    /** The ISO 639-3, ISO 639-2 or ISO 639-1 language code for that track. */
    language?: string;
    /** The different qualities this track is available in. */
    representations: ILocalRepresentation[];
}
/** Sub-part of a "local" Manifest, with specific tracks and qualities.  */
export interface ILocalPeriod {
    /** Start time at which the Period begins, in seconds. */
    start: number;
    /** End time at which the Period ends, in seconds. */
    end: number;
    /** The different "tracks" available for this Period. */
    adaptations: ILocalAdaptation[];
}
/**
 * Format of a "local" Manifest, which allows to play locally-stored contents.
 *
 * Special properties also allow to play content that are still being
 * downloaded.
 */
export interface ILocalManifest {
    /** Required. Confirms that the current object is a "local" Manifest */
    type: "local";
    /**
     * Version of the object, under a `MAJOR.MINOR` format.
     * MAJOR: A parser compatible to a different major version should not try to
     *        parse it
     * MINOR: Retro-compatible format change.
     *
     * The exception is the `0` MAJOR version (i.e. experimental versions).
     * A parser for a version in that major (let's say `0.1`) might be unable to
     * parse local Manifests of another version (e.g. `0.2`).
     *
     * There are two versions defined for now and we are compatible to both:
     *
     *   - "0.1": initial version
     *
     *   - "0.2": `minimumPosition` and `maximumPosition` are now defined.
     *            `duration` has been removed.
     *
     *            `start` and `duration` from a ILocalPeriod and `time` and
     *            `duration` from a `ILocalIndexSegment` are now in seconds
     *            instead of milliseconds.
     *
     *   - "0.3": optional `futureSegments` has been added to `ILocalIndex`
     *            `duration` has been removed.
     *
     *            A mandatory `isFinished` boolean should now be set on a
     *            `ILocalIndex`.
     */
    version: string;
    /**
     * Minimum position reachable in this content once fully downloaded, in
     * seconds.
     *
     * Set to `0` by default.
     */
    minimumPosition?: number;
    /**
     * Maximum position reachable in this content once fully downloaded, in
     * seconds.
     */
    maximumPosition: number;
    /**
     * Optional Promise used to trigger a Manifest refresh.
     *
     * When this Promise resolves, it means that the Local Manifest needs to be
     * updated.
     */
    expired?: Promise<void>;
    /** Sub-parts of the content, each with specific tracks and qualities.  */
    periods: ILocalPeriod[];
    /**
     * Whether the "local" Manifest generation is finished.
     * `true` if it is already fully-loaded.
     * `false` if it is still being downloaded.
     */
    isFinished: boolean;
}
//# sourceMappingURL=types.d.ts.map