rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/commonjs/core/fetchers/segment/task_prioritizer.js

@@ -97,11 +97,13 @@ var TaskPrioritizer = /** @class */ (function () {
                         callbacks.beforeInterrupted();
                     }
                 });
-                _this._minPendingPriority = _this._minPendingPriority === null ?
-                    newTask.priority :
-                    Math.min(_this._minPendingPriority, newTask.priority);
+                _this._minPendingPriority =
+                    _this._minPendingPriority === null
+                        ? newTask.priority
+                        : Math.min(_this._minPendingPriority, newTask.priority);
                 _this._pendingTasks.push(newTask);
-                newTask.taskFn(interrupter.signal)
+                newTask
+                    .taskFn(interrupter.signal)
                     .then(onResolve)
                     .catch(function (err) {
                     if (!cancelSignal.isCancelled() &&
@@ -171,7 +173,8 @@ var TaskPrioritizer = /** @class */ (function () {
      */
     TaskPrioritizer.prototype.updatePriority = function (promise, priority) {
         var waitingQueueIndex = _findTaskIndex(promise, this._waitingQueue);
-        if (waitingQueueIndex >= 0) { // If it was still waiting for its turn
+        if (waitingQueueIndex >= 0) {
+            // If it was still waiting for its turn
             var waitingQueueElt = this._waitingQueue[waitingQueueIndex];
             if (waitingQueueElt.priority === priority) {
                 return;
@@ -216,7 +219,8 @@ var TaskPrioritizer = /** @class */ (function () {
         if (this._minPendingPriority === null || priority < this._minPendingPriority) {
             this._minPendingPriority = priority;
         }
-        else if (this._minPendingPriority === prevPriority) { // was highest priority
+        else if (this._minPendingPriority === prevPriority) {
+            // was highest priority
             if (this._pendingTasks.length === 1) {
                 this._minPendingPriority = priority;
             }
@@ -241,18 +245,16 @@ var TaskPrioritizer = /** @class */ (function () {
      */
     TaskPrioritizer.prototype._loopThroughWaitingQueue = function () {
         var minWaitingPriority = this._waitingQueue.reduce(function (acc, elt) {
-            return acc === null || acc > elt.priority ? elt.priority :
-                acc;
+            return acc === null || acc > elt.priority ? elt.priority : acc;
         }, null);
         if (minWaitingPriority === null ||
-            (this._minPendingPriority !== null &&
-                this._minPendingPriority < minWaitingPriority)) {
+            (this._minPendingPriority !== null && this._minPendingPriority < minWaitingPriority)) {
             return;
         }
         for (var i = 0; i < this._waitingQueue.length; i++) {
-            var priorityToCheck = this._minPendingPriority === null ?
-                minWaitingPriority :
-                Math.min(this._minPendingPriority, minWaitingPriority);
+            var priorityToCheck = this._minPendingPriority === null
+                ? minWaitingPriority
+                : Math.min(this._minPendingPriority, minWaitingPriority);
             var elt = this._waitingQueue[i];
             if (elt.priority <= priorityToCheck) {
                 this._findAndRunWaitingQueueTask(i);
@@ -321,8 +323,7 @@ var TaskPrioritizer = /** @class */ (function () {
      * @returns {boolean}
      */
     TaskPrioritizer.prototype._canBeStartedNow = function (task) {
-        return this._minPendingPriority === null ||
-            task.priority <= this._minPendingPriority;
+        return this._minPendingPriority === null || task.priority <= this._minPendingPriority;
     };
     /**
      * Returns `true` if any running task is considered "high priority".
@@ -330,8 +331,8 @@ var TaskPrioritizer = /** @class */ (function () {
      * @returns {boolean}
      */
     TaskPrioritizer.prototype._isRunningHighPriorityTasks = function () {
-        return this._minPendingPriority !== null &&
-            this._minPendingPriority <= this._prioritySteps.high;
+        return (this._minPendingPriority !== null &&
+            this._minPendingPriority <= this._prioritySteps.high);
     };
     return TaskPrioritizer;
 }());

package/dist/commonjs/core/fetchers/utils/error_selector.d.ts

@@ -13,10 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IPlayerError } from "../../../public_types";
+import type { IPlayerError } from "../../../public_types";
 /**
  * Generate a new error from the infos given.
- * @param {string} code
  * @param {Error} error
  * @returns {Error}
  */

package/dist/commonjs/core/fetchers/utils/error_selector.js

@@ -19,7 +19,6 @@ var errors_1 = require("../../../errors");
 var request_1 = require("../../../utils/request");
 /**
  * Generate a new error from the infos given.
- * @param {string} code
  * @param {Error} error
  * @returns {Error}
  */

package/dist/commonjs/core/fetchers/utils/schedule_request.d.ts

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ICdnMetadata } from "../../../parsers/manifest";
-import { CancellationSignal } from "../../../utils/task_canceller";
-import CdnPrioritizer from "../cdn_prioritizer";
+import type { ICdnMetadata } from "../../../parsers/manifest";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type CdnPrioritizer from "../cdn_prioritizer";
 /** Settings to give to the backoff functions to configure their behavior. */
 export interface IBackoffSettings {
     /**

package/dist/commonjs/core/fetchers/utils/schedule_request.js

@@ -75,27 +75,27 @@ var task_canceller_1 = require("../../../utils/task_canceller");
 function shouldRetry(error) {
     if (error instanceof request_1.RequestError) {
         if (error.type === errors_1.NetworkErrorTypes.ERROR_HTTP_CODE) {
-            return error.status >= 500 ||
+            return (error.status >= 500 ||
                 error.status === 404 ||
                 error.status === 415 || // some CDN seems to use that code when
                 // requesting low-latency segments too much
                 // in advance
-                error.status === 412;
+                error.status === 412);
         }
-        return error.type === errors_1.NetworkErrorTypes.TIMEOUT ||
-            error.type === errors_1.NetworkErrorTypes.ERROR_EVENT;
+        return (error.type === errors_1.NetworkErrorTypes.TIMEOUT ||
+            error.type === errors_1.NetworkErrorTypes.ERROR_EVENT);
     }
     else if (error instanceof errors_1.CustomLoaderError) {
         if (typeof error.canRetry === "boolean") {
             return error.canRetry;
         }
         if (error.xhr !== undefined) {
-            return error.xhr.status >= 500 ||
+            return (error.xhr.status >= 500 ||
                 error.xhr.status === 404 ||
                 error.xhr.status === 415 || // some CDN seems to use that code when
                 // requesting low-latency segments too much
                 // in advance
-                error.xhr.status === 412;
+                error.xhr.status === 412);
         }
         return false;
     }
@@ -214,9 +214,11 @@ function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, options,
                             }
                             missedAttemptsObj = missedAttempts.get(cdn);
                             if (missedAttemptsObj === undefined) {
-                                missedAttemptsObj = { errorCounter: 1,
+                                missedAttemptsObj = {
+                                    errorCounter: 1,
                                     blockedUntil: undefined,
-                                    isBlacklisted: false };
+                                    isBlacklisted: false,
+                                };
                                 missedAttempts.set(cdn, missedAttemptsObj);
                             }
                             else {
@@ -282,8 +284,7 @@ function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, options,
          */
         function waitPotentialBackoffAndRequest(nextWantedCdn, prevRequestError) {
             var nextCdnAttemptObj = missedAttempts.get(nextWantedCdn);
-            if (nextCdnAttemptObj === undefined ||
-                nextCdnAttemptObj.blockedUntil === undefined) {
+            if (nextCdnAttemptObj === undefined || nextCdnAttemptObj.blockedUntil === undefined) {
                 return requestCdn(nextWantedCdn);
             }
             var now = (0, monotonic_timestamp_1.default)();
@@ -305,13 +306,10 @@ function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, options,
                     }
                     if (updatedPrioritaryCdn !== nextWantedCdn) {
                         canceller.cancel();
-                        waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
-                            .then(cleanAndResolve, cleanAndReject);
+                        waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError).then(cleanAndResolve, cleanAndReject);
                     }
                 }, canceller.signal);
-                (0, cancellable_sleep_1.default)(blockedFor, canceller.signal)
-                    .then(function () { return requestCdn(nextWantedCdn)
-                    .then(cleanAndResolve, cleanAndReject); }, noop_1.default);
+                (0, cancellable_sleep_1.default)(blockedFor, canceller.signal).then(function () { return requestCdn(nextWantedCdn).then(cleanAndResolve, cleanAndReject); }, noop_1.default);
                 function cleanAndResolve(response) {
                     unlinkCanceller();
                     res(response);
@@ -350,15 +348,16 @@ function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, options,
                 if (acc === undefined) {
                     return [x, blockedUntil];
                 }
+                if (acc[1] === undefined) {
+                    return acc;
+                }
                 if (blockedUntil === undefined) {
-                    if (acc[1] === undefined) {
-                        return acc;
-                    }
                     return [x, undefined];
                 }
-                return acc[1] === undefined ? acc :
-                    blockedUntil < acc[1] ? [x, blockedUntil] :
-                        acc;
+                if (blockedUntil < acc[1]) {
+                    return [x, blockedUntil];
+                }
+                return acc;
             }, undefined)) === null || _a === void 0 ? void 0 : _a[0];
         }
         var baseDelay, maxDelay, maxRetry, onRetry, missedAttempts, initialCdnToRequest;

package/dist/commonjs/core/main/common/DecipherabilityFreezeDetector.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IFreezingStatus, IRebufferingStatus } from "../../../playback_observer";
+import type SegmentSinksStore from "../../segment_sinks";
+export default class DecipherabilityFreezeDetector {
+    /** Emit the current playback conditions */
+    private _segmentSinksStore;
+    /**
+     * If set to something else than `null`, this is the monotonically-raising
+     * timestamp used by the RxPlayer when playback begin to seem to not start
+     * despite having decipherable data in the buffer(s).
+     *
+     * If enough time in that condition is spent, special considerations are
+     * taken at which point `_currentFreezeTimestamp` is reset to `null`.
+     *
+     * It is also reset to `null` when and if there is no such issue anymore.
+     */
+    private _currentFreezeTimestamp;
+    constructor(segmentSinksStore: SegmentSinksStore);
+    /**
+     * Support of contents with DRM on all the platforms out there is a pain in
+     * the *ss considering all the DRM-related bugs there are.
+     *
+     * We found out a frequent issue which is to be unable to play despite having
+     * all the decryption keys to play what is currently buffered.
+     * When this happens, re-creating the buffers from scratch, with a reload, is
+     * usually sufficient to unlock the situation.
+     *
+     * Although we prefer providing more targeted fixes or telling to platform
+     * developpers to fix their implementation, it's not always possible.
+     * We thus resorted to developping an heuristic which detects such situation
+     * and reload in that case.
+     *
+     * @param {Object} observation - The last playback observation produced, it
+     * has to be recent (just triggered for example).
+     * @returns {boolean} - Returns `true` if it seems to be such kind of
+     * decipherability freeze, in which case you should probably reload the
+     * content.
+     */
+    needToReload(observation: IDecipherabilityFreezeDetectorObservation): boolean;
+}
+/** Playback observation needed by the `DecipherabilityFreezeDetector`. */
+export interface IDecipherabilityFreezeDetectorObservation {
+    /** Current `readyState` value on the media element. */
+    readyState: number;
+    /**
+     * Set if the player is short on audio and/or video media data and is a such,
+     * rebuffering.
+     * `null` if not.
+     */
+    rebuffering: IRebufferingStatus | null;
+    /**
+     * Set if the player is frozen, that is, stuck in place for unknown reason.
+     * Note that this reason can be a valid one, such as a necessary license not
+     * being obtained yet.
+     *
+     * `null` if the player is not frozen.
+     */
+    freezing: IFreezingStatus | null;
+    /**
+     * Gap between `currentTime` and the next position with un-buffered data.
+     * `Infinity` if we don't have buffered data right now.
+     * `undefined` if we cannot determine the buffer gap.
+     */
+    bufferGap: number | undefined;
+}

package/dist/commonjs/core/main/common/DecipherabilityFreezeDetector.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var log_1 = require("../../../log");
+var monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
+var DecipherabilityFreezeDetector = /** @class */ (function () {
+    function DecipherabilityFreezeDetector(segmentSinksStore) {
+        this._segmentSinksStore = segmentSinksStore;
+        this._currentFreezeTimestamp = null;
+    }
+    /**
+     * Support of contents with DRM on all the platforms out there is a pain in
+     * the *ss considering all the DRM-related bugs there are.
+     *
+     * We found out a frequent issue which is to be unable to play despite having
+     * all the decryption keys to play what is currently buffered.
+     * When this happens, re-creating the buffers from scratch, with a reload, is
+     * usually sufficient to unlock the situation.
+     *
+     * Although we prefer providing more targeted fixes or telling to platform
+     * developpers to fix their implementation, it's not always possible.
+     * We thus resorted to developping an heuristic which detects such situation
+     * and reload in that case.
+     *
+     * @param {Object} observation - The last playback observation produced, it
+     * has to be recent (just triggered for example).
+     * @returns {boolean} - Returns `true` if it seems to be such kind of
+     * decipherability freeze, in which case you should probably reload the
+     * content.
+     */
+    DecipherabilityFreezeDetector.prototype.needToReload = function (observation) {
+        var e_1, _a, e_2, _b;
+        var readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
+        var bufferGap = observation.bufferGap !== undefined && isFinite(observation.bufferGap)
+            ? observation.bufferGap
+            : 0;
+        if (bufferGap < 6 || (rebuffering === null && freezing === null) || readyState > 1) {
+            this._currentFreezeTimestamp = null;
+            return false;
+        }
+        var now = (0, monotonic_timestamp_1.default)();
+        if (this._currentFreezeTimestamp === null) {
+            this._currentFreezeTimestamp = now;
+        }
+        var rebufferingForTooLong = rebuffering !== null && now - rebuffering.timestamp > 4000;
+        var frozenForTooLong = freezing !== null && now - freezing.timestamp > 4000;
+        if ((rebufferingForTooLong || frozenForTooLong) &&
+            (0, monotonic_timestamp_1.default)() - this._currentFreezeTimestamp > 4000) {
+            var statusAudio = this._segmentSinksStore.getStatus("audio");
+            var statusVideo = this._segmentSinksStore.getStatus("video");
+            var hasOnlyDecipherableSegments = true;
+            var isClear = true;
+            try {
+                for (var _c = __values([statusAudio, statusVideo]), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var status_1 = _d.value;
+                    if (status_1.type === "initialized") {
+                        try {
+                            for (var _e = (e_2 = void 0, __values(status_1.value.getLastKnownInventory())), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                var segment = _f.value;
+                                var representation = segment.infos.representation;
+                                if (representation.decipherable === false) {
+                                    log_1.default.warn("Init: we have undecipherable segments left in the buffer, reloading");
+                                    this._currentFreezeTimestamp = null;
+                                    return true;
+                                }
+                                else if (representation.contentProtections !== undefined) {
+                                    isClear = false;
+                                    if (representation.decipherable !== true) {
+                                        hasOnlyDecipherableSegments = false;
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (!isClear && hasOnlyDecipherableSegments) {
+                log_1.default.warn("Init: we are frozen despite only having decipherable " +
+                    "segments left in the buffer, reloading");
+                this._currentFreezeTimestamp = null;
+                return true;
+            }
+        }
+        return false;
+    };
+    return DecipherabilityFreezeDetector;
+}());
+exports.default = DecipherabilityFreezeDetector;

package/dist/commonjs/core/main/common/content_time_boundaries_observer.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IStreamOrchestratorPlaybackObservation, IBufferType } from "../../../core/types";
+import type { IManifest, IAdaptation, IPeriod } from "../../../manifest";
+import type { IReadOnlyPlaybackObserver } from "../../../playback_observer";
+import type { IPlayerError } from "../../../public_types";
+import EventEmitter from "../../../utils/event_emitter";
+/**
+ * Observes what's being played and take care of media events relating to time
+ * boundaries:
+ *   - Emits a `endingPositionChange` when the known maximum playable position
+ *     of the current content is known and every time it changes.
+ *   - Emits `endOfStream` API once segments have been pushed until the end and
+ *     `resumeStream` if downloads starts back.
+ *   - Emits a `periodChange` event when the currently-playing Period seemed to
+ *     have changed.
+ *   - emit "warning" events when what is being played is outside of the
+ *     Manifest range.
+ * @class ContentTimeBoundariesObserver
+ */
+export default class ContentTimeBoundariesObserver extends EventEmitter<IContentTimeBoundariesObserverEvent> {
+    /** Allows to interrupt everything the `ContentTimeBoundariesObserver` is doing. */
+    private _canceller;
+    /** Store information on every created "Streams". */
+    private _activeStreams;
+    /** The `Manifest` object linked to the current content. */
+    private _manifest;
+    /** Allows to calculate at any time maximum positions of the content */
+    private _maximumPositionCalculator;
+    /** Enumerate all possible buffer types in the current content. */
+    private _allBufferTypes;
+    /**
+     * Stores the `id` property of the last Period for which a `periodChange`
+     * event has been sent.
+     * Allows to avoid multiple times in a row `periodChange` for the same
+     * Period.
+     */
+    private _lastCurrentPeriodId;
+    /**
+     * @param {Object} manifest
+     * @param {Object} playbackObserver
+     */
+    constructor(manifest: IManifest, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, bufferTypes: IBufferType[]);
+    /**
+     * Returns an estimate of the current last position which may be played in
+     * the content at the moment.
+     * @returns {Object}
+     */
+    getCurrentEndingTime(): IEndingPositionInformation;
+    /**
+     * Method to call any time an Adaptation has been selected.
+     *
+     * That Adaptation switch will be considered as active until the
+     * `onPeriodCleared` method has been called for the same `bufferType` and
+     * `Period`, or until `dispose` is called.
+     * @param {string} bufferType - The type of buffer concerned by the Adaptation
+     * switch
+     * @param {Object} period - The Period concerned by the Adaptation switch
+     * @param {Object|null} adaptation - The Adaptation selected. `null` if the
+     * absence of `Adaptation` has been explicitely selected for this Period and
+     * buffer type (e.g. no video).
+     */
+    onAdaptationChange(bufferType: IBufferType, period: IPeriod, adaptation: IAdaptation | null): void;
+    /**
+     * Method to call any time a Representation has been selected.
+     *
+     * That Representation switch will be considered as active until the
+     * `onPeriodCleared` method has been called for the same `bufferType` and
+     * `Period`, or until `dispose` is called.
+     * @param {string} bufferType - The type of buffer concerned by the
+     * Representation switch
+     * @param {Object} period - The Period concerned by the Representation switch
+     */
+    onRepresentationChange(bufferType: IBufferType, period: IPeriod): void;
+    /**
+     * Method to call any time a Period and type combination is not considered
+     * anymore.
+     *
+     * Calling this method allows to signal that a previous Adaptation and/or
+     * Representation change respectively indicated by an `onAdaptationChange` and
+     * an `onRepresentationChange` call, are not active anymore.
+     * @param {string} bufferType - The type of buffer concerned
+     * @param {Object} period - The Period concerned
+     */
+    onPeriodCleared(bufferType: IBufferType, period: IPeriod): void;
+    /**
+     * Method to call when the last chronological segment for a given buffer type
+     * is known to have been loaded and is either pushed or in the process of
+     * being pushed to the corresponding MSE `SourceBuffer` or equivalent.
+     *
+     * This method can even be called multiple times in a row as long as the
+     * aforementioned condition is true, if it simplify your code's management.
+     * @param {string} bufferType
+     */
+    onLastSegmentFinishedLoading(bufferType: IBufferType): void;
+    /**
+     * Method to call to "cancel" a previous call to
+     * `onLastSegmentFinishedLoading`.
+     *
+     * That is, calling this method indicates that the last chronological segment
+     * of a given buffer type is now either not loaded or it is not known.
+     *
+     * This method can even be called multiple times in a row as long as the
+     * aforementioned condition is true, if it simplify your code's management.
+     * @param {string} bufferType
+     */
+    onLastSegmentLoadingResume(bufferType: IBufferType): void;
+    /**
+     * Free all resources used by the `ContentTimeBoundariesObserver` and cancels
+     * all recurring processes it performs.
+     */
+    dispose(): void;
+    private _addActivelyLoadedPeriod;
+    private _removeActivelyLoadedPeriod;
+    private _checkCurrentPeriod;
+    private _getManifestEndTime;
+    private _lazilyCreateActiveStreamInfo;
+    private _checkEndOfStream;
+}
+export interface IEndingPositionInformation {
+    /**
+     * The new maximum known position (note that this is the ending position
+     * currently known of the current content, it might be superior to the last
+     * position at which segments are available and it might also evolve over
+     * time), in seconds.
+     */
+    endingPosition: number;
+    /**
+     * If `true`, the communicated `endingPosition` is the actual end of the content.
+     * It may still be updated due to a track change or to add precision, but it
+     * is still a (rough) estimate of the maximum position that content should
+     * have.
+     *
+     * If `false`, this is the currently known maximum position associated to
+     * the content, but the content is still evolving (typically, new media
+     * segments are still being generated) and as such it can still have a
+     * longer `endingPosition` in the future.
+     */
+    isEnd: boolean;
+}
+/**
+ * Events triggered by a `ContentTimeBoundariesObserver` where the keys are the
+ * event names and the value is the payload of those events.
+ */
+export interface IContentTimeBoundariesObserverEvent {
+    /** Triggered when a minor error is encountered. */
+    warning: IPlayerError;
+    /** Triggered when a new `Period` is currently playing. */
+    periodChange: IPeriod;
+    /**
+     * Triggered when the ending position of the currently-playing content became
+     * known or changed.
+     */
+    endingPositionChange: IEndingPositionInformation;
+    /**
+     * Triggered when the last possible chronological segment for all types of
+     * buffers has either been pushed or is being pushed to the corresponding
+     * MSE `SourceBuffer` or equivalent.
+     * As such, the `endOfStream` MSE API might from now be able to be called.
+     *
+     * Note that it is possible to receive this event even if `endOfStream` has
+     * already been called and even if an "endOfStream" event has already been
+     * triggered.
+     */
+    endOfStream: null;
+    /**
+     * Triggered when the last possible chronological segment for all types of
+     * buffers have NOT been pushed, or if it is not known whether is has been
+     * pushed, and as such any potential pending `endOfStream` MSE API call
+     * need to be cancelled.
+     *
+     * Note that it is possible to receive this event even if `endOfStream` has
+     * not been called and even if an "resumeStream" event has already been
+     * triggered.
+     */
+    resumeStream: null;
+}
+export type IContentTimeObserverPlaybackObservation = Pick<IStreamOrchestratorPlaybackObservation, "position">;