shaka-player 4.7.13 → 4.8.1

package/dist/shaka-player.ui.debug.externs.js

@@ -127,6 +127,61 @@ shaka.util.FakeEventTarget = class {
  * @typedef {EventListener|function(!Event):*}
  */
 shaka.util.FakeEventTarget.ListenerType;
+/**
+ * @summary A set of BufferSource utility functions.
+ */
+shaka.util.BufferUtils = class {
+  /**
+   * Compare two buffers for equality.  For buffers of different types, this
+   * compares the underlying buffers as binary data.
+   * @param {?BufferSource} arr1
+   * @param {?BufferSource} arr2
+   * @return {boolean}
+   * @suppress {strictMissingProperties}
+   */
+  static equal(arr1, arr2) {}
+  /**
+   * Gets an ArrayBuffer that contains the data from the given TypedArray.  Note
+   * this will allocate a new ArrayBuffer if the object is a partial view of
+   * the data.
+   * @param {!BufferSource} view
+   * @return {!ArrayBuffer}
+   */
+  static toArrayBuffer(view) {}
+  /**
+   * Creates a new Uint8Array view on the same buffer.  This clamps the values
+   * to be within the same view (i.e. you can't use this to move past the end
+   * of the view, even if the underlying buffer is larger).  However, you can
+   * pass a negative offset to access the data before the view.
+   * @param {BufferSource} data
+   * @param {number=} offset The offset from the beginning of this data's view
+   *   to start the new view at.
+   * @param {number=} length The byte length of the new view.
+   * @return {!Uint8Array}
+   */
+  static toUint8(data, offset, length) {}
+  /**
+   * Creates a new Uint16Array view on the same buffer.  This clamps the values
+   * to be within the same view (i.e. you can't use this to move past the end
+   * of the view, even if the underlying buffer is larger).  However, you can
+   * pass a negative offset to access the data before the view.
+   * @param {BufferSource} data
+   * @param {number=} offset The offset from the beginning of this data's view
+   *   to start the new view at.
+   * @param {number=} length The byte length of the new view.
+   * @return {!Uint16Array}
+   */
+  static toUint16(data, offset, length) {}
+  /**
+   * Creates a DataView over the given buffer.
+   * @see toUint8
+   * @param {BufferSource} buffer
+   * @param {number=} offset
+   * @param {number=} length
+   * @return {!DataView}
+   */
+  static toDataView(buffer, offset, length) {}
+};
 /**
  * @summary
  * Describes an error that happened.
@@ -313,6 +368,7 @@ shaka.util.Error.Code = {
   'NO_VIDEO_ELEMENT': 7002,
   'OBJECT_DESTROYED': 7003,
   'CONTENT_NOT_LOADED': 7004,
+  'SRC_EQUALS_PRELOAD_NOT_SUPPORTED': 7005,
   'CAST_API_UNAVAILABLE': 8000,
   'NO_CAST_RECEIVERS': 8001,
   'ALREADY_CASTING': 8002,
@@ -342,6 +398,137 @@ shaka.util.Error.Code = {
   'CURRENT_DAI_REQUEST_NOT_FINISHED': 10004,
   'MT_AD_MANAGER_NOT_INITIALIZED': 10005
 };
+/**
+ * A timer allows a single function to be executed at a later time or at
+ * regular intervals.
+ * @final
+ */
+shaka.util.Timer = class {
+  /**
+   * Create a new timer. A timer is committed to a single callback function.
+   * While there is no technical reason to do this, it is far easier to
+   * understand and use timers when they are connected to one functional idea.
+   * @param {function()} onTick
+   */
+  constructor(onTick) {}
+  /**
+   * Have the timer call |onTick| now.
+   * @return {!shaka.util.Timer}
+   */
+  tickNow() {}
+  /**
+   * Have the timer call |onTick| after |seconds| has elapsed unless |stop| is
+   * called first.
+   * @param {number} seconds
+   * @return {!shaka.util.Timer}
+   */
+  tickAfter(seconds) {}
+  /**
+   * Have the timer call |onTick| every |seconds| until |stop| is called.
+   * @param {number} seconds
+   * @return {!shaka.util.Timer}
+   */
+  tickEvery(seconds) {}
+  /**
+   * Stop the timer and clear the previous behaviour. The timer is still usable
+   * after calling |stop|.
+   */
+  stop() {}
+};
+/**
+ * @namespace shaka.util.StringUtils
+ * @summary A set of string utility functions.
+ */
+shaka.util.StringUtils = class {
+  /**
+   * Creates a string from the given buffer as UTF-8 encoding.
+   * @param {?BufferSource} data
+   * @return {string}
+   */
+  static fromUTF8(data) {}
+  /**
+   * Creates a string from the given buffer as UTF-16 encoding.
+   * @param {?BufferSource} data
+   * @param {boolean} littleEndian
+         true to read little endian, false to read big.
+   * @param {boolean=} noThrow true to avoid throwing in cases where we may
+   *     expect invalid input.  If noThrow is true and the data has an odd
+   *     length,it will be truncated.
+   * @return {string}
+   */
+  static fromUTF16(data, littleEndian, noThrow) {}
+  /**
+   * Creates a string from the given buffer, auto-detecting the encoding that is
+   * being used.  If it cannot detect the encoding, it will throw an exception.
+   * @param {?BufferSource} data
+   * @return {string}
+   */
+  static fromBytesAutoDetect(data) {}
+  /**
+   * Creates a ArrayBuffer from the given string, converting to UTF-8 encoding.
+   * @param {string} str
+   * @return {!ArrayBuffer}
+   */
+  static toUTF8(str) {}
+  /**
+   * Creates a ArrayBuffer from the given string, converting to UTF-16 encoding.
+   * @param {string} str
+   * @param {boolean} littleEndian
+   * @return {!ArrayBuffer}
+   */
+  static toUTF16(str, littleEndian) {}
+  /**
+   * Resets the fromCharCode method's implementation.
+   * For debug use.
+   */
+  static resetFromCharCode() {}
+};
+/**
+ * @summary A set of Uint8Array utility functions.
+ */
+shaka.util.Uint8ArrayUtils = class {
+  /**
+   * Convert a buffer to a base64 string. The output will be standard
+   * alphabet as opposed to base64url safe alphabet.
+   * @param {BufferSource} data
+   * @return {string}
+   */
+  static toStandardBase64(data) {}
+  /**
+   * Convert a buffer to a base64 string.  The output will always use the
+   * alternate encoding/alphabet also known as "base64url".
+   * @param {BufferSource} data
+   * @param {boolean=} padding If true, pad the output with equals signs.
+   *   Defaults to true.
+   * @return {string}
+   */
+  static toBase64(data, padding) {}
+  /**
+   * Convert a base64 string to a Uint8Array.  Accepts either the standard
+   * alphabet or the alternate "base64url" alphabet.
+   * @param {string} str
+   * @return {!Uint8Array}
+   */
+  static fromBase64(str) {}
+  /**
+   * Convert a hex string to a Uint8Array.
+   * @param {string} str
+   * @return {!Uint8Array}
+   */
+  static fromHex(str) {}
+  /**
+   * Convert a buffer to a hex string.
+   * @param {BufferSource} data
+   * @return {string}
+   */
+  static toHex(data) {}
+  /**
+   * Concatenate buffers.
+   * @param {...BufferSource} varArgs
+   * @return {!Uint8Array}
+   */
+  static concat(...varArgs) {}
+};
 /**
  * @summary A set of language utility functions.
  * @final
@@ -648,61 +835,6 @@ shaka.util.EventManager = class {
  * @typedef {function(!Event)}
  */
 shaka.util.EventManager.ListenerType;
-/**
- * @summary A set of BufferSource utility functions.
- */
-shaka.util.BufferUtils = class {
-  /**
-   * Compare two buffers for equality.  For buffers of different types, this
-   * compares the underlying buffers as binary data.
-   * @param {?BufferSource} arr1
-   * @param {?BufferSource} arr2
-   * @return {boolean}
-   * @suppress {strictMissingProperties}
-   */
-  static equal(arr1, arr2) {}
-  /**
-   * Gets an ArrayBuffer that contains the data from the given TypedArray.  Note
-   * this will allocate a new ArrayBuffer if the object is a partial view of
-   * the data.
-   * @param {!BufferSource} view
-   * @return {!ArrayBuffer}
-   */
-  static toArrayBuffer(view) {}
-  /**
-   * Creates a new Uint8Array view on the same buffer.  This clamps the values
-   * to be within the same view (i.e. you can't use this to move past the end
-   * of the view, even if the underlying buffer is larger).  However, you can
-   * pass a negative offset to access the data before the view.
-   * @param {BufferSource} data
-   * @param {number=} offset The offset from the beginning of this data's view
-   *   to start the new view at.
-   * @param {number=} length The byte length of the new view.
-   * @return {!Uint8Array}
-   */
-  static toUint8(data, offset, length) {}
-  /**
-   * Creates a new Uint16Array view on the same buffer.  This clamps the values
-   * to be within the same view (i.e. you can't use this to move past the end
-   * of the view, even if the underlying buffer is larger).  However, you can
-   * pass a negative offset to access the data before the view.
-   * @param {BufferSource} data
-   * @param {number=} offset The offset from the beginning of this data's view
-   *   to start the new view at.
-   * @param {number=} length The byte length of the new view.
-   * @return {!Uint16Array}
-   */
-  static toUint16(data, offset, length) {}
-  /**
-   * Creates a DataView over the given buffer.
-   * @see toUint8
-   * @param {BufferSource} buffer
-   * @param {number=} offset
-   * @param {number=} length
-   * @return {!DataView}
-   */
-  static toDataView(buffer, offset, length) {}
-};
 /**
  * The IClosedCaptionParser defines the interface to provide all operations for
  * parsing the closed captions embedded in Dash videos streams.
@@ -1287,46 +1419,9 @@ shaka.text.TextEngine = class {
   destroy() {}
 };
 /**
- * A timer allows a single function to be executed at a later time or at
- * regular intervals.
- * @final
+ * @summary A set of utility functions for dealing with Streams and Manifests.
  */
-shaka.util.Timer = class {
-  /**
-   * Create a new timer. A timer is committed to a single callback function.
-   * While there is no technical reason to do this, it is far easier to
-   * understand and use timers when they are connected to one functional idea.
-   * @param {function()} onTick
-   */
-  constructor(onTick) {}
-  /**
-   * Have the timer call |onTick| now.
-   * @return {!shaka.util.Timer}
-   */
-  tickNow() {}
-  /**
-   * Have the timer call |onTick| after |seconds| has elapsed unless |stop| is
-   * called first.
-   * @param {number} seconds
-   * @return {!shaka.util.Timer}
-   */
-  tickAfter(seconds) {}
-  /**
-   * Have the timer call |onTick| every |seconds| until |stop| is called.
-   * @param {number} seconds
-   * @return {!shaka.util.Timer}
-   */
-  tickEvery(seconds) {}
-  /**
-   * Stop the timer and clear the previous behaviour. The timer is still usable
-   * after calling |stop|.
-   */
-  stop() {}
-};
-/**
- * @summary A set of utility functions for dealing with Streams and Manifests.
- */
-shaka.util.StreamUtils = class {
+shaka.util.StreamUtils = class {
   /**
    * @param {shaka.extern.Variant} variant
    * @param {shaka.extern.Restrictions} restrictions
@@ -1389,9 +1484,16 @@ shaka.abr.SimpleAbrManager = class {
    */
   disable() {}
   /**
+   * @param {number} deltaTimeMs The duration, in milliseconds, that the request
+   *     took to complete.
+   * @param {number} numBytes The total number of bytes transferred.
+   * @param {boolean} allowSwitch Indicate if the segment is allowed to switch
+   *     to another stream.
+   * @param {shaka.extern.Request=} request
+   *     A reference to the request
    * @override
    */
-  segmentDownloaded(deltaTimeMs, numBytes, allowSwitch) {}
+  segmentDownloaded(deltaTimeMs, numBytes, allowSwitch, request) {}
   /**
    * @override
    */
@@ -1531,7 +1633,8 @@ shaka.util.AbortableOperation.prototype.promise;
  */
 shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
   /**
-   * @param {function(number, number, boolean)=} onProgressUpdated Called when
+   * @param {shaka.net.NetworkingEngine.onProgressUpdated=} onProgressUpdated
+   *   Called when
    *   a progress event is triggered. Passed the duration, in milliseconds,
    *   that the request took, the number of bytes transferred, and the boolean
    *   of whether the switching is allowed.
@@ -1543,8 +1646,10 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    *   Called when a request is made
    * @param {shaka.net.NetworkingEngine.OnRetry=} onRetry
    *   Called when a request retry is made
+   * @param {shaka.net.NetworkingEngine.OnResponse=} onResponse
+   *   Called when receive the response
    */
-  constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed, onRequest, onRetry) {}
+  constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed, onRequest, onRetry, onResponse) {}
   /**
    * @param {boolean} forceHTTPS
    */
@@ -1713,6 +1818,19 @@ shaka.net.NetworkingEngine.PluginPriority = {
  * the player, plus some extra data.
  */
 shaka.net.NetworkingEngine.OnHeadersReceived;
+/**
+ * @typedef {function(
+ *    number,
+ *    number,
+ *    boolean,
+ *    shaka.extern.Request=)}
+ * @description
+ * A callback that is passed the duration, in milliseconds,
+ * that the request took, the number of bytes transferred, a boolean
+ * representing whether the switching is allowed and a ref to the
+ * original request.
+ */
+shaka.net.NetworkingEngine.onProgressUpdated;
 /**
  * @typedef {function(
  *    !shaka.extern.Request,
@@ -1745,53 +1863,14 @@ shaka.net.NetworkingEngine.OnRequest;
  */
 shaka.net.NetworkingEngine.OnRetry;
 /**
- * @namespace shaka.util.StringUtils
- * @summary A set of string utility functions.
+ * @typedef {function(
+ *    !shaka.net.NetworkingEngine.RequestType,
+ *    !shaka.extern.Response,
+ *    (shaka.extern.RequestContext|undefined))}
+ * @description
+ * A callback function called on every request
  */
-shaka.util.StringUtils = class {
-  /**
-   * Creates a string from the given buffer as UTF-8 encoding.
-   * @param {?BufferSource} data
-   * @return {string}
-   */
-  static fromUTF8(data) {}
-  /**
-   * Creates a string from the given buffer as UTF-16 encoding.
-   * @param {?BufferSource} data
-   * @param {boolean} littleEndian
-         true to read little endian, false to read big.
-   * @param {boolean=} noThrow true to avoid throwing in cases where we may
-   *     expect invalid input.  If noThrow is true and the data has an odd
-   *     length,it will be truncated.
-   * @return {string}
-   */
-  static fromUTF16(data, littleEndian, noThrow) {}
-  /**
-   * Creates a string from the given buffer, auto-detecting the encoding that is
-   * being used.  If it cannot detect the encoding, it will throw an exception.
-   * @param {?BufferSource} data
-   * @return {string}
-   */
-  static fromBytesAutoDetect(data) {}
-  /**
-   * Creates a ArrayBuffer from the given string, converting to UTF-8 encoding.
-   * @param {string} str
-   * @return {!ArrayBuffer}
-   */
-  static toUTF8(str) {}
-  /**
-   * Creates a ArrayBuffer from the given string, converting to UTF-16 encoding.
-   * @param {string} str
-   * @param {boolean} littleEndian
-   * @return {!ArrayBuffer}
-   */
-  static toUTF16(str, littleEndian) {}
-  /**
-   * Resets the fromCharCode method's implementation.
-   * For debug use.
-   */
-  static resetFromCharCode() {}
-};
+shaka.net.NetworkingEngine.OnResponse;
 /**
   * @summary DataViewReader abstracts a DataView object.
   */
@@ -1978,52 +2057,6 @@ shaka.util.Mp4Parser = class {
  * @typedef {function(!shaka.extern.ParsedBox)}
  */
 shaka.util.Mp4Parser.CallbackType;
-/**
- * @summary A set of Uint8Array utility functions.
- */
-shaka.util.Uint8ArrayUtils = class {
-  /**
-   * Convert a buffer to a base64 string. The output will be standard
-   * alphabet as opposed to base64url safe alphabet.
-   * @param {BufferSource} data
-   * @return {string}
-   */
-  static toStandardBase64(data) {}
-  /**
-   * Convert a buffer to a base64 string.  The output will always use the
-   * alternate encoding/alphabet also known as "base64url".
-   * @param {BufferSource} data
-   * @param {boolean=} padding If true, pad the output with equals signs.
-   *   Defaults to true.
-   * @return {string}
-   */
-  static toBase64(data, padding) {}
-  /**
-   * Convert a base64 string to a Uint8Array.  Accepts either the standard
-   * alphabet or the alternate "base64url" alphabet.
-   * @param {string} str
-   * @return {!Uint8Array}
-   */
-  static fromBase64(str) {}
-  /**
-   * Convert a hex string to a Uint8Array.
-   * @param {string} str
-   * @return {!Uint8Array}
-   */
-  static fromHex(str) {}
-  /**
-   * Convert a buffer to a hex string.
-   * @param {BufferSource} data
-   * @return {string}
-   */
-  static toHex(data) {}
-  /**
-   * Concatenate buffers.
-   * @param {...BufferSource} varArgs
-   * @return {!Uint8Array}
-   */
-  static concat(...varArgs) {}
-};
 /**
  * @summary An interface to register manifest parsers.
  */
@@ -2072,10 +2105,10 @@ shaka.media.InitSegmentReference = class {
    *   the quality of the media associated with this init segment.
    * @param {(null|number)=} timescale
    * @param {(null|BufferSource)=} segmentData
-   * @param {?shaka.extern.aes128Key=} aes128Key
+   * @param {?shaka.extern.aesKey=} aesKey
    *  The segment's AES-128-CBC full segment encryption key and iv.
    */
-  constructor(uris, startByte, endByte, mediaQuality, timescale, segmentData, aes128Key) {}
+  constructor(uris, startByte, endByte, mediaQuality, timescale, segmentData, aesKey) {}
   /**
    * Returns the offset from the start of the resource to the
    * start of the segment.
@@ -2148,12 +2181,12 @@ shaka.media.SegmentReference = class {
    * @param {shaka.media.SegmentReference.Status=} status
    *  The segment status is used to indicate that a segment does not exist or is
    *  not available.
-   * @param {?shaka.extern.aes128Key=} aes128Key
+   * @param {?shaka.extern.aesKey=} aesKey
    *  The segment's AES-128-CBC full segment encryption key and iv.
    * @param {boolean=} allPartialSegments
    *  Indicate if the segment has all partial segments
    */
-  constructor(startTime, endTime, uris, startByte, endByte, initSegmentReference, timestampOffset, appendWindowStart, appendWindowEnd, partialReferences, tilesLayout, tileDuration, syncTime, status, aes128Key, allPartialSegments) {}
+  constructor(startTime, endTime, uris, startByte, endByte, initSegmentReference, timestampOffset, appendWindowStart, appendWindowEnd, partialReferences, tilesLayout, tileDuration, syncTime, status, aesKey, allPartialSegments) {}
   /**
    * Creates and returns the URIs of the resource containing the segment.
    * @return {!Array.<string>}
@@ -2271,6 +2304,16 @@ shaka.media.SegmentReference = class {
    * @param {number} lowestSyncTime
    */
   syncAgainst(lowestSyncTime) {}
+  /**
+   * Set the segment data.
+   * @param {!BufferSource} segmentData
+   */
+  setSegmentData(segmentData) {}
+  /**
+   * Return the segment data.
+   * @return {?BufferSource}
+   */
+  getSegmentData() {}
 };
 /**
  * Rather than using booleans to communicate what the state of the reference,
@@ -2508,6 +2551,11 @@ shaka.media.PresentationTimeline = class {
    *   availability duration in seconds.
    */
   setSegmentAvailabilityDuration(segmentAvailabilityDuration) {}
+  /**
+   * Gets the presentation's segment availability duration.
+   * @return {number}
+   */
+  getSegmentAvailabilityDuration() {}
   /**
    * Sets the presentation delay in seconds.
    * @param {number} delay
@@ -2673,6 +2721,7 @@ shaka.media.PresentationTimeline = class {
 shaka.media.PresentationTimeline.TimeRange;
 /**
  * SegmentIndex.
+ * @implements {shaka.extern.SegmentIndex}
  * @implements {shaka.util.IReleasable}
  * @implements {Iterable.<!shaka.media.SegmentReference>}
  */
@@ -2683,6 +2732,14 @@ shaka.media.SegmentIndex = class {
    *   (ascending) and second by their end times (ascending).
    */
   constructor(references) {}
+  /**
+   * @override
+   */
+  getNumReferences() {}
+  /**
+   * @override
+   */
+  getNumEvicted() {}
   /**
    * @override
    */
@@ -2695,20 +2752,11 @@ shaka.media.SegmentIndex = class {
    */
   markImmutable() {}
   /**
-   * Finds the position of the segment for the given time, in seconds, relative
-   * to the start of the presentation.  Returns the position of the segment
-   * with the largest end time if more than one segment is known for the given
-   * time.
-   * @param {number} time
-   * @return {?number} The position of the segment, or null if the position of
-   *   the segment could not be determined.
+   * @override
    */
   find(time) {}
   /**
-   * Gets the SegmentReference for the segment at the given position.
-   * @param {number} position The position of the segment as returned by find().
-   * @return {shaka.media.SegmentReference} The SegmentReference, or null if
-   *   no such SegmentReference exists.
+   * @override
    */
   get(position) {}
   /**
@@ -2766,9 +2814,11 @@ shaka.media.SegmentIndex = class {
    * RFC 8216 rev 13, section 8.1: "Each (non-Partial) Media Segment in a Media
    * Playlist will contain at least one independent frame."
    * @param {number} time
+   * @param {boolean=} allowNonIndepedent
+   * @param {boolean=} reverse
    * @return {?shaka.media.SegmentIterator}
    */
-  getIteratorForTime(time) {}
+  getIteratorForTime(time, allowNonIndepedent, reverse) {}
   /**
    * Create a SegmentIndex for a single segment of the given start time and
    * duration at the given URIs.
@@ -2788,8 +2838,13 @@ shaka.media.SegmentIterator = class {
    * @param {shaka.media.SegmentIndex} segmentIndex
    * @param {number} index
    * @param {number} partialSegmentIndex
+   * @param {boolean} reverse
    */
-  constructor(segmentIndex, index, partialSegmentIndex) {}
+  constructor(segmentIndex, index, partialSegmentIndex, reverse) {}
+  /**
+   * @param {boolean} reverse
+   */
+  setReverse(reverse) {}
   /**
    * @return {number}
    */
@@ -2817,6 +2872,10 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
    * @override
    */
   release() {}
+  /**
+   * @override
+   */
+  forEachTopLevelReference(fn) {}
   /**
    * @override
    */
@@ -2830,36 +2889,198 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
    */
   offset(offset) {}
   /**
-   * @override
+   * @override
+   */
+  merge(references) {}
+  /**
+   * @override
+   */
+  evict(time) {}
+  /**
+   * @override
+   */
+  mergeAndEvict(references, windowStart) {}
+  /**
+   * @override
+   */
+  fit(windowStart, windowEnd) {}
+  /**
+   * @override
+   */
+  updateEvery(interval, updateCallback) {}
+};
+/**
+ * @typedef {function(
+ *  !(shaka.media.InitSegmentReference|shaka.media.SegmentReference),
+ *  shaka.extern.Stream,
+ *  ?function(BufferSource):!Promise=
+ * ):!shaka.net.NetworkingEngine.PendingRequest}
+ * @description
+ * A callback function that fetches a segment.
+ */
+shaka.media.SegmentPrefetch.FetchDispatcher;
+/**  */
+shaka.util.ConfigUtils = class {
+  /**
+   * @param {!Object} destination
+   * @param {!Object} source
+   * @param {!Object} template supplies default values
+   * @param {!Object} overrides
+   *   Supplies override type checking.  When the current path matches
+   *   the key in this object, each sub-value must match the type in this
+   *   object. If this contains an Object, it is used as the template.
+   * @param {string} path to this part of the config
+   * @return {boolean}
+   */
+  static mergeConfigObjects(destination, source, template, overrides, path) {}
+  /**
+   * Convert config from ('fieldName', value) format to a partial config object.
+   * E. g. from ('manifest.retryParameters.maxAttempts', 1) to
+   * { manifest: { retryParameters: { maxAttempts: 1 }}}.
+   * @param {string} fieldName
+   * @param {*} value
+   * @return {!Object}
+   */
+  static convertToConfigObject(fieldName, value) {}
+};
+/**
+ * @summary A set of FairPlay utility functions.
+ */
+shaka.util.FairPlayUtils = class {
+  /**
+   * Check if FairPlay is supported.
+   * @return {!Promise.<boolean>}
+   */
+  static isFairPlaySupported() {}
+  /**
+   * Using the default method, extract a content ID from the init data.  This is
+   * based on the FairPlay example documentation.
+   * @param {!BufferSource} initData
+   * @return {string}
+   */
+  static defaultGetContentId(initData) {}
+  /**
+   * Transforms the init data buffer using the given data.  The format is:
+   * <pre>
+   * [4 bytes] initDataSize
+   * [initDataSize bytes] initData
+   * [4 bytes] contentIdSize
+   * [contentIdSize bytes] contentId
+   * [4 bytes] certSize
+   * [certSize bytes] cert
+   * </pre>
+   * @param {!BufferSource} initData
+   * @param {!BufferSource|string} contentId
+   * @param {?BufferSource} cert  The server certificate; this will throw if not
+   *   provided.
+   * @return {!Uint8Array}
+   */
+  static initDataTransform(initData, contentId, cert) {}
+  /**
+   * Verimatrix initDataTransform configuration.
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   */
+  static verimatrixInitDataTransform(initData, initDataType, drmInfo) {}
+  /**
+   * EZDRM initDataTransform configuration.
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   */
+  static ezdrmInitDataTransform(initData, initDataType, drmInfo) {}
+  /**
+   * Conax initDataTransform configuration.
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   */
+  static conaxInitDataTransform(initData, initDataType, drmInfo) {}
+  /**
+   * ExpressPlay initDataTransform configuration.
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   */
+  static expressplayInitDataTransform(initData, initDataType, drmInfo) {}
+  /**
+   * Verimatrix FairPlay request.
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
+   */
+  static verimatrixFairPlayRequest(type, request, context) {}
+  /**
+   * EZDRM FairPlay request.
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
+   */
+  static ezdrmFairPlayRequest(type, request, context) {}
+  /**
+   * Conax FairPlay request.
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
+   */
+  static conaxFairPlayRequest(type, request, context) {}
+  /**
+   * ExpressPlay FairPlay request.
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
+   */
+  static expressplayFairPlayRequest(type, request, context) {}
+  /**
+   * Common FairPlay response transform for some DRMs providers.
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Response} response
+   * @param {shaka.extern.RequestContext=} context
+   */
+  static commonFairPlayResponse(type, response, context) {}
+};
+/**
+ * @final
+ */
+shaka.util.PlayerConfiguration = class {
+  /**
+   * @return {shaka.extern.PlayerConfiguration}
    */
-  merge(references) {}
+  static createDefault() {}
   /**
-   * @override
+   * Merges the given configuration changes into the given destination.  This
+   * uses the default Player configurations as the template.
+   * @param {shaka.extern.PlayerConfiguration} destination
+   * @param {!Object} updates
+   * @param {shaka.extern.PlayerConfiguration=} template
+   * @return {boolean}
    */
-  evict(time) {}
+  static mergeConfigObjects(destination, updates, template) {}
+};
+/**
+ * @implements {shaka.util.IDestroyable}
+ */
+shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
   /**
-   * @override
+   * @param {string} assetUri
+   * @param {?string} mimeType
+   * @param {number} startTimeOfLoad
+   * @param {?number} startTime
+   * @param {*} playerInterface
    */
-  mergeAndEvict(references, windowStart) {}
+  constructor(assetUri, mimeType, startTimeOfLoad, startTime, playerInterface) {}
   /**
-   * @override
+   * Waits for the loading to be finished (or to fail with an error).
+   * @return {!Promise}
    */
-  fit(windowStart, windowEnd) {}
+  waitForFinish() {}
   /**
+   * Releases or stops all non-entrusted resources.
    * @override
    */
-  updateEvery(interval, updateCallback) {}
+  destroy() {}
 };
-/**
- * @typedef {function(
- *  !(shaka.media.InitSegmentReference|shaka.media.SegmentReference),
- *  shaka.extern.Stream,
- *  ?function(BufferSource):!Promise=
- * ):!shaka.net.NetworkingEngine.PendingRequest}
- * @description
- * A callback function that fetches a segment.
- */
-shaka.media.SegmentPrefetch.FetchDispatcher;
 /**
  * A text displayer plugin using the browser's native VTTCue interface.
  * @implements {shaka.extern.TextDisplayer}
@@ -2870,6 +3091,10 @@ shaka.text.SimpleTextDisplayer = class {
    * @param {string} label
    */
   constructor(video, label) {}
+  /**
+   * @override
+   */
+  configure(config) {}
   /**
    * @override
    */
@@ -2896,6 +3121,10 @@ shaka.text.SimpleTextDisplayer = class {
 * @implements {shaka.extern.TextDisplayer}
 */
 shaka.text.StubTextDisplayer = class {
+  /**
+   * @override
+   */
+  configure(config) {}
   /**
    * @override
    */
@@ -2936,8 +3165,13 @@ shaka.text.UITextDisplayer = class {
    * Constructor.
    * @param {HTMLMediaElement} video
    * @param {HTMLElement} videoContainer
+   * @param {shaka.extern.TextDisplayerConfiguration} config
+   */
+  constructor(video, videoContainer, config) {}
+  /**
+   * @override
    */
-  constructor(video, videoContainer) {}
+  configure(config) {}
   /**
    * @override
    */
@@ -3014,145 +3248,6 @@ shaka.util.CmsdManager = class {
    */
   getBandwidthEstimate(defaultEstimate) {}
 };
-/**  */
-shaka.util.ConfigUtils = class {
-  /**
-   * @param {!Object} destination
-   * @param {!Object} source
-   * @param {!Object} template supplies default values
-   * @param {!Object} overrides
-   *   Supplies override type checking.  When the current path matches
-   *   the key in this object, each sub-value must match the type in this
-   *   object. If this contains an Object, it is used as the template.
-   * @param {string} path to this part of the config
-   * @return {boolean}
-   */
-  static mergeConfigObjects(destination, source, template, overrides, path) {}
-  /**
-   * Convert config from ('fieldName', value) format to a partial config object.
-   * E. g. from ('manifest.retryParameters.maxAttempts', 1) to
-   * { manifest: { retryParameters: { maxAttempts: 1 }}}.
-   * @param {string} fieldName
-   * @param {*} value
-   * @return {!Object}
-   */
-  static convertToConfigObject(fieldName, value) {}
-};
-/**
- * @summary A set of FairPlay utility functions.
- */
-shaka.util.FairPlayUtils = class {
-  /**
-   * Check if FairPlay is supported.
-   * @return {!Promise.<boolean>}
-   */
-  static isFairPlaySupported() {}
-  /**
-   * Using the default method, extract a content ID from the init data.  This is
-   * based on the FairPlay example documentation.
-   * @param {!BufferSource} initData
-   * @return {string}
-   */
-  static defaultGetContentId(initData) {}
-  /**
-   * Transforms the init data buffer using the given data.  The format is:
-   * <pre>
-   * [4 bytes] initDataSize
-   * [initDataSize bytes] initData
-   * [4 bytes] contentIdSize
-   * [contentIdSize bytes] contentId
-   * [4 bytes] certSize
-   * [certSize bytes] cert
-   * </pre>
-   * @param {!BufferSource} initData
-   * @param {!BufferSource|string} contentId
-   * @param {?BufferSource} cert  The server certificate; this will throw if not
-   *   provided.
-   * @return {!Uint8Array}
-   */
-  static initDataTransform(initData, contentId, cert) {}
-  /**
-   * Verimatrix initDataTransform configuration.
-   * @param {!Uint8Array} initData
-   * @param {string} initDataType
-   * @param {?shaka.extern.DrmInfo} drmInfo
-   */
-  static verimatrixInitDataTransform(initData, initDataType, drmInfo) {}
-  /**
-   * EZDRM initDataTransform configuration.
-   * @param {!Uint8Array} initData
-   * @param {string} initDataType
-   * @param {?shaka.extern.DrmInfo} drmInfo
-   */
-  static ezdrmInitDataTransform(initData, initDataType, drmInfo) {}
-  /**
-   * Conax initDataTransform configuration.
-   * @param {!Uint8Array} initData
-   * @param {string} initDataType
-   * @param {?shaka.extern.DrmInfo} drmInfo
-   */
-  static conaxInitDataTransform(initData, initDataType, drmInfo) {}
-  /**
-   * ExpressPlay initDataTransform configuration.
-   * @param {!Uint8Array} initData
-   * @param {string} initDataType
-   * @param {?shaka.extern.DrmInfo} drmInfo
-   */
-  static expressplayInitDataTransform(initData, initDataType, drmInfo) {}
-  /**
-   * Verimatrix FairPlay request.
-   * @param {shaka.net.NetworkingEngine.RequestType} type
-   * @param {shaka.extern.Request} request
-   * @param {shaka.extern.RequestContext=} context
-   */
-  static verimatrixFairPlayRequest(type, request, context) {}
-  /**
-   * EZDRM FairPlay request.
-   * @param {shaka.net.NetworkingEngine.RequestType} type
-   * @param {shaka.extern.Request} request
-   * @param {shaka.extern.RequestContext=} context
-   */
-  static ezdrmFairPlayRequest(type, request, context) {}
-  /**
-   * Conax FairPlay request.
-   * @param {shaka.net.NetworkingEngine.RequestType} type
-   * @param {shaka.extern.Request} request
-   * @param {shaka.extern.RequestContext=} context
-   */
-  static conaxFairPlayRequest(type, request, context) {}
-  /**
-   * ExpressPlay FairPlay request.
-   * @param {shaka.net.NetworkingEngine.RequestType} type
-   * @param {shaka.extern.Request} request
-   * @param {shaka.extern.RequestContext=} context
-   */
-  static expressplayFairPlayRequest(type, request, context) {}
-  /**
-   * Common FairPlay response transform for some DRMs providers.
-   * @param {shaka.net.NetworkingEngine.RequestType} type
-   * @param {shaka.extern.Response} response
-   * @param {shaka.extern.RequestContext=} context
-   */
-  static commonFairPlayResponse(type, response, context) {}
-};
-/**
- * @final
- */
-shaka.util.PlayerConfiguration = class {
-  /**
-   * @return {shaka.extern.PlayerConfiguration}
-   */
-  static createDefault() {}
-  /**
-   * Merges the given configuration changes into the given destination.  This
-   * uses the default Player configurations as the template.
-   * @param {shaka.extern.PlayerConfiguration} destination
-   * @param {!Object} updates
-   * @param {shaka.extern.PlayerConfiguration=} template
-   * @return {boolean}
-   */
-  static mergeConfigObjects(destination, updates, template) {}
-};
 /**
  * @summary The main player object for Shaka Player.
  * @implements {shaka.util.IDestroyable}
@@ -3245,7 +3340,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   /**
    * Loads a new stream.
    * If another stream was already playing, first unloads that stream.
-   * @param {string} assetUri
+   * @param {string|shaka.media.PreloadManager} assetUriOrPreloader
    * @param {?number=} startTime
    *    When <code>startTime</code> is <code>null</code> or
    *    <code>undefined</code>, playback will start at the default start time (0
@@ -3253,7 +3348,39 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @param {?string=} mimeType
    * @return {!Promise}
    */
-  load(assetUri, startTime, mimeType) {}
+  load(assetUriOrPreloader, startTime, mimeType) {}
+  /**
+   * Unloads the currently playing stream, if any, and returns a PreloadManager
+   * that contains the loaded manifest of that asset, if any.
+   * Allows for the asset to be re-loaded by this player faster, in the future.
+   * When in src= mode, this unloads but does not make a PreloadManager.
+   * @param {boolean=} initializeMediaSource
+   * @param {boolean=} keepAdManager
+   * @return {!Promise.<?shaka.media.PreloadManager>}
+   */
+  unloadAndSavePreload(initializeMediaSource, keepAdManager) {}
+  /**
+   * Starts to preload a given asset, and returns a PreloadManager object that
+   * represents that preloading process.
+   * The PreloadManager will load the manifest for that asset, as well as the
+   * initialization segment. It will not preload anything more than that;
+   * this feature is intended for reducing start-time latency, not for fully
+   * downloading assets before playing them (for that, use
+   * |shaka.offline.Storage|).
+   * You can pass that PreloadManager object in to the |load| method on this
+   * Player instance to finish loading that particular asset, or you can call
+   * the |destroy| method on the manager if the preload is no longer necessary.
+   * If this returns null rather than a PreloadManager, that indicates that the
+   * asset must be played with src=, which cannot be preloaded.
+   * @param {string} assetUri
+   * @param {?number=} startTime
+   *    When <code>startTime</code> is <code>null</code> or
+   *    <code>undefined</code>, playback will start at the default start time (0
+   *    for VOD and liveEdge for LIVE).
+   * @param {?string=} mimeType
+   * @return {!Promise.<?shaka.media.PreloadManager>}
+   */
+  preload(assetUri, startTime, mimeType) {}
   /**
    * Releases all of the mutexes of the player. Meant for use by the tests.
    */
@@ -3584,19 +3711,22 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    */
   setTextTrackVisibility(isVisible) {}
   /**
-   * Get the current playhead position as a date. This should only be called
-   * when the player has loaded a live stream. If the player has not loaded a
-   * live stream, this will return <code>null</code>.
+   * Get the current playhead position as a date.
    * @return {Date}
    */
   getPlayheadTimeAsDate() {}
   /**
-   * Get the presentation start time as a date. This should only be called when
-   * the player has loaded a live stream. If the player has not loaded a live
-   * stream, this will return <code>null</code>.
+   * Get the presentation start time as a date.
    * @return {Date}
    */
   getPresentationStartTimeAsDate() {}
+  /**
+   * Get the presentation segment availability duration. This should only be
+   * called when the player has loaded a live stream. If the player has not
+   * loaded a live stream, this will return <code>null</code>.
+   * @return {?number}
+   */
+  getSegmentAvailabilityDuration() {}
   /**
    * Get information about what the player has buffered. If the player has not
    * loaded content or is currently loading content, the buffered content will
@@ -3648,8 +3778,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   addChaptersTrack(uri, language, mimeType) {}
   /**
    * Set the maximum resolution that the platform's hardware can handle.
-   * This will be called automatically by <code>shaka.cast.CastReceiver</code>
-   * to enforce limitations of the Chromecast hardware.
    * @param {number} width
    * @param {number} height
    */
@@ -4153,6 +4281,11 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
    * @override
    */
   requestMediaTailorStream(url, adsParams, backupUrl) {}
+  /**
+   * @param {string} url
+   * @override
+   */
+  addMediaTailorTrackingUrl(url) {}
   /**
    * @override
    */
@@ -4558,6 +4691,16 @@ shaka.util.PeriodCombiner = class {
    * @return {!Promise}
    */
   combinePeriods(periods, isDynamic) {}
+  /**
+   * @param {boolean} allowed If set to true, multi-mimeType or multi-codec
+   *   variants will be allowed.
+   */
+  setAllowMultiTypeVariants(allowed) {}
+  /**
+   * @param {boolean} useOnce if true, stream will be used only once in period
+   *   flattening algoritnm.
+   */
+  setUseStreamOnce(useOnce) {}
 };
 /**
  * Creates a new DASH parser.
@@ -5771,9 +5914,10 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
    * @param {!shaka.Player} player
    * @param {!HTMLElement} videoContainer
    * @param {!HTMLMediaElement} video
+   * @param {?HTMLCanvasElement} vrCanvas
    * @param {shaka.extern.UIConfiguration} config
    */
-  constructor(player, videoContainer, video, config) {}
+  constructor(player, videoContainer, video, vrCanvas, config) {}
   /**
    * @override
    */
@@ -5916,6 +6060,60 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
    * @return {boolean}
    */
   isOpaque() {}
+  /**
+   */
+  showUI() {}
+  /**
+   */
+  hideUI() {}
+  /**
+   * Returns if a VR is capable.
+   * @return {boolean}
+   */
+  canPlayVR() {}
+  /**
+   * Returns if a VR is supported.
+   * @return {boolean}
+   */
+  isPlayingVR() {}
+  /**
+   * Get the angle of the north.
+   * @return {?number}
+   */
+  getVRNorth() {}
+  /**
+   * Returns the angle of the current field of view displayed in degrees.
+   * @return {?number}
+   */
+  getVRFieldOfView() {}
+  /**
+   * Changing the field of view increases or decreases the portion of the video
+   * that is viewed at one time. If the field of view is decreased, a small
+   * part of the video will be seen, but with more detail. If the field of view
+   * is increased, a larger part of the video will be seen, but with less
+   * detail.
+   * @param {number} fieldOfView In degrees
+   */
+  setVRFieldOfView(fieldOfView) {}
+  /**
+   * Toggle stereoscopic mode.
+   */
+  toggleStereoscopicMode() {}
+  /**
+   * Increment the yaw in X angle in degrees.
+   * @param {number} angle In degrees
+   */
+  incrementYaw(angle) {}
+  /**
+   * Increment the pitch in X angle in degrees.
+   * @param {number} angle In degrees
+   */
+  incrementPitch(angle) {}
+  /**
+   * Increment the roll in X angle in degrees.
+   * @param {number} angle In degrees
+   */
+  incrementRoll(angle) {}
 };
 /**
  * @extends {shaka.ui.Element}
@@ -5952,8 +6150,9 @@ shaka.ui.Overlay = class {
    * @param {!shaka.Player} player
    * @param {!HTMLElement} videoContainer
    * @param {!HTMLMediaElement} video
+   * @param {?HTMLCanvasElement=} vrCanvas
    */
-  constructor(player, videoContainer, video) {}
+  constructor(player, videoContainer, video, vrCanvas) {}
   /**
    * @override
    */
@@ -6116,6 +6315,17 @@ shaka.ui.PresentationTimeTracker = class extends shaka.ui.Element {
    */
   constructor(parent, controls) {}
 };
+/**
+ * @extends {shaka.ui.Element}
+ * @final
+ */
+shaka.ui.RecenterVRButton = class extends shaka.ui.Element {
+  /**
+   * @param {!HTMLElement} parent
+   * @param {!shaka.ui.Controls} controls
+   */
+  constructor(parent, controls) {}
+};
 /**
  * @extends {shaka.ui.Element}
  * @final
@@ -6204,6 +6414,17 @@ shaka.ui.TextSelection = class extends shaka.ui.SettingsMenu {
    */
   constructor(parent, controls) {}
 };
+/**
+ * @extends {shaka.ui.Element}
+ * @final
+ */
+shaka.ui.ToggleStereoscopicButton = class extends shaka.ui.Element {
+  /**
+   * @param {!HTMLElement} parent
+   * @param {!shaka.ui.Controls} controls
+   */
+  constructor(parent, controls) {}
+};
 /**
  * @extends {shaka.ui.RangeElement}
  * @final