rx-player 3.28.0-dev.2022063000 → 3.28.1-dev.2022083000

package/dist/_esm5.processed/core/stream/representation/get_buffer_status.js

@@ -64,38 +64,30 @@ export default function getBufferStatus(content, initialWantedTime, playbackObse
      * `true` if the current `RepresentationStream` has loaded all the
      * needed segments for this Representation until the end of the Period.
      */
-    var hasFinishedLoading = neededRange.hasReachedPeriodEnd &&
+    var hasFinishedLoading = representation.index.isInitialized() &&
+        representation.index.isFinished() &&
+        neededRange.hasReachedPeriodEnd &&
         prioritizedNeededSegments.length === 0 &&
         segmentsOnHold.length === 0;
-    var imminentDiscontinuity;
-    if (!representation.index.isInitialized() ||
-        // TODO better handle contents not chronologically generated
-        (!representation.index.areSegmentsChronologicallyGenerated() &&
-            !hasFinishedLoading)) {
-        // We might be missing information about future segments
-        imminentDiscontinuity = null;
+    /**
+     * Start time in seconds of the next available not-yet pushed segment.
+     * `null` if no segment is wanted for the current wanted range.
+     */
+    var nextSegmentStart = null;
+    if (segmentsBeingPushed.length > 0) {
+        nextSegmentStart = Math.min.apply(Math, segmentsBeingPushed.map(function (info) { return info.segment.time; }));
     }
-    else {
-        /**
-         * Start time in seconds of the next available not-yet pushed segment.
-         * `null` if no segment is wanted for the current wanted range.
-         */
-        var nextSegmentStart = null;
-        if (segmentsBeingPushed.length > 0) {
-            nextSegmentStart = Math.min.apply(Math, segmentsBeingPushed.map(function (info) { return info.segment.time; }));
-        }
-        if (segmentsOnHold.length > 0) {
-            nextSegmentStart = nextSegmentStart !== null ?
-                Math.min(nextSegmentStart, segmentsOnHold[0].time) :
-                segmentsOnHold[0].time;
-        }
-        if (prioritizedNeededSegments.length > 0) {
-            nextSegmentStart = nextSegmentStart !== null ?
-                Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :
-                prioritizedNeededSegments[0].segment.time;
-        }
-        imminentDiscontinuity = checkForDiscontinuity(content, neededRange, nextSegmentStart, hasFinishedLoading, bufferedSegments);
+    if (segmentsOnHold.length > 0) {
+        nextSegmentStart = nextSegmentStart !== null ?
+            Math.min(nextSegmentStart, segmentsOnHold[0].time) :
+            segmentsOnHold[0].time;
+    }
+    if (prioritizedNeededSegments.length > 0) {
+        nextSegmentStart = nextSegmentStart !== null ?
+            Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :
+            prioritizedNeededSegments[0].segment.time;
     }
+    var imminentDiscontinuity = checkForDiscontinuity(content, neededRange, nextSegmentStart, hasFinishedLoading, bufferedSegments);
     return { imminentDiscontinuity: imminentDiscontinuity, hasFinishedLoading: hasFinishedLoading, neededSegments: prioritizedNeededSegments, isBufferFull: isBufferFull, shouldRefreshManifest: shouldRefreshManifest };
 }
 /**
@@ -111,7 +103,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
     var _a;
     var wantedStartPosition;
     var manifest = content.manifest, period = content.period, representation = content.representation;
-    var lastIndexPosition = representation.index.getLastPosition();
+    var lastIndexPosition = representation.index.getLastAvailablePosition();
     var representationIndex = representation.index;
     // There is an exception for when the current initially wanted time is already
     // after the last position with segments AND when we're playing the absolute

package/dist/_esm5.processed/errors/encrypted_media_error.d.ts

@@ -22,14 +22,13 @@ import { IEncryptedMediaErrorCode } from "./error_codes";
  */
 export default class EncryptedMediaError extends Error {
     readonly name: "EncryptedMediaError";
-    readonly type: string;
+    readonly type: "ENCRYPTED_MEDIA_ERROR";
     readonly code: IEncryptedMediaErrorCode;
     message: string;
     fatal: boolean;
     /**
      * @param {string} code
      * @param {string} reason
-     * @Param {Boolean} fatal
      */
     constructor(code: IEncryptedMediaErrorCode, reason: string);
 }

package/dist/_esm5.processed/errors/encrypted_media_error.js

@@ -41,7 +41,6 @@ var EncryptedMediaError = /** @class */ (function (_super) {
     /**
      * @param {string} code
      * @param {string} reason
-     * @Param {Boolean} fatal
      */
     function EncryptedMediaError(code, reason) {
         var _this = _super.call(this) || this;

package/dist/_esm5.processed/errors/error_codes.d.ts

@@ -20,7 +20,12 @@ export declare type INetworkErrorCode = "PIPELINE_LOAD_ERROR";
 export declare type IOtherErrorCode = "PIPELINE_LOAD_ERROR" | "PIPELINE_PARSE_ERROR" | "INTEGRITY_ERROR" | "NONE";
 export declare type IErrorCode = INetworkErrorCode | IMediaErrorCode | IEncryptedMediaErrorCode | IOtherErrorCode;
 export declare type INetworkErrorType = "TIMEOUT" | "ERROR_EVENT" | "PARSE_ERROR" | "ERROR_HTTP_CODE";
-declare const ErrorTypes: Record<IErrorType, IErrorType>;
+declare const ErrorTypes: {
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly MEDIA_ERROR: "MEDIA_ERROR";
+    readonly ENCRYPTED_MEDIA_ERROR: "ENCRYPTED_MEDIA_ERROR";
+    readonly OTHER_ERROR: "OTHER_ERROR";
+};
 declare const NetworkErrorTypes: Record<INetworkErrorType, INetworkErrorType>;
 declare const ErrorCodes: Record<IErrorCode, IErrorCode>;
 export { ErrorTypes, NetworkErrorTypes, ErrorCodes, };

package/dist/_esm5.processed/errors/media_error.d.ts

@@ -22,14 +22,13 @@ import { IMediaErrorCode } from "./error_codes";
  */
 export default class MediaError extends Error {
     readonly name: "MediaError";
-    readonly type: string;
+    readonly type: "MEDIA_ERROR";
     readonly message: string;
     readonly code: IMediaErrorCode;
     fatal: boolean;
     /**
      * @param {string} code
      * @param {string} reason
-     * @param {Boolean} fatal
      */
     constructor(code: IMediaErrorCode, reason: string);
 }

package/dist/_esm5.processed/errors/media_error.js

@@ -41,7 +41,6 @@ var MediaError = /** @class */ (function (_super) {
     /**
      * @param {string} code
      * @param {string} reason
-     * @param {Boolean} fatal
      */
     function MediaError(code, reason) {
         var _this = _super.call(this) || this;

package/dist/_esm5.processed/errors/network_error.d.ts

@@ -23,7 +23,7 @@ import RequestError from "./request_error";
  */
 export default class NetworkError extends Error {
     readonly name: "NetworkError";
-    readonly type: string;
+    readonly type: "NETWORK_ERROR";
     readonly message: string;
     readonly code: INetworkErrorCode;
     readonly xhr: XMLHttpRequest | null;
@@ -34,7 +34,6 @@ export default class NetworkError extends Error {
     /**
      * @param {string} code
      * @param {Error} baseError
-     * @param {Boolean} fatal
      */
     constructor(code: INetworkErrorCode, baseError: RequestError);
     /**

package/dist/_esm5.processed/errors/network_error.js

@@ -41,7 +41,6 @@ var NetworkError = /** @class */ (function (_super) {
     /**
      * @param {string} code
      * @param {Error} baseError
-     * @param {Boolean} fatal
      */
     function NetworkError(code, baseError) {
         var _this = _super.call(this) || this;

package/dist/_esm5.processed/errors/other_error.d.ts

@@ -20,14 +20,13 @@ import { IOtherErrorCode } from "./error_codes";
  */
 export default class OtherError extends Error {
     readonly name: "OtherError";
-    readonly type: string;
+    readonly type: "OTHER_ERROR";
     readonly message: string;
     readonly code: IOtherErrorCode;
     fatal: boolean;
     /**
      * @param {string} code
      * @param {string} reason
-     * @param {Boolean} fatal
      */
     constructor(code: IOtherErrorCode, reason: string);
 }

package/dist/_esm5.processed/errors/other_error.js

@@ -39,7 +39,6 @@ var OtherError = /** @class */ (function (_super) {
     /**
      * @param {string} code
      * @param {string} reason
-     * @param {Boolean} fatal
      */
     function OtherError(code, reason) {
         var _this = _super.call(this) || this;

package/dist/_esm5.processed/manifest/manifest.d.ts

@@ -277,7 +277,7 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
      * and mark them as being impossible to decrypt.
      * Then trigger a "decipherabilityUpdate" event to notify everyone of the
      * changes performed.
-     * @param {Object} keyUpdates
+     * @param {Function} isDecipherableCb
      */
     updateRepresentationsDeciperability(isDecipherableCb: (rep: Representation) => boolean | undefined): void;
     /**

package/dist/_esm5.processed/manifest/manifest.js

@@ -251,7 +251,7 @@ var Manifest = /** @class */ (function (_super) {
      * and mark them as being impossible to decrypt.
      * Then trigger a "decipherabilityUpdate" event to notify everyone of the
      * changes performed.
-     * @param {Object} keyUpdates
+     * @param {Function} isDecipherableCb
      */
     Manifest.prototype.updateRepresentationsDeciperability = function (isDecipherableCb) {
         var updates = updateDeciperability(this, isDecipherableCb);

package/dist/_esm5.processed/manifest/representation_index/static.d.ts

@@ -43,12 +43,31 @@ export default class StaticRepresentationIndex implements IRepresentationIndex {
      * Returns first position in index.
      * @returns {undefined}
      */
-    getFirstPosition(): undefined;
+    getFirstAvailablePosition(): undefined;
     /**
      * Returns last position in index.
      * @returns {undefined}
      */
-    getLastPosition(): undefined;
+    getLastAvailablePosition(): undefined;
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    getEnd(): undefined;
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     *
+     * Always `false` in a `StaticRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    awaitSegmentBetween(): false;
     /**
      * Returns false as a static file never need to be refreshed.
      * @returns {Boolean}
@@ -58,10 +77,6 @@ export default class StaticRepresentationIndex implements IRepresentationIndex {
      * @returns {null}
      */
     checkDiscontinuity(): null;
-    /**
-     * @returns {boolean}
-     */
-    areSegmentsChronologicallyGenerated(): boolean;
     /**
      * Returns true as a static file should never need lose availability.
      * @returns {Boolean}

package/dist/_esm5.processed/manifest/representation_index/static.js

@@ -46,22 +46,46 @@ var StaticRepresentationIndex = /** @class */ (function () {
                 end: Number.MAX_VALUE,
                 duration: Number.MAX_VALUE,
                 complete: true,
+                privateInfos: {},
                 timescale: 1 }];
     };
     /**
      * Returns first position in index.
      * @returns {undefined}
      */
-    StaticRepresentationIndex.prototype.getFirstPosition = function () {
+    StaticRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         return;
     };
     /**
      * Returns last position in index.
      * @returns {undefined}
      */
-    StaticRepresentationIndex.prototype.getLastPosition = function () {
+    StaticRepresentationIndex.prototype.getLastAvailablePosition = function () {
         return;
     };
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    StaticRepresentationIndex.prototype.getEnd = function () {
+        return;
+    };
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     *
+     * Always `false` in a `StaticRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    StaticRepresentationIndex.prototype.awaitSegmentBetween = function () {
+        return false;
+    };
     /**
      * Returns false as a static file never need to be refreshed.
      * @returns {Boolean}
@@ -75,12 +99,6 @@ var StaticRepresentationIndex = /** @class */ (function () {
     StaticRepresentationIndex.prototype.checkDiscontinuity = function () {
         return null;
     };
-    /**
-     * @returns {boolean}
-     */
-    StaticRepresentationIndex.prototype.areSegmentsChronologicallyGenerated = function () {
-        return true;
-    };
     /**
      * Returns true as a static file should never need lose availability.
      * @returns {Boolean}

package/dist/_esm5.processed/manifest/representation_index/types.d.ts

@@ -99,11 +99,23 @@ export interface ILocalManifestSegmentPrivateInfos {
  * exploited by the corresponding transport logic.
  */
 export interface IPrivateInfos {
+    /** Smooth-specific information allowing to generate an initialization segment. */
     smoothInitSegment?: ISmoothInitSegmentPrivateInfos | undefined;
+    /** Smooth-specific information linked to all Smooth media segments. */
     smoothMediaSegment?: ISmoothSegmentPrivateInfos | undefined;
+    /** Information that should be present on all MetaPlaylist segments. */
     metaplaylistInfos?: IMetaPlaylistPrivateInfos | undefined;
+    /**
+     * Local Manifest-specific information allowing to request the
+     * initialization segment.
+     */
     localManifestInitSegment?: ILocalManifestInitSegmentPrivateInfos | undefined;
+    /** Local Manifest-specific information allowing to request any media segment. */
     localManifestSegment?: ILocalManifestSegmentPrivateInfos | undefined;
+    /**
+     * Function allowing to know if a given emsg's event name has been
+     * explicitely authorized.
+     */
     isEMSGWhitelisted?: ((evt: IEMSG) => boolean) | undefined;
 }
 /** Represent a single Segment from a Representation. */
@@ -128,26 +140,16 @@ export interface ISegment {
      * segments" in the code.
      */
     isInit: boolean;
-    /** URLs where this segment is available. From the most to least prioritary. */
-    mediaURLs: string[] | null;
-    /**
-     * If set, the corresponding byte-range in the downloaded segment will
-     * contain an index describing other Segments
-     * TODO put in privateInfos?
-     */
-    indexRange?: [number, number] | undefined;
     /**
-     * Optional number of the Segment
-     * TODO put in privateInfos?
+     * URLs where this segment is available. From the most to least prioritary.
+     * `null` if no URL exists.
      */
-    number?: number | undefined;
+    mediaURLs: string[] | null;
     /**
      * Allows to store supplementary information on a segment that can be later
      * exploited by the transport logic.
      */
-    privateInfos?: IPrivateInfos | undefined;
-    /** Optional byte range to retrieve the Segment from its URL(s) */
-    range?: [number, number] | undefined;
+    privateInfos: IPrivateInfos | undefined;
     /**
      * Estimated time, in seconds, at which the concerned segment should be
      * offseted when decoded.
@@ -209,6 +211,31 @@ export interface ISegment {
      * generated.
      */
     complete: boolean;
+    /**
+     * Optional byte range to retrieve the Segment from its URL(s).
+     * TODO this should probably moved to `privateInfos` as this is
+     * transport-specific metadata only useful for performing requests, but it is
+     * sadly documented in the API, so moving it is actuall a v3.X.X breaking
+     * change.
+     */
+    range?: [number, number] | undefined;
+    /**
+     * If set, the corresponding byte-range in the downloaded segment will
+     * contain an index describing other Segments
+     * TODO this should probably moved to `privateInfos` as this is
+     * transport-specific metadata only useful for performing requests, but it is
+     * sadly documented in the API, so moving it is actuall a v3.X.X breaking
+     * change.
+     */
+    indexRange?: [number, number] | undefined;
+    /**
+     * Optional number of the Segment.
+     * TODO this should probably moved to `privateInfos` as this is
+     * transport-specific metadata only useful for performing requests, but it is
+     * sadly documented in the API, so moving it is actuall a v3.X.X breaking
+     * change.
+     */
+    number?: number | undefined;
 }
 /** Interface that should be implemented by any Representation's `index` value. */
 export interface IRepresentationIndex {
@@ -246,7 +273,7 @@ export interface IRepresentationIndex {
      * Returns `undefined` if we cannot know this value.
      * @returns {Number|null}
      */
-    getFirstPosition(): number | null | undefined;
+    getFirstAvailablePosition(): number | null | undefined;
     /**
      * Returns the ending time, in seconds, of the last playable position
      * currently available in this index.
@@ -259,7 +286,18 @@ export interface IRepresentationIndex {
      * instead.
      * @returns {Number|null|undefined}
      */
-    getLastPosition(): number | null | undefined;
+    getLastAvailablePosition(): number | null | undefined;
+    /**
+     * Returns the ending time, in seconds, of the Representation once it is
+     * "finished" (@see isFinished).
+     * Should thus be equivalent to `getLastAvailablePosition` once finished.
+     *
+     * Returns `null` if nothing is in the index
+     * Returns `undefined` if we cannot know this value.
+     *
+     * @returns {number|undefined}
+     */
+    getEnd(): number | null | undefined;
     /**
      * Returns `true` if a Segment returned by this index is still considered
      * available.
@@ -298,34 +336,6 @@ export interface IRepresentationIndex {
      * position for which a segment is available in seconds.
      */
     checkDiscontinuity(time: number): number | null;
-    /**
-     * Most RepresentationIndex are linked to segments which are generated in
-     * chronological order: from an initial position (obtainable with
-     * `getFirstPosition`) to the last position of the corresponding Period
-     * (obtainable with `getLastPosition`).
-     *
-     * However, some RepresentationIndex could announce segments in a more random
-     * order.
-     * Examples of such RepresentationIndex are ones for contents which are being
-     * downloaded locally. Here a seek close to the end could schedule the
-     * download of the last segments immediately, which might thus be announced
-     * in this index before segments in the middle are.
-     *
-     * Knowing this value serves for example to check if a discontinuity
-     * encountered in the content can be skipped over, or if it's possible that
-     * this discontinuity is due to a segment not yet being generated.
-     *
-     * You should return `true` only if there is a chance that segments are not
-     * chronologically generated (even if they all have since been generated, this
-     * function is only to know if it's possible, not if it's the case now).
-     *
-     * In other most likely cases, you should return `false`.
-     *
-     * TODO find a better way with the "local" RepresentationIndex, like
-     * explicitely declaring which segments have not been downloaded yet.
-     * @returns {boolean}
-     */
-    areSegmentsChronologicallyGenerated(): boolean;
     /**
      * Returns `true` if the last segments in this index have already been
      * generated so that we can freely go to the next period.
@@ -355,6 +365,7 @@ export interface IRepresentationIndex {
      * @returns {boolean}
      */
     isInitialized(): boolean;
+    awaitSegmentBetween(start: number, end: number): boolean | undefined;
     /**
      * Replace the index with another one, such as after a Manifest update.
      * @param {Object} newIndex

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/base.d.ts

@@ -154,12 +154,31 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
      * Returns first position in index.
      * @returns {Number|null}
      */
-    getFirstPosition(): number | null;
+    getFirstAvailablePosition(): number | null;
     /**
      * Returns last position in index.
      * @returns {Number|null}
      */
-    getLastPosition(): number | null;
+    getLastAvailablePosition(): number | null;
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    getEnd(): number | null;
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     *
+     * Always `false` in a `BaseRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    awaitSegmentBetween(): false;
     /**
      * Segments in a segmentBase scheme should stay available.
      * @returns {Boolean|undefined}
@@ -170,12 +189,6 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
      * @returns {null}
      */
     checkDiscontinuity(): null;
-    /**
-     * `BaseRepresentationIndex` should just already all be generated.
-     * Return `true` as a default value here.
-     * @returns {boolean}
-     */
-    areSegmentsChronologicallyGenerated(): true;
     /**
      * No segment in a `BaseRepresentationIndex` are known initially.
      * It is only defined generally in an "index segment" that will thus need to

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/base.js

@@ -118,7 +118,7 @@ var BaseRepresentationIndex = /** @class */ (function () {
      * Returns first position in index.
      * @returns {Number|null}
      */
-    BaseRepresentationIndex.prototype.getFirstPosition = function () {
+    BaseRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         var index = this._index;
         if (index.timeline.length === 0) {
             return null;
@@ -129,7 +129,7 @@ var BaseRepresentationIndex = /** @class */ (function () {
      * Returns last position in index.
      * @returns {Number|null}
      */
-    BaseRepresentationIndex.prototype.getLastPosition = function () {
+    BaseRepresentationIndex.prototype.getLastAvailablePosition = function () {
         var _a;
         var timeline = this._index.timeline;
         if (timeline.length === 0) {
@@ -139,6 +139,29 @@ var BaseRepresentationIndex = /** @class */ (function () {
         var lastTime = Math.min(getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd), (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
         return fromIndexTime(lastTime, this._index);
     };
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    BaseRepresentationIndex.prototype.getEnd = function () {
+        return this.getLastAvailablePosition();
+    };
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     *
+     * Always `false` in a `BaseRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    BaseRepresentationIndex.prototype.awaitSegmentBetween = function () {
+        return false;
+    };
     /**
      * Segments in a segmentBase scheme should stay available.
      * @returns {Boolean|undefined}
@@ -153,14 +176,6 @@ var BaseRepresentationIndex = /** @class */ (function () {
     BaseRepresentationIndex.prototype.checkDiscontinuity = function () {
         return null;
     };
-    /**
-     * `BaseRepresentationIndex` should just already all be generated.
-     * Return `true` as a default value here.
-     * @returns {boolean}
-     */
-    BaseRepresentationIndex.prototype.areSegmentsChronologicallyGenerated = function () {
-        return true;
-    };
     /**
      * No segment in a `BaseRepresentationIndex` are known initially.
      * It is only defined generally in an "index segment" that will thus need to

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/list.d.ts

@@ -36,7 +36,10 @@ export interface IListIndex {
     } | undefined;
     /** Information on the list of segments for this index. */
     list: Array<{
-        /** URLs of the segment. */
+        /**
+         * URLs of the segment.
+         * `null` if no URL exists.
+         */
         mediaURLs: string[] | null;
         /** Possible byte-range of the segment. */
         mediaRange?: [number, number] | undefined;
@@ -114,7 +117,7 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
     getInitSegment(): ISegment;
     /**
      * @param {Number} fromTime
-     * @param {Number} duration
+     * @param {Number} dur
      * @returns {Array.<Object>}
      */
     getSegments(fromTime: number, dur: number): ISegment[];
@@ -131,16 +134,34 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
      * Returns first position in this index, in seconds.
      * @returns {Number}
      */
-    getFirstPosition(): number;
+    getFirstAvailablePosition(): number;
     /**
      * Returns last position in this index, in seconds.
      * @returns {Number}
      */
-    getLastPosition(): number;
+    getLastAvailablePosition(): number;
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    getEnd(): number | null;
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     *
+     * Always `false` in a `ListRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    awaitSegmentBetween(): false;
     /**
      * Returns true if a Segment returned by this index is still considered
      * available.
-     * @param {Object} segment
      * @returns {Boolean}
      */
     isSegmentStillAvailable(): true;
@@ -149,10 +170,6 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
      * @returns {null}
      */
     checkDiscontinuity(): null;
-    /**
-     * @returns {boolean}
-     */
-    areSegmentsChronologicallyGenerated(): boolean;
     /**
      * SegmentList should not be updated.
      * @returns {Boolean}
@@ -170,8 +187,5 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
      * @param {Object} newIndex
      */
     _replace(newIndex: ListRepresentationIndex): void;
-    /**
-     * @param {Object} newIndex
-     */
     _update(): void;
 }