@castlabs/prestoplay 6.17.1 → 6.19.0

package/typings.d.ts

@@ -183,6 +183,9 @@ export namespace clpp {
     create(config: clpp.PlayerConfiguration): clpp.PlayerPlugin|null;
   }
   
+  /**
+   * Adaptive Bitrate Streaming (ABR) configuration.
+   */
   export type AbrConfiguration = {
     /**
      * The largest fraction of the estimated bandwidth we should use. We should
@@ -209,7 +212,7 @@ export namespace clpp {
     enabled: boolean;
     /**
      * Restrictions used only for initial ABR selection. This can be used i.e.
-     * in DRM multikey scenarios, to ensure that first selected track will be
+     * in DRM multikey scenarios, to ensure that the first selected track will be
      * playable on any platform. Restrictions are applied on every playback
      * attempt if defined.
      */
@@ -219,23 +222,26 @@ export namespace clpp {
      * Any track that fails to meet these restrictions will not be selected
      * automatically, but will still appear in the track list and can be selected
      * via {@link clpp.TrackManager#setVideoTrack}. If no tracks meet these
-     * restrictions, AbrManager should not fail but should choose a low-resolution
-     * or low-bandwidth variant instead.
+     * restrictions, the ABR Manager should not fail but should choose
+     * a low-resolution or low-bandwidth variant instead.
      */
-    restrictions: clpp.Restrictions;
+    restrictions?: clpp.Restrictions;
     /**
      * The minimum amount of time that must pass between switches, in
      * seconds. This keeps us from changing too often and annoying the user.
      */
     switchInterval: number;
     /**
-     * Defaults to false. 
+     * Defaults to true. 
      * 
-     * Enables reading CMSD (Common Media Server Data) of media requests
+     * Enables reading CMSD (Common Media Server Data) of requests
      * and use it for ABR decisions.
-     * estimatedThroughputKbps(etp) is supported,
-     * value is used as an bandwidth estimate. If the header is not present,
-     * the default ABR bandwidth estimation is used.
+     * estimatedThroughputKbps (etp)
+     * When property is present as part of CMSD-Dynamic header
+     * its value is used as a bandwidth estimate.
+     * maxSuggestedBitrateKbps (mb)
+     * When property is present as part of CMSD-Dynamic header
+     * its value is used as a maximum bandwidth limit.
      */
     useCmsd: boolean;
     /**
@@ -246,6 +252,16 @@ export namespace clpp {
     useSwitchIntervalForInitialSwitch: boolean;
   }
   
+  /**
+   * Configuration for ads.
+   */
+  export type AdsConfiguration = {
+    /**
+     * Configuration for ads based on HLS interstitials.
+     */
+    hls?: clpp.HlsAdsConfiguration;
+  }
+  
   /**
    * Broadpeak plugin configuration.
    */
@@ -437,6 +453,12 @@ export namespace clpp {
      * By default player tries to setup most secure system on given platform.
      */
     preferredDrmSystem?: clpp.drm.KeySystem;
+    /**
+     * The version of the Widevine key system. This option may be used in order
+     * to enable experimental versions of the Widevine key system such as
+     * "com.widevine.alpha.experiment" or "com.widevine.alpha.experiment2".
+     */
+    widevineVersion?: string;
   }
   
   /**
@@ -690,6 +712,21 @@ export namespace clpp {
     type: clpp.ads.PodType;
   }
   
+  /**
+   * Configuration for ads based on HLS interstitials.
+   */
+  export type HlsAdsConfiguration = {
+    /**
+     * If true enable support.
+     */
+    enable?: boolean;
+    /**
+     * How many seconds ahead of an interstitial date range should its
+     * interstitial assets or asset lists be requested and preloaded.
+     */
+    resolutionOffsetSec?: number;
+  }
+  
   /**
    * HLS-SMPTE plugin configuration.
    */
@@ -883,6 +920,10 @@ export namespace clpp {
      * Supported values: `4.0.0.0`, `4.1.0.0`, `4.2.0.0`, `4.3.0.0`.
      */
     playreadyVersion: string;
+    /**
+     * Configuration of the timeline.
+     */
+    timeline?: clpp.TimelineConfiguration;
     /**
      * If true, xlink-related errors will result in a fallback to the tag's
      * existing contents. If false, xlink-related errors will be propagated
@@ -897,15 +938,14 @@ export namespace clpp {
    */
   export type MediaSourceConfiguration = {
     /**
-     * The switching
-     * strategy determines how to handle codec changes during playback. The `SMOOTH`
-     * strategy uses `SourceBuffer.changeType()` - if it’s available and reliably
-     * supported on a device - to dynamically switch between streams encoded with
-     * different codecs. The `PREVENT` strategy, which is the default, actively
-     * tries to prevent scenarios where different codecs are available for
-     * switching, whether through ABR or user selection.
+     * The switching strategy determines how to handle codec changes during
+     * playback. The `SMOOTH` strategy uses `SourceBuffer.changeType()` - if
+     * it’s available and reliably supported on a device - to dynamically switch
+     * between streams encoded with different codecs. The `PREVENT` strategy,
+     * which is the default, actively tries to prevent scenarios where different
+     * codecs are available for switching, whether through ABR or user selection.
      */
-    codecSwitchingStrategy: clpp.CodecSwitchingStrategy;
+    codecSwitchingStrategy?: clpp.CodecSwitchingStrategy;
   }
   
   /**
@@ -1123,6 +1163,10 @@ export namespace clpp {
      * ABR configuration and settings.
      */
     abr?: Partial<clpp.AbrConfiguration>;
+    /**
+     * Ads configuration.
+     */
+    ads?: Partial<clpp.AdsConfiguration>;
     /**
      * Configures the autoplay behavior.
      */
@@ -1185,7 +1229,7 @@ export namespace clpp {
      */
     id?: string;
     /**
-     * Ads plugin configuration.
+     * Google IMA ads plugin configuration.
      */
     ima?: Partial<clpp.ImaConfiguration>;
     /**
@@ -1210,7 +1254,7 @@ export namespace clpp {
      */
     manifest?: Partial<clpp.ManifestConfiguration>;
     /**
-     * Media source configuration and settings.
+     * Media source configuration.
      */
     mediaSource?: Partial<clpp.MediaSourceConfiguration>;
     /**
@@ -1236,13 +1280,8 @@ export namespace clpp {
      */
     playlist?: Partial<clpp.PlaylistConfiguration>;
     /**
-     * Defaults to `false`. 
-     * 
-     * If `true`, a forced text track is preferred. If the content has no text
-     * tracks marked as forced and the value is `true`, no text track is chosen.
-     * If `true` and the `preferredTextLanguage` is set, and the specified
-     * language is available for the forced text track, the forced text track will
-     * be preferred over the non-forced subtitles and be enabled at startup.
+     * If `true`, the forced text track is preferred during automatic
+     * track selection.
      */
     preferForcedSubtitles?: boolean;
     /**
@@ -1325,7 +1364,7 @@ export namespace clpp {
      */
     sessions?: Partial<clpp.SessionsConfiguration>;
     /**
-     * SIMID plugin configuration
+     * SIMID plugin configuration.
      */
     simid?: Partial<clpp.SimidConfiguration>;
     /**
@@ -1339,7 +1378,7 @@ export namespace clpp {
      */
     startTime?: number|null;
     /**
-     * The streaming configuration
+     * The streaming configuration.
      */
     streaming?: Partial<clpp.StreamingConfiguration>;
     /**
@@ -1642,7 +1681,7 @@ export namespace clpp {
    */
   export type Restrictions = {
     /**
-     * The minimum bandwidth of a track in bit/sec.
+     * The maximum bandwidth of a track in bit/sec.
      */
     maxBandwidth: number;
     /**
@@ -2321,6 +2360,21 @@ export namespace clpp {
     url: string;
   }
   
+  /**
+   * Configuration of the timeline.
+   */
+  export type TimelineConfiguration = {
+    /**
+     * This option applies only to DASH, otherwise it is ignored.
+     * If type is 'startover' it is possible to seek to the very start of
+     * the stream even though it is live and the timeline
+     * is updated based on the manifest without interpolation.
+     * Note: the 'startover' type is compatible with manifests based on
+     * SegmentTimeline or SegmentList.
+     */
+    type?: string;
+  }
+  
   /**
    * Contains information about a cue in the timeline that will cause an event
    * to be raised when the playhead enters or exits it.  In DASH this is the
@@ -3180,6 +3234,14 @@ export namespace clpp {
      * Triggered when an ad pod ended.
      */
     AD_BREAK_STOPPED = "ad-break-stopped",
+    /**
+     * Triggered when the X-ASSET-LIST request is sent.
+     */
+    AD_HLS_ASSET_LIST_REQUEST = "ad-hls-asset-list-request",
+    /**
+     * Triggered when the X-ASSET-LIST response is received.
+     */
+    AD_HLS_ASSET_LIST_RESPONSE = "ad-hls-asset-list-response",
     /**
      * Triggered when a SIMID Ad started.
      */
@@ -3213,7 +3275,7 @@ export namespace clpp {
      */
     AIRPLAY_CASTING_ENDED = "airplay-casting-ended",
     /**
-     * Triggered a new cue have been added to the timeline
+     * Triggered when a new cue has been added to the timeline.
      */
     TIMELINE_CUE_ADDED = "timeline-cue-added",
     /**
@@ -3224,6 +3286,10 @@ export namespace clpp {
      * Triggered when a timeline cue is exited.
      */
     TIMELINE_CUE_EXIT = "timeline-cue-exit",
+    /**
+     * Triggered when timeline cues have changed.
+     */
+    TIMELINE_CUES_CHANGED = "timeline-cues-changed",
     /**
      * Triggered when a MPD type has changed from dynamic to static.
      * Note: You can also listen to the {@link clpp.events.LIVE_TURNED_STATIC}
@@ -3280,6 +3346,10 @@ export namespace clpp {
      * Online status changed.
      */
     ONLINE_STATUS_CHANGED = "online-status-changed",
+    /**
+     * Triggered when CMSD headers were detected as part of a network response.
+     */
+    CMSD_EVENT = "cmsd-event",
   }
   
   /**
@@ -3474,9 +3544,9 @@ export namespace clpp {
     destroy(): Promise<void>;
     /**
      * Returns the ads manager or null if not available.
-     * The ads manager is available when {@clpp.Player.load} is resolved.
+     * The ads manager is available when {@link clpp.Player.load} is resolved.
      */
-    getAdsManager(): clpp.ads.IAdsManager;
+    getAdsManager(): clpp.ads.IAdsManager|null;
     /**
      * Returns an instance of {@link clpp.BufferInfo} which is an extended version
      * of the native {@link TimeRanges} from the browser and adds some utility
@@ -4554,6 +4624,10 @@ export namespace clpp {
        * An error raised when the play is not allowed.
        */
       PLAY_NOT_ALLOWED = 3200,
+      /**
+       * An error raised when the player fails to be paused.
+       */
+      PAUSE_FAILED = 3201,
       /**
        * The Player was unable to guess the manifest type based on file extension
        * or MIME type. To fix, try one of the following:
@@ -4819,6 +4893,10 @@ export namespace clpp {
        * transition, it will pause, waiting for the audio stream.
        */
       INVALID_STREAMS_CHOSEN = 5005,
+      /**
+       * An error occurred while streaming the content.
+       */
+      STREAMING_ERROR = 5006,
       /**
        * The manifest indicated protected content, but the manifest parser was
        * unable to determine what key systems should be used.
@@ -5361,6 +5439,10 @@ export namespace clpp {
        * The type of the ad pod.
        */
       getPodType(): clpp.ads.PodType;
+      /**
+       * The playback position of the ad.
+       */
+      getPosition(): number;
       /**
        * The position of the ad within the ad pod.
        */
@@ -5409,63 +5491,33 @@ export namespace clpp {
     
     export interface IAdsManager {
       /**
-       * Gets the current time of the current ad that is playing.
-       * If the ad is not loaded yet or has finished playing, the API would return
-       * -1.
+       * Gets the current time of the currently playing ad.
        */
       getPosition(): number;
       /**
-       * Gets the volume for the current ad.
+       * Gets the audio volume of the current ad.
        */
       getVolume(): number;
       /**
-       * Pauses the current ad that is playing.
-       * This function will be no-op when the ad is not loaded yet or is done
-       * playing.
+       * Pauses the currently playing ad.
        */
       pause(): void;
       /**
-       * Resumes the current ad that is loaded and paused.
-       * This function will be no-op when the ad is not loaded yet or is done
-       * playing.
+       * Resumes playback of the ad if it is paused.
        */
       resume(): void;
       /**
-       * Sets the volume for the current ad.
+       * Sets the audio volume for the current ad.
        *
-       * @param volume The volume to set, from 0 (muted) to 1 (loudest).
+       * @param volume The volume to set, from 0 to 1.
        */
       setVolume(volume: number): void;
       /**
-       * Skips the current ad when {@link clpp.IAd.getSkipTimeOffset} is reached.
-       * When called under other circumstances, skip has no effect.
-       * After the skip is completed the AdsManager fires
-       * an {@link clpp.events.AD_SKIPPED} event.
+       * Skips the current ad if allowed by {@link clpp.ads.IAd.getSkipTimeOffset}.
        */
       skip(): void;
     }
     
-    export interface IAdsManagerFactory {
-      /**
-       * Creates an ads manager.
-       *
-       * @param player The proxy player.
-       */
-      create(player: clpp.Player): clpp.ads.IAdsManager;
-      /**
-       * Checks if this factory creates an ads manager that can play specified
-       * ads.
-       *
-       * @param player Player instance
-       * @param config The player configuration.
-       */
-      isSupported(player: clpp.Player, config: clpp.PlayerConfiguration): boolean;
-      /**
-       * The factory name.
-       */
-      name(): string;
-    }
-    
     export interface IAdsTimeline {
       /**
        * An array of offsets in seconds indicating
@@ -5534,6 +5586,10 @@ export namespace clpp {
        * 1 - Server side
        */
       SERVER_SIDE = 1,
+      /**
+       * 2 - Server guided
+       */
+      SERVER_GUIDED = 2,
     }
   }
   
@@ -5745,6 +5801,12 @@ export namespace clpp {
        *   broadcasted to all connected senders.
        */
       sendMessage(message: any, senderId?: string): void;
+      /**
+       * Set a Cast metadata object to be displayed on the Cast receiver and
+       * broadcast it to all senders. This will overwrite any existing metadata or
+       * remove it if `null` is passed.
+       */
+      setContentMetadata(metadata: clpp.cast.utils.ReceiverMetadataObject|null): void;
       /**
        * Gives a possibility to intercept a `LoadRequestData` instance before
        * passing it to Chromecast. Interceptor function takes load request data as
@@ -5820,6 +5882,15 @@ export namespace clpp {
        * Shutdown receiver application and removes bound player instance.
        */
       stop(): void;
+      /**
+       * Updates the Cast metadata object with new values. Any existing metadata
+       * properties will be updated or replaced with the values provided in the
+       * `metadata` object. If the `metadata` object is `null` or not provided, the
+       * current metadata will remain unchanged. If no metadata is currently set,
+       * and a valid `metadata` object is provided, it will initialize the metadata
+       * with the given values.
+       */
+      updateContentMetadata(metadata: clpp.cast.utils.ReceiverMetadataObject|null): void;
     }
     
     namespace utils {
@@ -6183,7 +6254,6 @@ export namespace clpp {
       
       /**
        * DRMtoday Widevine Server Certificates.
-       * 
        * Use these constants to specify a specific DRMtoday Widevine Server
        * Certificate to be used.
        */
@@ -6197,7 +6267,8 @@ export namespace clpp {
          */
         V1_STAGING = "V1_STAGING",
         /**
-         * The DRMtoday widevine certificate version 2
+         * The DRMtoday widevine certificate version 2 (latest version for both
+         * prod and staging)
          */
         V2 = "V2",
       }
@@ -6299,6 +6370,133 @@ export namespace clpp {
       reason: number;
     }
     
+    /**
+     * CMSD Dynamic values.
+     * Keys whose values apply only to the next transmission hop.
+     * Typically a new CMSD-Dynamic header instance will be added
+     * by each intermediary participating in the delivery.
+     */
+    export type CmsdDynamic = {
+      /**
+       * Key is included without a value if the server is under duress,
+       * due to cpu, memory, disk IO, network IO or other reasons.
+       * Header-Key: du
+       */
+      duress?: boolean;
+      /**
+       * The throughput between the server and the client over the currently
+       * negotiated transport as estimated by the server  at the start
+       * of the response. The value is expressed in units of kilobits per second.
+       * Header-Key: etp
+       */
+      estimatedThroughputKbps?: number;
+      /**
+       * The maximum bitrate value that the player
+       * SHOULD play in its Adaptive Bit Rate (ABR) ladder.
+       * Header-Key: mb
+       */
+      maxSuggestedBitrateKbps?: number;
+      /**
+       * The time elapsed between the receipt of the request
+       * and when the first byte of the body becomes available to send to the client.
+       * Header-Key: rd
+       */
+      responseDelay?: number;
+      /**
+       * Estimated round trip time between client and server.
+       * This estimate may be derived from the transport handshake.
+       * Header-Key: rtt
+       */
+      roundTripTime?: number;
+    }
+    
+    /**
+     * CMSD Static values.
+     * Keys whose values persist over multiple requests for the object.
+     */
+    export type CmsdStatic = {
+      /**
+       * The wallclock time at which the first byte of this object
+       * became available at the origin for successful request.
+       * The time is expressed as integer milliseconds since the Unix Epoch.
+       * Header-Key: at
+       */
+      availabilityTime?: number;
+      /**
+       * The encoded bitrate of the audio or video object being requested.
+       * Header-Key: br
+       */
+      encodedBitrateKbps?: number;
+      /**
+       * The number of milliseconds that this response was held back by
+       * an origin before returning.
+       * Header-Key: ht
+       */
+      heldTime?: number;
+      /**
+       * An identifier for the processing server.
+       * Header-Key: n
+       */
+      intermediaryIdentifier?: string;
+      /**
+       * The URL-encoded relative path to one or more objects which can
+       * reasonably be expected to be requested by a client.
+       * Header-Key: nor
+       */
+      nextObjectResponse?: string;
+      /**
+       * If the next response will be a partial object response,
+       * then this string denotes the byte range that will be returned.
+       * Header-Key: nrr
+       */
+      nextRangeResponse?: string;
+      /**
+       * The playback duration in milliseconds of the object.
+       * Header-Key: d
+       */
+      objectDuration?: number;
+      /**
+       * The media role of the current object being returned:
+       * m = text file, such as a manifest or playlist
+       * a = audio only
+       * v = video only
+       * av = muxed audio and video
+       * i = init segment
+       * c = caption or subtitle
+       * tt = ISOBMFF timed text track
+       * k = cryptographic key, license or certificate.
+       * o = other
+       * Header-Key: ot
+       */
+      objectType?: string;
+      /**
+       * It should approximate the starting buffer of the intended players.
+       * Header-Key: su
+       */
+      startup?: boolean;
+      /**
+       * v = all segments are available – e.g., VoD.
+       * l = segments become available over time – e.g., live.
+       * Header-Key: st
+       */
+      streamType?: string;
+      /**
+       * The streaming format that defines the current response.
+       * d = MPEG DASH
+       * h = HTTP Live Streaming (HLS)
+       * s = Smooth Streaming
+       * o = other
+       * Header-Key: sf
+       */
+      streamingFormat?: string;
+      /**
+       * The version of this specification used
+       * for interpreting the defined key names and values.
+       * Header-Key: v
+       */
+      version?: number;
+    }
+    
     /**
      * Container object that is send with state change events.
      */
@@ -6467,312 +6665,6 @@ export namespace clpp {
     }
   }
   
-  namespace interstitial {
-    /**
-     * A function that can be used to modify the metadata of an interstitial cue.
-     * It receives one argument of type {@link clpp.interstitial.PlaylistItem} and
-     * returns a modified {@link clpp.interstitial.PlaylistItem}.
-     */
-    export type AssetConverter = Function;
-    
-    /**
-     * Configuration options of the interstitial player.
-     */
-    export type Options = {
-      /**
-       * The HTML element to be used as a container for video elements created
-       * by the interstitial player. Typically this would be a div element.
-       */
-      anchorEl: HTMLElement;
-      /**
-       * The configuration of the HLS asset to be played.
-       */
-      config: clpp.PlayerConfiguration;
-      /**
-       * A function that can be used to modify the metadata of an interstitial cue.
-       */
-      interstitialAssetConverter?: clpp.interstitial.AssetConverter;
-      /**
-       * A preroll margin. If an interstitial cue is within this many seconds of
-       * the beginning of the playlist timeline, it is considered to be a preroll.
-       */
-      prerollMarginSec?: number;
-      /**
-       * How many seconds on the timeline before the interstitial cue should
-       * the cue be resolved and preloaded.
-       */
-      resolutionOffsetSec?: number;
-      /**
-       * Configuration options of the Yospace plugin.
-       */
-      yospace?: clpp.interstitial.YospacePluginOptions;
-    }
-    
-    /**
-     * A MultiController item.
-     * It consists of an asset/config, a player instance selected
-     * to play this asset and the underlying video element to which the player is
-     * attached.
-     */
-    export type PlayerItem = {
-      /**
-       * Source configuration.
-       */
-      config: clpp.PlayerConfiguration;
-      /**
-       * A unique ID.
-       */
-      id: number;
-      /**
-       * A player instance.
-       */
-      player: clpp.Player|null;
-      /**
-       * Whether the item is a primary item.
-       */
-      primary?: boolean;
-      /**
-       * The role of the item.
-       */
-      role: string;
-      /**
-       * The state of the item (e.g. 'preloading', 'preloaded', 'preload-failed',
-       * 'loading', 'loaded', 'playing', 'idle').
-       */
-      state: string;
-    }
-    
-    /**
-     * A playable item of the interstitial player.
-     * It can represent either the primary content or an interstitial asset.
-     * This type extends {@link clpp.interstitial.MultiControllerInputItem}
-     */
-    export type PlaylistItem = {
-      /**
-       * Configuration of the interstitial asset.
-       */
-      config: clpp.PlayerConfiguration;
-      /**
-       * Sum of durations of this asset and all previous to it in the same list.
-       */
-      cumulativeDuration: number;
-      /**
-       * Duration of the asset.
-       */
-      duration: number;
-      /**
-       * ID of the interstitial asset.
-       */
-      id: string;
-      /**
-       * ID of the interstitial to which this asset belongs.
-       */
-      interstitialId: string;
-    }
-    
-    /**
-     * A timeline cue representing one interstitial EXT-X-DATERANGE tag.
-     */
-    export type UiCue = {
-      /**
-       * ID of the cue.
-       */
-      cueId: string;
-      /**
-       * End time of the interstitial in seconds.
-       */
-      endTime: number;
-      /**
-       * Duration of the primary content in seconds.
-       */
-      primaryDuration: number;
-      /**
-       * Start time of the interstitial in seconds.
-       */
-      startTime: number;
-    }
-    
-    /**
-     * Configuration options of the Yospace plugin.
-     */
-    export type YospacePluginOptions = {
-      /**
-       * True to enable the Yospace plugin.
-       */
-      enabled: boolean;
-    }
-    
-    /**
-     * Events fired by interstitial player.
-     */
-    export enum Event {
-      /**
-       * Triggered when the resolution/preloading of an interstitial started.
-       * In case of X-ASSET-LIST this is the same as x-asset-list-request-started,
-       * in case of X-ASSET-URI this is the time when the media of the interstitial
-       * asset started preloading.
-       */
-      RESOLUTION_STARTED = "interstitial-preload-started",
-      /**
-       * Triggered when the X-ASSET-LIST request started.
-       */
-      ASSET_LIST_STARTED = "x-asset-list-request-started",
-      /**
-       * Triggered when the X-ASSET-LIST request ended (even if it failed).
-       */
-      ASSET_LIST_ENDED = "x-asset-list-request-ended",
-      /**
-       * Triggered when an interstitial ad break has been scheduled to be played.
-       * This happens several seconds before the playback position reaches
-       * interstitial date range. In case of preroll this happens immediately.
-       */
-      SCHEDULED = "interstitial-scheduled",
-      /**
-       * Triggered when an interstitial break started.
-       * One break contains one or more interstitial assets.
-       */
-      STARTED = "interstitial-started",
-      /**
-       * Triggered when an interstitial break ended.
-       */
-      ENDED = "interstitial-ended",
-      /**
-       * Triggered when the playback of one interstitial item started.
-       * One interstitial ad break (one EXT-X-DATERANGE) can contain multiple
-       * interstitial items.
-       */
-      ITEM_STARTED = "interstitial-item-started",
-      /**
-       * Triggered when the primary player changed.
-       * (Deprecated.)
-       */
-      PRIMARY_PLAYER_CHANGED = "primary-player-changed",
-      /**
-       * Triggered when a new/different item started playing.
-       * This could be either the first time something started playing or
-       * a transition between primary and interstitial content or a transition
-       * between two interstitial items.
-       */
-      ITEM_CHANGED = "item-changed",
-      /**
-       * Triggered when playback started. The content which started playing can
-       * either by primary content or an interstitial preroll.
-       * In contrast {@link clpp.interstitial.Event.PRIMARY_STARTED} is triggered
-       * when the primary content started playing which can be after a preroll.
-       */
-      PLAYBACK_STARTED = "playback-started",
-      /**
-       * Triggered when primary content playback started.
-       */
-      PRIMARY_STARTED = "primary-started",
-      /**
-       * Triggered when primary content playback ended.
-       */
-      PRIMARY_ENDED = "primary-ended",
-      /**
-       * Triggered when interstitial cues changed.
-       * For VOD this is triggered only once during load.
-       */
-      CUES_CHANGED = "cues-changed",
-    }
-    
-    /**
-     * A player that plays HLS assets containing interstitials.
-     * It fires the following events {@link clpp.interstitial.Event}.
-     * Supported parts for the HLS spec:
-     * 
-     * X-ASSET-LIST, X-ASSET-URI, X-RESUME-OFFSET, X-PLAYOUT-LIMIT
-     * 
-     * Limitations:
-     * 
-     * Only supports VOD.
-     * Interstitials must not be too close to each other.
-     * Interstitials cannot overlap.
-     * No error handling (for when some asset/list fails to load).
-     * No support for #EXT-X-DATERANGE.CUE
-     * No support for X-RESTRICT
-     * No support for _HLS_start_offset query in live (because no support
-     * for live)
-     * No support for _HLS_primary_id
-     * 
-     */
-    export class Player {
-      /**
-       * A player that plays HLS assets containing interstitials.
-       * It fires the following events {@link clpp.interstitial.Event}.
-       * Supported parts for the HLS spec:
-       * 
-       * X-ASSET-LIST, X-ASSET-URI, X-RESUME-OFFSET, X-PLAYOUT-LIMIT
-       * 
-       * Limitations:
-       * 
-       * Only supports VOD.
-       * Interstitials must not be too close to each other.
-       * Interstitials cannot overlap.
-       * No error handling (for when some asset/list fails to load).
-       * No support for #EXT-X-DATERANGE.CUE
-       * No support for X-RESTRICT
-       * No support for _HLS_start_offset query in live (because no support
-       * for live)
-       * No support for _HLS_primary_id
-       * 
-       *
-       * @param options configuration options
-       */
-      constructor(options: clpp.interstitial.Options);
-      /**
-       * Request that this object be destroyed, releasing all resources and shutting
-       * down all operations. Returns a Promise which is resolved when destruction
-       * is complete. This Promise should never be rejected.
-       */
-      destroy(): Promise<void>;
-      /**
-       * Get interstitial cues of the loaded asset.
-       */
-      getCues(): Array<clpp.interstitial.UiCue>;
-      /**
-       * Get the current item.
-       */
-      getCurrentItem(): clpp.interstitial.PlayerItem|null;
-      /**
-       * Get the current player.
-       */
-      getCurrentPlayer(): clpp.Player|null;
-      /**
-       * Get the current playback position.
-       * This is either of the position in the primary content or in
-       * the interstitial asset depending on which one is currently playing.
-       */
-      getPosition(): number|null;
-      /**
-       * Get the Yospace Ad Management session created by the last {@link load} or
-       * {@link loadPaused} call.
-       * This is only available if the Yospace plugin is enabled.
-       */
-      getYospaceSession(): any;
-      /**
-       * Load and play the asset.
-       *
-       * @param config configuration of the HLS asset
-       */
-      load(config: clpp.PlayerConfiguration): Promise<void>;
-      /**
-       * Load the asset and keep it paused.
-       *
-       * @param config configuration of the HLS asset
-       */
-      loadPaused(config: clpp.PlayerConfiguration): Promise<void>;
-      /**
-       * Unload the source and release resources.
-       */
-      unload(): Promise<void>;
-      /**
-       * Unpause the playback.
-       */
-      unpause(): Promise<void>;
-    }
-  }
-  
   namespace log {
     /**
      * Implement an interceptor and add it using {@link clpp.log#addInterceptor}
@@ -8044,6 +7936,20 @@ export namespace clpp {
     }
   }
   
+  namespace polyfill {
+    /**
+     * Install all polyfills.
+     */
+    function installAll(): void;
+    /**
+     * Registers a new polyfill to be installed.
+     *
+     * @param polyfill 
+     * @param priority An optional number priority.  Higher priorities
+     *   will be executed before lower priority ones.  Default is 0.
+     */
+  function register(polyfill: Function, priority?: number): void;}
+  
   namespace smooth {
     export class SmoothComponent {
       
@@ -8753,6 +8659,129 @@ export namespace clpp {
         
       }
     }
+    
+    namespace dom {
+      /**
+       * Creates an element, and cast the type from Element to HTMLElement.
+       */
+    function createHTMLElement(tagName: string): HTMLElement;}
+    
+    namespace media {
+      /**
+       * Tries to detect the media type from the URL.
+       * i.e. detecting whether it is an MP4, DASH or HLS, manifest URL.
+       *
+       * @param url The source URL
+       */
+    function detectType(url: string): clpp.Type|null;}
+    
+    namespace obj {
+      /**
+       * Clones the given object.
+       * This creates a copy for primitives or plain objects.
+       *
+       * @param item The item to clone
+       */
+      function cloneItem<T>(item: T): T;
+      /**
+       * Merge multiple plain objects from left to right.
+       * This copies over primitive values, plain Objects,
+       * functions, DOM Elements and arrays.
+       * If an item is null of undefined, it is ignored.
+       *
+       * @param args two or more objects to be merged
+       */
+    function merge(...args: any[]): Record<string,any>|null;}
+    
+    namespace strings {
+      /**
+       * Takes a bitrate and returns a string representation.
+       * Units are in bps, Kbps, Mbps.
+       *
+       * @param bps The bitrate in bps
+       */
+      function bitrateToString(bps: number|string|null|undefined): string;
+      /**
+       * Translates a duration in seconds to a human readable format.
+       * You can use the following format specifiers:
+       * 
+       * `%h` for Hours
+       * `%m` for Minutes
+       * `%s` for Seconds
+       * 
+       * The formatters can be repeated to pad the output.
+       * For example, `'%m'` will return '1' if you pass 60 seconds,
+       * while `'%mm'` will left pad the output and return '01'.
+       *
+       * @param duration The duration in seconds
+       * @param opt_format The output format
+       */
+      function durationToString(duration: number, opt_format?: string): string;
+      /**
+       * Returns true if the given string ends with the given query.
+       *
+       * @param str The source string which we search in
+       * @param query The target string that we search for
+       */
+      function endsWith(str: string, query: string): boolean;
+      /**
+       * Creates a string from the given buffer, auto-detecting the encoding.
+       * If it cannot detect the encoding, it will throw an exception.
+       */
+      function fromBytesAutoDetect(sourceData: BufferSource|string, escapeStr?: boolean): string;
+      /**
+       * Creates a string from the given buffer as UTF-8 encoding.
+       *
+       * @param data binary data encoded as UTF-8
+       */
+      function fromUtf8(data: BufferSource|null): string;
+      /**
+       * Generate the hash code from the given input.
+       *
+       * @param str the input string
+       */
+      function hashCode(str: string): number;
+      /**
+       * Returns true if the given string starts with the given query.
+       *
+       * @param str The source string which we search in
+       * @param query The target string that we search for
+       */
+      function startsWith(str: string, query: string): boolean;
+      /**
+       * Converts an ASCII string to a byte array.
+       * ASCII is converted using the specified number of bytes per character.
+       *
+       * @param s The string
+       * @param opt_size Number of bytes per character
+       */
+      function toByteArray(s: string, opt_size?: number): ArrayBuffer;
+      /**
+       * Creates a ArrayBuffer from the given string, converting to UTF-16 encoding.
+       */
+      function toUtf16(str: string, littleEndian: boolean): ArrayBuffer;
+      /**
+       * Creates a Uint8Array from the given string, converting to UTF-8 encoding.
+       */
+    function toUtf8(str: string): Uint8Array;}
+    
+    namespace url {
+      /**
+       * Encodes the given dictionary to URL query parameters. Both keys and
+       * values will be URI encoded so they should be provided un-encoded.
+       * You can optionally specify an array of keys that should be included. If
+       * specified, only those keys will be included in the resulting query string.
+       * Please note that unless filter keys are specified, the keys will be
+       * appended in sort order. This is necessary to ensure consistent results
+       * across browsers.
+       *
+       * @param queryParams The query parameters
+       * @param opt_ignoreQuestionMark If true, the result will not start
+       *   with a '?'
+       * @param opt_keys Optionally only contain the keys in this
+       *   array. All other query parameters will be omitted
+       */
+    function queryString(queryParams: Record<string, string>, opt_ignoreQuestionMark?: boolean, opt_keys?: Array<string>): string;}
   }
   
   namespace verimatrix {