rx-player 4.0.0-dev.2023111400 → 4.0.0-dev.2023121900

package/dist/es2017/manifest/representation_index/static.d.ts

@@ -89,7 +89,7 @@ export default class StaticRepresentationIndex implements IRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished(): true;
+    isStillAwaitingFutureSegments(): false;
     /**
      * @returns {Boolean}
      */

package/dist/es2017/manifest/representation_index/static.js

@@ -115,8 +115,8 @@ export default class StaticRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished() {
-        return true;
+    isStillAwaitingFutureSegments() {
+        return false;
     }
     /**
      * @returns {Boolean}

package/dist/es2017/manifest/representation_index/types.d.ts

@@ -304,7 +304,7 @@ export interface IRepresentationIndex {
     getLastAvailablePosition(): number | null | undefined;
     /**
      * Returns the ending time, in seconds, of the Representation once it is
-     * "finished" (@see isFinished).
+     * "finished" (@see isStillAwaitingFutureSegments).
      * Should thus be equivalent to `getLastAvailablePosition` once finished.
      *
      * Returns `null` if nothing is in the index
@@ -352,13 +352,13 @@ export interface IRepresentationIndex {
      */
     checkDiscontinuity(time: number): number | null;
     /**
-     * Returns `true` if the last segments in this index have already been
+     * Returns `false` if the last segments in this index have already been
      * generated so that we can freely go to the next period.
-     * Returns `false` if the index is still waiting on future segments to be
+     * Returns `true` if the index is still waiting on future segments to be
      * generated.
      * @returns {boolean}
      */
-    isFinished(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * Returns `true` if this index has all the data it needs to give the list
      * of available segments.

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

@@ -17,6 +17,7 @@ import { IRepresentationIndex, ISegment } from "../../../../../manifest";
 import { ISegmentInformation } from "../../../../../transports";
 import { IEMSG } from "../../../../containers/isobmff";
 import { IIndexSegment } from "../../../utils/index_helpers";
+import ManifestBoundsCalculator from "../manifest_bounds_calculator";
 /**
  * Index property defined for a SegmentBase RepresentationIndex
  * This object contains every property needed to generate an ISegment for a
@@ -108,6 +109,8 @@ export interface IBaseIndexContextArgument {
     representationId?: string | undefined;
     /** Bitrate of the Representation concerned. */
     representationBitrate?: number | undefined;
+    /** Allows to obtain the minimum and maximum positions of a content. */
+    manifestBoundsCalculator: ManifestBoundsCalculator;
     isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean;
 }
 export default class BaseRepresentationIndex implements IRepresentationIndex {
@@ -124,6 +127,8 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
     private _scaledPeriodStart;
     /** Absolute end of the period, timescaled and converted to index time. */
     private _scaledPeriodEnd;
+    /** Allows to obtain the minimum and maximum positions of a content. */
+    private _manifestBoundsCalculator;
     private _isEMSGWhitelisted;
     /**
      * @param {Object} index
@@ -205,7 +210,7 @@ export default class BaseRepresentationIndex implements IRepresentationIndex {
      * should become available in the future.
      * @returns {Boolean}
      */
-    isFinished(): true;
+    isStillAwaitingFutureSegments(): false;
     /**
      * No segment in a `BaseRepresentationIndex` are known initially.
      * It is only defined generally in an "index segment" that will thus need to

package/dist/es2017/parsers/manifest/dash/common/indexes/base.js

@@ -83,6 +83,7 @@ export default class BaseRepresentationIndex {
             endNumber: index.endNumber,
             timeline: (_c = index.timeline) !== null && _c !== void 0 ? _c : [],
             timescale };
+        this._manifestBoundsCalculator = context.manifestBoundsCalculator;
         this._scaledPeriodStart = toIndexTime(periodStart, this._index);
         this._scaledPeriodEnd = periodEnd == null ? undefined :
             toIndexTime(periodEnd, this._index);
@@ -111,7 +112,7 @@ export default class BaseRepresentationIndex {
      * @returns {Array.<Object>}
      */
     getSegments(from, dur) {
-        return getSegmentsFromTimeline(this._index, from, dur, this._isEMSGWhitelisted, this._scaledPeriodEnd);
+        return getSegmentsFromTimeline(this._index, from, dur, this._manifestBoundsCalculator, this._scaledPeriodEnd, this._isEMSGWhitelisted);
     }
     /**
      * Returns false as no Segment-Base based index should need to be refreshed.
@@ -195,8 +196,8 @@ export default class BaseRepresentationIndex {
      * should become available in the future.
      * @returns {Boolean}
      */
-    isFinished() {
-        return true;
+    isStillAwaitingFutureSegments() {
+        return false;
     }
     /**
      * No segment in a `BaseRepresentationIndex` are known initially.

package/dist/es2017/parsers/manifest/dash/common/indexes/get_segments_from_timeline.d.ts

@@ -16,21 +16,24 @@
 import { ISegment } from "../../../../../manifest";
 import { IEMSG } from "../../../../containers/isobmff";
 import { IIndexSegment } from "../../../utils/index_helpers";
+import ManifestBoundsCalculator from "../manifest_bounds_calculator";
 /**
  * Get a list of Segments for the time range wanted.
  * @param {Object} index - index object, constructed by parsing the manifest.
  * @param {number} from - starting timestamp wanted, in seconds
  * @param {number} durationWanted - duration wanted, in seconds
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
  * @param {function} isEMSGWhitelisted
- * @param {number|undefined} maximumTime
  * @returns {Array.<Object>}
  */
 export default function getSegmentsFromTimeline(index: {
     availabilityTimeComplete?: boolean | undefined;
+    availabilityTimeOffset?: number | undefined;
     segmentUrlTemplate: string | null;
     startNumber?: number | undefined;
     endNumber?: number | undefined;
     timeline: IIndexSegment[];
     timescale: number;
     indexTimeOffset: number;
-}, from: number, durationWanted: number, isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean, maximumTime?: number): ISegment[];
+}, from: number, durationWanted: number, manifestBoundsCalculator: ManifestBoundsCalculator, scaledPeriodEnd: number | undefined, isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean): ISegment[];

package/dist/es2017/parsers/manifest/dash/common/indexes/get_segments_from_timeline.js

@@ -34,13 +34,17 @@ function getWantedRepeatIndex(segmentStartTime, segmentDuration, wantedTime) {
  * @param {Object} index - index object, constructed by parsing the manifest.
  * @param {number} from - starting timestamp wanted, in seconds
  * @param {number} durationWanted - duration wanted, in seconds
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
  * @param {function} isEMSGWhitelisted
- * @param {number|undefined} maximumTime
  * @returns {Array.<Object>}
  */
-export default function getSegmentsFromTimeline(index, from, durationWanted, isEMSGWhitelisted, maximumTime) {
+export default function getSegmentsFromTimeline(index, from, durationWanted, manifestBoundsCalculator, scaledPeriodEnd, isEMSGWhitelisted) {
+    var _a;
+    const maximumTime = manifestBoundsCalculator.getEstimatedMaximumPosition((_a = index.availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0);
+    const wantedMaximum = Math.min(from + durationWanted, maximumTime !== null && maximumTime !== void 0 ? maximumTime : Infinity);
     const scaledUp = toIndexTime(from, index);
-    const scaledTo = toIndexTime(from + durationWanted, index);
+    const scaledTo = toIndexTime(wantedMaximum, index);
     const { timeline, timescale, segmentUrlTemplate, startNumber, endNumber } = index;
     let currentNumber = startNumber !== null && startNumber !== void 0 ? startNumber : 1;
     const segments = [];
@@ -48,7 +52,14 @@ export default function getSegmentsFromTimeline(index, from, durationWanted, isE
     for (let i = 0; i < timelineLength; i++) {
         const timelineItem = timeline[i];
         const { duration, start, range } = timelineItem;
-        const repeat = calculateRepeat(timelineItem, timeline[i + 1], maximumTime);
+        let maxRepeatTime;
+        if (maximumTime === undefined) {
+            maxRepeatTime = scaledPeriodEnd;
+        }
+        else {
+            maxRepeatTime = Math.min(maximumTime * timescale, scaledPeriodEnd !== null && scaledPeriodEnd !== void 0 ? scaledPeriodEnd : Infinity);
+        }
+        const repeat = calculateRepeat(timelineItem, timeline[i + 1], maxRepeatTime);
         const complete = index.availabilityTimeComplete !== false ||
             i !== timelineLength - 1 &&
                 repeat !== 0;

package/dist/es2017/parsers/manifest/dash/common/indexes/index.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import BaseRepresentationIndex from "./base";
-import ListRepresentationIndex from "./list";
-import TemplateRepresentationIndex from "./template";
-import TimelineRepresentationIndex from "./timeline";
-export { BaseRepresentationIndex, ListRepresentationIndex, TemplateRepresentationIndex, TimelineRepresentationIndex, };
+import BaseRepresentationIndex, { IBaseIndexContextArgument } from "./base";
+import ListRepresentationIndex, { IListIndexContextArgument } from "./list";
+import TemplateRepresentationIndex, { ITemplateIndexContextArgument } from "./template";
+import TimelineRepresentationIndex, { ITimelineIndexContextArgument } from "./timeline";
+export { BaseRepresentationIndex, ListRepresentationIndex, TemplateRepresentationIndex, TimelineRepresentationIndex, IBaseIndexContextArgument, IListIndexContextArgument, ITemplateIndexContextArgument, ITimelineIndexContextArgument, };

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

@@ -178,7 +178,7 @@ export default class ListRepresentationIndex implements IRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished(): true;
+    isStillAwaitingFutureSegments(): false;
     /**
      * @returns {Boolean}
      */

package/dist/es2017/parsers/manifest/dash/common/indexes/list.js

@@ -179,8 +179,8 @@ export default class ListRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished() {
-        return true;
+    isStillAwaitingFutureSegments() {
+        return false;
     }
     /**
      * @returns {Boolean}

package/dist/es2017/parsers/manifest/dash/common/indexes/template.d.ts

@@ -102,8 +102,15 @@ export interface ITemplateIndexIndexArgument {
 }
 /** Aditional context needed by a SegmentTemplate RepresentationIndex. */
 export interface ITemplateIndexContextArgument {
-    /** Minimum availabilityTimeOffset concerning the segments of this Representation. */
-    availabilityTimeOffset: number;
+    /**
+     * availability time offset of the concerned Adaptation.
+     *
+     * If `undefined`, the corresponding property was not set in the MPD and it is
+     * thus assumed to be equal to `0`.
+     * It might however be semantically different than `0` in the RxPlayer as it
+     * means that the packager didn't include that information in the MPD.
+     */
+    availabilityTimeOffset: number | undefined;
     /** Allows to obtain the minimum and maximum positions of a content. */
     manifestBoundsCalculator: ManifestBoundsCalculator;
     /** Start of the period concerned by this RepresentationIndex, in seconds. */
@@ -208,13 +215,13 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
      */
     canBeOutOfSyncError(): false;
     /**
-     * Returns `true` if the last segments in this index have already been
+     * Returns `false` if the last segments in this index have already been
      * generated so that we can freely go to the next period.
-     * Returns `false` if the index is still waiting on future segments to be
+     * Returns `true` if the index is still waiting on future segments to be
      * generated.
      * @returns {Boolean}
      */
-    isFinished(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * @returns {Boolean}
      */

package/dist/es2017/parsers/manifest/dash/common/indexes/template.js

@@ -205,13 +205,24 @@ export default class TemplateRepresentationIndex {
         const { timescale } = this._index;
         const segmentTimeRounding = getSegmentTimeRoundingError(timescale);
         const scaledPeriodStart = this._periodStart * timescale;
-        const scaledRelativeEnd = end * timescale - scaledPeriodStart;
+        const scaledRelativeStart = (start * timescale) - scaledPeriodStart;
+        const scaledRelativeEnd = (end * timescale) - scaledPeriodStart;
+        const lastSegmentStart = this._getLastSegmentStart();
+        if (isNullOrUndefined(lastSegmentStart)) {
+            const relativeScaledIndexEnd = this._estimateRelativeScaledEnd();
+            if (relativeScaledIndexEnd === undefined) {
+                return scaledRelativeEnd + segmentTimeRounding >= 0;
+            }
+            return scaledRelativeEnd + segmentTimeRounding >= 0 &&
+                scaledRelativeStart < relativeScaledIndexEnd - segmentTimeRounding;
+        }
+        const lastSegmentEnd = lastSegmentStart + this._index.duration;
         const relativeScaledIndexEnd = this._estimateRelativeScaledEnd();
         if (relativeScaledIndexEnd === undefined) {
-            return (scaledRelativeEnd + segmentTimeRounding) >= 0;
+            return scaledRelativeEnd > lastSegmentEnd - segmentTimeRounding;
         }
-        const scaledRelativeStart = start * timescale - scaledPeriodStart;
-        return (scaledRelativeStart - segmentTimeRounding) < relativeScaledIndexEnd;
+        return scaledRelativeEnd > lastSegmentEnd - segmentTimeRounding &&
+            scaledRelativeStart < relativeScaledIndexEnd - segmentTimeRounding;
     }
     /**
      * Returns true if, based on the arguments, the index should be refreshed.
@@ -256,30 +267,30 @@ export default class TemplateRepresentationIndex {
         return false;
     }
     /**
-     * Returns `true` if the last segments in this index have already been
+     * Returns `false` if the last segments in this index have already been
      * generated so that we can freely go to the next period.
-     * Returns `false` if the index is still waiting on future segments to be
+     * Returns `true` if the index is still waiting on future segments to be
      * generated.
      * @returns {Boolean}
      */
-    isFinished() {
+    isStillAwaitingFutureSegments() {
         if (!this._isDynamic) {
-            return true;
+            return false;
         }
         const scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
         if (scaledRelativeIndexEnd === undefined) {
-            return false;
+            return true;
         }
         const { timescale } = this._index;
         const lastSegmentStart = this._getLastSegmentStart();
         // As last segment start is null if live time is before
         // current period, consider the index not to be finished.
         if (isNullOrUndefined(lastSegmentStart)) {
-            return false;
+            return true;
         }
         const lastSegmentEnd = lastSegmentStart + this._index.duration;
         const segmentTimeRounding = getSegmentTimeRoundingError(timescale);
-        return (lastSegmentEnd + segmentTimeRounding) >= scaledRelativeIndexEnd;
+        return (lastSegmentEnd + segmentTimeRounding) < scaledRelativeIndexEnd;
     }
     /**
      * @returns {Boolean}
@@ -317,6 +328,7 @@ export default class TemplateRepresentationIndex {
      * @returns {number | null | undefined}
      */
     _getFirstSegmentStart() {
+        var _a;
         if (!this._isDynamic) {
             return 0; // it is the start of the Period
         }
@@ -326,15 +338,15 @@ export default class TemplateRepresentationIndex {
             // /!\ The scaled max position augments continuously and might not
             // reflect exactly the real server-side value. As segments are
             // generated discretely.
-            const maximumBound = this._manifestBoundsCalculator.estimateMaximumBound();
-            if (maximumBound !== undefined && maximumBound < this._periodStart) {
+            const maximumSegmentTime = this._manifestBoundsCalculator.getEstimatedMaximumPosition((_a = this._availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0);
+            if (maximumSegmentTime !== undefined && maximumSegmentTime < this._periodStart) {
                 // Maximum position is before this period.
                 // No segment is yet available here
                 return null;
             }
         }
         const { duration, timescale } = this._index;
-        const firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
+        const firstPosition = this._manifestBoundsCalculator.getEstimatedMinimumSegmentTime();
         if (firstPosition === undefined) {
             return undefined;
         }
@@ -351,34 +363,35 @@ export default class TemplateRepresentationIndex {
      * @returns {number|null|undefined}
      */
     _getLastSegmentStart() {
-        var _a;
+        var _a, _b;
         const { duration, timescale, endNumber, startNumber = 1 } = this._index;
         if (this._isDynamic) {
-            const lastPos = this._manifestBoundsCalculator.estimateMaximumBound();
-            if (lastPos === undefined) {
-                return undefined;
-            }
-            if (this._scaledRelativePeriodEnd !== undefined &&
-                this._scaledRelativePeriodEnd <
-                    (lastPos - this._periodStart) * this._index.timescale) {
+            const liveEdge = this._manifestBoundsCalculator.getEstimatedLiveEdge();
+            if (liveEdge !== undefined &&
+                this._scaledRelativePeriodEnd !== undefined &&
+                this._scaledRelativePeriodEnd < liveEdge - (this._periodStart *
+                    this._index.timescale)) {
                 let numberOfSegments = Math.ceil(this._scaledRelativePeriodEnd / duration);
                 if (endNumber !== undefined && (endNumber - startNumber + 1) < numberOfSegments) {
                     numberOfSegments = endNumber - startNumber + 1;
                 }
                 return (numberOfSegments - 1) * duration;
             }
+            const lastPosition = this._manifestBoundsCalculator
+                .getEstimatedMaximumPosition((_a = this._availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0);
+            if (lastPosition === undefined) {
+                return undefined;
+            }
             // /!\ The scaled last position augments continuously and might not
             // reflect exactly the real server-side value. As segments are
             // generated discretely.
-            const scaledLastPosition = (lastPos - this._periodStart) * timescale;
+            const scaledLastPosition = (lastPosition - this._periodStart) * timescale;
             // Maximum position is before this period.
             // No segment is yet available here
             if (scaledLastPosition < 0) {
                 return null;
             }
-            const availabilityTimeOffset = ((this._availabilityTimeOffset !== undefined ? this._availabilityTimeOffset : 0))
-                * timescale;
-            let numberOfSegmentsAvailable = Math.floor((scaledLastPosition + availabilityTimeOffset) / duration);
+            let numberOfSegmentsAvailable = Math.floor(scaledLastPosition / duration);
             if (endNumber !== undefined &&
                 (endNumber - startNumber + 1) < numberOfSegmentsAvailable) {
                 numberOfSegmentsAvailable = endNumber - startNumber + 1;
@@ -388,7 +401,7 @@ export default class TemplateRepresentationIndex {
                 (numberOfSegmentsAvailable - 1) * duration;
         }
         else {
-            const maximumTime = (_a = this._scaledRelativePeriodEnd) !== null && _a !== void 0 ? _a : 0;
+            const maximumTime = (_b = this._scaledRelativePeriodEnd) !== null && _b !== void 0 ? _b : 0;
             let numberOfSegments = Math.ceil(maximumTime / duration);
             if (endNumber !== undefined && (endNumber - startNumber + 1) < numberOfSegments) {
                 numberOfSegments = endNumber - startNumber + 1;

package/dist/es2017/parsers/manifest/dash/common/indexes/timeline/index.d.ts

@@ -13,5 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import TimelineRepresentationIndex from "./timeline_representation_index";
+import TimelineRepresentationIndex, { ITimelineIndexContextArgument } from "./timeline_representation_index";
 export default TimelineRepresentationIndex;
+export { ITimelineIndexContextArgument };

package/dist/es2017/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.d.ts

@@ -27,6 +27,8 @@ import ManifestBoundsCalculator from "../../manifest_bounds_calculator";
 export interface ITimelineIndex {
     /** If `false`, the last segment anounced might be still incomplete. */
     availabilityTimeComplete: boolean;
+    /** Minimum availabilityTimeOffset concerning the segments of this Representation. */
+    availabilityTimeOffset: number;
     /** Byte range for a possible index of segments in the server. */
     indexRange?: [number, number] | undefined;
     /**
@@ -123,8 +125,25 @@ export interface ITimelineIndexIndexArgument {
 }
 /** Aditional context needed by a SegmentTimeline RepresentationIndex. */
 export interface ITimelineIndexContextArgument {
-    /** If `false`, the last segment anounced might be still incomplete. */
-    availabilityTimeComplete: boolean;
+    /**
+     * If `false`, declared segments in the MPD might still be not completely generated.
+     * If `true`, they are completely generated.
+     *
+     * If `undefined`, the corresponding property was not set in the MPD and it is
+     * thus assumed that they are all generated.
+     * It might however be semantically different than `true` in the RxPlayer as it
+     * means that the packager didn't include that information in the MPD.
+     */
+    availabilityTimeComplete: boolean | undefined;
+    /**
+     * availability time offset of the concerned Adaptation.
+     *
+     * If `undefined`, the corresponding property was not set in the MPD and it is
+     * thus assumed to be equal to `0`.
+     * It might however be semantically different than `0` in the RxPlayer as it
+     * means that the packager didn't include that information in the MPD.
+     */
+    availabilityTimeOffset: number | undefined;
     /** Allows to obtain the minimum and maximum positions of a content. */
     manifestBoundsCalculator: ManifestBoundsCalculator;
     /** Start of the period linked to this RepresentationIndex, in seconds. */
@@ -164,6 +183,11 @@ export interface ILastSegmentInformation {
     /** Defines the time at which `lastPosition` was last calculated. */
     time: number;
 }
+/**
+ * `IRepresentationIndex` implementation for a DASH `SegmentTimeline` segment
+ * indexing scheme.
+ * @class TimelineRepresentationIndex
+ */
 export default class TimelineRepresentationIndex implements IRepresentationIndex {
     /** Underlying structure to retrieve segment information. */
     protected _index: ITimelineIndex;
@@ -287,12 +311,12 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      */
     _update(newIndex: TimelineRepresentationIndex): void;
     /**
-     * Returns `true` if this RepresentationIndex currently contains its last
+     * Returns `false` if this RepresentationIndex currently contains its last
      * segment.
-     * Returns `false` if it's still pending.
+     * Returns `true` if it's still pending.
      * @returns {Boolean}
      */
-    isFinished(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * @returns {Boolean}
      */
@@ -311,7 +335,6 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      * available due to timeshifting.
      */
     private _refreshTimeline;
-    static getIndexEnd(timeline: IIndexSegment[], scaledPeriodEnd: number | undefined): number | null;
     /**
      * Allows to generate the "timeline" for this RepresentationIndex.
      * Call this function when the timeline is unknown.
@@ -336,3 +359,73 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      */
     private _getTimeline;
 }
+/**
+ * Returns true if a Segment returned by the corresponding index is still
+ * considered available.
+ * Returns false if it is not available anymore.
+ * Returns undefined if we cannot know whether it is still available or not.
+ * /!\ We do not check the mediaURLs of the segment.
+ * @param {Object} segment
+ * @param {Object} index
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @returns {Boolean|undefined}
+ */
+export declare function isSegmentStillAvailable(segment: ISegment, index: {
+    availabilityTimeOffset: number;
+    timeline: IIndexSegment[];
+    indexTimeOffset: number;
+    timescale: number;
+}, manifestBoundsCalculator: ManifestBoundsCalculator, scaledPeriodEnd: number | undefined): boolean | undefined;
+/**
+ * Returns from the given RepresentationIndex information on the last segment
+ * that may be requested currently.
+ *
+ * Returns `null` if there's no such segment.
+ * @param {Object} index
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @returns {number|null}
+ */
+export declare function getLastRequestableSegmentInfo(index: {
+    availabilityTimeOffset: number;
+    timeline: IIndexSegment[];
+    timescale: number;
+}, manifestBoundsCalculator: ManifestBoundsCalculator, scaledPeriodEnd: number | undefined): ILastRequestableSegmentInfo | null;
+/**
+ * Information on the last requestable segment deduced from a timeline array of
+ * segment information.
+ */
+export interface ILastRequestableSegmentInfo {
+    /**
+     * If `true`, we know that the last requestable segment is equal to the last
+     * segment that can be deduced from the corresponding given timeline.
+     * Written another way, there seem to be no segment announced in the timeline
+     * that are not yet requestable.
+     *
+     * If `false`, we know that the last requestable segment is not the last
+     * segment that can be deduced from the corresponding timeline.
+     * Written another way, there are supplementary segments in the timeline which
+     * are not yet requestable.
+     *
+     * Note that if the last requestable segment has its information from the last
+     * element from the timeline but it's not the last segment that would be
+     * deduced from the `repeatCount` property, then this value is set to `false`.
+     */
+    isLastOfTimeline: boolean;
+    /**
+     * End time at which the last requestable segment ends, in the corresponding
+     * index timescale (__NOT__ in seconds).
+     */
+    end: number;
+    /**
+     * The index in `timeline` of the last requestable segment.
+     * Note that its `repeatCount` may be updated and put as `newRepeatCount`.
+     */
+    timelineIdx: number;
+    /**
+     * The new `repeatCount` value for that last segment. May be equal or
+     * different from the timeline element found at `timelineIdx`.
+     */
+    newRepeatCount: number;
+}