rx-player 3.28.0 → 3.28.1-dev.2022083000

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;
 }

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

@@ -60,7 +60,7 @@ var ListRepresentationIndex = /** @class */ (function () {
     };
     /**
      * @param {Number} fromTime
-     * @param {Number} duration
+     * @param {Number} dur
      * @returns {Array.<Object>}
      */
     ListRepresentationIndex.prototype.getSegments = function (fromTime, dur) {
@@ -104,23 +104,45 @@ var ListRepresentationIndex = /** @class */ (function () {
      * Returns first position in this index, in seconds.
      * @returns {Number}
      */
-    ListRepresentationIndex.prototype.getFirstPosition = function () {
+    ListRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         return this._periodStart;
     };
     /**
      * Returns last position in this index, in seconds.
      * @returns {Number}
      */
-    ListRepresentationIndex.prototype.getLastPosition = function () {
+    ListRepresentationIndex.prototype.getLastAvailablePosition = function () {
         var _a;
         var index = this._index;
         var duration = index.duration, list = index.list;
         return Math.min(((list.length * duration) / index.timescale) + this._periodStart, (_a = this._periodEnd) !== null && _a !== void 0 ? _a : Infinity);
     };
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    ListRepresentationIndex.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 `ListRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    ListRepresentationIndex.prototype.awaitSegmentBetween = function () {
+        return false;
+    };
     /**
      * Returns true if a Segment returned by this index is still considered
      * available.
-     * @param {Object} segment
      * @returns {Boolean}
      */
     ListRepresentationIndex.prototype.isSegmentStillAvailable = function () {
@@ -133,12 +155,6 @@ var ListRepresentationIndex = /** @class */ (function () {
     ListRepresentationIndex.prototype.checkDiscontinuity = function () {
         return null;
     };
-    /**
-     * @returns {boolean}
-     */
-    ListRepresentationIndex.prototype.areSegmentsChronologicallyGenerated = function () {
-        return true;
-    };
     /**
      * SegmentList should not be updated.
      * @returns {Boolean}
@@ -164,9 +180,6 @@ var ListRepresentationIndex = /** @class */ (function () {
     ListRepresentationIndex.prototype._replace = function (newIndex) {
         this._index = newIndex._index;
     };
-    /**
-     * @param {Object} newIndex
-     */
     ListRepresentationIndex.prototype._update = function () {
         log.error("List RepresentationIndex: Cannot update a SegmentList");
     };