rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/transports/types.d.ts

@@ -13,12 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import { IInbandEvent } from "../core/stream";
-import Manifest, { Adaptation, IRepresentationFilter, ISegment, ISupplementaryImageTrack, ISupplementaryTextTrack, Period, Representation } from "../manifest";
+import Manifest, { Adaptation, IExposedAdaptation, IExposedManifest, IExposedPeriod, IExposedRepresentation, IExposedSegment, IRepresentationFilter, ISegment, ISupplementaryImageTrack, ISupplementaryTextTrack, Period, Representation } from "../manifest";
 import { IBifThumbnail } from "../parsers/images/bif";
 import { ILocalManifest } from "../parsers/manifest/local";
 import { IMetaPlaylist } from "../parsers/manifest/metaplaylist";
+import TaskCanceller, { CancellationSignal } from "../utils/task_canceller";
 /**
  * Interface returned by any transport implementation.
  * @param {Object} options - Options allowing to configure the transport's
@@ -35,337 +35,548 @@ export interface ITransportPipelines {
     /** Functions allowing to load an parse the Manifest for this transport. */
     manifest: ITransportManifestPipeline;
     /** Functions allowing to load an parse audio segments. */
-    audio: ISegmentPipeline<Uint8Array | ArrayBuffer | null, Uint8Array | ArrayBuffer | null, Uint8Array | ArrayBuffer | null>;
+    audio: ISegmentPipeline<ILoadedAudioVideoSegmentFormat, Uint8Array | ArrayBuffer | null>;
     /** Functions allowing to load an parse video segments. */
-    video: ISegmentPipeline<Uint8Array | ArrayBuffer | null, Uint8Array | ArrayBuffer | null, Uint8Array | ArrayBuffer | null>;
+    video: ISegmentPipeline<ILoadedAudioVideoSegmentFormat, Uint8Array | ArrayBuffer | null>;
     /** Functions allowing to load an parse text (e.g. subtitles) segments. */
-    text: ISegmentPipeline<Uint8Array | ArrayBuffer | string | null, null, ITextTrackSegmentData>;
+    text: ISegmentPipeline<ILoadedTextSegmentFormat, ITextTrackSegmentData | null>;
     /** Functions allowing to load an parse image (e.g. thumbnails) segments. */
