store(uri, appMetadata, mimeType, externalThumbnails, externalText) {
    goog.asserts.assert(
        this.networkingEngine_,
        'Cannot call |store| after calling |destroy|.');

    // Get a copy of the current config.
    const config = this.getConfiguration();

    const getParser = async () => {
      goog.asserts.assert(
          this.networkingEngine_, 'Should not call |store| after |destroy|');

      if (!mimeType) {
        mimeType = await shaka.net.NetworkingUtils.getMimeType(
            uri, this.networkingEngine_, config.manifest.retryParameters);
      }

      const factory = shaka.media.ManifestParser.getFactory(
          uri,
          mimeType || null);

      return factory();
    };

    /** @type {!shaka.offline.DownloadManager} */
    const downloader =
        new shaka.offline.DownloadManager(this.networkingEngine_);
    this.openDownloadManagers_.push(downloader);

    const storeOp = this.store_(
        uri, appMetadata || {}, externalThumbnails || [], externalText || [],
        getParser, config, downloader);
    const abortableStoreOp = new shaka.util.AbortableOperation(storeOp, () => {
      return downloader.abortAll();
    });
    abortableStoreOp.finally(() => {
      shaka.util.ArrayUtils.remove(this.openDownloadManagers_, downloader);
    });

    return this.startAbortableOperation_(abortableStoreOp);
  }
Stores the given manifest.  If the content is encrypted, and encrypted
content cannot be stored on this platform, the Promise will be rejected
with error code 6001, REQUESTED_KEY_SYSTEM_CONFIG_UNAVAILABLE.
Multiple assets can be downloaded at the same time, but note that since
the storage instance has a single networking engine, multiple storage
objects will be necessary if some assets require unique network filters.
This snapshots the storage config at the time of the call, so it will not
honor any changes to config mid-store operation.

@param {string} uri The URI of the manifest to store.
@param {!Object=} appMetadata An arbitrary object from the application
  that will be stored along-side the offline content.  Use this for any
  application-specific metadata you need associated with the stored
  content.  For details on the data types that can be stored here, please
  refer to {@link https://bit.ly/StructClone}
@param {?string=} mimeType
  The mime type for the content |manifestUri| points to.
@param {?Array<string>=} externalThumbnails
  The external thumbnails to store along the main content.
@param {?Array<shaka.extern.ExtraText>=} externalText
  The external text to store along the main content.
@return {!shaka.extern.IAbortableOperation.<shaka.extern.StoredContent>}
  An AbortableOperation that resolves with a structure representing what
  was stored.  The "offlineUri" member is the URI that should be given to
  Player.load() to play this piece of content offline.  The "appMetadata"
  member is the appMetadata argument you passed to store().
  If you want to cancel this download, call the "abort" method on
  AbortableOperation.
@export