-    image: ISegmentPipeline<Uint8Array | ArrayBuffer | null, null, IImageTrackSegmentData>;
+    image: ISegmentPipeline<ILoadedImageSegmentFormat, IImageTrackSegmentData | null>;
 }
 /** Functions allowing to load and parse the Manifest. */
 export interface ITransportManifestPipeline {
-    resolver?: IManifestResolverFunction;
-    loader: IManifestLoaderFunction;
-    parser: IManifestParserFunction;
+    /**
+     * "Loader" of the Manifest pipeline, allowing to request a Manifest so it can
+     * later be parsed by the `parseManifest` function.
+     *
+     * @param {string|undefined} url - URL of the Manifest we want to load.
+     * `undefined` if the Manifest doesn't have an URL linked to it, in which case
+     * the Manifest should be loaded through another mean.
+     * @param {CancellationSignal} cancellationSignal - Signal which will allow to
+     * cancel the loading operation if the Manifest is not needed anymore (for
+     * example, if the content has just been stopped).
+     * When cancelled, the promise returned by this function will reject with a
+     * `CancellationError`.
+     * @returns {Promise.<Object>} - Promise emitting the loaded Manifest, that
+     * then can be parsed through the `parseManifest` function.
+     *
+     * Rejects in two cases:
+     *   - The loading operation has been cancelled through the `cancelSignal`
+     *     given in argument.
+     *     In that case, this Promise will reject with a `CancellationError`.
+     *   - The loading operation failed, most likely due to a request error.
+     *     In that case, this Promise will reject with the corresponding Error.
+     */
+    loadManifest: (url: string | undefined, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;
+    /**
+     * "Parser" of the Manifest pipeline, allowing to parse a loaded Manifest so
+     * it can be exploited by the rest of the RxPlayer's logic.
+     *
+     * @param {Object} manifestData - Response obtained from the `loadManifest`
+     * function.
+     * @param {Object} parserOptions - Various options relative to the parsing
+     * operation.
+     * @param {Function} onWarnings - Callbacks called:
+     *   - when minor Manifest parsing errors are found
+     *   - when `scheduleRequest` rejects on requests this function can do
+     *     without.
+     * @param {CancellationSignal} cancelSignal - Cancellation signal which will
+     * allow to abort the parsing operation if you do not want the Manifest
+     * anymore.
+     *
+     * That cancellationSignal can be triggered at any time, such as:
+     *   - after a warning is received
+     *   - while a request scheduled through the `scheduleRequest` argument is
+     *     pending.
+     *
+     * `parseManifest` will interrupt all operations if the signal has been
+     * triggered in one of those scenarios, and will automatically reject with
+     * the corresponding `CancellationError` instance.
+     * @param {Function} scheduleRequest - Allows `parseManifest` to schedule
+     * network requests, for example to fetch sub-parts of the Manifest or
+     * supplementary resources we can only know of at Manifest parsing time.
+     *
+     * All requests scheduled through `scheduleRequest` should abort (and the
+     * corresponding Promise reject a `CancellationError`) when/if `cancelSignal`
+     * is triggered.
+     *
+     * If a request scheduled through `scheduleRequest` rejects with an error:
+     *   - either the error was due to a cancellation, in which case
+     *     `parseManifest` should reject the same error immediately.
+     *   - either the requested resource was mandatory to parse the Manifest
+     *     in which case `parseManifest` will reject with the same error.
+     *   - either the parser can make up for that error, in which case it will
+     *     just be emitted as a warning and `parseManifest` will continue its
+     *     operations.
+     * @returns {Object | Promise.<Object>} - Returns directly the Manifest data
+     * if the parsing can be performed synchronously or through a Promise if it
+     * needs to perform network requests first through the `scheduleRequest`
+     * function.
+     *
+     * Throws if an error happens synchronously and rejects if it happens
+     * asynchronously.
+     *
+     * If this error is due to a failed request performed through the
+     * `scheduleRequest` argument, then the rejected error should be the same one
+     * than the one rejected by `scheduleRequest`.
+     *
+     * If this error is due to a cancellation instead (indicated through the
+     * `cancelSignal` argument), then the rejected error should be the
+     * `CancellationError` instance instead.
+     */
+    parseManifest: (manifestData: IRequestedData<unknown>, parserOptions: IManifestParserOptions, onWarnings: (warnings: Error[]) => void, cancelSignal: CancellationSignal, scheduleRequest: IManifestParserRequestScheduler) => IManifestParserResult | Promise<IManifestParserResult>;
+    /**
+     * @deprecated
+     * "Resolves the Manifest's URL, to obtain its true URL.
+     * This is a deprecated function which corresponds to an old use case at
+     * Canal+ where the URL of the Manifest first need to be parsed from a .wsx
+     * file.
+     * Thankfully this API should not be used anymore, though to not break
+     * compatibility, we have to keep it until a v4.x.x release.
+     *
+     * @param {string | undefined} url - URL used to obtain the real URL of the
+     * Manifest.
+     * @param {CancellationSignal} cancelSignal - Cancellation signal which will
+     * allow to abort the resolving operation if you do not want the Manifest
+     * anymore.
+     * When cancelled, the promise returned by this function will reject with a
+     * `CancellationError`.
+     * @returns {Promise.<string|undefined>} - Promise emitting the "real" URL of
+     * the Manifest, that should be loaded by the `loadManifest` function.
+     * `undefined` if the URL is either unknown or inexistant.
+     *
+     * Rejects in two cases:
+     *
+     *   1. The resolving operation has been aborted through the `cancelSignal`
+     *      given in argument.
+     *      In that case, this Promise will reject a `CancellationError`.
+     *
+     *   2. The resolving operation failed, most likely due to a request error.
+     *      In that case, this Promise will reject the corresponding Error.
+     */
+    resolveManifestUrl?: (url: string | undefined, cancelSignal: CancellationSignal) => Promise<string | undefined>;
+}
+/** Functions allowing to load and parse segments of any type. */
+export interface ISegmentPipeline<TLoadedFormat, TParsedSegmentDataFormat> {
+    loadSegment: ISegmentLoader<TLoadedFormat>;
+    parseSegment: ISegmentParser<TLoadedFormat, TParsedSegmentDataFormat>;
 }
 /**
- * @deprecated
- * "Resolves the Manifest's URL, to obtain its true URL.
- * This is a deprecated function which corresponds to an old use case at
- * Canal+ where the URL of the Manifest first need to be parsed from a .wsx
- * file.
- * Thankfully this API should not be used anymore, though to not break
- * compatibility, we have to keep it until a v4.x.x release.
+ * Segment loader function, allowing to load a segment of any type.
+ * @param {stop|null} url - URL at which the segment should be downloaded.
+ * `null` if we do not have an URL (in which case the segment should be loaded
+ * through other means, such as information taken from the segment's content).
+ * @param {Object} content - Content linked to the wanted segment.
+ * @param {CancellationSignal} cancelSignal - Cancellation signal which will
+ * allow to cancel the loading operation if the segment is not needed anymore.
  *
- * @param {Object} x - Object containing the URL used to obtain the real URL of
- * the Manifest.
- * @returns {Observable.<Object>}
+ * When cancelled, this loader should stop any pending operation (such as an
+ * HTTP request) and the Promise returned should reject immediately with a
+ * `CancellationError`, generated through this CancellationSignal object.
+ * @param {Object} callbacks - Callbacks called on various loader events.
+ * @returns {Promise.<Object>} - Promise resolving when it has finished loading
+ * the segment.
  */
-export declare type IManifestResolverFunction = (x: IManifestLoaderArguments) => Observable<IManifestLoaderArguments>;
+export declare type ISegmentLoader<TLoadedFormat> = (url: string | null, content: ISegmentContext, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<TLoadedFormat>) => Promise<ISegmentLoaderResultSegmentCreated<TLoadedFormat> | ISegmentLoaderResultSegmentLoaded<TLoadedFormat> | ISegmentLoaderResultChunkedComplete>;
 /**
- * "Loader" of the Manifest pipeline, allowing to request a Manifest so it can
- * later be parsed by the `parseManifest` function.
+ * Segment parser function, allowing to parse a chunk (which may be a sub-part
+ * of a segment) of any type.
  *
- * @param {Object} x - Object containing the URL of the Manifest we want to
- * load.
- * @returns {Observable.<Object>}
+ * This function will throw if it encounters any error it cannot recover from.
  */
-export declare type IManifestLoaderFunction = (x: IManifestLoaderArguments) => Observable<IManifestLoaderEvent>;
+export declare type ISegmentParser<TLoadedFormat, TParsedSegmentDataFormat> = (
+/** Attributes of the corresponding loader's response. */
+loadedSegment: {
+    /** The loaded segment data. */
+    data: TLoadedFormat;
+    /**
+     * If `true`,`data` is only a "chunk" of the whole segment (which potentially
+     * will contain multiple chunks).
+     * If `false`, `data` is the data for the whole segment.
+     */
+    isChunked: boolean;
+}, 
+/** Context about the wanted segment. */
+content: ISegmentContext, 
 /**
- * "Parser" of the Manifest pipeline, allowing to parse a loaded Manifest so
- * it can be exploited by the rest of the RxPlayer's logic.
+ * "Timescale" obtained from parsing the wanted representation's initialization
+ * segment.
  *
- * @param {Object} x
- * @returns {Observable.<Object>}
- */
-export declare type IManifestParserFunction = (x: IManifestParserArguments) => Observable<IManifestParserResponseEvent | IManifestParserWarningEvent>;
-/** Functions allowing to load and parse segments of any type. */
-export interface ISegmentPipeline<LoadedFormat, ParsedInitDataFormat, ParsedMediaDataFormat> {
-    loader: ISegmentLoader<LoadedFormat>;
-    parser: ISegmentParser<LoadedFormat, ParsedInitDataFormat, ParsedMediaDataFormat>;
-}
-/**
- * Segment loader function, allowing to load a segment of any type.
- * @param {Object} x
- * @returns {Observable.<Object>}
+ * `undefined` if either no such `timescale` has been parsed yet or if this
+ * value doesn't exist for the wanted segment.
+ *
+ * This value can be useful when parsing the loaded segment's data.
  */
-export declare type ISegmentLoader<LoadedFormat> = (x: ISegmentLoaderArguments) => Observable<ISegmentLoaderEvent<LoadedFormat>>;
+initTimescale: number | undefined) => 
 /**
- * Segment parser function, allowing to parse a segment of any type.
- * @param {Object} x
- * @returns {Observable.<Object>}
+ * The parsed data.
+ *
+ * Can be of two types:
+ *   - `ISegmentParserParsedInitChunk`: When the parsed chunk was part of an
+ *     initialization segment.
+ *     Such segments only serve to initialize the decoder and do not contain
+ *     any decodable media data.
+ *   - `ISegmentParserParsedMediaChunk`: When the parsed chunk was part of a
+ *     media segment.
+ *     Such segments generally contain decodable media data.
  */
-export declare type ISegmentParser<LoadedFormat, ParsedInitDataFormat, ParsedMediaDataFormat> = (x: ISegmentParserArguments<LoadedFormat>) => Observable<ISegmentParserInitSegment<ParsedInitDataFormat> | ISegmentParserSegment<ParsedMediaDataFormat>>;
-/** Arguments for the loader of the manifest pipeline. */
-export interface IManifestLoaderArguments {
+ISegmentParserParsedInitChunk<TParsedSegmentDataFormat> | ISegmentParserParsedMediaChunk<TParsedSegmentDataFormat>;
+export interface IManifestParserOptions {
     /**
-     * URL of the Manifest we want to load.
-     * `undefined` if the Manifest doesn't have an URL linked to it, in which
-     *  case the Manifest should be loaded from another mean.
+     * If set, offset to add to `performance.now()` to obtain the current
+     * server's time.
      */
-    url: string | undefined;
+    externalClockOffset: number | undefined;
+    /** Original URL used for the full version of the Manifest. */
+    originalUrl: string | undefined;
+    /** The previous value of the Manifest (when updating). */
+    previousManifest: Manifest | null;
+    /**
+     * If set to `true`, the Manifest parser can perform advanced optimizations
+     * to speed-up the parsing process. Those optimizations might lead to a
+     * de-synchronization with what is actually on the server, hence the "unsafe"
+     * part.
+     * To use with moderation and only when needed.
+     */
+    unsafeMode: boolean;
 }
-/** Arguments for the loader of the segment pipelines. */
-export interface ISegmentLoaderArguments {
-    /** Manifest object related to this segment. */
-    manifest: Manifest;
-    /** Period object related to this segment. */
-    period: Period;
-    /** Adaptation object related to this segment. */
-    adaptation: Adaptation;
-    /** Representation Object related to this segment. */
-    representation: Representation;
-    /** Segment we want to load. */
-    segment: ISegment;
+export interface IManifestParserCallbacks {
+    onWarning: (warning: Error) => void;
     /**
-     * URL at which the segment should be downloaded.
-     * `null` if we do not have an URL (in which case the segment should be loaded
-     * through an other mean).
+     * @param {Function} performRequest - Function performing the request
+     * @param {TaskCanceller} canceller - Interface allowing to cancel the request
+     * performed by the `performRequest` argument.
+     * @returns {Promise.<Object>}
      */
-    url: string | null;
+    scheduleRequest: (performRequest: () => Promise<IRequestedData<Document | string>>, canceller: TaskCanceller) => Promise<IRequestedData<Document | string>>;
 }
-/** Payload of a "data-loaded" event. */
-export interface ILoaderDataLoadedValue<T> {
-    /** The loaded response data. */
-    responseData: T;
-    /** Duration the request took to be performed, in seconds. */
-    duration: number | undefined;
+/**
+ * Function allowing a Manifest parser to perform a request needed for the
+ * parsing of the Manifest.
+ *
+ * @param {Function} performRequest - Function performing the wanted request.
+ * Note that this function might be called multiple times depending on the error
+ * obtained at the last call.
+ *
+ * Should resolve with the requested data on success.
+ *
+ * Rejects in two cases:
+ *   - The request has been cancelled through the `canceller` given.
+ *     In that case, this Promise will reject with a `CancellationError`.
+ *
+ *   - The request failed.
+ *     In that case, this Promise will reject with the corresponding Error.
+ *
+ * @param {TaskCanceller} canceller - Interface allowing to cancel the request
+ * performed by the `performRequest` argument.
+ *
+ * When triggered, the request should be aborted and the Promise returned by
+ * `performRequest` should reject the corresponding `CancellationError`.
+ *
+ * The Promise returned by that function should in consequence also reject the
+ * same `CancellationError`.
+ *
+ * @returns {Promise.<Object>} - Promise resolving with the requested data on
+ * success.
+ *
+ * Rejects in two cases:
+ *   - The request has been cancelled through the `canceller` given.
+ *     In that case, this Promise will reject with a `CancellationError`.
+ *
+ *   - All the attempts to perform the request failed.
+ *     In that case, this Promise will reject with the Error corresponding to
+ *     the last performed request.
+ */
+export declare type IManifestParserRequestScheduler = (performRequest: () => Promise<IRequestedData<ILoadedManifestFormat>>) => Promise<IRequestedData<ILoadedManifestFormat>>;
+/** Event emitted when a Manifest has been parsed by a Manifest parser. */
+export interface IManifestParserResult {
+    /** The parsed Manifest Object itself. */
+    manifest: Manifest;
     /**
-     * "Real" URL (post-redirection) at which the data can be loaded.
+     * "Real" URL (post-redirection) at which the Manifest can be refreshed.
      *
-     * Note that this doesn't always apply e.g. some data might need multiple
+     * Note that this doesn't always apply e.g. some Manifest might need multiple
      * URLs to be fetched, some other might need to fetch no URL.
      * This property should only be set when a unique URL is sufficient to
      * retrieve the whole data.
      */
-    url?: string;
+    url?: string | undefined;
+}
+/**
+ * Allow the parser to ask for loading supplementary ressources while still
+ * profiting from the same retries and error management than the loader.
+ */
+export interface IManifestParserRequestNeeded {
+    resultType: "request-needed";
+    performRequest: IManifestParserRequest;
+}
+/**
+ * Time information for a single segment.
+ * Those variables expose the best guess we have on the effective duration and
+ * starting time that the corresponding segment should have at decoding time.
+ */
+export interface IChunkTimeInfo {
     /**
-     * Time at which the request began in terms of `performance.now`.
-     * If fetching the corresponding data necessitated to perform multiple
-     * requests, this time corresponds to the first request made.
+     * Difference between the latest and the earliest presentation time
+     * available in that chunk, in seconds.
+     *
+     * If multiple chunks are present in a single segment (e.g. low-latency CMAF
+     * chunks, this is only the duration of the current chunk).
+     *
+     * Either `undefined` or set to `0` for an initialization segment.
      */
-    sendingTime?: number;
+    duration: number | undefined;
+    /** Earliest presentation time available in that segment, in seconds. */
+    time: number;
+}
+/** Text track segment data, once parsed. */
+export interface ITextTrackSegmentData {
+    /** The text track data, in the format indicated in `type`. */
+    data: string;
+    /** The format of `data` (examples: "ttml", "srt" or "vtt") */
+    type: string;
     /**
-     * Time at which the request ended in terms of `performance.now`.
-     * If fetching the corresponding data necessitated to perform multiple
-     * requests, this time corresponds to the last request to end.
+     * Language in which the text track is, as a language code.
+     * This is mostly needed for "sami" subtitles, to know which cues can / should
+     * be parsed.
      */
-    receivedTime?: number;
-    /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
-    size: number | undefined;
-}
-/** Form that can take a loaded Manifest once loaded. */
-export declare type ILoadedManifest = Document | ArrayBuffer | string | IMetaPlaylist | ILocalManifest | Manifest;
-/** Event emitted by a Manifest loader when the Manifest is fully available. */
-export interface IManifestLoaderDataLoadedEvent {
-    type: "data-loaded";
-    value: ILoaderDataLoadedValue<ILoadedManifest>;
+    language?: string | undefined;
+    /** start time from which the segment apply, in seconds. */
+    start?: number | undefined;
+    /** end time until which the segment apply, in seconds. */
+    end?: number | undefined;
 }
-/** Event emitted by a segment loader when the data has been fully loaded. */
-export interface ISegmentLoaderDataLoadedEvent<T> {
-    type: "data-loaded";
-    value: ILoaderDataLoadedValue<T>;
+/** Format under which image data is decodable by the RxPlayer. */
+export interface IImageTrackSegmentData {
+    data: IBifThumbnail[];
+    end: number;
+    start: number;
+    timescale: number;
+    type: string;
 }
+export declare type IManifestParserRequest1 = ((
 /**
- * Event emitted by a segment loader when the data is available without needing
- * to perform any request.
+ * Cancellation signal which will allow to cancel the request if the
+ * Manifest is not needed anymore.
  *
- * Such data are for example directly generated from already-available data,
- * such as properties of a Manifest.
+ * When cancelled, this parser should stop any pending operation (such as an
+ * HTTP request) and the Promise returned should reject immediately after with
+ * a `CancellationError`.
  */
-export interface ISegmentLoaderDataCreatedEvent<T> {
-    type: "data-created";
-    value: {
-        responseData: T;
-    };
-}
+cancelSignal: CancellationSignal) => Promise<IRequestedData<Document | string>>);
+export declare type IManifestParserRequest = (
 /**
- * Event emitted by a segment loader when new information on a pending request
- * is available.
+ * Cancellation signal which will allow to cancel the request if the
+ * Manifest is not needed anymore.
  *
- * Note that this event is not mandatory.
- * It will be used to allow to communicate network metrics to the rest of the
- * player, like to adapt the quality of the content depending on the user's
- * bandwidth.
+ * When cancelled, this parser should stop any pending operation (such as an
+ * HTTP request) and the Promise returned should reject immediately after with
+ * a `CancellationError`.
  */
-export interface ILoaderProgressEvent {
-    type: "progress";
-    value: {
-        /** Time since the beginning of the request so far, in seconds. */
-        duration: number;
-        /** Size of the data already downloaded, in bytes. */
-        size: number;
-        /** Size of whole data to download (data already-loaded included), in bytes. */
-        totalSize?: number;
-    };
+cancelSignal: CancellationSignal) => Promise<IManifestParserResult | IManifestParserRequestNeeded>;
+export interface ITransportAudioVideoSegmentPipeline {
+    loadSegment: ISegmentLoader<ILoadedAudioVideoSegmentFormat>;
+    parseSegment: ISegmentParser<ILoadedAudioVideoSegmentFormat, Uint8Array | ArrayBuffer | null>;
 }
-/** Event emitted by a segment loader when a chunk of the response is available. */
-export interface ISegmentLoaderDataChunkEvent {
-    type: "data-chunk";
-    value: {
-        /** Loaded chunk, as raw data. */
-        responseData: ArrayBuffer | Uint8Array;
-    };
+export interface ITransportTextSegmentPipeline {
+    loadSegment: ISegmentLoader<ILoadedTextSegmentFormat>;
+    parseSegment: ISegmentParser<ILoadedTextSegmentFormat, ITextTrackSegmentData | null>;
 }
-/**
- * Event emitted by segment loaders when all data from a segment has been
- * communicated through `ISegmentLoaderDataChunkEvent` events.
- */
-export interface ISegmentLoaderDataChunkCompleteEvent {
-    type: "data-chunk-complete";
-    value: {
-        /** Duration the request took to be performed, in seconds. */
-        duration: number | undefined;
-        /**
-         * "Real" URL (post-redirection) at which the segment was loaded.
-         *
-         * Note that this doesn't always apply e.g. some segment might need multiple
-         * URLs to be fetched, some other might need to fetch no URL.
-         * This property should only be set when a unique URL is sufficient to
-         * retrieve the whole data.
-         */
-        url?: string;
-        /**
-         * Time at which the request began in terms of `performance.now`.
-         * If fetching the corresponding data necessitated to perform multiple
-         * requests, this time corresponds to the first request made.
-         */
-        sendingTime?: number;
-        /**
-         * Time at which the request ended in terms of `performance.now`.
-         * If fetching the corresponding data necessitated to perform multiple
-         * requests, this time corresponds to the last request to end.
-         */
-        receivedTime?: number;
-        /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
-        size: number | undefined;
-    };
+export interface ITransportImageSegmentPipeline {
+    loadSegment: ISegmentLoader<ILoadedImageSegmentFormat>;
+    parseSegment: ISegmentParser<ILoadedImageSegmentFormat, IImageTrackSegmentData | null>;
 }
-/**
- * Event sent by a segment loader when the corresponding segment is available
- * chunk per chunk.
- */
-export declare type ISegmentLoaderChunkEvent = ISegmentLoaderDataChunkEvent | ISegmentLoaderDataChunkCompleteEvent;
-/** Event emitted by a Manifest loader. */
-export declare type IManifestLoaderEvent = IManifestLoaderDataLoadedEvent;
-/** Event emitted by a segment loader. */
-export declare type ISegmentLoaderEvent<T> = ILoaderProgressEvent | ISegmentLoaderChunkEvent | ISegmentLoaderDataLoadedEvent<T> | ISegmentLoaderDataCreatedEvent<T>;
-/** Arguments given to the `parser` function of the Manifest pipeline. */
-export interface IManifestParserArguments {
-    /** Response obtained from the loader. */
-    response: ILoaderDataLoadedValue<unknown>;
-    /** Original URL used for the full version of the Manifest. */
-    url?: string;
-    /**
-     * If set, offset to add to `performance.now()` to obtain the current
-     * server's time.
-     */
-    externalClockOffset?: number;
-    /** The previous value of the Manifest (when updating). */
-    previousManifest: Manifest | null;
-    /**
-     * Allow the parser to ask for loading supplementary ressources while still
-     * profiting from the same retries and error management than the loader.
-     */
-    scheduleRequest: (request: () => Observable<ILoaderDataLoadedValue<string | Document | ArrayBuffer>>) => Observable<ILoaderDataLoadedValue<string | Document | ArrayBuffer>>;
+export declare type ITransportSegmentPipeline = ITransportAudioVideoSegmentPipeline | ITransportTextSegmentPipeline | ITransportImageSegmentPipeline;
+export declare type ITransportPipeline = ITransportManifestPipeline | ITransportSegmentPipeline;
+interface IServerSyncInfos {
+    serverTimestamp: number;
+    clientTime: number;
+}
+export interface ITransportOptions {
+    aggressiveMode?: boolean | undefined;
+    checkMediaSegmentIntegrity?: boolean | undefined;
+    lowLatencyMode: boolean;
+    manifestLoader?: ICustomManifestLoader | undefined;
+    manifestUpdateUrl?: string | undefined;
+    referenceDateTime?: number | undefined;
+    representationFilter?: IRepresentationFilter | undefined;
+    segmentLoader?: ICustomSegmentLoader | undefined;
+    serverSyncInfos?: IServerSyncInfos | undefined;
+    supplementaryImageTracks?: ISupplementaryImageTrack[] | undefined;
+    supplementaryTextTracks?: ISupplementaryTextTrack[] | undefined;
+    __priv_patchLastSegmentInSidx?: boolean | undefined;
+}
+export declare type ICustomSegmentLoader = (infos: {
+    url: string;
+    manifest: IExposedManifest;
+    period: IExposedPeriod;
+    adaptation: IExposedAdaptation;
+    representation: IExposedRepresentation;
+    segment: IExposedSegment;
+}, callbacks: {
+    resolve: (rArgs: {
+        data: ArrayBuffer | Uint8Array;
+        sendingTime?: number | undefined;
+        receivingTime?: number | undefined;
+        size?: number | undefined;
+        duration?: number | undefined;
+    }) => void;
+    reject: (err?: unknown) => void;
+    fallback: () => void;
+    progress: (info: {
+        duration: number;
+        size: number;
+        totalSize?: number | undefined;
+    }) => void;
+}) => (() => void) | void;
+export declare type ICustomManifestLoader = (url: string | undefined, callbacks: {
+    resolve: (args: {
+        data: ILoadedManifestFormat;
+        url?: string | undefined;
+        sendingTime?: number | undefined;
+        receivingTime?: number | undefined;
+        size?: number | undefined;
+        duration?: number | undefined;
+    }) => void;
+    reject: (err?: Error) => void;
+    fallback: () => void;
+}) => (() => void) | void;
+export interface ISegmentContext {
+    /** Manifest object related to this segment. */
+    manifest: Manifest;
+    /** Period object related to this segment. */
+    period: Period;
+    /** Adaptation object related to this segment. */
+    adaptation: Adaptation;
+    /** Representation Object related to this segment. */
+    representation: Representation;
+    /** Segment we want to load. */
+    segment: ISegment;
+}
+export interface ISegmentLoaderCallbacks<T> {
     /**
-     * If set to `true`, the Manifest parser can perform advanced optimizations
-     * to speed-up the parsing process. Those optimizations might lead to a
-     * de-synchronization with what is actually on the server, hence the "unsafe"
-     * part.
-     * To use with moderation and only when needed.
+     * Callback called when new progress information on a segment request is
+     * available.
+     * The information emitted though this callback can be used to gather
+     * metrics on a current, un-terminated, request.
      */
-    unsafeMode: boolean;
-}
-/** Arguments given to the `parser` function of the segment pipeline. */
-export interface ISegmentParserArguments<T> {
-    /** Attributes of the corresponding loader's response. */
-    response: {
-        /** The loaded data. */
-        data: T;
-        /**
-         * If `true`,`data` is only a "chunk" of the whole segment (which potentially
-         * will contain multiple chunks).
-         * If `false`, `data` is the data for the whole segment.
-         */
-        isChunked: boolean;
-    };
+    onProgress: (info: ISegmentLoadingProgressInformation) => void;
     /**
-     * "Timescale" obtained from parsing the wanted representation's initialization
+     * Callback called when a decodable sub-part of the segment is available.
+     *
+     * Note that this callback is only called if the loader decides to load the
+     * wanted segment in a "chunk" mode, that is, when the segment is loaded
+     * decodable chunk by decodable chunk, each being a subpart of this same
      * segment.
      *
-     * `undefined` if either no such `timescale` has been parsed yet or if this
-     * value doesn't exist for the wanted segment.
+     * In that case, this callback might be called multiple times for subsequent
+     * decodable chunks until the Promise resolves.
      *
-     * This value can be useful when parsing the loaded segment's data.
+     * Not all segments are loaded in a "chunk" mode.
+     * The alternatives to this mode are:
+     *
+     *   - when the segment is created locally without needing to perform any
+     *     request.
+     *
+     *   - when the segment is loaded as a whole.
+     *
+     * In both of those other cases, the segment data can be retrieved in the
+     * Promise returned by the segment loader instead.
      */
-    initTimescale?: number;
-    /** Context about the wanted segment. */
-    content: {
-        /** Manifest object related to this segment. */
-        manifest: Manifest;
-        /** Period object related to this segment. */
-        period: Period;
-        /** Adaptation object related to this segment. */
-        adaptation: Adaptation;
-        /** Representation Object related to this segment. */
-        representation: Representation;
-        /** Segment we want to parse. */
-        segment: ISegment;
-    };
+    onNewChunk: (data: T) => void;
 }
-/** Event emitted when a Manifest object has been parsed. */
-export interface IManifestParserResponseEvent {
-    type: "parsed";
-    value: {
-        /** The parsed Manifest Object itself. */
-        manifest: Manifest;
-        /**
-         * "Real" URL (post-redirection) at which the Manifest can be refreshed.
-         *
-         * Note that this doesn't always apply e.g. some Manifest might need multiple
-         * URLs to be fetched, some other might need to fetch no URL.
-         * This property should only be set when a unique URL is sufficient to
-         * retrieve the whole data.
-         */
-        url?: string;
-    };
+/** Information related to a pending Segment request progressing. */
+export interface ISegmentLoadingProgressInformation {
+    /** Time since the beginning of the request so far, in seconds. */
+    duration: number;
+    /** Size of the data already downloaded, in bytes. */
+    size: number;
+    /** Size of whole data to download (data already-loaded included), in bytes. */
+    totalSize?: number | undefined;
 }
-/** Event emitted when a minor error was encountered when parsing the Manifest. */
-export interface IManifestParserWarningEvent {
-    type: "warning";
-    /** Error describing the minor parsing error encountered. */
-    value: Error;
+/**
+ * Result returned by a segment loader when a segment has been loaded in a
+ * "chunk" mode.
+ * In that mode, the segment has been divided into multiple decodable chunks
+ * each sent in order through the `onNewChunk` callback of the corresponding
+ * loader.
+ */
+export interface ISegmentLoaderResultChunkedComplete {
+    resultType: "chunk-complete";
+    /** Information on the request performed. */
+    resultData: IChunkCompleteInformation;
 }
 /**
- * Time information for a single segment.
- * Those variables expose the best guess we have on the effective duration and
- * starting time that the corresponding segment should have at decoding time.
+ * Result returned by a segment loader when a segment has been loaded
+ * by performing a request.
  */
-export interface IChunkTimeInfo {
+export interface ISegmentLoaderResultSegmentLoaded<T> {
+    resultType: "segment-loaded";
+    /** Segment data and information on the request. */
+    resultData: IRequestedData<T>;
+}
+/**
+ * Result returned by a segment loader when a segment has been fully
+ * created locally and thus did not depend on a request.
+ * TODO merge with ISegmentLoaderResultSegmentLoaded?
+ */
+export interface ISegmentLoaderResultSegmentCreated<T> {
+    resultType: "segment-created";
+    /** The data iself. */
+    resultData: T;
+}
+/** Data emitted in a `ISegmentLoaderResultChunkedComplete`. */
+export interface IChunkCompleteInformation {
+    /** Duration the request took to be performed, in seconds. */
+    requestDuration: number | undefined;
     /**
-     * Difference between the latest and the earliest presentation time
-     * available in that segment, in seconds.
+     * "Real" URL (post-redirection) at which the segment was loaded.
      *
-     * Either `undefined` or set to `0` for an initialization segment.
+     * Note that this doesn't always apply e.g. some segment might need multiple
+     * URLs to be fetched, some other might need to fetch no URL.
+     * This property should only be set when a unique URL is sufficient to
+     * retrieve the whole data.
      */
-    duration: number | undefined;
-    /** Earliest presentation time available in that segment, in seconds. */
-    time: number;
+    url?: string | undefined;
+    /**
+     * Time at which the request began in terms of `performance.now`.
+     * If fetching the corresponding data necessitated to perform multiple
+     * requests, this time corresponds to the first request made.
+     */
+    sendingTime?: number | undefined;
+    /**
+     * Time at which the request ended in terms of `performance.now`.
+     * If fetching the corresponding data necessitated to perform multiple
+     * requests, this time corresponds to the last request to end.
+     */
+    receivedTime?: number | undefined;
+    /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
+    size: number | undefined;
 }
-/** Payload sent when an initialization segment has been parsed. */
-export interface ISegmentParserParsedInitSegment<T> {
+/** Format of a loaded Manifest before parsing. */
+export declare type ILoadedManifestFormat = Document | string | ArrayBuffer | IMetaPlaylist | ILocalManifest | Manifest;
+/** Format of a loaded audio and video segment before parsing. */
+export declare type ILoadedAudioVideoSegmentFormat = Uint8Array | ArrayBuffer | null;
+/** Format of a loaded text segment before parsing. */
+export declare type ILoadedTextSegmentFormat = Uint8Array | ArrayBuffer | string | null;
+/** Format of a loaded image segment before parsing. */
+export declare type ILoadedImageSegmentFormat = Uint8Array | ArrayBuffer | null;
+/**
+ * Result returned by a segment parser when it parsed a chunk from an init
+ * segment (which does not contain media data).
+ */
+export interface ISegmentParserParsedInitChunk<DataType> {
+    segmentType: "init";
     /**
      * Initialization segment that can be directly pushed to the corresponding
      * buffer.
      */
-    initializationData: T | null;
+    initializationData: DataType | null;
     /**
      * Timescale metadata found inside this initialization segment.
      * That timescale might be useful when parsing further merdia segments.
      */
-    initTimescale?: number;
+    initTimescale?: number | undefined;
     /**
      * If set to `true`, some protection information has been found in this
      * initialization segment and lead the corresponding `Representation`
@@ -379,36 +590,53 @@ export interface ISegmentParserParsedInitSegment<T> {
      */
     protectionDataUpdate: boolean;
 }
-/** Payload sent when an media segment has been parsed. */
-export interface ISegmentParserParsedSegment<T> {
-    /** Data to decode. */
-    chunkData: T | null;
-    /** Time information about the segment. */
+/**
+ * Result returned by a segment parser when it parsed a chunk from a media
+ * segment (which contains media data, unlike an initialization segment).
+ */
+export interface ISegmentParserParsedMediaChunk<DataType> {
+    segmentType: "media";
+    /**
+     * Parsed chunk of data that can be decoded.
+     * `null` if no data was parsed.
+     */
+    chunkData: DataType | null;
+    /**
+     * Time information on this parsed chunk.
+     * `null` if unknown.
+     */
     chunkInfos: IChunkTimeInfo | null;
     /**
-     * Time offset, in seconds, to add to the absolute timed data defined in
+     * time offset, in seconds, to add to the absolute timed data defined in
      * `chunkData` to obtain the "real" wanted effective time.
      *
      * For example:
-     *   If `chunkData` announce that the segment begins at 32 seconds, and
-     *   `chunkOffset` equals to `4`, then the segment should really begin at 36
-     *   seconds (32 + 4).
+     *   If `chunkData` announces (when parsed by the demuxer or decoder) that the
+     *   segment begins at 32 seconds, and `chunkOffset` equals to `4`, then the
+     *   segment should really begin at 36 seconds (32 + 4).
      *
      * Note that `chunkInfos` needs not to be offseted as it should already
      * contain the correct time information.
      */
     chunkOffset: number;
     /**
-     * Start and end windows at which this segment applies (part of the segment
-     * respectively before and after that time will be ignored).
+     * start and end windows for the segment (part of the chunk respectively
+     * before and after that time will be ignored).
+     * `undefined` when their is no such limitation.
      */
     appendWindow: [
         number | undefined,
         number | undefined
     ];
-    /** Inband events parsed from segment data. */
-    inbandEvents?: IInbandEvent[];
-    /** Tells if the result of the parsing shows that the manifest should be refreshed */
+    /**
+     * If set and not empty, then "events" have been encountered in this parsed
+     * chunks.
+     */
+    inbandEvents?: IInbandEvent[] | undefined;
+    /**
+     * If set to `true`, then parsing this chunk revealed that the current
+     * Manifest instance needs to be refreshed.
+     */
     needsManifestRefresh?: boolean;
     /**
      * If set to `true`, some protection information has been found in this
@@ -423,105 +651,34 @@ export interface ISegmentParserParsedSegment<T> {
      */
     protectionDataUpdate: boolean;
 }
-/**
- * What a segment parser returns when parsing an initialization segment.
- *
- * Those types of segment contain no decodable data and are only there for
- * initialization purposes, such as giving initial infos to the decoder on
- * subsequent media segments that will be pushed.
- */
-export interface ISegmentParserInitSegment<T> {
-    type: "parsed-init-segment";
-    value: ISegmentParserParsedInitSegment<T>;
-}
-/**
- * What a segment parser returns when parsing a media segment.
- * Those types of segment contain decodable data.
- */
-export interface ISegmentParserSegment<T> {
-    type: "parsed-segment";
-    value: ISegmentParserParsedSegment<T>;
-}
-/** Text track segment data, once parsed. */
-export interface ITextTrackSegmentData {
-    /** The text track data, in the format indicated in `type`. */
-    data: string;
-    /** The format of `data` (examples: "ttml", "srt" or "vtt") */
-    type: string;
+/** Describe data loaded through a request. */
+export interface IRequestedData<T> {
+    /** The loaded response data. */
+    responseData: T;
+    /** Duration the request took to be performed, in seconds. */
+    requestDuration: number | undefined;
     /**
-     * Language in which the text track is, as a language code.
-     * This is mostly needed for "sami" subtitles, to know which cues can / should
-     * be parsed.
+     * "Real" URL (post-redirection) at which the data can be loaded.
+     *
+     * Note that this doesn't always apply e.g. some data might need multiple
+     * URLs to be fetched, some other might need to fetch no URL.
+     * This property should only be set when a unique URL is sufficient to
+     * retrieve the whole data.
      */
-    language?: string;
-    /** start time from which the segment apply, in seconds. */
-    start?: number;
-    /** end time until which the segment apply, in seconds. */
-    end?: number;
-}
-/** Format under which image data is decodable by the RxPlayer. */
-export interface IImageTrackSegmentData {
-    /** Exploitable image track data. */
-    data: IBifThumbnail[];
-    /** End time time until which the segment apply, in the timescale given. */
-    end: number;
-    /** Start time time from which the segment apply, in the timescale given. */
-    start: number;
-    /** Timescale to convert the `start` and `end` properties into seconds. */
-    timescale: number;
-    /** The format the data is in (example: "bif"). */
-    type: "bif";
-}
-interface IServerSyncInfos {
-    serverTimestamp: number;
-    clientTime: number;
-}
-export interface ITransportOptions {
-    aggressiveMode?: boolean;
-    checkMediaSegmentIntegrity?: boolean;
-    lowLatencyMode: boolean;
-    manifestLoader?: CustomManifestLoader;
-    manifestUpdateUrl?: string;
-    referenceDateTime?: number;
-    representationFilter?: IRepresentationFilter;
-    segmentLoader?: CustomSegmentLoader;
-    serverSyncInfos?: IServerSyncInfos;
-    supplementaryImageTracks?: ISupplementaryImageTrack[];
-    supplementaryTextTracks?: ISupplementaryTextTrack[];
-    __priv_patchLastSegmentInSidx?: boolean;
+    url?: string | undefined;
+    /**
+     * Time at which the request began in terms of `performance.now`.
+     * If fetching the corresponding data necessitated to perform multiple
+     * requests, this time corresponds to the first request made.
+     */
+    sendingTime?: number | undefined;
+    /**
+     * Time at which the request ended in terms of `performance.now`.
+     * If fetching the corresponding data necessitated to perform multiple
+     * requests, this time corresponds to the last request to end.
+     */
+    receivedTime?: number | undefined;
+    /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
+    size: number | undefined;
 }
-export declare type CustomSegmentLoader = (args: {
-    adaptation: Adaptation;
-    representation: Representation;
-    segment: ISegment;
-    transport: string;
-    url: string;
-    manifest: Manifest;
-}, callbacks: {
-    resolve: (rArgs: {
-        data: ArrayBuffer | Uint8Array;
-        sendingTime?: number;
-        receivingTime?: number;
-        size?: number;
-        duration?: number;
-    }) => void;
-    progress: (pArgs: {
-        duration: number;
-        size: number;
-        totalSize?: number;
-    }) => void;
-    reject: (err?: Error) => void;
-    fallback?: () => void;
-}) => (() => void) | void;
-export declare type CustomManifestLoader = (url: string | undefined, callbacks: {
-    resolve: (args: {
-        data: ILoadedManifest;
-        sendingTime?: number;
-        receivingTime?: number;
-        size?: number;
-        duration?: number;
-    }) => void;
-    reject: (err?: Error) => void;
-    fallback?: () => void;
-}) => (() => void) | void;
 export {};