diff --git a/index.d.ts b/index.d.ts
index 16fb376005..7ec95e8678 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -5,5975 +5,5977 @@ import {
     ResponseInterceptor
 } from '@svta/common-media-library/request'
 
-export = dashjs;
 export as namespace dashjs;
 
-declare namespace dashjs {
+/**
+ * Core - Errors
+ */
 
+export class Errors extends ErrorsBase {
     /**
-     * Core - Errors
+     * Error code returned when a manifest parsing error occurs
      */
+    MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE: 10;
 
-    class Errors extends ErrorsBase {
-        /**
-         * Error code returned when a manifest parsing error occurs
-         */
-        MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE: 10;
-
-        /**
-         * Error code returned when a manifest loading error occurs
-         */
-        MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE: 11;
-
-        /**
-         * Error code returned when a xlink loading error occurs
-         */
-        XLINK_LOADER_LOADING_FAILURE_ERROR_CODE: 12;
-
-        /**
-         * Error code returned when no segment ranges could be determined from the sidx box
-         */
-        SEGMENT_BASE_LOADER_ERROR_CODE: 15;
-
-        /**
-         * Error code returned when the time synchronization failed
-         */
-        TIME_SYNC_FAILED_ERROR_CODE: 16;
-
-        /**
-         * Error code returned when loading a fragment failed
-         */
-        FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE: 17;
-
-        /**
-         * Error code returned when the FragmentLoader did not receive a request object
-         */
-        FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE: 18;
-
-        /**
-         * Error code returned when the BaseUrl resolution failed
-         */
-        URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE: 19;
-
-        /**
-         * Error code returned when the append operation in the SourceBuffer failed
-         */
-        APPEND_ERROR_CODE: 20;
-
-        /**
-         * Error code returned when the remove operation in the SourceBuffer failed
-         */
-        REMOVE_ERROR_CODE: 21;
-
-        /**
-         * Error code returned when updating the internal objects after loading an MPD failed
-         */
-        DATA_UPDATE_FAILED_ERROR_CODE: 22;
-
-        /**
-         * Error code returned when MediaSource is not supported by the browser
-         */
-        CAPABILITY_MEDIASOURCE_ERROR_CODE: 23;
-
-        /**
-         * Error code returned when Protected contents are not supported
-         */
-        CAPABILITY_MEDIAKEYS_ERROR_CODE: 24;
-
-        /**
-         * Error code returned when loading the manifest failed
-         */
-        DOWNLOAD_ERROR_ID_MANIFEST_CODE: 25;
-
-        /**
-         * Error code returned when loading the sidx failed
-         */
-        DOWNLOAD_ERROR_ID_SIDX_CODE: 26;
-
-        /**
-         * Error code returned when loading the media content failed
-         */
-        DOWNLOAD_ERROR_ID_CONTENT_CODE: 27;
-
-        /**
-         * Error code returned when loading the init segment failed
-         */
-        DOWNLOAD_ERROR_ID_INITIALIZATION_CODE: 28;
-
-        /**
-         * Error code returned when loading the XLink content failed
-         */
-        DOWNLOAD_ERROR_ID_XLINK_CODE: 29;
-
-        /**
-         * Error code returned when parsing the MPD resulted in a logical error
-         */
-        MANIFEST_ERROR_ID_PARSE_CODE: 31;
-
-        /**
-         * Error code returned when no stream (period) has been detected in the manifest
-         */
-        MANIFEST_ERROR_ID_NOSTREAMS_CODE: 32;
-
-        /**
-         * Error code returned when something wrong has happened during parsing and appending subtitles (TTML or VTT)
-         */
-        TIMED_TEXT_ERROR_ID_PARSE_CODE: 33;
-
-        /**
-         * Error code returned when a 'muxed' media type has been detected in the manifest. This type is not supported
-         */
-
-        MANIFEST_ERROR_ID_MULTIPLEXED_CODE: 34;
-
-        /**
-         * Error code returned when a media source type is not supported
-         */
-        MEDIASOURCE_TYPE_UNSUPPORTED_CODE: 35;
-
-        /**
-         * Error code returned when the available Adaptation Sets can not be selected because the corresponding key ids have an invalid key status
-         * @type {number}
-         */
-        NO_SUPPORTED_KEY_IDS: 36;
-
-        MANIFEST_LOADER_PARSING_FAILURE_ERROR_MESSAGE: 'parsing failed for ';
-        MANIFEST_LOADER_LOADING_FAILURE_ERROR_MESSAGE: 'Failed loading manifest: ';
-        XLINK_LOADER_LOADING_FAILURE_ERROR_MESSAGE: 'Failed loading Xlink element: ';
-        SEGMENTS_UPDATE_FAILED_ERROR_MESSAGE: 'Segments update failed';
-        SEGMENTS_UNAVAILABLE_ERROR_MESSAGE: 'no segments are available yet';
-        SEGMENT_BASE_LOADER_ERROR_MESSAGE: 'error loading segment ranges from sidx';
-        TIME_SYNC_FAILED_ERROR_MESSAGE: 'Failed to synchronize client and server time';
-        FRAGMENT_LOADER_NULL_REQUEST_ERROR_MESSAGE: 'request is null';
-        URL_RESOLUTION_FAILED_GENERIC_ERROR_MESSAGE: 'Failed to resolve a valid URL';
-        APPEND_ERROR_MESSAGE: 'chunk is not defined';
-        REMOVE_ERROR_MESSAGE: 'Removing data from the SourceBuffer';
-        DATA_UPDATE_FAILED_ERROR_MESSAGE: 'Data update failed';
-        CAPABILITY_MEDIASOURCE_ERROR_MESSAGE: 'mediasource is not supported';
-        CAPABILITY_MEDIAKEYS_ERROR_MESSAGE: 'mediakeys is not supported';
-        TIMED_TEXT_ERROR_MESSAGE_PARSE: 'parsing error :';
-        MEDIASOURCE_TYPE_UNSUPPORTED_MESSAGE: 'Error creating source buffer of type : ';
-        NO_SUPPORTED_KEY_IDS_MESSAGE: 'All possible Adaptation Sets have an invalid key status';
-    }
+    /**
+     * Error code returned when a manifest loading error occurs
+     */
+    MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE: 11;
 
-    class ErrorsBase {
-        extend(errors: any, config: any): void;
-    }
+    /**
+     * Error code returned when a xlink loading error occurs
+     */
+    XLINK_LOADER_LOADING_FAILURE_ERROR_CODE: 12;
 
     /**
-     * Core - Events
+     * Error code returned when no segment ranges could be determined from the sidx box
      */
+    SEGMENT_BASE_LOADER_ERROR_CODE: 15;
 
-    class CoreEvents extends EventsBase {
-        ATTEMPT_BACKGROUND_SYNC: 'attemptBackgroundSync';
-        BUFFERING_COMPLETED: 'bufferingCompleted';
-        BUFFER_CLEARED: 'bufferCleared';
-        BYTES_APPENDED_END_FRAGMENT: 'bytesAppendedEndFragment';
-        BUFFER_REPLACEMENT_STARTED: 'bufferReplacementStarted';
-        CHECK_FOR_EXISTENCE_COMPLETED: 'checkForExistenceCompleted';
-        CMSD_STATIC_HEADER: 'cmsdStaticHeader';
-        CURRENT_TRACK_CHANGED: 'currentTrackChanged';
-        DATA_UPDATE_COMPLETED: 'dataUpdateCompleted';
-        INBAND_EVENTS: 'inbandEvents';
-        INITIAL_STREAM_SWITCH: 'initialStreamSwitch';
-        INIT_FRAGMENT_LOADED: 'initFragmentLoaded';
-        INIT_FRAGMENT_NEEDED: 'initFragmentNeeded';
-        INTERNAL_MANIFEST_LOADED: 'internalManifestLoaded';
-        ORIGINAL_MANIFEST_LOADED: 'originalManifestLoaded';
-        LOADING_COMPLETED: 'loadingCompleted';
-        LOADING_PROGRESS: 'loadingProgress';
-        LOADING_DATA_PROGRESS: 'loadingDataProgress';
-        LOADING_ABANDONED: 'loadingAborted';
-        MANIFEST_UPDATED: 'manifestUpdated';
-        MEDIA_FRAGMENT_LOADED: 'mediaFragmentLoaded';
-        MEDIA_FRAGMENT_NEEDED: 'mediaFragmentNeeded';
-        MEDIAINFO_UPDATED: 'mediaInfoUpdated';
-        QUOTA_EXCEEDED: 'quotaExceeded';
-        SEGMENT_LOCATION_BLACKLIST_ADD: 'segmentLocationBlacklistAdd';
-        SEGMENT_LOCATION_BLACKLIST_CHANGED: 'segmentLocationBlacklistChanged';
-        SERVICE_LOCATION_BASE_URL_BLACKLIST_ADD: 'serviceLocationBlacklistAdd';
-        SERVICE_LOCATION_BASE_URL_BLACKLIST_CHANGED: 'serviceLocationBlacklistChanged';
-        SERVICE_LOCATION_LOCATION_BLACKLIST_ADD: 'serviceLocationLocationBlacklistAdd';
-        SERVICE_LOCATION_LOCATION_BLACKLIST_CHANGED: 'serviceLocationLocationBlacklistChanged';
-        SET_FRAGMENTED_TEXT_AFTER_DISABLED: 'setFragmentedTextAfterDisabled';
-        SET_NON_FRAGMENTED_TEXT: 'setNonFragmentedText';
-        SOURCE_BUFFER_ERROR: 'sourceBufferError';
-        STREAMS_COMPOSED: 'streamsComposed';
-        STREAM_BUFFERING_COMPLETED: 'streamBufferingCompleted';
-        STREAM_REQUESTING_COMPLETED: 'streamRequestingCompleted';
-        TEXT_TRACKS_QUEUE_INITIALIZED: 'textTracksQueueInitialized';
-        TIME_SYNCHRONIZATION_COMPLETED: 'timeSynchronizationComplete';
-        UPDATE_TIME_SYNC_OFFSET: 'updateTimeSyncOffset';
-        URL_RESOLUTION_FAILED: 'urlResolutionFailed';
-        VIDEO_CHUNK_RECEIVED: 'videoChunkReceived';
-        WALLCLOCK_TIME_UPDATED: 'wallclockTimeUpdated';
-        XLINK_ELEMENT_LOADED: 'xlinkElementLoaded';
-        XLINK_READY: 'xlinkReady';
-        SEEK_TARGET: 'seekTarget';
-        SETTING_UPDATED_LIVE_DELAY: 'settingUpdatedLiveDelay';
-        SETTING_UPDATED_LIVE_DELAY_FRAGMENT_COUNT: 'settingUpdatedLiveDelayFragmentCount';
-        SETTING_UPDATED_CATCHUP_ENABLED: 'settingUpdatedCatchupEnabled';
-        SETTING_UPDATED_PLAYBACK_RATE_MIN: 'settingUpdatedPlaybackRateMin';
-        SETTING_UPDATED_PLAYBACK_RATE_MAX: 'settingUpdatedPlaybackRateMax';
-        SETTING_UPDATED_ABR_ACTIVE_RULES: 'settingUpdatedAbrActiveRules';
-        SETTING_UPDATED_MAX_BITRATE: 'settingUpdatedMaxBitrate';
-        SETTING_UPDATED_MIN_BITRATE: 'settingUpdatedMinBitrate';
-    }
+    /**
+     * Error code returned when the time synchronization failed
+     */
+    TIME_SYNC_FAILED_ERROR_CODE: 16;
 
-    class Events extends CoreEvents {
+    /**
+     * Error code returned when loading a fragment failed
+     */
+    FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE: 17;
 
-    }
+    /**
+     * Error code returned when the FragmentLoader did not receive a request object
+     */
+    FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE: 18;
 
-    class EventsBase {
-        extend(events: any, config: any): void;
-    }
+    /**
+     * Error code returned when the BaseUrl resolution failed
+     */
+    URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE: 19;
 
     /**
-     * Core
+     * Error code returned when the append operation in the SourceBuffer failed
      */
+    APPEND_ERROR_CODE: 20;
 
-    interface Debug {
-        getLogger(): Logger;
+    /**
+     * Error code returned when the remove operation in the SourceBuffer failed
+     */
+    REMOVE_ERROR_CODE: 21;
 
-        setLogTimestampVisible(flag: boolean): void;
+    /**
+     * Error code returned when updating the internal objects after loading an MPD failed
+     */
+    DATA_UPDATE_FAILED_ERROR_CODE: 22;
 
-        setCalleeNameVisible(flag: boolean): void;
-    }
+    /**
+     * Error code returned when MediaSource is not supported by the browser
+     */
+    CAPABILITY_MEDIASOURCE_ERROR_CODE: 23;
 
-    namespace Debug {
-        const LOG_LEVEL_NONE = 0;
-        const LOG_LEVEL_FATAL = 1;
-        const LOG_LEVEL_ERROR = 2;
-        const LOG_LEVEL_WARNING = 3;
-        const LOG_LEVEL_INFO = 4;
-        const LOG_LEVEL_DEBUG = 5;
-    }
+    /**
+     * Error code returned when Protected contents are not supported
+     */
+    CAPABILITY_MEDIAKEYS_ERROR_CODE: 24;
 
-    interface EventBus {
-        on(type: string, listener: any, scope: any, options?: object): void;
+    /**
+     * Error code returned when loading the manifest failed
+     */
+    DOWNLOAD_ERROR_ID_MANIFEST_CODE: 25;
 
-        off(type: string, listener: any, scope: any): void;
+    /**
+     * Error code returned when loading the sidx failed
+     */
+    DOWNLOAD_ERROR_ID_SIDX_CODE: 26;
 
-        trigger(type: string, payload?: object, filters?: object): void;
+    /**
+     * Error code returned when loading the media content failed
+     */
+    DOWNLOAD_ERROR_ID_CONTENT_CODE: 27;
 
-        reset(): void;
-    }
+    /**
+     * Error code returned when loading the init segment failed
+     */
+    DOWNLOAD_ERROR_ID_INITIALIZATION_CODE: 28;
 
-    export interface FactoryMaker {
-        extend(name: string, childInstance: object, override: boolean, context: object): void;
+    /**
+     * Error code returned when loading the XLink content failed
+     */
+    DOWNLOAD_ERROR_ID_XLINK_CODE: 29;
 
-        getSingletonInstance(context: object, className: string): any,
+    /**
+     * Error code returned when parsing the MPD resulted in a logical error
+     */
+    MANIFEST_ERROR_ID_PARSE_CODE: 31;
 
-        setSingletonInstance(context: object, className: string, instance: object): void;
+    /**
+     * Error code returned when no stream (period) has been detected in the manifest
+     */
+    MANIFEST_ERROR_ID_NOSTREAMS_CODE: 32;
 
-        deleteSingletonInstances(context: object): void;
+    /**
+     * Error code returned when something wrong has happened during parsing and appending subtitles (TTML or VTT)
+     */
+    TIMED_TEXT_ERROR_ID_PARSE_CODE: 33;
 
-        getFactoryByName(name: string, factoriesArray: Factory[]): Factory;
+    /**
+     * Error code returned when a 'muxed' media type has been detected in the manifest. This type is not supported
+     */
 
-        updateFactory(name: string, factoriesArray: Factory[]): void;
+    MANIFEST_ERROR_ID_MULTIPLEXED_CODE: 34;
 
-        getSingletonFactory(classConstructor: ClassConstructor): SingletonFactory,
+    /**
+     * Error code returned when a media source type is not supported
+     */
+    MEDIASOURCE_TYPE_UNSUPPORTED_CODE: 35;
 
-        getSingletonFactoryByName(name: string): SingletonFactory;
+    /**
+     * Error code returned when the available Adaptation Sets can not be selected because the corresponding key ids have an invalid key status
+     * @type {number}
+     */
+    NO_SUPPORTED_KEY_IDS: 36;
+
+    MANIFEST_LOADER_PARSING_FAILURE_ERROR_MESSAGE: 'parsing failed for ';
+    MANIFEST_LOADER_LOADING_FAILURE_ERROR_MESSAGE: 'Failed loading manifest: ';
+    XLINK_LOADER_LOADING_FAILURE_ERROR_MESSAGE: 'Failed loading Xlink element: ';
+    SEGMENTS_UPDATE_FAILED_ERROR_MESSAGE: 'Segments update failed';
+    SEGMENTS_UNAVAILABLE_ERROR_MESSAGE: 'no segments are available yet';
+    SEGMENT_BASE_LOADER_ERROR_MESSAGE: 'error loading segment ranges from sidx';
+    TIME_SYNC_FAILED_ERROR_MESSAGE: 'Failed to synchronize client and server time';
+    FRAGMENT_LOADER_NULL_REQUEST_ERROR_MESSAGE: 'request is null';
+    URL_RESOLUTION_FAILED_GENERIC_ERROR_MESSAGE: 'Failed to resolve a valid URL';
+    APPEND_ERROR_MESSAGE: 'chunk is not defined';
+    REMOVE_ERROR_MESSAGE: 'Removing data from the SourceBuffer';
+    DATA_UPDATE_FAILED_ERROR_MESSAGE: 'Data update failed';
+    CAPABILITY_MEDIASOURCE_ERROR_MESSAGE: 'mediasource is not supported';
+    CAPABILITY_MEDIAKEYS_ERROR_MESSAGE: 'mediakeys is not supported';
+    TIMED_TEXT_ERROR_MESSAGE_PARSE: 'parsing error :';
+    MEDIASOURCE_TYPE_UNSUPPORTED_MESSAGE: 'Error creating source buffer of type : ';
+    NO_SUPPORTED_KEY_IDS_MESSAGE: 'All possible Adaptation Sets have an invalid key status';
+}
 
-        updateSingletonFactory(name: string, factory: SingletonFactory): void;
+export class ErrorsBase {
+    extend(errors: any, config: any): void;
+}
 
-        getClassFactory(classConstructor: ClassConstructor): Factory;
+/**
+ * Core - Events
+ */
+
+export class CoreEvents extends EventsBase {
+    ATTEMPT_BACKGROUND_SYNC: 'attemptBackgroundSync';
+    BUFFERING_COMPLETED: 'bufferingCompleted';
+    BUFFER_CLEARED: 'bufferCleared';
+    BYTES_APPENDED_END_FRAGMENT: 'bytesAppendedEndFragment';
+    BUFFER_REPLACEMENT_STARTED: 'bufferReplacementStarted';
+    CHECK_FOR_EXISTENCE_COMPLETED: 'checkForExistenceCompleted';
+    CMSD_STATIC_HEADER: 'cmsdStaticHeader';
+    CURRENT_TRACK_CHANGED: 'currentTrackChanged';
+    DATA_UPDATE_COMPLETED: 'dataUpdateCompleted';
+    INBAND_EVENTS: 'inbandEvents';
+    INITIAL_STREAM_SWITCH: 'initialStreamSwitch';
+    INIT_FRAGMENT_LOADED: 'initFragmentLoaded';
+    INIT_FRAGMENT_NEEDED: 'initFragmentNeeded';
+    INTERNAL_MANIFEST_LOADED: 'internalManifestLoaded';
+    ORIGINAL_MANIFEST_LOADED: 'originalManifestLoaded';
+    LOADING_COMPLETED: 'loadingCompleted';
+    LOADING_PROGRESS: 'loadingProgress';
+    LOADING_DATA_PROGRESS: 'loadingDataProgress';
+    LOADING_ABANDONED: 'loadingAborted';
+    MANIFEST_UPDATED: 'manifestUpdated';
+    MEDIA_FRAGMENT_LOADED: 'mediaFragmentLoaded';
+    MEDIA_FRAGMENT_NEEDED: 'mediaFragmentNeeded';
+    MEDIAINFO_UPDATED: 'mediaInfoUpdated';
+    QUOTA_EXCEEDED: 'quotaExceeded';
+    SEGMENT_LOCATION_BLACKLIST_ADD: 'segmentLocationBlacklistAdd';
+    SEGMENT_LOCATION_BLACKLIST_CHANGED: 'segmentLocationBlacklistChanged';
+    SERVICE_LOCATION_BASE_URL_BLACKLIST_ADD: 'serviceLocationBlacklistAdd';
+    SERVICE_LOCATION_BASE_URL_BLACKLIST_CHANGED: 'serviceLocationBlacklistChanged';
+    SERVICE_LOCATION_LOCATION_BLACKLIST_ADD: 'serviceLocationLocationBlacklistAdd';
+    SERVICE_LOCATION_LOCATION_BLACKLIST_CHANGED: 'serviceLocationLocationBlacklistChanged';
+    SET_FRAGMENTED_TEXT_AFTER_DISABLED: 'setFragmentedTextAfterDisabled';
+    SET_NON_FRAGMENTED_TEXT: 'setNonFragmentedText';
+    SOURCE_BUFFER_ERROR: 'sourceBufferError';
+    STREAMS_COMPOSED: 'streamsComposed';
+    STREAM_BUFFERING_COMPLETED: 'streamBufferingCompleted';
+    STREAM_REQUESTING_COMPLETED: 'streamRequestingCompleted';
+    TEXT_TRACKS_QUEUE_INITIALIZED: 'textTracksQueueInitialized';
+    TIME_SYNCHRONIZATION_COMPLETED: 'timeSynchronizationComplete';
+    UPDATE_TIME_SYNC_OFFSET: 'updateTimeSyncOffset';
+    URL_RESOLUTION_FAILED: 'urlResolutionFailed';
+    VIDEO_CHUNK_RECEIVED: 'videoChunkReceived';
+    WALLCLOCK_TIME_UPDATED: 'wallclockTimeUpdated';
+    XLINK_ELEMENT_LOADED: 'xlinkElementLoaded';
+    XLINK_READY: 'xlinkReady';
+    SEEK_TARGET: 'seekTarget';
+    SETTING_UPDATED_LIVE_DELAY: 'settingUpdatedLiveDelay';
+    SETTING_UPDATED_LIVE_DELAY_FRAGMENT_COUNT: 'settingUpdatedLiveDelayFragmentCount';
+    SETTING_UPDATED_CATCHUP_ENABLED: 'settingUpdatedCatchupEnabled';
+    SETTING_UPDATED_PLAYBACK_RATE_MIN: 'settingUpdatedPlaybackRateMin';
+    SETTING_UPDATED_PLAYBACK_RATE_MAX: 'settingUpdatedPlaybackRateMax';
+    SETTING_UPDATED_ABR_ACTIVE_RULES: 'settingUpdatedAbrActiveRules';
+    SETTING_UPDATED_MAX_BITRATE: 'settingUpdatedMaxBitrate';
+    SETTING_UPDATED_MIN_BITRATE: 'settingUpdatedMinBitrate';
+}
 
-        getClassFactoryByName(name: string): Factory;
+export class Events extends CoreEvents {
 
-        updateClassFactory(name: string, factory: Factory): void;
-    }
+}
 
-    interface Logger {
-        debug(...params: any[]): void;
+export class EventsBase {
+    extend(events: any, config: any): void;
+}
 
-        info(...params: any[]): void;
+/**
+ * Core
+ */
 
-        warn(...params: any[]): void;
+export interface Debug {
+    getLogger(): Logger;
 
-        error(...params: any[]): void;
+    setLogTimestampVisible(flag: boolean): void;
 
-        fatal(...params: any[]): void;
-    }
+    setCalleeNameVisible(flag: boolean): void;
+}
 
-    export function Version(): string;
+export namespace Debug {
+    const LOG_LEVEL_NONE = 0;
+    const LOG_LEVEL_FATAL = 1;
+    const LOG_LEVEL_ERROR = 2;
+    const LOG_LEVEL_WARNING = 3;
+    const LOG_LEVEL_INFO = 4;
+    const LOG_LEVEL_DEBUG = 5;
+}
 
-    const enum LogLevel {
-        LOG_LEVEL_NONE = 0,
-        LOG_LEVEL_FATAL = 1,
-        LOG_LEVEL_ERROR = 2,
-        LOG_LEVEL_WARNING = 3,
-        LOG_LEVEL_INFO = 4,
-        LOG_LEVEL_DEBUG = 5
-    }
+export interface EventBus {
+    on(type: string, listener: any, scope: any, options?: object): void;
 
-    /**
-     * Dash - Controllers
-     **/
+    off(type: string, listener: any, scope: any): void;
 
-    export interface ContentSteeringController {
-        reset(): void;
+    trigger(type: string, payload?: object, filters?: object): void;
 
-        setConfig(config: object): void;
+    reset(): void;
+}
 
-        loadSteeringData(): Promise<any>;
+export interface FactoryMaker {
+    extend(name: string, childInstance: object, override: boolean, context: object): void;
 
-        getCurrentSteeringResponseData(): ContentSteeringResponse;
+    getSingletonInstance(context: object, className: string): any,
 
-        shouldQueryBeforeStart(): boolean;
+    setSingletonInstance(context: object, className: string, instance: object): void;
 
-        getSteeringDataFromManifest(): ContentSteering[];
+    deleteSingletonInstances(context: object): void;
 
-        stopSteeringRequestTimer(): void;
+    getFactoryByName(name: string, factoriesArray: Factory[]): Factory;
 
-        getSynthesizedBaseUrlElements(referenceElements: BaseURL[]): BaseURL[];
+    updateFactory(name: string, factoriesArray: Factory[]): void;
 
-        getSynthesizedLocationElements(referenceElements: MpdLocation[]): MpdLocation;
+    getSingletonFactory(classConstructor: ClassConstructor): SingletonFactory,
 
-        initialize(): void
-    }
+    getSingletonFactoryByName(name: string): SingletonFactory;
 
-    export interface RepresentationController {
-        getStreamId(): string;
+    updateSingletonFactory(name: string, factory: SingletonFactory): void;
 
-        getType(): string;
+    getClassFactory(classConstructor: ClassConstructor): Factory;
 
-        getDate(): AdaptationSet;
+    getClassFactoryByName(name: string): Factory;
 
-        isUpdating(): boolean;
+    updateClassFactory(name: string, factory: Factory): void;
+}
 
-        updateData(newRealAdaptation: object, availableRepresentations: object[], type: string, isFragmented: boolean, quality: number): any;
+export interface Logger {
+    debug(...params: any[]): void;
 
-        getCurrentRepresentation(): object;
+    info(...params: any[]): void;
 
-        getCurrentRepresentation(): Representation;
+    warn(...params: any[]): void;
 
-        getRepresentationForQuality(quality: number): object | null;
+    error(...params: any[]): void;
 
-        prepareQualityChange(newRep: Representation): void;
+    fatal(...params: any[]): void;
+}
 
-        reset(): void;
-    }
+export function Version(): string;
 
-    export interface SegmentBaseController {
-        initialize(): void;
+export const enum LogLevel {
+    LOG_LEVEL_NONE = 0,
+    LOG_LEVEL_FATAL = 1,
+    LOG_LEVEL_ERROR = 2,
+    LOG_LEVEL_WARNING = 3,
+    LOG_LEVEL_INFO = 4,
+    LOG_LEVEL_DEBUG = 5
+}
 
-        getSegmentBaseInitSegment(data: any): Promise<any>;
+/**
+ * Dash - Controllers
+ **/
 
-        getSegmentList(e: object): Promise<any>;
+export interface ContentSteeringController {
+    reset(): void;
 
-        reset(): void;
-    }
+    setConfig(config: object): void;
 
-    export interface SegmentsController {
-        initialize(isDynamic: boolean): void;
+    loadSteeringData(): Promise<any>;
 
-        updateInitData(voRepresentation: Representation, hasInitialization: boolean): Promise<any>;
+    getCurrentSteeringResponseData(): ContentSteeringResponse;
 
-        updateSegmentData(voRepresentation: Representation, hasSegments: boolean): Promise<any>;
+    shouldQueryBeforeStart(): boolean;
 
-        getSegmentByIndex(representation: Representation, index: number, lastSegmentTime: number): any;
+    getSteeringDataFromManifest(): ContentSteering[];
 
-        getSegmentByTime(representation: Representation, time: number): any;
+    stopSteeringRequestTimer(): void;
 
-        getMediaFinishedInformation(representation: Representation): any;
-    }
+    getSynthesizedBaseUrlElements(referenceElements: BaseURL[]): BaseURL[];
 
-    /**
-     * Dash - Models
-     **/
+    getSynthesizedLocationElements(referenceElements: MpdLocation[]): MpdLocation;
 
-    export interface DashManifestModel {
-        getAccessibilityForAdaptation(adaptation: object): DescriptorType[];
+    initialize(): void
+}
 
-        getAdaptationForId(id: string, manifest: object, periodIndex: number): any;
+export interface RepresentationController {
+    getStreamId(): string;
 
-        getAdaptationForIndex(index: number, manifest: object, periodIndex: number): any;
+    getType(): string;
 
-        getAdaptationsForPeriod(voPeriod: Period): AdaptationSet[];
+    getDate(): AdaptationSet;
 
-        getAdaptationsForType(manifest: object, periodIndex: number, type: string): any[];
+    isUpdating(): boolean;
 
-        getAudioChannelConfigurationForAdaptation(adaptation: object): DescriptorType[];
+    updateData(newRealAdaptation: object, availableRepresentations: object[], type: string, isFragmented: boolean, quality: number): any;
 
-        getAudioChannelConfigurationForRepresentation(adaptation: object): DescriptorType[];
+    getCurrentRepresentation(): object;
 
-        getAvailabilityStartTime(mpd: Mpd): any;
+    getCurrentRepresentation(): Representation;
 
-        getBandwidth(representation: object): number;
+    getRepresentationForQuality(quality: number): object | null;
 
-        getBaseURLsFromElement(node: object): BaseURL[];
+    prepareQualityChange(newRep: Representation): void;
 
-        getBitrateListForAdaptation(realAdaptation: object): {
-            bandwidth: number,
-            width: number,
-            height: number,
-            scanType: string | null,
-            id: string | null
-        };
+    reset(): void;
+}
 
-        getCodec(adaptation: object, representationIndex: number, addResolutionInfo: boolean): string;
+export interface SegmentBaseController {
+    initialize(): void;
 
-        getCodecForPreselection(preselection: Preselection, adaptations: AdaptationSet[], addResolutionInfo: boolean): string;
+    getSegmentBaseInitSegment(data: any): Promise<any>;
 
-        getContentProtectionByAdaptation(adaptation: object): any;
+    getSegmentList(e: object): Promise<any>;
 
-        getContentProtectionByManifest(manifest: object): any[];
+    reset(): void;
+}
 
-        getContentProtectionByPeriod(period: Period): any;
+export interface SegmentsController {
+    initialize(isDynamic: boolean): void;
 
-        getContentSteering(manifest: object): ContentSteering | undefined;
+    updateInitData(voRepresentation: Representation, hasInitialization: boolean): Promise<any>;
 
-        getDuration(manifest: object): number;
+    updateSegmentData(voRepresentation: Representation, hasSegments: boolean): Promise<any>;
 
-        getEndTimeForLastPeriod(voPeriod: Period): number;
+    getSegmentByIndex(representation: Representation, index: number, lastSegmentTime: number): any;
 
-        getEssentialProperties(element: object): DescriptorType | [];
+    getSegmentByTime(representation: Representation, time: number): any;
 
-        getEventStreamForAdaptationSet(manifest: object, adaptation: object): EventStream[];
+    getMediaFinishedInformation(representation: Representation): any;
+}
 
-        getEventStreamForRepresentation(manifest: object, representation: Representation): EventStream[];
+/**
+ * Dash - Models
+ **/
 
-        getEventStreams(inbandStreams: EventStream[], representation: Representation): EventStream[];
+export interface DashManifestModel {
+    getAccessibilityForAdaptation(adaptation: object): DescriptorType[];
 
-        getEventsForPeriod(period: Period): any[];
+    getAdaptationForId(id: string, manifest: object, periodIndex: number): any;
 
-        getFramerate(representation: object): number;
+    getAdaptationForIndex(index: number, manifest: object, periodIndex: number): any;
 
-        getId(manifest: object): string;
+    getAdaptationsForPeriod(voPeriod: Period): AdaptationSet[];
 
-        getIndexForAdaptation(realAdaptation: object, manifest: object, periodIndex: number): number;
+    getAdaptationsForType(manifest: object, periodIndex: number, type: string): any[];
 
-        getIsAudio(adaptation: object): boolean;
+    getAudioChannelConfigurationForAdaptation(adaptation: object): DescriptorType[];
 
-        getIsDynamic(manifest: object): boolean;
+    getAudioChannelConfigurationForRepresentation(adaptation: object): DescriptorType[];
 
-        getIsFragmented(adaptation: object): boolean;
+    getAvailabilityStartTime(mpd: Mpd): any;
 
-        getIsImage(adaptation: object): boolean;
+    getBandwidth(representation: object): number;
 
-        getIsMuxed(adaptation: object): boolean;
+    getBaseURLsFromElement(node: object): BaseURL[];
 
-        getIsText(adaptation: object): boolean;
+    getBitrateListForAdaptation(realAdaptation: object): {
+        bandwidth: number,
+        width: number,
+        height: number,
+        scanType: string | null,
+        id: string | null
+    };
 
-        getIsTypeOf(adaptation: object, type: string): boolean;
+    getCodec(adaptation: object, representationIndex: number, addResolutionInfo: boolean): string;
 
-        getIsVideo(adaptation: object): boolean;
+    getCodecForPreselection(preselection: Preselection, adaptations: AdaptationSet[], addResolutionInfo: boolean): string;
 
-        getKID(adaptation: object): any;
+    getContentProtectionByAdaptation(adaptation: object): any;
 
-        getLabelsForAdaptation(adaptation: object): any[];
+    getContentProtectionByManifest(manifest: object): any[];
 
-        getLanguageForAdaptation(adaptation: object): string;
+    getContentProtectionByPeriod(period: Period): any;
 
-        getLoction(manifest: object): MpdLocation | [];
+    getContentSteering(manifest: object): ContentSteering | undefined;
 
-        getMainAdaptationSetForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): AdaptationSet | undefined;
+    getDuration(manifest: object): number;
 
-        getCommonRepresentationForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): Representation | undefined;
+    getEndTimeForLastPeriod(voPeriod: Period): number;
 
-        getManifestUpdatePeriod(manifest: object, latencyOfLastUpdate?: number): number;
+    getEssentialProperties(element: object): DescriptorType | [];
 
-        getMimeType(adaptation: object): object;
+    getEventStreamForAdaptationSet(manifest: object, adaptation: object): EventStream[];
 
-        getMpd(manifest: object): Mpd;
+    getEventStreamForRepresentation(manifest: object, representation: Representation): EventStream[];
 
-        getPatchLocation(manifest: object): PatchLocation[];
+    getEventStreams(inbandStreams: EventStream[], representation: Representation): EventStream[];
 
-        getPreselectionIsTypeOf(preselection: Preselection, adaptations: AdaptationSet[], type: MediaType): boolean;
+    getEventsForPeriod(period: Period): any[];
 
-        getPreselectionsForPeriod(voPeriod: object): Preselection[];
+    getFramerate(representation: object): number;
 
-        getPeriodId(realPeriod: Period, i: number): string;
+    getId(manifest: object): string;
 
-        getProducerReferenceTimesForAdaptation(adaptation: object): any[];
+    getIndexForAdaptation(realAdaptation: object, manifest: object, periodIndex: number): number;
 
-        getPublishTime(manifest: object): Date | null;
+    getIsAudio(adaptation: object): boolean;
 
-        getRealAdaptationFor(voAdaptation: object): object;
+    getIsDynamic(manifest: object): boolean;
 
-        getRealAdaptations(manifest: object, periodIndex: number): any[];
+    getIsFragmented(adaptation: object): boolean;
 
-        getRealPeriodForIndex(index: number, manifest: object): any;
+    getIsImage(adaptation: object): boolean;
 
-        getRealPeriods(manifest: object): any[];
+    getIsMuxed(adaptation: object): boolean;
 
-        getRegularPeriods(mpd: Mpd): Period[];
+    getIsText(adaptation: object): boolean;
 
-        getRepresentationCount(adaptation: object): number;
+    getIsTypeOf(adaptation: object, type: string): boolean;
 
-        getRepresentationFor(index: number, adaptation: object): object;
+    getIsVideo(adaptation: object): boolean;
 
-        getRepresentationSortFunction(): (a: object, b: object) => number;
+    getKID(adaptation: object): any;
 
-        getRepresentationsForAdaptation(voAdaptation: object): object[];
+    getLabelsForAdaptation(adaptation: object): any[];
 
-        getRolesForAdaptation(adaptation: object): DescriptorType[];
+    getLanguageForAdaptation(adaptation: object): string;
 
-        getSegmentAlignment(adaptation: object): boolean;
+    getLoction(manifest: object): MpdLocation | [];
 
-        getSelectionPriority(realAdaptation: object): number;
+    getMainAdaptationSetForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): AdaptationSet | undefined;
 
-        getServiceDescriptions(manifest: object): serviceDescriptions;
+    getCommonRepresentationForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): Representation | undefined;
 
-        getSubSegmentAlignment(adaptation: object): boolean;
+    getManifestUpdatePeriod(manifest: object, latencyOfLastUpdate?: number): number;
 
-        getSuggestedPresentationDelay(mpd: Mpd): any;
+    getMimeType(adaptation: object): object;
 
-        getSupplementalProperties(element: object): DescriptorType | [];
+    getMpd(manifest: object): Mpd;
 
-        getUTCTimingSources(manifest: object): any[];
+    getPatchLocation(manifest: object): PatchLocation[];
 
-        getViewpointForAdaptation(adaptation: object): DescriptorType[];
+    getPreselectionIsTypeOf(preselection: Preselection, adaptations: AdaptationSet[], type: MediaType): boolean;
 
-        hasProfile(manifest: object, profile: object): boolean;
+    getPreselectionsForPeriod(voPeriod: object): Preselection[];
 
-        isPeriodEncrypted(period: any): boolean;
+    getPeriodId(realPeriod: Period, i: number): string;
 
-        processAdaptation(realAdaptation: object): object;
+    getProducerReferenceTimesForAdaptation(adaptation: object): any[];
 
-        setConfig(config: any): void;
-    }
+    getPublishTime(manifest: object): Date | null;
 
-    export interface PatchManifestModel {
-        getIsPatch(patch: object): boolean;
+    getRealAdaptationFor(voAdaptation: object): object;
 
-        getPublishTime(patch: object): number | null;
+    getRealAdaptations(manifest: object, periodIndex: number): any[];
 
-        getOriginalPublishTime(patch: object): number | null;
+    getRealPeriodForIndex(index: number, manifest: object): any;
 
-        getMpdId(patch: object): string | null;
+    getRealPeriods(manifest: object): any[];
 
-        getPatchOperations(patch: object): PatchOperation | [];
-    }
+    getRegularPeriods(mpd: Mpd): Period[];
 
-    /**
-     * Dash - Parser - Maps
-     **/
+    getRepresentationCount(adaptation: object): number;
 
-    export class CommonProperty {
-        constructor(name: string);
-    }
+    getRepresentationFor(index: number, adaptation: object): object;
 
-    export class MapNode {
-        constructor(name: string, properties: object, children: object);
-    }
+    getRepresentationSortFunction(): (a: object, b: object) => number;
 
-    export class RepresentationBaseValuesMap extends MapNode {
+    getRepresentationsForAdaptation(voAdaptation: object): object[];
 
-    }
+    getRolesForAdaptation(adaptation: object): DescriptorType[];
 
-    export class SegmentsValuesMap extends MapNode {
+    getSegmentAlignment(adaptation: object): boolean;
 
-    }
+    getSelectionPriority(realAdaptation: object): number;
 
-    /**
-     * Dash - Parser - Matchers
-     **/
+    getServiceDescriptions(manifest: object): serviceDescriptions;
 
-    export class BaseMatcher {
-        constructor(test: any, covnerter: any);
-    }
+    getSubSegmentAlignment(adaptation: object): boolean;
 
-    export class DateTimeMatcher extends BaseMatcher {
+    getSuggestedPresentationDelay(mpd: Mpd): any;
 
-    }
+    getSupplementalProperties(element: object): DescriptorType | [];
 
-    export class DurationMatcher extends BaseMatcher {
+    getUTCTimingSources(manifest: object): any[];
 
-    }
+    getViewpointForAdaptation(adaptation: object): DescriptorType[];
 
-    export class LangMatcher extends BaseMatcher {
+    hasProfile(manifest: object, profile: object): boolean;
 
-    }
+    isPeriodEncrypted(period: any): boolean;
 
-    export class NumericMatcher extends BaseMatcher {
+    processAdaptation(realAdaptation: object): object;
 
-    }
+    setConfig(config: any): void;
+}
 
-    /**
-     * Dash - Parser
-     **/
+export interface PatchManifestModel {
+    getIsPatch(patch: object): boolean;
 
-    export interface DashParser {
-        getIron(): any;
+    getPublishTime(patch: object): number | null;
 
-        parse(data: any): any;
+    getOriginalPublishTime(patch: object): number | null;
 
-        parseXml(data: any): any;
-    }
+    getMpdId(patch: object): string | null;
 
-    export interface objectiron {
-        run(source: string): void;
-    }
+    getPatchOperations(patch: object): PatchOperation | [];
+}
 
-    /**
-     * Dash - Utils
-     **/
+/**
+ * Dash - Parser - Maps
+ **/
 
-    export interface ListSegmentsGetter {
-        getMediaFinishedInformation(representation: Representation): MediaFinishedInformation;
+export class CommonProperty {
+    constructor(name: string);
+}
 
-        getSegmentByIndex(representation: Representation, index: number): any;
+export class MapNode {
+    constructor(name: string, properties: object, children: object);
+}
 
-        getSegmentByTime(representation: Representation, requestedTime: number): any;
-    }
+export class RepresentationBaseValuesMap extends MapNode {
 
-    export interface Round10 {
-        round10(value: number, exp: number): number;
-    }
+}
 
-    export interface SegmentBaseGetter {
-        getMediaFinishedInformation(representation: Representation): MediaFinishedInformation;
+export class SegmentsValuesMap extends MapNode {
 
-        getSegmentByIndex(representation: Representation, index: number): any;
+}
 
-        getSegmentByTime(representation: Representation, requestedTime: number): any;
-    }
+/**
+ * Dash - Parser - Matchers
+ **/
 
-    export interface TemplateSegmentsGetter {
-        getMediaFinishedInformation(representation: Representation): MediaFinishedInformation;
+export class BaseMatcher {
+    constructor(test: any, covnerter: any);
+}
 
-        getSegmentByIndex(representation: Representation, index: number): any;
+export class DateTimeMatcher extends BaseMatcher {
 
-        getSegmentByTime(representation: Representation, requestedTime: number): any;
-    }
+}
 
-    export interface TimelineConverter {
-        initialize(): void;
+export class DurationMatcher extends BaseMatcher {
 
-        getClientTimeOffset(): number;
+}
 
-        setClientTimeOffset(): number;
+export class LangMatcher extends BaseMatcher {
 
-        getClientReferenceTime(): number;
+}
 
-        calcAvailabilityStartTimeFromPresentationTime(presentationEndTime: number, representation: Representation, isDynamic: boolean): number;
+export class NumericMatcher extends BaseMatcher {
 
-        calcAvailabilityEndTimeFromPresentationTime(presentationEndTime: number, representation: Representation, isDynamic: boolean, trueBool?: boolean): number;
+}
 
-        calcPresentationTimeFromWallTime(wallTime: number, period: Period): number;
+/**
+ * Dash - Parser
+ **/
 
-        calcPresentationTimeFromMediaTime(mediaTime: number, representation: Representation): number;
+export interface DashParser {
+    getIron(): any;
 
-        calcMediaTimeFromPresentationTime(presentationTime: number, representation: Representation): number;
+    parse(data: any): any;
 
-        calcWallTimeForSegment(segment: any, isDynamic: boolean): number;
+    parseXml(data: any): any;
+}
 
-        calcTimeShiftBufferWindow(streams: any[], isDynamic: boolean): object;
+export interface objectiron {
+    run(source: string): void;
+}
 
-        calcPeriodRelativeTimeFromMpdRelativeTime(representation: Representation, mpdRelativeTime: number): number;
+/**
+ * Dash - Utils
+ **/
 
-        reset(): void;
-    }
+export interface ListSegmentsGetter {
+    getMediaFinishedInformation(representation: Representation): MediaFinishedInformation;
 
-    export interface TimelineSegmentsGetter {
-        getSegmentByIndex(representation: Representation, index: number, lastSegmentTime: number): Segment | null;
+    getSegmentByIndex(representation: Representation, index: number): any;
 
-        getSegmentByTime(representation: Representation, requestedTime: number): Segment | null;
+    getSegmentByTime(representation: Representation, requestedTime: number): any;
+}
 
-        getMediaFinishedInformation(representation: Representation): number | object;
-    }
+export interface Round10 {
+    round10(value: number, exp: number): number;
+}
 
-    /**
-     * Dash - Vo
-     **/
-
-    export class AdaptationSet {
-        period: Period | null;
-        id: string | null;
-        index: number;
-        type: string | null;
-    }
+export interface SegmentBaseGetter {
+    getMediaFinishedInformation(representation: Representation): MediaFinishedInformation;
 
-    export interface ThroughputDictEntry {
-        downloadTimeInMs: number;
-        downloadedBytes: number;
-        latencyInMs: number;
-        serviceLocation: string;
-        value: number;
-    }
+    getSegmentByIndex(representation: Representation, index: number): any;
 
-    export interface ThroughputEwmaDictEntry {
-        fastEstimate: number;
-        slowEstimate: number;
-        totalWeight: number;
-    }
+    getSegmentByTime(representation: Representation, requestedTime: number): any;
+}
 
-    export interface BaseURL {
-        availabilityTimeComplete: boolean;
-        availabilityTimeOffset: number;
-        dvbPriority: number;
-        dvbWeight: number;
-        queryParams: object;
-        serviceLocation: string;
-        url: string;
-    }
+export interface TemplateSegmentsGetter {
+    getMediaFinishedInformation(representation: Representation): MediaFinishedInformation;
 
-    export interface ClientDataReporting {
-        adaptationSets: AdaptationSet;
-        adaptationSetsArray: Array<AdaptationSet>;
-        cmcdParameters: CMCDParameters;
-        serviceLocations: any;
-        serviceLocationsArray: Array<any>;
-    }
+    getSegmentByIndex(representation: Representation, index: number): any;
 
-    export class CMCDParameters extends DescriptorType {
-        contentID: string;
-        keys: Array<string>;
-        mode: string;
-        schemeIdUri: string;
-        sessionID: string;
-        version: number;
-    }
+    getSegmentByTime(representation: Representation, requestedTime: number): any;
+}
 
-    export class ContentProtection extends DescriptorType {
-        cencDefaultKid: any;
-        keyId: any;
-        laUrl: string;
-        pro: any;
-        pssh: any;
-        ref: any;
-        refId: any;
-        robustness: any;
+export interface TimelineConverter {
+    initialize(): void;
 
-        init(data: any): void;
+    getClientTimeOffset(): number;
 
-        mergeAttributesFromReference(reference: any): any;
-    }
+    setClientTimeOffset(): number;
 
-    export class ContentSteering {
-        clientRequirement: boolean;
-        defaultServiceLocation: string;
-        defaultServiceLocationArray: string[];
-        queryBeforeStart: boolean;
-        serverUrl: string;
-    }
+    getClientReferenceTime(): number;
 
-    export class ContentSteeringRequest {
-        constructor(url: any);
+    calcAvailabilityStartTimeFromPresentationTime(presentationEndTime: number, representation: Representation, isDynamic: boolean): number;
 
-        url: string;
-    }
+    calcAvailabilityEndTimeFromPresentationTime(presentationEndTime: number, representation: Representation, isDynamic: boolean, trueBool?: boolean): number;
 
-    export class ContentSteeringResponse {
-        pathwayClones: object[];
-        pathwayPriority: string[];
-        reloadUri: string;
-        ttl: number;
-        version: number;
-    }
+    calcPresentationTimeFromWallTime(wallTime: number, period: Period): number;
 
-    export class DescriptorType {
-        dvbFontFamily?: string;
-        dvbMimeType?: string;
-        dvbUrl?: string;
-        id?: string;
-        schemeIdUri: string;
-        value?: string;
-    }
+    calcPresentationTimeFromMediaTime(mediaTime: number, representation: Representation): number;
 
-    export interface Event {
-        duration: number;
-        eventStream: EventStream;
-        id: number;
-        messageData: string;
-        parsedMessageData: any;
-        presentationTime: number;
-        presentationTimeDelta: number;
-        type: string;
-    }
+    calcMediaTimeFromPresentationTime(presentationTime: number, representation: Representation): number;
 
-    export interface EventStream {
-        adaptationSet: AdaptationSet | null;
-        period: Period | null;
-        presentationTimeOffset: number;
-        representation: Representation | null;
-        schemeIdUri: string;
-        timescale: number;
-        value: string;
-    }
+    calcWallTimeForSegment(segment: any, isDynamic: boolean): number;
 
-    export interface IManifestInfo {
-        availableFrom: Date;
-        duration: number;
-        dvrWindowSize: number;
-        isDynamic: boolean;
-        loadedTime: Date;
-        maxFragmentDuration: number;
-        minBufferTime: number;
-        protocol?: string;
-        serviceDescriptions: serviceDescriptions[]
-    }
+    calcTimeShiftBufferWindow(streams: any[], isDynamic: boolean): object;
 
-    export interface IAdaptation {
-        ContentProtection: IContentProtection | IContentProtection[];
-        Role: IRole | IRole[];
-        SegmentTemplate: ISegmentTemplate | ISegmentTemplate[];
-        Representation: Representation | Representation[];
-        id: string;
-        group: number;
-        contentType: string;
-        lang: string;
-        par: string;
-        minBandwidth: number;
-        maxBandwidth: number;
-        maxWidth: number;
-        maxHeight: number;
-        SegmentAlignment: boolean;
-        sar: string;
-        frameRate: number;
-        mimeType: string;
-        startWithSAP: number;
-    }
+    calcPeriodRelativeTimeFromMpdRelativeTime(representation: Representation, mpdRelativeTime: number): number;
 
-    export interface IRole { // same content as UTCTiming ?
-        schemeIdUri: string;
-        value: string;
-    }
+    reset(): void;
+}
 
-    export interface ISegmentTemplate {
-        SegmentTimeline: ISegmentTimeline | ISegmentTimeline[];
-        timescale: number;
-        initialization: string;
-        media: string;
-    }
+export interface TimelineSegmentsGetter {
+    getSegmentByIndex(representation: Representation, index: number, lastSegmentTime: number): Segment | null;
 
-    export interface ISegmentTimeline {
-        S: ISegmentTimelineProperty | ISegmentTimelineProperty[];
-    }
+    getSegmentByTime(representation: Representation, requestedTime: number): Segment | null;
 
-    export interface ISegmentTimelineProperty {
-        d?: number;
-        r?: number;
-        t?: number;
-    }
+    getMediaFinishedInformation(representation: Representation): number | object;
+}
 
-    export interface IRepresentation {
-        id: string;
-        bandwidth: number;
-        width: number;
-        height: number;
-        codecs: string;
-        scanType: string;
-        SegmentTemplate: ISegmentTemplate;
-        sar: string;
-        frameRate: number;
-        mimeType: string,
-        startWithSAP: number;
-        ContentProtection: IContentProtection[];
-    }
+/**
+ * Dash - Vo
+ **/
 
-    export interface IContentProtection {
-        keyId: string;
-        schemeIdUri: string;
-        "cenc:default_KID"?: string;
-        value?: string;
-        pssh?: IPssh | IPssh[];
-    }
+export class AdaptationSet {
+    period: Period | null;
+    id: string | null;
+    index: number;
+    type: string | null;
+}
 
-    export interface IPssh {
-        __prefix: string;
-        __text: string;
-    }
+export interface ThroughputDictEntry {
+    downloadTimeInMs: number;
+    downloadedBytes: number;
+    latencyInMs: number;
+    serviceLocation: string;
+    value: number;
+}
 
-    export class MediaInfo {
-        KID: any | null;
-        accessibility: DescriptorType[] | null;
-        audioChannelConfiguration: DescriptorType[] | null;
-        bitrateList: Bitrate[];
-        codec: string | null;
-        contentProtection: any | null;
-        essentialProperties: object;
-        id: string | null;
-        index: number | null;
-        isEmbedded: any | null;
-        isFragmented: any | null;
-        isPreselection: boolean;
-        isText: boolean;
-        labels: { text: string, lang?: string }[];
-        lang: string | null;
-        mimeType: string | null;
-        representationCount: number;
-        roles: DescriptorType[] | null;
-        segmentAlignment: boolean;
-        selectionPriority: number;
-        streamInfo: StreamInfo | null;
-        subSegmentAlignment: boolean;
-        supplementalProperties: object;
-        type: MediaType | null;
-        viewpoint: DescriptorType[] | null;
-    }
+export interface ThroughputEwmaDictEntry {
+    fastEstimate: number;
+    slowEstimate: number;
+    totalWeight: number;
+}
 
-    export interface Mpd {
-        availabilityEndTime: number;
-        availabilityStartTime: number | null;
-        manifest: object;
-        maxSegmentDuration: number;
-        mediaPresentationDuration: number;
-        minimumUpdatePeriod: number;
-        publishTime: number | null;
-        suggestedPresentationDelay: number;
-        timeShiftBufferDepth: number;
-    }
+export interface BaseURL {
+    availabilityTimeComplete: boolean;
+    availabilityTimeOffset: number;
+    dvbPriority: number;
+    dvbWeight: number;
+    queryParams: object;
+    serviceLocation: string;
+    url: string;
+}
 
-    export class MpdLocation {
-        constructor(url: string, serviceLocation: string | null);
+export interface ClientDataReporting {
+    adaptationSets: AdaptationSet;
+    adaptationSetsArray: Array<AdaptationSet>;
+    cmcdParameters: CMCDParameters;
+    serviceLocations: any;
+    serviceLocationsArray: Array<any>;
+}
 
-        url: string;
-        serviceLocation: string | null;
-        queryParams: object;
-    }
+export class CMCDParameters extends DescriptorType {
+    contentID: string;
+    keys: Array<string>;
+    mode: string;
+    schemeIdUri: string;
+    sessionID: string;
+    version: number;
+}
 
-    export class PatchLocation {
-        constructor(url: string, serviceLocation: string, ttl: number);
+export class ContentProtection extends DescriptorType {
+    cencDefaultKid: any;
+    keyId: any;
+    laUrl: string;
+    pro: any;
+    pssh: any;
+    ref: any;
+    refId: any;
+    robustness: any;
 
-        url: string;
-        serviceLocation: string;
-        ttl: number;
-        queryParams: object;
-    }
+    init(data: any): void;
 
-    export class PatchOperation {
-        constructor(action: any, xpath: any, value: string);
+    mergeAttributesFromReference(reference: any): any;
+}
 
-        action: any;
-        xpath: any;
-        value: string;
-        position: any | null;
+export class ContentSteering {
+    clientRequirement: boolean;
+    defaultServiceLocation: string;
+    defaultServiceLocationArray: string[];
+    queryBeforeStart: boolean;
+    serverUrl: string;
+}
 
-        getMpdTarget(root: any): any;
-    }
+export class ContentSteeringRequest {
+    constructor(url: any);
 
-    export interface Period {
-        duration: number;
-        id: string | null;
-        index: number;
-        isEncrypted: boolean;
-        mpd: Mpd;
-        nextPeriodId: string | null;
-        start: number;
-    }
+    url: string;
+}
 
-    export interface Preselection {
-        period: Period | null;
-        index: number;
-        id: string | null;
-        order: string | null;
-        preselectionComponents: any[];
-        tag: string | null;
-        type: string | null;
-    }
+export class ContentSteeringResponse {
+    pathwayClones: object[];
+    pathwayPriority: string[];
+    reloadUri: string;
+    ttl: number;
+    version: number;
+}
 
-    export interface ProducerReferenceTime {
-        UTCTiming: any;
-        applicationSchme: any;
-        id: any;
-        inband: boolean;
-        presentationTime: number;
-        type: 'encoder';
-        wallClockTime: any;
-    }
+export class DescriptorType {
+    dvbFontFamily?: string;
+    dvbMimeType?: string;
+    dvbUrl?: string;
+    id: string;
+    schemeIdUri: string;
+    value: string;
+}
 
-    export interface Representation {
-        absoluteIndex: number;
-        adaptation: AdaptationSet | null;
-        availabilityTimeComplete: boolean;
-        availabilityTimeOffset: number;
-        availableSegmentsNumber: number;
-        bandwidth: number;
-        bitrateInKbit: number;
-        bitsPerPixel: number;
-        codecPrivateData: string | null;
-        codecs: string | null;
-        fragmentDuration: number | null;
-        frameRate: number;
-        height: number;
-        id: string;
-        index: number;
-        indexRange: string | null;
-        initialization: object | null;
-        maxPlayoutRate: number;
-        mediaFinishedInformation: MediaFinishedInformation;
-        mediaInfo: MediaInfo | null;
-        mimeType: string | null;
-        mseTimeOffset: number;
-        pixelsPerSecond: number;
-        presentationTimeOffset: number;
-        qualityRanking: number;
-        range: Range | null;
-        scanType: string;
-        segments: any[];
-        segmentDuration: number;
-        segmentInfoType: string | null;
-        supplementalProperties: Array<any>;
-        startNumber: number;
-        timescale: number;
-        width: number;
-        endNumber: number | null;
-    }
+export interface Event {
+    duration: number;
+    eventStream: EventStream;
+    id: number;
+    messageData: string;
+    parsedMessageData: any;
+    presentationTime: number;
+    presentationTimeDelta: number;
+    type: string;
+}
 
-    export interface Segment {
-        availabilityEndTime: number;
-        availabilityStartTime: number;
-        duration: number;
-        index: number | null;
-        indexRange: any;
-        media: any;
-        mediaRange: any;
-        mediaStartTime: number;
-        presentationStartTime: number;
-        replacementNumber: number;
-        replacementTime: number;
-        representation: Representation | null;
-        wallStartTime: number;
-    }
+export interface EventStream {
+    adaptationSet: AdaptationSet | null;
+    period: Period | null;
+    presentationTimeOffset: number;
+    representation: Representation | null;
+    schemeIdUri: string;
+    timescale: number;
+    value: string;
+}
 
-    export class SimpleXPath {
-        constructor(selector: any);
-    }
+export interface IManifestInfo {
+    availableFrom: Date;
+    duration: number;
+    dvrWindowSize: number;
+    isDynamic: boolean;
+    loadedTime: Date;
+    maxFragmentDuration: number;
+    minBufferTime: number;
+    protocol?: string;
+    serviceDescriptions: serviceDescriptions[]
+}
 
-    export class StreamInfo {
-        duration: number;
-        id: string;
-        index: number;
-        isEncrypted: boolean;
-        isLast: boolean;
-        manifestInfo: IManifestInfo;
-        start: number;
-    }
+export interface IAdaptation {
+    ContentProtection: IContentProtection | IContentProtection[];
+    Role: IRole | IRole[];
+    SegmentTemplate: ISegmentTemplate | ISegmentTemplate[];
+    Representation: Representation | Representation[];
+    id: string;
+    group: number;
+    contentType: string;
+    lang: string;
+    par: string;
+    minBandwidth: number;
+    maxBandwidth: number;
+    maxWidth: number;
+    maxHeight: number;
+    SegmentAlignment: boolean;
+    sar: string;
+    frameRate: number;
+    mimeType: string;
+    startWithSAP: number;
+}
 
-    export class UTCTiming {
-        schemeIdUri: string;
-        value: string;
-    }
+export interface IRole { // same content as UTCTiming ?
+    schemeIdUri: string;
+    value: string;
+}
 
-    export interface ThroughputDictValue {
-        downloadTimeInMs: number,
-        downloadedBytes: number,
-        latencyInMs: number
-        serviceLocation: string,
-        value: number,
-    }
+export interface ISegmentTemplate {
+    SegmentTimeline: ISegmentTimeline | ISegmentTimeline[];
+    timescale: number;
+    initialization: string;
+    media: string;
+}
 
-    /**
-     * Dash
-     **/
+export interface ISegmentTimeline {
+    S: ISegmentTimelineProperty | ISegmentTimelineProperty[];
+}
 
-    export interface DashAdapter {
-        applyPatchToManifest(manifest: object, patch: object): void;
+export interface ISegmentTimelineProperty {
+    d?: number;
+    r?: number;
+    t?: number;
+}
 
-        areMediaInfosEqual(mInfoOne: MediaInfo, mInfoTwo: MediaInfo): boolean;
+export interface IRepresentation {
+    id: string;
+    bandwidth: number;
+    width: number;
+    height: number;
+    codecs: string;
+    scanType: string;
+    SegmentTemplate: ISegmentTemplate;
+    sar: string;
+    frameRate: number;
+    mimeType: string,
+    startWithSAP: number;
+    ContentProtection: IContentProtection[];
+}
 
-        getMainAdaptationForType(type: MediaType, streamInfo: object): IAdaptation | null;
+export interface IContentProtection {
+    keyId: string;
+    schemeIdUri: string;
+    "cenc:default_KID"?: string;
+    value?: string;
+    pssh?: IPssh | IPssh[];
+}
 
-        getAllMediaInfoForType(streamInfo: object, type: MediaType, externalManifest?: object | null): any[];
+export interface IPssh {
+    __prefix: string;
+    __text: string;
+}
 
-        getAvailabilityStartTime(externalManifest?: object): number;
+export class MediaInfo {
+    KID: any | null;
+    accessibility: DescriptorType[] | null;
+    audioChannelConfiguration: DescriptorType[] | null;
+    bitrateList: Bitrate[];
+    codec: string | null;
+    contentProtection: any | null;
+    essentialProperties: object;
+    id: string | null;
+    index: number | null;
+    isEmbedded: any | null;
+    isFragmented: any | null;
+    isPreselection: boolean;
+    isText: boolean;
+    labels: { text: string, lang?: string }[];
+    lang: string | null;
+    mimeType: string | null;
+    representationCount: number;
+    roles: DescriptorType[] | null;
+    segmentAlignment: boolean;
+    selectionPriority: number;
+    streamInfo: StreamInfo | null;
+    subSegmentAlignment: boolean;
+    supplementalProperties: object;
+    type: MediaType | null;
+    viewpoint: DescriptorType[] | null;
+}
 
-        getBandwidthForRepresentation(representationId: string, periodIdx: number): number;
+export interface Mpd {
+    availabilityEndTime: number;
+    availabilityStartTime: number | null;
+    manifest: object;
+    maxSegmentDuration: number;
+    mediaPresentationDuration: number;
+    minimumUpdatePeriod: number;
+    publishTime: number | null;
+    suggestedPresentationDelay: number;
+    timeShiftBufferDepth: number;
+}
 
-        getBaseURLsFromElement(node: object): BaseURL[];
+export class MpdLocation {
+    constructor(url: string, serviceLocation: string | null);
 
-        getCodec(adaptation: object, representationIndex: number, addResolutionInfo: boolean): string;
+    url: string;
+    serviceLocation: string | null;
+    queryParams: object;
+}
 
-        getCodecForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): string;
+export class PatchLocation {
+    constructor(url: string, serviceLocation: string, ttl: number);
 
-        getCommonRepresentationForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): Representation | null;
-        
-        getContentSteering(manifest: object): object;
+    url: string;
+    serviceLocation: string;
+    ttl: number;
+    queryParams: object;
+}
 
-        getDuration(externalManifest?: object): number;
+export class PatchOperation {
+    constructor(action: any, xpath: any, value: string);
 
-        getEssentialProperties(element: AdaptationSet | Representation | Preselection): DescriptorType | [];
+    action: any;
+    xpath: any;
+    value: string;
+    position: any | null;
 
-        getEvent(eventBox: object, eventStreams: object, mediaStartTime: number, voRepresentation: object): null | Event;
+    getMpdTarget(root: any): any;
+}
 
-        getEventsFor(info: object, voRepresentation: object): Array<Event>;
+export interface Period {
+    duration: number;
+    id: string | null;
+    index: number;
+    isEncrypted: boolean;
+    mpd: Mpd;
+    nextPeriodId: string | null;
+    start: number;
+}
 
-        getFramerate(representation: object): number;
+export interface Preselection {
+    period: Period | null;
+    index: number;
+    id: string | null;
+    order: string | null;
+    preselectionComponents: any[];
+    tag: string | null;
+    type: string | null;
+}
 
-        getIndexForRepresentation(representationId: string, periodIdx: number): number;
+export interface ProducerReferenceTime {
+    UTCTiming: any;
+    applicationSchme: any;
+    id: any;
+    inband: boolean;
+    presentationTime: number;
+    type: 'encoder';
+    wallClockTime: any;
+}
 
-        getIsDVB(manifest: object): boolean;
+export interface Representation {
+    absoluteIndex: number;
+    adaptation: AdaptationSet | null;
+    availabilityTimeComplete: boolean;
+    availabilityTimeOffset: number;
+    availableSegmentsNumber: number;
+    bandwidth: number;
+    bitrateInKbit: number;
+    bitsPerPixel: number;
+    codecPrivateData: string | null;
+    codecs: string | null;
+    fragmentDuration: number | null;
+    frameRate: number;
+    height: number;
+    id: string;
+    index: number;
+    indexRange: string | null;
+    initialization: object | null;
+    maxPlayoutRate: number;
+    mediaFinishedInformation: MediaFinishedInformation;
+    mediaInfo: MediaInfo | null;
+    mimeType: string | null;
+    mseTimeOffset: number;
+    pixelsPerSecond: number;
+    presentationTimeOffset: number;
+    qualityRanking: number;
+    range: Range | null;
+    scanType: string;
+    segments: any[];
+    segmentDuration: number;
+    segmentInfoType: string | null;
+    supplementalProperties: Array<any>;
+    startNumber: number;
+    timescale: number;
+    width: number;
+    endNumber: number | null;
+}
 
-        getIsDynamic(externalManifest?: object): boolean;
+export interface Segment {
+    availabilityEndTime: number;
+    availabilityStartTime: number;
+    duration: number;
+    index: number | null;
+    indexRange: any;
+    media: any;
+    mediaRange: any;
+    mediaStartTime: number;
+    presentationStartTime: number;
+    replacementNumber: number;
+    replacementTime: number;
+    representation: Representation | null;
+    wallStartTime: number;
+}
 
-        getIsMain(adaptation: object): boolean;
+export class SimpleXPath {
+    constructor(selector: any);
+}
 
-        getIsPatch(manifest: object): boolean;
+export class StreamInfo {
+    duration: number;
+    id: string;
+    index: number;
+    isEncrypted: boolean;
+    isLast: boolean;
+    manifestInfo: IManifestInfo;
+    start: number;
+}
 
-        getIsTextTrack(adaptation: object): boolean;
+export class UTCTiming {
+    schemeIdUri: string;
+    value: string;
+}
 
-        getIsTypeOf(adaptation: object, type: string): boolean;
+export interface ThroughputDictValue {
+    downloadTimeInMs: number,
+    downloadedBytes: number,
+    latencyInMs: number
+    serviceLocation: string,
+    value: number,
+}
 
-        getLocation(manifest: object): MpdLocation[];
+/**
+ * Dash
+ **/
 
-        getMainAdaptationForType(type: string, streamInfo: object): object;
-        
-        getMainAdaptationSetForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): AdaptationSet | undefined; 
+export interface DashAdapter {
+    applyPatchToManifest(manifest: object, patch: object): void;
 
-        getManifestUpdatePeriod(manifest: object, latencyOfLastUpdate?: number): number;
+    areMediaInfosEqual(mInfoOne: MediaInfo, mInfoTwo: MediaInfo): boolean;
 
-        getMediaInfoForType(streamInfo: object, type: MediaType): MediaInfo | null;
+    getMainAdaptationForType(type: MediaType, streamInfo: object): IAdaptation | null;
 
-        getMpd(externalManifest?: object): Mpd;
+    getAllMediaInfoForType(streamInfo: object, type: MediaType, externalManifest?: object | null): any[];
 
-        getPatchLocation(manifest: object): PatchLocation[];
+    getAvailabilityStartTime(externalManifest?: object): number;
 
-        getPeriodById(id: string): Period | null;
+    getBandwidthForRepresentation(representationId: string, periodIdx: number): number;
 
-        getPreselectionIsTypeOf(preselection: Preselection, adaptations: AdaptationSet[], type: MediaType): boolean;
+    getBaseURLsFromElement(node: object): BaseURL[];
 
-        getProducerReferenceTime(streamInfo: StreamInfo, mediaInfo: MediaInfo): object | [];
+    getCodec(adaptation: object, representationIndex: number, addResolutionInfo: boolean): string;
 
-        getPublishTime(manifest: object): number | null;
+    getCodecForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): string;
 
-        getRealAdaptation(streamInfo: StreamInfo, mediaInfo: MediaInfo): object;
+    getCommonRepresentationForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): Representation | null;
 
-        getRealPeriodByIndex(index: number): object;
+    getContentSteering(manifest: object): object;
 
-        getRegularPeriods(externalManifest?: object): any[];
+    getDuration(externalManifest?: object): number;
 
-        getRepresentationSortFunction(): (a: object, b: object) => number;
+    getEssentialProperties(element: AdaptationSet | Representation | Preselection): DescriptorType | [];
 
-        getStreamsInfo(externalManifest: object, maxStreamsInfo: number): Array<any>;
+    getEvent(eventBox: object, eventStreams: object, mediaStartTime: number, voRepresentation: object): null | Event;
 
-        getSuggestedPresentationDelay(): string;
+    getEventsFor(info: object, voRepresentation: object): Array<Event>;
 
-        getSupplementalCodecs(representation: Representation): Array<any>;
+    getFramerate(representation: object): number;
 
-        getUTCTimingSources(): any[];
+    getIndexForRepresentation(representationId: string, periodIdx: number): number;
 
-        getVoRepresentations(mediaInfo: MediaInfo): Representation[];
+    getIsDVB(manifest: object): boolean;
 
-        isPatchValid(manifest: object, patch: object): boolean;
+    getIsDynamic(externalManifest?: object): boolean;
 
-        reset(): void;
-    }
+    getIsMain(adaptation: object): boolean;
 
-    export interface DashHandler {
-        getCurrentIndex(): number;
+    getIsPatch(manifest: object): boolean;
 
-        getInitRequest(mediaInfo: MediaInfo, representation: Representation): FragmentRequest | null;
+    getIsTextTrack(adaptation: object): boolean;
 
-        getNextSegmentRequest(mediaInfo: MediaInfo, representation: Representation): FragmentRequest | null;
+    getIsTypeOf(adaptation: object, type: string): boolean;
 
-        getNextSegmentRequestIdempotent(mediaInfo: MediaInfo, representation: Representation): FragmentRequest | null;
+    getLocation(manifest: object): MpdLocation[];
 
-        getSegmentRequestForTime(mediaInfo: MediaInfo, representation: Representation, time: number): FragmentRequest | null;
+    getMainAdaptationForType(type: string, streamInfo: object): object;
 
-        getStreamId(): string;
+    getMainAdaptationSetForPreselection(preselection: Preselection, adaptations: AdaptationSet[]): AdaptationSet | undefined;
 
-        getStreamInfo(): StreamInfo;
+    getManifestUpdatePeriod(manifest: object, latencyOfLastUpdate?: number): number;
 
-        getType(): string;
+    getMediaInfoForType(streamInfo: object, type: MediaType): MediaInfo | null;
 
-        getValidTimeAheadOfTargetTime(time: number, mediaInfo: MediaInfo, representation: Representation, targetThreshold: number): number;
+    getMpd(externalManifest?: object): Mpd;
 
-        initialize(isDynamic: boolean): void;
+    getPatchLocation(manifest: object): PatchLocation[];
 
-        isLastSegmentRequested(representation: Representation, bufferingTime: number): boolean;
+    getPeriodById(id: string): Period | null;
 
-        repeatSegmentRequest(mediaInfo: MediaInfo, representation: Representation): FragmentRequest | null;
+    getPreselectionIsTypeOf(preselection: Preselection, adaptations: AdaptationSet[], type: MediaType): boolean;
 
-        reset(): void;
-    }
+    getProducerReferenceTime(streamInfo: StreamInfo, mediaInfo: MediaInfo): object | [];
 
-    export interface DashMetrics {
+    getPublishTime(manifest: object): number | null;
 
+    getRealAdaptation(streamInfo: StreamInfo, mediaInfo: MediaInfo): object;
 
-        addBufferLevel(mediaType: MediaType, t: number, level: number): void;
+    getRealPeriodByIndex(index: number): object;
 
-        addBufferState(mediaType: MediaType, state: string, target: number): void;
+    getRegularPeriods(externalManifest?: object): any[];
 
-        addDVBErrors(errors: object): void;
+    getRepresentationSortFunction(): (a: object, b: object) => number;
 
-        addDVRInfo(mediaType: MediaType, currentTime: Date, mpd: Mpd, range: Range): void;
+    getStreamsInfo(externalManifest: object, maxStreamsInfo: number): Array<any>;
 
-        addDroppedFrames(quality: number): void;
+    getSuggestedPresentationDelay(): string;
 
-        addHttpRequest(request: HTTPRequest, responseURL: string, responseStatus: number, responseHeaders: object, traces: object): void;
+    getSupplementalCodecs(representation: Representation): Array<any>;
 
-        addManifestUpdate(request: ManifestUpdate): void;
+    getUTCTimingSources(): any[];
 
-        addManifestUpdateRepresentationInfo(representation: Representation, mediaType: MediaType): void;
+    getVoRepresentations(mediaInfo: MediaInfo): Representation[];
 
-        addManifestUpdateStreamInfo(streamInfo: StreamInfo): void;
+    isPatchValid(manifest: object, patch: object): boolean;
 
-        addPlayList(): void;
+    reset(): void;
+}
 
-        addRepresentationSwitch(mediaType: MediaType, t: Date, mt: Date, to: string, lto: string): void;
+export interface DashHandler {
+    getCurrentIndex(): number;
 
-        addRequestsQueue(mediaType: MediaType, loadingRequests: any[], executedRequests: any[]): void;
+    getInitRequest(mediaInfo: MediaInfo, representation: Representation): FragmentRequest | null;
 
-        addSchedulingInfo(request: SchedulingInfo, state: string): void;
+    getNextSegmentRequest(mediaInfo: MediaInfo, representation: Representation): FragmentRequest | null;
 
-        clearAllCurrentMetrics(): void;
+    getNextSegmentRequestIdempotent(mediaInfo: MediaInfo, representation: Representation): FragmentRequest | null;
 
-        createPlaylistMetrics(mediaStartTime: number, startReason: string): void;
+    getSegmentRequestForTime(mediaInfo: MediaInfo, representation: Representation, time: number): FragmentRequest | null;
 
-        createPlaylistTraceMetrics(representationId: number, mediaStartTime: number, speed: number): void;
+    getStreamId(): string;
 
-        getCurrent(metrics: MetricsList, metricName: string): DroppedFrames;
+    getStreamInfo(): StreamInfo;
 
-        getCurrentBufferLevel(type: MediaType): number;
+    getType(): string;
 
-        getCurrentBufferState(type: MediaType): IBufferState;
+    getValidTimeAheadOfTargetTime(time: number, mediaInfo: MediaInfo, representation: Representation, targetThreshold: number): number;
 
-        getCurrentDVRInfo(type?: MediaType): DVRInfo;
+    initialize(isDynamic: boolean): void;
 
-        getCurrentDroppedFrames(): DroppedFrames;
+    isLastSegmentRequested(representation: Representation, bufferingTime: number): boolean;
 
-        getCurrentHttpRequest(type: MediaType): object;
+    repeatSegmentRequest(mediaInfo: MediaInfo, representation: Representation): FragmentRequest | null;
 
-        getCurrentManifestUpdate(): any;
+    reset(): void;
+}
 
-        getCurrentRepresentationSwitch(type: MediaType): ICurrentRepresentationSwitch;
+export interface DashMetrics {
 
-        getCurrentSchedulingInfo(type: MediaType): object;
 
-        getHttpRequests(type: MediaType): object[];
+    addBufferLevel(mediaType: MediaType, t: number, level: number): void;
 
-        getLatestFragmentRequestHeaderValueByID(id: string): string;
+    addBufferState(mediaType: MediaType, state: string, target: number): void;
 
-        getLatestMPDRequestHeaderValueByID(type: MediaType, id: string): string;
+    addDVBErrors(errors: object): void;
 
-        pushPlaylistTraceMetrics(endTime: number, reason: string): void;
+    addDVRInfo(mediaType: MediaType, currentTime: Date, mpd: Mpd, range: Range): void;
 
-        updateManifestUpdateInfo(updateFields: any[]): void;
+    addDroppedFrames(quality: number): void;
 
-        updatePlayListTraceMetrics(traceToUpdate: object): void;
-    }
+    addHttpRequest(request: HTTPRequest, responseURL: string, responseStatus: number, responseHeaders: object, traces: object): void;
 
-    export interface SegmentBaseLoader {
-        initialize(): void;
+    addManifestUpdate(request: ManifestUpdate): void;
 
-        loadInitialization(representation: Representation, mediaType: MediaType): Promise<any>;
+    addManifestUpdateRepresentationInfo(representation: Representation, mediaType: MediaType): void;
 
-        loadSegments(representation: Representation, mediaType: MediaType, range: Range): Promise<any>;
+    addManifestUpdateStreamInfo(streamInfo: StreamInfo): void;
 
-        reset(): any;
+    addPlayList(): void;
 
-        setConfig(config: object): void;
-    }
+    addRepresentationSwitch(mediaType: MediaType, t: Date, mt: Date, to: string, lto: string): void;
 
-    export interface WebSegmentBaseLoader {
-        initialize(): void;
+    addRequestsQueue(mediaType: MediaType, loadingRequests: any[], executedRequests: any[]): void;
 
-        loadInitialization(representation: Representation, mediaType: MediaType): Promise<any>;
+    addSchedulingInfo(request: SchedulingInfo, state: string): void;
 
-        loadSegments(representation: Representation, mediaType: MediaType, range: Range): Promise<any>;
+    clearAllCurrentMetrics(): void;
 
-        reset(): any;
+    createPlaylistMetrics(mediaStartTime: number, startReason: string): void;
 
-        setConfig(config: object): void;
-    }
+    createPlaylistTraceMetrics(representationId: number, mediaStartTime: number, speed: number): void;
 
-    /**
-     * MSS - Errors
-     **/
-
-    export interface MssError extends ErrorsBase {
-        MSS_NO_TFRF_CODE: 200;
-        MSS_NO_TFRF_MESSAGE: 'Missing tfrf in live media segment';
-        MSS_UNSUPPORTED_CODEC_CODE: 201;
-        MSS_UNSUPPORTED_CODEC_MESSAGE: 'Unsupported codec';
-    }
+    getCurrent(metrics: MetricsList, metricName: string): DroppedFrames;
 
-    /**
-     * MSS - Parser
-     **/
+    getCurrentBufferLevel(type: MediaType): number;
 
-    export interface MssParser {
-        getIron(): null;
+    getCurrentBufferState(type: MediaType): IBufferState;
 
-        parse(data: any): object;
+    getCurrentDVRInfo(type?: MediaType): DVRInfo;
 
-        reset(): void;
+    getCurrentDroppedFrames(): DroppedFrames;
 
-        setup(): void;
-    }
+    getCurrentHttpRequest(type: MediaType): object;
 
-    /**
-     * MSS
-     **/
+    getCurrentManifestUpdate(): any;
 
-    export interface MssFragmentInfoController {
-        controllerType: 'MssFragmentInfoController';
+    getCurrentRepresentationSwitch(type: MediaType): ICurrentRepresentationSwitch;
 
-        fragmentInfoLoaded(e: object): void;
+    getCurrentSchedulingInfo(type: MediaType): object;
 
-        getType(): string;
+    getHttpRequests(type: MediaType): object[];
 
-        initialize(): void;
+    getLatestFragmentRequestHeaderValueByID(id: string): string;
 
-        reset(): void;
+    getLatestMPDRequestHeaderValueByID(type: MediaType, id: string): string;
 
-        start(): void;
-    }
+    pushPlaylistTraceMetrics(endTime: number, reason: string): void;
 
-    export interface MssFragmentMoofProcessor {
-        convertFragment(e: object, streamProcessor: any): void;
+    updateManifestUpdateInfo(updateFields: any[]): void;
 
-        getType(): string;
+    updatePlayListTraceMetrics(traceToUpdate: object): void;
+}
 
-        updateSegmentList(e: object, streamProcessor: any): void;
-    }
+export interface SegmentBaseLoader {
+    initialize(): void;
 
-    export interface MssFragmentMoovProcessor {
-        generateMoov(rep: Representation): ArrayBuffer;
-    }
+    loadInitialization(representation: Representation, mediaType: MediaType): Promise<any>;
 
-    export interface MssFragmentProcessor {
-        generateMoov(rep: Representation): ArrayBuffer;
+    loadSegments(representation: Representation, mediaType: MediaType, range: Range): Promise<any>;
 
-        processFragment(e: object, streamProcessor: any): void;
-    }
+    reset(): any;
 
-    export interface MssHandler {
-        createMssFragmentProcessor(): void;
+    setConfig(config: object): void;
+}
 
-        createMssParser(): void;
+export interface WebSegmentBaseLoader {
+    initialize(): void;
 
-        registerEvents(): void;
+    loadInitialization(representation: Representation, mediaType: MediaType): Promise<any>;
 
-        reset(): void;
-    }
+    loadSegments(representation: Representation, mediaType: MediaType, range: Range): Promise<any>;
 
-    /**
-     * Offline - Constants
-     **/
-
-    class OfflineConstants {
-        OFFLINE_SCHEME: 'offline_indexeddb';
-        OFFLINE_STATUS_CREATED: 'created';
-        OFFLINE_STATUS_ERROR: 'error';
-        OFFLINE_STATUS_FINISHED: 'finished';
-        OFFLINE_STATUS_STARTED: 'started';
-        OFFLINE_STATUS_STOPPED: 'stopped';
-        OFFLINE_URL_REGEX: RegExp;
-    }
+    reset(): any;
 
-    /**
-     * Offline - Controllers
-     */
+    setConfig(config: object): void;
+}
 
-    export interface OfflineRecord {
-        id: string;
-        originalUrl: string;
-        progress: number;
-        status: string;
-        url: string;
-    }
+/**
+ * MSS - Errors
+ **/
 
-    interface OfflineController {
-        createRecord(manifestURL: string): Promise<string>;
+export interface MssError extends ErrorsBase {
+    MSS_NO_TFRF_CODE: 200;
+    MSS_NO_TFRF_MESSAGE: 'Missing tfrf in live media segment';
+    MSS_UNSUPPORTED_CODEC_CODE: 201;
+    MSS_UNSUPPORTED_CODEC_MESSAGE: 'Unsupported codec';
+}
 
-        deleteRecord(id: string): void;
+/**
+ * MSS - Parser
+ **/
 
-        getAllRecords(): OfflineRecord[];
+export interface MssParser {
+    getIron(): null;
 
-        getRecordProgression(id: string): number;
+    parse(data: any): object;
 
-        loadRecordsFromStorage(): Promise<void>;
+    reset(): void;
 
-        reset(): void;
+    setup(): void;
+}
 
-        resetRecords(): void;
+/**
+ * MSS
+ **/
 
-        resumeRecord(id: string): void;
+export interface MssFragmentInfoController {
+    controllerType: 'MssFragmentInfoController';
 
-        startRecord(id: string, mediaInfos: MediaInfo[]): void;
+    fragmentInfoLoaded(e: object): void;
 
-        stopRecord(id: string): void;
-    }
+    getType(): string;
 
-    interface OfflineStoreController {
-        createFragmentStore(manifestId: number | string, storeName: string): void;
+    initialize(): void;
 
-        createOfflineManifest(manifest: object): object;
+    reset(): void;
 
-        deleteDownloadById(manifestId: number | string): object;
+    start(): void;
+}
 
-        getAllManifests(): object;
+export interface MssFragmentMoofProcessor {
+    convertFragment(e: object, streamProcessor: any): void;
 
-        getCurrentHigherManifestId(): object;
+    getType(): string;
 
-        getManifestById(manifestId: number | string): object;
+    updateSegmentList(e: object, streamProcessor: any): void;
+}
 
-        getRepresentationCurrentState(manifestId: number | string, representationId: number | string): object;
+export interface MssFragmentMoovProcessor {
+    generateMoov(rep: Representation): ArrayBuffer;
+}
 
-        saveSelectedRepresentations(manifestId: number | string, selected: Representation): object;
+export interface MssFragmentProcessor {
+    generateMoov(rep: Representation): ArrayBuffer;
 
-        setDownloadingStatus(manifestId: number | string, status: any): object;
+    processFragment(e: object, streamProcessor: any): void;
+}
 
-        setRepresentationCurrentState(manifestId: number | string, representationId: number | string, state: any): object;
+export interface MssHandler {
+    createMssFragmentProcessor(): void;
 
-        storeFragment(manifestId: number | string, fragmentId: number | string, fragmentData: any): object;
+    createMssParser(): void;
 
-        updateOfflineManifest(manifest: object): object;
-    }
+    registerEvents(): void;
 
-    /**
-     * Offline - Errors
-     */
+    reset(): void;
+}
 
-    export class OfflineErrors extends ErrorsBase {
-        /**
-         * Error code returned when an error occurs in offline module
-         */
-        OFFLINE_ERROR: 11000;
-
-        // Based upon https://developer.mozilla.org/fr/docs/Web/API/DOMException
-        INDEXEDDB_QUOTA_EXCEED_ERROR: 11001;
-        INDEXEDDB_INVALID_STATE_ERROR: 11002;
-        INDEXEDDB_NOT_READABLE_ERROR: 11003;
-        INDEXEDDB_NOT_FOUND_ERROR: 11004;
-        INDEXEDDB_NETWORK_ERROR: 11005;
-        INDEXEDDB_DATA_ERROR: 11006;
-        INDEXEDDB_TRANSACTION_INACTIVE_ERROR: 11007;
-        INDEXEDDB_NOT_ALLOWED_ERROR: 11008;
-        INDEXEDDB_NOT_SUPPORTED_ERROR: 11009;
-        INDEXEDDB_VERSION_ERROR: 11010;
-        INDEXEDDB_TIMEOUT_ERROR: 11011;
-        INDEXEDDB_ABORT_ERROR: 11012;
-        INDEXEDDB_UNKNOWN_ERROR: 11013;
-    }
+/**
+ * Offline - Constants
+ **/
+
+export class OfflineConstants {
+    OFFLINE_SCHEME: 'offline_indexeddb';
+    OFFLINE_STATUS_CREATED: 'created';
+    OFFLINE_STATUS_ERROR: 'error';
+    OFFLINE_STATUS_FINISHED: 'finished';
+    OFFLINE_STATUS_STARTED: 'started';
+    OFFLINE_STATUS_STOPPED: 'stopped';
+    OFFLINE_URL_REGEX: RegExp;
+}
 
-    export class OfflineEvents extends EventsBase {
-        /**
-         * Triggered when all mediaInfo has been loaded
-         * @event OfflineEvents#OFFLINE_RECORD_LOADEDMETADATA
-         */
-        OFFLINE_RECORD_LOADEDMETADATA: 'public_offlineRecordLoadedmetadata';
-
-        /**
-         * Triggered when a record is initialized and download is started
-         * @event OfflineEvents#OFFLINE_RECORD_STARTED
-         */
-        OFFLINE_RECORD_STARTED: 'public_offlineRecordStarted';
-
-        /**
-         * Triggered when the user stop downloading a record
-         * @event OfflineEvents#OFFLINE_RECORD_STOPPED
-         */
-        OFFLINE_RECORD_STOPPED: 'public_offlineRecordStopped';
-
-        /**
-         * Triggered when all record has been downloaded
-         * @event OfflineEvents#OFFLINE_RECORD_FINISHED
-         */
-        OFFLINE_RECORD_FINISHED: 'public_offlineRecordFinished';
-    }
+/**
+ * Offline - Controllers
+ */
+
+export interface OfflineRecord {
+    id: string;
+    originalUrl: string;
+    progress: number;
+    status: string;
+    url: string;
+}
+
+export interface OfflineController {
+    createRecord(manifestURL: string): Promise<string>;
+
+    deleteRecord(id: string): void;
+
+    getAllRecords(): OfflineRecord[];
+
+    getRecordProgression(id: string): number;
+
+    loadRecordsFromStorage(): Promise<void>;
+
+    reset(): void;
+
+    resetRecords(): void;
+
+    resumeRecord(id: string): void;
+
+    startRecord(id: string, mediaInfos: MediaInfo[]): void;
+
+    stopRecord(id: string): void;
+}
+
+export interface OfflineStoreController {
+    createFragmentStore(manifestId: number | string, storeName: string): void;
+
+    createOfflineManifest(manifest: object): object;
+
+    deleteDownloadById(manifestId: number | string): object;
+
+    getAllManifests(): object;
+
+    getCurrentHigherManifestId(): object;
+
+    getManifestById(manifestId: number | string): object;
+
+    getRepresentationCurrentState(manifestId: number | string, representationId: number | string): object;
+
+    saveSelectedRepresentations(manifestId: number | string, selected: Representation): object;
 
+    setDownloadingStatus(manifestId: number | string, status: any): object;
+
+    setRepresentationCurrentState(manifestId: number | string, representationId: number | string, state: any): object;
+
+    storeFragment(manifestId: number | string, fragmentId: number | string, fragmentData: any): object;
+
+    updateOfflineManifest(manifest: object): object;
+}
+
+/**
+ * Offline - Errors
+ */
+
+export class OfflineErrors extends ErrorsBase {
     /**
-     * Offline - Net
+     * Error code returned when an error occurs in offline module
      */
+    OFFLINE_ERROR: 11000;
+
+    // Based upon https://developer.mozilla.org/fr/docs/Web/API/DOMException
+    INDEXEDDB_QUOTA_EXCEED_ERROR: 11001;
+    INDEXEDDB_INVALID_STATE_ERROR: 11002;
+    INDEXEDDB_NOT_READABLE_ERROR: 11003;
+    INDEXEDDB_NOT_FOUND_ERROR: 11004;
+    INDEXEDDB_NETWORK_ERROR: 11005;
+    INDEXEDDB_DATA_ERROR: 11006;
+    INDEXEDDB_TRANSACTION_INACTIVE_ERROR: 11007;
+    INDEXEDDB_NOT_ALLOWED_ERROR: 11008;
+    INDEXEDDB_NOT_SUPPORTED_ERROR: 11009;
+    INDEXEDDB_VERSION_ERROR: 11010;
+    INDEXEDDB_TIMEOUT_ERROR: 11011;
+    INDEXEDDB_ABORT_ERROR: 11012;
+    INDEXEDDB_UNKNOWN_ERROR: 11013;
+}
 
-    export class IndexDBOfflineLoader {
-        abort(): void;
+export class OfflineEvents extends EventsBase {
+    /**
+     * Triggered when all mediaInfo has been loaded
+     * @event OfflineEvents#OFFLINE_RECORD_LOADEDMETADATA
+     */
+    OFFLINE_RECORD_LOADEDMETADATA: 'public_offlineRecordLoadedmetadata';
 
-        config: object | {};
+    /**
+     * Triggered when a record is initialized and download is started
+     * @event OfflineEvents#OFFLINE_RECORD_STARTED
+     */
+    OFFLINE_RECORD_STARTED: 'public_offlineRecordStarted';
 
-        load(config: object | {}): void;
-    }
+    /**
+     * Triggered when the user stop downloading a record
+     * @event OfflineEvents#OFFLINE_RECORD_STOPPED
+     */
+    OFFLINE_RECORD_STOPPED: 'public_offlineRecordStopped';
 
     /**
-     * Offline - Storage
+     * Triggered when all record has been downloaded
+     * @event OfflineEvents#OFFLINE_RECORD_FINISHED
      */
+    OFFLINE_RECORD_FINISHED: 'public_offlineRecordFinished';
+}
 
-    export class IndexDBStore {
-        createFragmentStore(storeName: string): void;
+/**
+ * Offline - Net
+ */
 
-        deleteDownloadById(manifestId: number): Promise<string | any>;
+export class IndexDBOfflineLoader {
+    abort(): void;
 
-        dropAll(): Promise<any>;
+    config: object | {};
 
-        dropFragmentStore(storeName: string): void;
+    load(config: object | {}): void;
+}
 
-        getAllManifests(): Promise<Object[] | String | Error>;
+/**
+ * Offline - Storage
+ */
 
-        getCurrentHigherManifestId(): Promise<number>;
+export class IndexDBStore {
+    createFragmentStore(storeName: string): void;
 
-        getFragmentByKey(manifestId: number, key: number): Promise<any>;
+    deleteDownloadById(manifestId: number): Promise<string | any>;
 
-        getManifestById(id: number): Promise<Object[] | String | Error>;
+    dropAll(): Promise<any>;
 
-        getRepresentationCurrentState(manifestId: number, state: number): Promise<number | Error>;
+    dropFragmentStore(storeName: string): void;
 
-        saveSelectedRepresentation(manifest: object, selected: object): Promise<string | Error>;
+    getAllManifests(): Promise<Object[] | String | Error>;
 
-        setDownloadingStatus(manifestId: number, newStatus: number): Promise<string | Error>;
+    getCurrentHigherManifestId(): Promise<number>;
 
-        setRepresentationCurrentState(manifestId: number, representationId: string, state: number): Promise<string | Error>;
+    getFragmentByKey(manifestId: number, key: number): Promise<any>;
 
-        storeFragment(manifestI: number, fragmentId: string, fragmentData: object): Promise<string | Error>;
+    getManifestById(id: number): Promise<Object[] | String | Error>;
 
-        storeManifest(manifest: object): Object[];
+    getRepresentationCurrentState(manifestId: number, state: number): Promise<number | Error>;
 
-        updateManifest(manifest: object): Promise<Object[] | Error>;
-    }
+    saveSelectedRepresentation(manifest: object, selected: object): Promise<string | Error>;
 
-    /**
-     * Offline - Parser
-     */
+    setDownloadingStatus(manifestId: number, newStatus: number): Promise<string | Error>;
 
-    export class OfflineIndexDBManifestParser {
-        config: object;
+    setRepresentationCurrentState(manifestId: number, representationId: string, state: number): Promise<string | Error>;
 
-        parse(XMLDoc: string, representation: object): Promise<any>;
-    }
+    storeFragment(manifestI: number, fragmentId: string, fragmentData: object): Promise<string | Error>;
 
-    export class OfflineUrlUtils {
-        getRegex(): RegExp | undefined;
+    storeManifest(manifest: object): Object[];
 
-        isRelative(): boolean;
+    updateManifest(manifest: object): Promise<Object[] | Error>;
+}
 
-        removeHostName(url: string): string;
+/**
+ * Offline - Parser
+ */
 
-        resolve(url: string, baseUrl: string): string;
-    }
+export class OfflineIndexDBManifestParser {
+    config: object;
 
-    /**
-     * Offline - Vo
-     */
+    parse(XMLDoc: string, representation: object): Promise<any>;
+}
 
-    export class OfflineDownload {
-        id: object;
-        originalUrl: object;
-        progress: object;
-        status: object;
-        url: object;
-    }
+export class OfflineUrlUtils {
+    getRegex(): RegExp | undefined;
 
-    /**
-     * Offline
-     */
+    isRelative(): boolean;
+
+    removeHostName(url: string): string;
 
-    export interface OfflineDownload {
-        config: object | {};
+    resolve(url: string, baseUrl: string): string;
+}
 
-        deleteDownload(): void;
+/**
+ * Offline - Vo
+ */
 
-        downloadFromUrl(url: string): object;
+export class OfflineDownload {
+    id: object;
+    originalUrl: object;
+    progress: object;
+    status: object;
+    url: object;
+}
 
-        getDownloadProgression(): number;
+/**
+ * Offline
+ */
 
-        getId(): number;
+export interface OfflineDownload {
+    config: object | {};
 
-        getManifestUrl(): string;
+    deleteDownload(): void;
 
-        getMediaInfos(): void;
+    downloadFromUrl(url: string): object;
 
-        getStatus(): number;
+    getDownloadProgression(): number;
 
-        initDownload(): void;
+    getId(): number;
 
-        isDownloading(): boolean;
+    getManifestUrl(): string;
 
-        reset(): void;
+    getMediaInfos(): void;
 
-        resetDownload(): void;
+    getStatus(): number;
 
-        resumeDownload(): void;
+    initDownload(): void;
 
-        setInitialState(state: object): void;
+    isDownloading(): boolean;
 
-        startDownload(mediaInfos: MediaInfo[]): any;
+    reset(): void;
 
-        stopDownload(): void;
-    }
+    resetDownload(): void;
 
-    export class OfflineStream {
-        getMediaInfos(): MediaInfo[];
+    resumeDownload(): void;
 
-        getStreamId(): string;
+    setInitialState(state: object): void;
 
-        getStreamInfo(): StreamInfo;
+    startDownload(mediaInfos: MediaInfo[]): any;
 
-        initialize(initStreamInfo: StreamInfo): void;
+    stopDownload(): void;
+}
 
-        initializeAllMediaInfoList(mediaInfoList: object): void;
+export class OfflineStream {
+    getMediaInfos(): MediaInfo[];
 
-        reset(): void;
+    getStreamId(): string;
 
-        startOfflineStreamProcessors(): void;
+    getStreamInfo(): StreamInfo;
 
-        stopOfflineStreamProcessors(): void;
-    }
+    initialize(initStreamInfo: StreamInfo): void;
 
-    export class OfflineStreamProcessor {
-        config: object | void;
+    initializeAllMediaInfoList(mediaInfoList: object): void;
 
-        getAvailableSegmentsNumber(): number;
+    reset(): void;
 
-        getMediaInfo(): MediaInfo;
+    startOfflineStreamProcessors(): void;
 
-        getRepresentationController(): RepresentationController;
+    stopOfflineStreamProcessors(): void;
+}
 
-        getRepresentationId(): number | string;
+export class OfflineStreamProcessor {
+    config: object | void;
 
-        getType(): any;
+    getAvailableSegmentsNumber(): number;
 
-        initialize(_mediaInfo: MediaInfo): void;
+    getMediaInfo(): MediaInfo;
 
-        isUpdating(): boolean;
+    getRepresentationController(): RepresentationController;
 
-        removeExecutedRequestsBeforeTime(time: any): void;
+    getRepresentationId(): number | string;
 
-        reset(): void;
+    getType(): any;
 
-        start(): void;
+    initialize(_mediaInfo: MediaInfo): void;
 
-        stop(): void;
-    }
+    isUpdating(): boolean;
 
-    export interface Bitrate {
-        bandwidth?: number;
-        height?: number;
-        id?: string;
-        scanType?: string;
-        width?: number;
-    }
+    removeExecutedRequestsBeforeTime(time: any): void;
 
-    export type MediaType = 'video' | 'audio' | 'text' | 'image';
-    export type ThroughputCalculationModes =
-        'throughputCalculationModeEwma'
-        | 'throughputCalculationModeZlema'
-        | 'throughputCalculationModeArithmeticMean'
-        | 'throughputCalculationModeByteSizeWeightedArithmeticMean'
-        | 'throughputCalculationModeDateWeightedArithmeticMean'
-        | 'throughputCalculationModeHarmonicMean'
-        | 'throughputCalculationModeByteSizeWeightedHarmonicMean'
-        | 'throughputCalculationModeDateWeightedHarmonicMean'
-        ;
-    export type LowLatencyDownloadTimeCalculationModes =
-        'lowLatencyDownloadTimeCalculationModeMoofParsing'
-        | 'lowLatencyDownloadTimeCalculationModeDownloadedData'
-        | 'lowLatencyDownloadTimeCalculationModeAast';
-
-    export class ProtectionMediaInfo {
-        codec: string | null;
-        contentProtection: any | null;
-    }
+    reset(): void;
 
-    export class MediaPlayerSettingClass {
-        debug?: {
-            logLevel?: LogLevel;
-            dispatchEvent?: boolean;
-        };
-        streaming?: {
-            abandonLoadTimeout?: number,
-            wallclockTimeUpdateInterval?: number,
-            manifestUpdateRetryInterval?: number,
-            liveUpdateTimeThresholdInMilliseconds?: number,
-            cacheInitSegments?: boolean,
-            applyServiceDescription?: boolean,
-            applyProducerReferenceTime?: boolean,
-            applyContentSteering?: boolean,
-            enableManifestDurationMismatchFix?: boolean,
-            parseInbandPrft?: boolean,
-            enableManifestTimescaleMismatchFix?: boolean,
-            capabilities?: {
-                filterUnsupportedEssentialProperties?: boolean,
-                supportedEssentialProperties?: [
-                    { schemeIdUri?: string, value?: RegExp }
-                ],
-                useMediaCapabilitiesApi?: boolean,
-                filterHDRMetadataFormatEssentialProperties?: boolean,
-                filterVideoColorimetryEssentialProperties?: boolean
-            },
-            events?: {
-                eventControllerRefreshDelay?: number,
-                deleteEventMessageDataTimeout?: number
+    start(): void;
+
+    stop(): void;
+}
+
+export interface Bitrate {
+    bandwidth?: number;
+    height?: number;
+    id?: string;
+    scanType?: string;
+    width?: number;
+}
+
+export type MediaType = 'video' | 'audio' | 'text' | 'image';
+export type ThroughputCalculationModes =
+    'throughputCalculationModeEwma'
+    | 'throughputCalculationModeZlema'
+    | 'throughputCalculationModeArithmeticMean'
+    | 'throughputCalculationModeByteSizeWeightedArithmeticMean'
+    | 'throughputCalculationModeDateWeightedArithmeticMean'
+    | 'throughputCalculationModeHarmonicMean'
+    | 'throughputCalculationModeByteSizeWeightedHarmonicMean'
+    | 'throughputCalculationModeDateWeightedHarmonicMean'
+    ;
+export type LowLatencyDownloadTimeCalculationModes =
+    'lowLatencyDownloadTimeCalculationModeMoofParsing'
+    | 'lowLatencyDownloadTimeCalculationModeDownloadedData'
+    | 'lowLatencyDownloadTimeCalculationModeAast';
+
+export class ProtectionMediaInfo {
+    codec: string | null;
+    contentProtection: any | null;
+}
+
+export class MediaPlayerSettingClass {
+    debug?: {
+        logLevel?: LogLevel;
+        dispatchEvent?: boolean;
+    };
+    streaming?: {
+        abandonLoadTimeout?: number,
+        wallclockTimeUpdateInterval?: number,
+        manifestUpdateRetryInterval?: number,
+        liveUpdateTimeThresholdInMilliseconds?: number,
+        cacheInitSegments?: boolean,
+        applyServiceDescription?: boolean,
+        applyProducerReferenceTime?: boolean,
+        applyContentSteering?: boolean,
+        enableManifestDurationMismatchFix?: boolean,
+        parseInbandPrft?: boolean,
+        enableManifestTimescaleMismatchFix?: boolean,
+        capabilities?: {
+            filterUnsupportedEssentialProperties?: boolean,
+            supportedEssentialProperties?: [
+                { schemeIdUri?: string, value?: RegExp }
+            ],
+            useMediaCapabilitiesApi?: boolean,
+            filterHDRMetadataFormatEssentialProperties?: boolean,
+            filterVideoColorimetryEssentialProperties?: boolean
+        },
+        events?: {
+            eventControllerRefreshDelay?: number,
+            deleteEventMessageDataTimeout?: number
+        }
+        timeShiftBuffer?: {
+            calcFromSegmentTimeline?: boolean
+            fallbackToSegmentTimeline?: boolean
+        },
+        metrics?: {
+            maxListDepth?: number
+        },
+        delay?: {
+            liveDelayFragmentCount?: number,
+            liveDelay?: number,
+            useSuggestedPresentationDelay?: boolean
+        },
+        protection?: {
+            keepProtectionMediaKeys?: boolean,
+            keepProtectionMediaKeysMaximumOpenSessions?: number,
+            ignoreEmeEncryptedEvent?: boolean,
+            detectPlayreadyMessageFormat?: boolean,
+            ignoreKeyStatuses?: boolean,
+        },
+        buffer?: {
+            enableSeekDecorrelationFix?: boolean,
+            fastSwitchEnabled?: boolean,
+            flushBufferAtTrackSwitch?: boolean,
+            reuseExistingSourceBuffers?: boolean,
+            bufferPruningInterval?: number,
+            bufferToKeep?: number,
+            bufferTimeAtTopQuality?: number,
+            bufferTimeAtTopQualityLongForm?: number,
+            initialBufferLevel?: number,
+            bufferTimeDefault?: number,
+            longFormContentDurationThreshold?: number,
+            stallThreshold?: number,
+            lowLatencyStallThreshold?: number,
+            useAppendWindow?: boolean,
+            setStallState?: boolean
+            avoidCurrentTimeRangePruning?: boolean
+            useChangeType?: boolean
+            mediaSourceDurationInfinity?: boolean
+            resetSourceBuffersForTrackSwitch?: boolean
+            syntheticStallEvents?: {
+                enabled?: boolean
+                ignoreReadyState?: boolean
             }
-            timeShiftBuffer?: {
-                calcFromSegmentTimeline?: boolean
-                fallbackToSegmentTimeline?: boolean
-            },
-            metrics?: {
-                maxListDepth?: number
-            },
-            delay?: {
-                liveDelayFragmentCount?: number,
-                liveDelay?: number,
-                useSuggestedPresentationDelay?: boolean
-            },
-            protection?: {
-                keepProtectionMediaKeys?: boolean,
-                keepProtectionMediaKeysMaximumOpenSessions?: number,
-                ignoreEmeEncryptedEvent?: boolean,
-                detectPlayreadyMessageFormat?: boolean,
-                ignoreKeyStatuses?: boolean,
-            },
-            buffer?: {
-                enableSeekDecorrelationFix?: boolean,
-                fastSwitchEnabled?: boolean,
-                flushBufferAtTrackSwitch?: boolean,
-                reuseExistingSourceBuffers?: boolean,
-                bufferPruningInterval?: number,
-                bufferToKeep?: number,
-                bufferTimeAtTopQuality?: number,
-                bufferTimeAtTopQualityLongForm?: number,
-                initialBufferLevel?: number,
-                bufferTimeDefault?: number,
-                longFormContentDurationThreshold?: number,
-                stallThreshold?: number,
-                lowLatencyStallThreshold?: number,
-                useAppendWindow?: boolean,
-                setStallState?: boolean
-                avoidCurrentTimeRangePruning?: boolean
-                useChangeType?: boolean
-                mediaSourceDurationInfinity?: boolean
-                resetSourceBuffersForTrackSwitch?: boolean
-                syntheticStallEvents?: {
-                    enabled?: boolean
-                    ignoreReadyState?: boolean
-                }
-            },
-            gaps?: {
-                jumpGaps?: boolean,
-                jumpLargeGaps?: boolean,
-                smallGapLimit?: number,
-                threshold?: number,
-                enableSeekFix?: boolean,
-                enableStallFix?: boolean,
-                stallSeek?: number
-            },
-            utcSynchronization?: {
-                enabled?: boolean,
-                useManifestDateHeaderTimeSource?: boolean,
-                backgroundAttempts?: number,
-                timeBetweenSyncAttempts?: number,
-                maximumTimeBetweenSyncAttempts?: number,
-                minimumTimeBetweenSyncAttempts?: number,
-                timeBetweenSyncAttemptsAdjustmentFactor?: number,
-                maximumAllowedDrift?: number,
-                enableBackgroundSyncAfterSegmentDownloadError?: boolean,
-                defaultTimingSource?: {
-                    scheme?: string,
-                    value?: string
-                }
+        },
+        gaps?: {
+            jumpGaps?: boolean,
+            jumpLargeGaps?: boolean,
+            smallGapLimit?: number,
+            threshold?: number,
+            enableSeekFix?: boolean,
+            enableStallFix?: boolean,
+            stallSeek?: number
+        },
+        utcSynchronization?: {
+            enabled?: boolean,
+            useManifestDateHeaderTimeSource?: boolean,
+            backgroundAttempts?: number,
+            timeBetweenSyncAttempts?: number,
+            maximumTimeBetweenSyncAttempts?: number,
+            minimumTimeBetweenSyncAttempts?: number,
+            timeBetweenSyncAttemptsAdjustmentFactor?: number,
+            maximumAllowedDrift?: number,
+            enableBackgroundSyncAfterSegmentDownloadError?: boolean,
+            defaultTimingSource?: {
+                scheme?: string,
+                value?: string
+            }
+        },
+        scheduling?: {
+            defaultTimeout?: number,
+            lowLatencyTimeout?: number,
+            scheduleWhilePaused?: boolean
+        },
+        text?: {
+            defaultEnabled?: boolean,
+            dispatchForManualRendering?: boolean,
+            extendSegmentedCues?: boolean,
+            imsc?: {
+                displayForcedOnlyMode?: boolean,
+                enableRollUp?: boolean
             },
-            scheduling?: {
-                defaultTimeout?: number,
-                lowLatencyTimeout?: number,
-                scheduleWhilePaused?: boolean
+            webvtt?: {
+                customRenderingEnabled?: number
+            }
+        },
+        liveCatchup?: {
+            maxDrift?: number;
+            playbackRate?: {
+                min?: number,
+                max?: number
             },
-            text?: {
-                defaultEnabled?: boolean,
-                dispatchForManualRendering?: boolean,
-                extendSegmentedCues?: boolean,
-                imsc?: {
-                    displayForcedOnlyMode?: boolean,
-                    enableRollUp?: boolean
+            playbackBufferMin?: number,
+            enabled?: boolean
+            mode?: string
+        }
+        lastBitrateCachingInfo?: {
+            enabled?: boolean;
+            ttl?: number;
+        };
+        lastMediaSettingsCachingInfo?: {
+            enabled?: boolean;
+            ttl?: number;
+        };
+        saveLastMediaSettingsForCurrentStreamingSession?: boolean;
+        cacheLoadThresholds?: {
+            video?: number;
+            audio?: number;
+        };
+        trackSwitchMode?: {
+            video?: TrackSwitchMode;
+            audio?: TrackSwitchMode;
+        };
+        includePreselectionsInMediainfo?: boolean;
+        includePreselectionsForInitialTrackSelection?: boolean;
+        ignoreSelectionPriority?: boolean;
+        prioritizeRoleMain?: boolean;
+        assumeDefaultRoleAsMain?: boolean;
+        selectionModeForInitialTrack?: TrackSelectionMode;
+        fragmentRequestTimeout?: number;
+        fragmentRequestProgressTimeout?: number;
+        manifestRequestTimeout?: number;
+        retryIntervals?: {
+            'MPD'?: number;
+            'XLinkExpansion'?: number;
+            'MediaSegment'?: number;
+            'InitializationSegment'?: number;
+            'BitstreamSwitchingSegment'?: number;
+            'IndexSegment'?: number;
+            'FragmentInfoSegment'?: number;
+            'license'?: number;
+            'other'?: number;
+            'lowLatencyReductionFactor'?: number;
+        };
+        retryAttempts?: {
+            'MPD'?: number;
+            'XLinkExpansion'?: number;
+            'MediaSegment'?: number;
+            'InitializationSegment'?: number;
+            'BitstreamSwitchingSegment'?: number;
+            'IndexSegment'?: number;
+            'FragmentInfoSegment'?: number;
+            'license'?: number;
+            'other'?: number;
+            'lowLatencyMultiplyFactor'?: number;
+        };
+        abr?: {
+            limitBitrateByPortal?: boolean;
+            usePixelRatioInLimitBitrateByPortal?: boolean;
+            enableSupplementalPropertyAdaptationSetSwitching?: boolean,
+            rules?: {
+                throughputRule?: {
+                    active?: boolean
                 },
-                webvtt?: {
-                    customRenderingEnabled?: number
-                }
-            },
-            liveCatchup?: {
-                maxDrift?: number;
-                playbackRate?: {
-                    min?: number,
-                    max?: number
+                bolaRule?: {
+                    active?: boolean
                 },
-                playbackBufferMin?: number,
-                enabled?: boolean
-                mode?: string
-            }
-            lastBitrateCachingInfo?: {
-                enabled?: boolean;
-                ttl?: number;
-            };
-            lastMediaSettingsCachingInfo?: {
-                enabled?: boolean;
-                ttl?: number;
-            };
-            saveLastMediaSettingsForCurrentStreamingSession?: boolean;
-            cacheLoadThresholds?: {
-                video?: number;
-                audio?: number;
-            };
-            trackSwitchMode?: {
-                video?: TrackSwitchMode;
-                audio?: TrackSwitchMode;
-            };
-            includePreselectionsInMediainfo?: boolean;
-            includePreselectionsForInitialTrackSelection?: boolean;
-            ignoreSelectionPriority?: boolean;
-            prioritizeRoleMain?: boolean;
-            assumeDefaultRoleAsMain?: boolean;
-            selectionModeForInitialTrack?: TrackSelectionMode;
-            fragmentRequestTimeout?: number;
-            fragmentRequestProgressTimeout?: number;
-            manifestRequestTimeout?: number;
-            retryIntervals?: {
-                'MPD'?: number;
-                'XLinkExpansion'?: number;
-                'MediaSegment'?: number;
-                'InitializationSegment'?: number;
-                'BitstreamSwitchingSegment'?: number;
-                'IndexSegment'?: number;
-                'FragmentInfoSegment'?: number;
-                'license'?: number;
-                'other'?: number;
-                'lowLatencyReductionFactor'?: number;
-            };
-            retryAttempts?: {
-                'MPD'?: number;
-                'XLinkExpansion'?: number;
-                'MediaSegment'?: number;
-                'InitializationSegment'?: number;
-                'BitstreamSwitchingSegment'?: number;
-                'IndexSegment'?: number;
-                'FragmentInfoSegment'?: number;
-                'license'?: number;
-                'other'?: number;
-                'lowLatencyMultiplyFactor'?: number;
-            };
-            abr?: {
-                limitBitrateByPortal?: boolean;
-                usePixelRatioInLimitBitrateByPortal?: boolean;
-                enableSupplementalPropertyAdaptationSetSwitching?: boolean,
-                rules?: {
-                    throughputRule?: {
-                        active?: boolean
-                    },
-                    bolaRule?: {
-                        active?: boolean
-                    },
-                    insufficientBufferRule?: {
-                        active?: boolean,
-                        parameters?: {
-                            throughputSafetyFactor?: number,
-                            segmentIgnoreCount?: number
-                        }
-                    },
-                    switchHistoryRule?: {
-                        active?: boolean,
-                        parameters?: {
-                            sampleSize?: number,
-                            switchPercentageThreshold?: number
-                        }
-                    },
-                    droppedFramesRule?: {
-                        active?: boolean,
-                        parameters?: {
-                            minimumSampleSize?: number,
-                            droppedFramesPercentageThreshold?: number
-                        }
-                    },
-                    abandonRequestsRule?: {
-                        active?: boolean,
-                        parameters?: {
-                            abandonDurationMultiplier?: number,
-                            minSegmentDownloadTimeThresholdInMs?: number,
-                            minThroughputSamplesThreshold?: number
-                        }
+                insufficientBufferRule?: {
+                    active?: boolean,
+                    parameters?: {
+                        throughputSafetyFactor?: number,
+                        segmentIgnoreCount?: number
                     }
-                    l2ARule?: {
-                        active?: boolean
+                },
+                switchHistoryRule?: {
+                    active?: boolean,
+                    parameters?: {
+                        sampleSize?: number,
+                        switchPercentageThreshold?: number
                     }
-                    loLPRule?: {
-                        active?: boolean
+                },
+                droppedFramesRule?: {
+                    active?: boolean,
+                    parameters?: {
+                        minimumSampleSize?: number,
+                        droppedFramesPercentageThreshold?: number
                     }
                 },
-                throughput?: {
-                    averageCalculationMode?: ThroughputCalculationModes,
-                    lowLatencyDownloadTimeCalculationMode?: LowLatencyDownloadTimeCalculationModes,
-                    useResourceTimingApi?: boolean,
-                    useNetworkInformationApi?: {
-                        xhr?: boolean,
-                        fetch?: boolean
-                    },
-                    useDeadTimeLatency?: boolean,
-                    bandwidthSafetyFactor?: number,
-                    sampleSettings: {
-                        live?: number,
-                        vod?: number,
-                        enableSampleSizeAdjustment?: boolean,
-                        decreaseScale?: number,
-                        increaseScale?: number,
-                        maxMeasurementsToKeep?: number,
-                        averageLatencySampleAmount?: number,
-                    },
-                    ewma: {
-                        throughputSlowHalfLifeSeconds?: number,
-                        throughputFastHalfLifeSeconds?: number,
-                        latencySlowHalfLifeCount?: number,
-                        latencyFastHalfLifeCount?: number,
-                        weightDownloadTmeMultiplicationFactor?: number
+                abandonRequestsRule?: {
+                    active?: boolean,
+                    parameters?: {
+                        abandonDurationMultiplier?: number,
+                        minSegmentDownloadTimeThresholdInMs?: number,
+                        minThroughputSamplesThreshold?: number
                     }
                 }
-                maxBitrate?: {
-                    audio?: number;
-                    video?: number;
-                };
-                minBitrate?: {
-                    audio?: number;
-                    video?: number;
-                };
-                initialBitrate?: {
-                    audio?: number;
-                    video?: number;
-                };
-                autoSwitchBitrate?: {
-                    audio?: boolean;
-                    video?: boolean;
+                l2ARule?: {
+                    active?: boolean
                 }
-            },
-            cmcd?: {
-                applyParametersFromMpd?: boolean,
-                enabled?: boolean,
-                sid?: string | null,
-                cid?: string | null,
-                rtp?: number | null,
-                rtpSafetyFactor?: number,
-                mode?: 'query' | 'header',
-                enabledKeys?: Array<string>,
-                includeInRequests?: Array<string>,
-                version?: number
-            },
-            cmsd?: {
-                enabled?: boolean,
-                abr?: {
-                    applyMb: boolean,
-                    etpWeightRatio?: number
+                loLPRule?: {
+                    active?: boolean
                 }
             },
-            defaultSchemeIdUri?: {
-                viewpoint?: string,
-                audioChannelConfiguration?: string,
-                role?: string,
-                accessibility?: string
+            throughput?: {
+                averageCalculationMode?: ThroughputCalculationModes,
+                lowLatencyDownloadTimeCalculationMode?: LowLatencyDownloadTimeCalculationModes,
+                useResourceTimingApi?: boolean,
+                useNetworkInformationApi?: {
+                    xhr?: boolean,
+                    fetch?: boolean
+                },
+                useDeadTimeLatency?: boolean,
+                bandwidthSafetyFactor?: number,
+                sampleSettings: {
+                    live?: number,
+                    vod?: number,
+                    enableSampleSizeAdjustment?: boolean,
+                    decreaseScale?: number,
+                    increaseScale?: number,
+                    maxMeasurementsToKeep?: number,
+                    averageLatencySampleAmount?: number,
+                },
+                ewma: {
+                    throughputSlowHalfLifeSeconds?: number,
+                    throughputFastHalfLifeSeconds?: number,
+                    latencySlowHalfLifeCount?: number,
+                    latencyFastHalfLifeCount?: number,
+                    weightDownloadTmeMultiplicationFactor?: number
+                }
             }
-        };
-        errors?: {
-            recoverAttempts?: {
-                mediaErrorDecode?: number
+            maxBitrate?: {
+                audio?: number;
+                video?: number;
+            };
+            minBitrate?: {
+                audio?: number;
+                video?: number;
+            };
+            initialBitrate?: {
+                audio?: number;
+                video?: number;
+            };
+            autoSwitchBitrate?: {
+                audio?: boolean;
+                video?: boolean;
+            }
+        },
+        cmcd?: {
+            applyParametersFromMpd?: boolean,
+            enabled?: boolean,
+            sid?: string | null,
+            cid?: string | null,
+            rtp?: number | null,
+            rtpSafetyFactor?: number,
+            mode?: 'query' | 'header',
+            enabledKeys?: Array<string>,
+            includeInRequests?: Array<string>,
+            version?: number
+        },
+        cmsd?: {
+            enabled?: boolean,
+            abr?: {
+                applyMb: boolean,
+                etpWeightRatio?: number
             }
+        },
+        defaultSchemeIdUri?: {
+            viewpoint?: string,
+            audioChannelConfiguration?: string,
+            role?: string,
+            accessibility?: string
+        }
+    };
+    errors?: {
+        recoverAttempts?: {
+            mediaErrorDecode?: number
         }
     }
+}
 
-    export interface MediaFinishedInformation {
-        mediaTimeOfLastSignaledSegment: number
-        numberOfSegments: number,
-    }
+export interface MediaFinishedInformation {
+    mediaTimeOfLastSignaledSegment: number
+    numberOfSegments: number,
+}
 
-    export type TrackSelectionFunction = (tracks: MediaInfo[]) => MediaInfo[];
+export type TrackSelectionFunction = (tracks: MediaInfo[]) => MediaInfo[];
 
-    export interface DvrWindow {
-        end: number;
-        endAsUtc: number;
-        size: number;
-        start: number;
-        startAsUtc: number;
-    }
+export interface DvrWindow {
+    end: number;
+    endAsUtc: number;
+    size: number;
+    start: number;
+    startAsUtc: number;
+}
 
-    export interface MediaPlayerClass {
-        setConfig(config: object): void;
+export interface MediaPlayerClass {
+    setConfig(config: object): void;
 
-        initialize(view?: HTMLMediaElement, source?: string, AutoPlay?: boolean, startTime?: number | string): void;
+    initialize(view?: HTMLMediaElement, source?: string, AutoPlay?: boolean, startTime?: number | string): void;
 
-        on(type: AstInFutureEvent['type'], listener: (e: AstInFutureEvent) => void, scope?: object): void;
+    on(type: AstInFutureEvent['type'], listener: (e: AstInFutureEvent) => void, scope?: object): void;
 
-        on(type: BufferEvent['type'], listener: (e: BufferEvent) => void, scope?: object): void;
+    on(type: BufferEvent['type'], listener: (e: BufferEvent) => void, scope?: object): void;
 
-        on(type: CaptionRenderedEvent['type'], listener: (e: CaptionRenderedEvent) => void, scope?: object): void;
+    on(type: CaptionRenderedEvent['type'], listener: (e: CaptionRenderedEvent) => void, scope?: object): void;
 
-        on(type: CaptionContainerResizeEvent['type'], listener: (e: CaptionContainerResizeEvent) => void, scope?: object): void;
+    on(type: CaptionContainerResizeEvent['type'], listener: (e: CaptionContainerResizeEvent) => void, scope?: object): void;
 
-        on(type: DynamicToStaticEvent['type'], listener: (e: DynamicToStaticEvent) => void, scope?: object): void;
+    on(type: DynamicToStaticEvent['type'], listener: (e: DynamicToStaticEvent) => void, scope?: object): void;
 
-        on(type: ErrorEvent['type'], listener: (e: ErrorEvent) => void, scope?: object): void;
+    on(type: ErrorEvent['type'], listener: (e: ErrorEvent) => void, scope?: object): void;
 
-        on(type: FragmentLoadingCompletedEvent['type'], listener: (e: FragmentLoadingCompletedEvent) => void, scope?: object): void;
+    on(type: FragmentLoadingCompletedEvent['type'], listener: (e: FragmentLoadingCompletedEvent) => void, scope?: object): void;
 
-        on(type: FragmentLoadingAbandonedEvent['type'], listener: (e: FragmentLoadingAbandonedEvent) => void, scope?: object): void;
+    on(type: FragmentLoadingAbandonedEvent['type'], listener: (e: FragmentLoadingAbandonedEvent) => void, scope?: object): void;
 
-        on(type: InbandPrftReceivedEvent['type'], listener: (e: InbandPrftReceivedEvent) => void, scope?: object): void;
+    on(type: InbandPrftReceivedEvent['type'], listener: (e: InbandPrftReceivedEvent) => void, scope?: object): void;
 
-        on(type: KeyErrorEvent['type'], listener: (e: KeyErrorEvent) => void, scope?: object): void;
+    on(type: KeyErrorEvent['type'], listener: (e: KeyErrorEvent) => void, scope?: object): void;
 
-        on(type: KeyMessageEvent['type'], listener: (e: KeyMessageEvent) => void, scope?: object): void;
+    on(type: KeyMessageEvent['type'], listener: (e: KeyMessageEvent) => void, scope?: object): void;
 
-        on(type: KeySessionClosedEvent['type'], listener: (e: KeySessionClosedEvent) => void, scope?: object): void;
+    on(type: KeySessionClosedEvent['type'], listener: (e: KeySessionClosedEvent) => void, scope?: object): void;
 
-        on(type: KeySessionEvent['type'], listener: (e: KeySessionEvent) => void, scope?: object): void;
+    on(type: KeySessionEvent['type'], listener: (e: KeySessionEvent) => void, scope?: object): void;
 
-        on(type: KeyStatusesChangedEvent['type'], listener: (e: KeyStatusesChangedEvent) => void, scope?: object): void;
+    on(type: KeyStatusesChangedEvent['type'], listener: (e: KeyStatusesChangedEvent) => void, scope?: object): void;
 
-        on(type: KeySystemSelectedEvent['type'], listener: (e: KeySystemSelectedEvent) => void, scope?: object): void;
+    on(type: KeySystemSelectedEvent['type'], listener: (e: KeySystemSelectedEvent) => void, scope?: object): void;
 
-        on(type: LicenseRequestCompleteEvent['type'], listener: (e: LicenseRequestCompleteEvent) => void, scope?: object): void;
+    on(type: LicenseRequestCompleteEvent['type'], listener: (e: LicenseRequestCompleteEvent) => void, scope?: object): void;
 
-        on(type: LogEvent['type'], listener: (e: LogEvent) => void, scope?: object): void;
+    on(type: LogEvent['type'], listener: (e: LogEvent) => void, scope?: object): void;
 
-        on(type: ManifestLoadedEvent['type'], listener: (e: ManifestLoadedEvent) => void, scope?: object): void;
+    on(type: ManifestLoadedEvent['type'], listener: (e: ManifestLoadedEvent) => void, scope?: object): void;
 
-        on(type: MetricEvent['type'], listener: (e: MetricEvent) => void, scope?: object): void;
+    on(type: MetricEvent['type'], listener: (e: MetricEvent) => void, scope?: object): void;
 
-        on(type: MetricChangedEvent['type'], listener: (e: MetricChangedEvent) => void, scope?: object): void;
+    on(type: MetricChangedEvent['type'], listener: (e: MetricChangedEvent) => void, scope?: object): void;
 
-        on(type: OfflineRecordEvent['type'], listener: (e: OfflineRecordEvent) => void, scope?: object): void;
+    on(type: OfflineRecordEvent['type'], listener: (e: OfflineRecordEvent) => void, scope?: object): void;
 
-        on(type: OfflineRecordLoadedmetadataEvent['type'], listener: (e: OfflineRecordLoadedmetadataEvent) => void, scope?: object): void;
+    on(type: OfflineRecordLoadedmetadataEvent['type'], listener: (e: OfflineRecordLoadedmetadataEvent) => void, scope?: object): void;
 
-        on(type: PeriodSwitchEvent['type'], listener: (e: PeriodSwitchEvent) => void, scope?: object): void;
+    on(type: PeriodSwitchEvent['type'], listener: (e: PeriodSwitchEvent) => void, scope?: object): void;
 
-        on(type: PlaybackErrorEvent['type'], listener: (e: PlaybackErrorEvent) => void, scope?: object): void;
+    on(type: PlaybackErrorEvent['type'], listener: (e: PlaybackErrorEvent) => void, scope?: object): void;
 
-        on(type: PlaybackPausedEvent['type'], listener: (e: PlaybackPausedEvent) => void, scope?: object): void;
+    on(type: PlaybackPausedEvent['type'], listener: (e: PlaybackPausedEvent) => void, scope?: object): void;
 
-        on(type: PlaybackPlayingEvent['type'], listener: (e: PlaybackPlayingEvent) => void, scope?: object): void;
+    on(type: PlaybackPlayingEvent['type'], listener: (e: PlaybackPlayingEvent) => void, scope?: object): void;
 
-        on(type: PlaybackRateChangedEvent['type'], listener: (e: PlaybackRateChangedEvent) => void, scope?: object): void;
+    on(type: PlaybackRateChangedEvent['type'], listener: (e: PlaybackRateChangedEvent) => void, scope?: object): void;
 
-        on(type: PlaybackSeekingEvent['type'], listener: (e: PlaybackSeekingEvent) => void, scope?: object): void;
+    on(type: PlaybackSeekingEvent['type'], listener: (e: PlaybackSeekingEvent) => void, scope?: object): void;
 
-        on(type: PlaybackStartedEvent['type'], listener: (e: PlaybackStartedEvent) => void, scope?: object): void;
+    on(type: PlaybackStartedEvent['type'], listener: (e: PlaybackStartedEvent) => void, scope?: object): void;
 
-        on(type: PlaybackTimeUpdatedEvent['type'], listener: (e: PlaybackTimeUpdatedEvent) => void, scope?: object): void;
+    on(type: PlaybackTimeUpdatedEvent['type'], listener: (e: PlaybackTimeUpdatedEvent) => void, scope?: object): void;
 
-        on(type: ProtectionCreatedEvent['type'], listener: (e: ProtectionCreatedEvent) => void, scope?: object): void;
+    on(type: ProtectionCreatedEvent['type'], listener: (e: ProtectionCreatedEvent) => void, scope?: object): void;
 
-        on(type: ProtectionDestroyedEvent['type'], listener: (e: ProtectionDestroyedEvent) => void, scope?: object): void;
+    on(type: ProtectionDestroyedEvent['type'], listener: (e: ProtectionDestroyedEvent) => void, scope?: object): void;
 
-        on(type: QualityChangeRenderedEvent['type'], listener: (e: QualityChangeRenderedEvent) => void, scope?: object): void;
+    on(type: QualityChangeRenderedEvent['type'], listener: (e: QualityChangeRenderedEvent) => void, scope?: object): void;
 
-        on(type: QualityChangeRequestedEvent['type'], listener: (e: QualityChangeRequestedEvent) => void, scope?: object): void;
+    on(type: QualityChangeRequestedEvent['type'], listener: (e: QualityChangeRequestedEvent) => void, scope?: object): void;
 
-        on(type: StreamInitializedEvent['type'], listener: (e: StreamInitializedEvent) => void, scope?: object): void;
+    on(type: StreamInitializedEvent['type'], listener: (e: StreamInitializedEvent) => void, scope?: object): void;
 
-        on(type: TextTracksAddedEvent['type'], listener: (e: TextTracksAddedEvent) => void, scope?: object): void;
+    on(type: TextTracksAddedEvent['type'], listener: (e: TextTracksAddedEvent) => void, scope?: object): void;
 
-        on(type: TtmlParsedEvent['type'], listener: (e: TtmlParsedEvent) => void, scope?: object): void;
+    on(type: TtmlParsedEvent['type'], listener: (e: TtmlParsedEvent) => void, scope?: object): void;
 
-        on(type: TtmlToParseEvent['type'], listener: (e: TtmlToParseEvent) => void, scope?: object): void;
+    on(type: TtmlToParseEvent['type'], listener: (e: TtmlToParseEvent) => void, scope?: object): void;
 
-        on(type: AdaptationSetRemovedNoCapabilitiesEvent['type'], listener: (e: AdaptationSetRemovedNoCapabilitiesEvent) => void, scope?: object): void;
+    on(type: AdaptationSetRemovedNoCapabilitiesEvent['type'], listener: (e: AdaptationSetRemovedNoCapabilitiesEvent) => void, scope?: object): void;
 
-        on(type: string, listener: (e: MediaPlayerEvent) => void, scope?: object, options?: object): void;
+    on(type: string, listener: (e: MediaPlayerEvent) => void, scope?: object, options?: object): void;
 
-        off(type: string, listener: (e: any) => void, scope?: object): void;
+    off(type: string, listener: (e: any) => void, scope?: object): void;
 
-        addABRCustomRule(type: string, rulename: string, rule: object): void;
+    addExternalSubtitle(externalSubtitle: ExternalSubtitle): void;
 
-        addExternalSubtitle(externalSubtitle: ExternalSubtitle): void;
+    addRequestInterceptor(interceptor: RequestInterceptor): void;
 
-        addRequestInterceptor(interceptor: RequestInterceptor): void;
+    addABRCustomRule(type: string, rulename: string, rule: object): void;
 
-        addResponseInterceptor(interceptor: ResponseInterceptor): void;
+    addRequestInterceptor(interceptor: RequestInterceptor): void;
 
-        addUTCTimingSource(schemeIdUri: string, value: string): void;
+    addResponseInterceptor(interceptor: ResponseInterceptor): void;
 
-        attachProtectionController(value: ProtectionController): void;
+    addUTCTimingSource(schemeIdUri: string, value: string): void;
 
-        attachSource(urlOrManifest: string | object, startTime?: number | string): void;
+    attachProtectionController(value: ProtectionController): void;
 
-        attachTTMLRenderingDiv(div: HTMLDivElement): void;
+    attachSource(urlOrManifest: string | object, startTime?: number | string): void;
 
-        attachView(element: HTMLMediaElement): void;
+    attachTTMLRenderingDiv(div: HTMLDivElement): void;
 
-        clearDefaultUTCTimingSources(): void;
+    attachView(element: HTMLMediaElement): void;
 
-        convertToTimeCode(value: number): string;
+    clearDefaultUTCTimingSources(): void;
 
-        destroy(): void;
+    convertToTimeCode(value: number): string;
 
-        duration(): number;
+    destroy(): void;
 
-        enableForcedTextStreaming(enable: boolean): boolean;
+    duration(): number;
 
-        enableText(enable: boolean): boolean;
+    enableForcedTextStreaming(enable: boolean): boolean;
 
-        extend(parentNameString: string, childInstance: object, override: boolean): void;
+    enableText(enable: boolean): boolean;
 
-        formatUTC(time: number, locales: string, hour12: boolean, withDate?: boolean): string;
+    extend(parentNameString: string, childInstance: object, override: boolean): void;
 
-        getABRCustomRules(): any[];
+    formatUTC(time: number, locales: string, hour12: boolean, withDate?: boolean): string;
 
-        getActiveStream(): Stream | null;
+    getABRCustomRules(): any[];
 
-        getAutoPlay(): boolean;
+    getActiveStream(): Stream | null;
 
-        getAvailableBaseUrls(): BaseURL[];
+    getAutoPlay(): boolean;
 
-        getAvailableLocations(): MpdLocation[];
+    getAvailableBaseUrls(): BaseURL[];
 
-        getAverageLatency(type: MediaType, calculationMode?: string | null, sampleSize?: number): number;
+    getAvailableLocations(): MpdLocation[];
 
-        getAverageThroughput(type: MediaType, calculationMode?: string | null, sampleSize?: number): number;
+    getAverageLatency(type: MediaType, calculationMode?: string | null, sampleSize?: number): number;
 
-        getBufferLength(type: MediaType): number;
+    getAverageThroughput(type: MediaType, calculationMode?: string | null, sampleSize?: number): number;
 
-        getCurrentLiveLatency(): number;
+    getBufferLength(type: MediaType): number;
 
-        getCurrentRepresentationForType(type: MediaType): Representation | null;
+    getCurrentLiveLatency(): number;
 
-        getCurrentSteeringResponseData(): object;
+    getCurrentRepresentationForType(type: MediaType): Representation | null;
 
-        getCurrentTextTrackIndex(): number;
+    getCurrentSteeringResponseData(): object;
 
-        getCurrentTrackFor(type: MediaType): MediaInfo | null;
+    getCurrentTextTrackIndex(): number;
 
-        getDashAdapter(): DashAdapter;
+    getCurrentTrackFor(type: MediaType): MediaInfo | null;
 
-        getDashMetrics(): DashMetrics;
+    getDashAdapter(): DashAdapter;
 
-        getDebug(): Debug;
+    getDashMetrics(): DashMetrics;
 
-        getDvrSeekOffset(value: number): number;
+    getDebug(): Debug;
 
-        getDvrWindow(): DvrWindow;
+    getDvrSeekOffset(value: number): number;
 
-        getExternalSubtitles(): ExternalSubtitle[];
+    getExternalSubtitles(): ExternalSubtitle[];
 
-        getInitialMediaSettingsFor(type: MediaType): MediaSettings;
+    getDvrWindow(): DvrWindow;
 
-        getLowLatencyModeEnabled(): boolean;
+    getInitialMediaSettingsFor(type: MediaType): MediaSettings;
 
-        getManifest(): object;
+    getLowLatencyModeEnabled(): boolean;
 
-        getOfflineController(): OfflineController;
+    getManifest(): object;
 
-        getPlaybackRate(): number;
+    getOfflineController(): OfflineController;
 
-        getProtectionController(): ProtectionController;
+    getPlaybackRate(): number;
 
-        getRawThroughputData(type: MediaType): ThroughputDictValue[];
+    getProtectionController(): ProtectionController;
 
-        getRepresentationsByType(type: MediaType, streamId?: string | null): Representation[];
+    getRawThroughputData(type: MediaType): ThroughputDictValue[];
 
-        getSafeAverageThroughput(type: MediaType, calculationMode?: string | null, sampleSize?: number): number;
+    getRepresentationsByType(type: MediaType, streamId?: string | null): Representation[];
 
-        getSettings(): MediaPlayerSettingClass;
+    getSafeAverageThroughput(type: MediaType, calculationMode?: string | null, sampleSize?: number): number;
 
-        getSource(): string | object;
+    getSettings(): MediaPlayerSettingClass;
 
-        getStreamsFromManifest(manifest: object): StreamInfo[];
+    getSource(): string | object;
 
-        getTTMLRenderingDiv(): HTMLDivElement | null;
+    getStreamsFromManifest(manifest: object): StreamInfo[];
 
-        getTargetLiveDelay(): number;
+    getTTMLRenderingDiv(): HTMLDivElement | null;
 
-        getTracksFor(type: MediaType): MediaInfo[];
+    getTargetLiveDelay(): number;
 
-        getTracksForTypeFromManifest(type: MediaType, manifest: object, streamInfo: StreamInfo): MediaInfo[];
+    getTracksFor(type: MediaType): MediaInfo[];
 
-        getVersion(): string;
+    getTracksForTypeFromManifest(type: MediaType, manifest: object, streamInfo: StreamInfo): MediaInfo[];
 
-        getVideoElement(): HTMLVideoElement;
+    getVersion(): string;
 
-        getVolume(): number;
+    getVideoElement(): HTMLVideoElement;
 
-        getXHRWithCredentialsForType(type: string): boolean;
+    getVolume(): number;
 
-        initialize(view: HTMLVideoElement, source: string, autoPlay: boolean, startTime: number | string): void;
+    getXHRWithCredentialsForType(type: string): boolean;
 
-        isDynamic(): boolean;
+    initialize(view: HTMLVideoElement, source: string, autoPlay: boolean, startTime: number | string): void;
 
-        isMuted(): boolean;
+    isDynamic(): boolean;
 
-        isPaused(): boolean;
+    isMuted(): boolean;
 
-        isReady(): boolean;
+    isPaused(): boolean;
 
-        isSeeking(): boolean;
+    isReady(): boolean;
 
-        isTextEnabled(): boolean;
+    isSeeking(): boolean;
 
-        off(type: string, listener: (e: any) => void, scope?: object): void;
+    isTextEnabled(): boolean;
 
-        on(type: string, listener: (e: any) => void, scope?: object, options?: object): void;
+    off(type: string, listener: (e: any) => void, scope?: object): void;
 
-        pause(): void;
+    on(type: string, listener: (e: any) => void, scope?: object, options?: object): void;
 
-        play(): void;
+    pause(): void;
 
-        preload(): void;
+    play(): void;
 
-        provideThumbnail(time: number, callback: (thumbnail: Thumbnail | null) => void): void;
+    preload(): void;
 
-        refreshManifest(callback: (manifest: object | null, error: unknown) => void): void;
+    provideThumbnail(time: number, callback: (thumbnail: Thumbnail | null) => void): void;
 
-        registerCustomCapabilitiesFilter(filter: CapabilitiesFilterFunction): void;
+    refreshManifest(callback: (manifest: object | null, error: unknown) => void): void;
 
-        registerLicenseRequestFilter(filter: RequestFilter): void;
+    registerCustomCapabilitiesFilter(filter: CapabilitiesFilterFunction): void;
 
-        registerLicenseResponseFilter(filter: ResponseFilter): void;
+    registerLicenseRequestFilter(filter: RequestFilter): void;
 
-        removeABRCustomRule(rulename: string): void;
+    registerLicenseResponseFilter(filter: ResponseFilter): void;
 
-        removeAllABRCustomRule(): void;
+    removeABRCustomRule(rulename: string): void;
 
-        removeExternalSubtitleById(id: string): void;
+    removeExternalSubtitleById(id: string): void;
 
-        removeExternalSubtitleByUrl(url:string): void;
+    removeExternalSubtitleByUrl(url: string): void;
 
-        removeRequestInterceptor(interceptor: RequestInterceptor): void;
+    removeAllABRCustomRule(): void;
 
-        removeResponseInterceptor(interceptor: ResponseInterceptor): void;
+    removeRequestInterceptor(interceptor: RequestInterceptor): void;
 
-        removeUTCTimingSource(schemeIdUri: string, value: string): void;
+    removeResponseInterceptor(interceptor: ResponseInterceptor): void;
 
-        reset(): void;
+    removeUTCTimingSource(schemeIdUri: string, value: string): void;
 
-        resetCustomInitialTrackSelectionFunction(fn: TrackSelectionFunction): void;
+    reset(): void;
 
-        resetSettings(): void;
+    resetCustomInitialTrackSelectionFunction(fn: TrackSelectionFunction): void;
 
-        restoreDefaultUTCTimingSources(): void;
+    resetSettings(): void;
 
-        retrieveManifest(url: string, callback: (manifest: object | null, error: any) => void): void;
+    restoreDefaultUTCTimingSources(): void;
 
-        seek(value: number): void;
+    retrieveManifest(url: string, callback: (manifest: object | null, error: any) => void): void;
 
-        seekToOriginalLive(): void;
+    seek(value: number): void;
 
-        seekToPresentationTime(value: number): void;
+    seekToOriginalLive(): void;
 
-        setAutoPlay(value: boolean): void;
+    seekToPresentationTime(value: number): void;
 
-        setConfig(config: object): void;
+    setAutoPlay(value: boolean): void;
 
-        setCurrentTrack(track: MediaInfo, noSettingsSave?: boolean): void;
+    setConfig(config: object): void;
 
-        setCustomInitialTrackSelectionFunction(fn: TrackSelectionFunction): void;
+    setCurrentTrack(track: MediaInfo, noSettingsSave?: boolean): void;
 
-        setInitialMediaSettingsFor(type: MediaType, value: MediaSettings): void;
+    setCustomInitialTrackSelectionFunction(fn: TrackSelectionFunction): void;
 
-        setMute(value: boolean): void;
+    setInitialMediaSettingsFor(type: MediaType, value: MediaSettings): void;
 
-        setPlaybackRate(value: number): void;
+    setMute(value: boolean): void;
 
-        setProtectionData(value: ProtectionDataSet): void;
+    setPlaybackRate(value: number): void;
 
-        setRepresentationForTypeById(type: MediaType, id: string, forceReplace?: boolean): void;
+    setProtectionData(value: ProtectionDataSet): void;
 
-        setRepresentationForTypeByIndex(type: MediaType, index: number, forceReplace?: boolean): void;
+    setRepresentationForTypeById(type: MediaType, id: string, forceReplace?: boolean): void;
 
-        setTextTrack(idx: number): void;
+    setRepresentationForTypeByIndex(type: MediaType, index: number, forceReplace?: boolean): void;
 
-        setVolume(value: number): void;
+    setTextTrack(idx: number): void;
 
-        setXHRWithCredentialsForType(type: string, value: boolean): void;
+    setVolume(value: number): void;
 
-        time(periodId?: string): number;
+    setXHRWithCredentialsForType(type: string, value: boolean): void;
 
-        timeAsUTC(): number;
+    time(periodId?: string): number;
 
-        timeInDvrWindow(): number;
+    timeAsUTC(): number;
 
-        trigger(type: MediaPlayerEvent, payload: object, filters: object): void;
+    timeInDvrWindow(): number;
 
-        triggerSteeringRequest(): Promise<any>;
+    trigger(type: MediaPlayerEvent, payload: object, filters: object): void;
 
-        unregisterCustomCapabilitiesFilter(filter: CapabilitiesFilterFunction): void;
+    triggerSteeringRequest(): Promise<any>;
 
-        unregisterLicenseRequestFilter(filter: RequestFilter): void;
+    unregisterCustomCapabilitiesFilter(filter: CapabilitiesFilterFunction): void;
 
-        unregisterLicenseResponseFilter(filter: ResponseFilter): void;
+    unregisterLicenseRequestFilter(filter: RequestFilter): void;
 
-        updateSettings(settings: MediaPlayerSettingClass): void;
+    unregisterLicenseResponseFilter(filter: ResponseFilter): void;
 
-        updateSource(urlOrManifest: string | object): void;
+    updateSettings(settings: MediaPlayerSettingClass): void;
 
-    }
+    updateSource(urlOrManifest: string | object): void;
 
-    interface MediaPlayerErrors {
-        APPEND_ERROR_CODE: 20;
-        CAPABILITY_MEDIAKEYS_ERROR_CODE: 24;
-        CAPABILITY_MEDIASOURCE_ERROR_CODE: 23;
-        DATA_UPDATE_FAILED_ERROR_CODE: 22;
-        DOWNLOAD_ERROR_ID_CONTENT_CODE: 27;
-        DOWNLOAD_ERROR_ID_INITIALIZATION_CODE: 28;
-        DOWNLOAD_ERROR_ID_MANIFEST_CODE: 25;
-        DOWNLOAD_ERROR_ID_SIDX_CODE: 26;
-        DOWNLOAD_ERROR_ID_XLINK_CODE: 29;
-        FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE: 17;
-        FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE: 18;
-        INDEXEDDB_ABORT_ERROR: 11012;
-        INDEXEDDB_DATA_ERROR: 11006;
-        INDEXEDDB_INVALID_STATE_ERROR: 11002;
-        INDEXEDDB_NETWORK_ERROR: 11005;
-        INDEXEDDB_NOT_ALLOWED_ERROR: 11008;
-        INDEXEDDB_NOT_FOUND_ERROR: 11004;
-        INDEXEDDB_NOT_READABLE_ERROR: 11003;
-        INDEXEDDB_NOT_SUPPORTED_ERROR: 11009;
-        INDEXEDDB_QUOTA_EXCEED_ERROR: 11001;
-        INDEXEDDB_TIMEOUT_ERROR: 11011;
-        INDEXEDDB_TRANSACTION_INACTIVE_ERROR: 11007;
-        INDEXEDDB_UNKNOWN_ERROR: 11013;
-        INDEXEDDB_VERSION_ERROR: 11010;
-        KEY_SESSION_CREATED_ERROR_CODE: 113;
-        KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE: 110;
-        KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE: 112;
-        MANIFEST_ERROR_ID_MULTIPLEXED_CODE: 34;
-        MANIFEST_ERROR_ID_NOSTREAMS_CODE: 32;
-        MANIFEST_ERROR_ID_PARSE_CODE: 31;
-        MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE: 11;
-        MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE: 10;
-        MEDIASOURCE_TYPE_UNSUPPORTED_CODE: 35;
-        MEDIA_KEYERR_CLIENT_CODE: 102;
-        MEDIA_KEYERR_CODE: 100;
-        MEDIA_KEYERR_DOMAIN_CODE: 106;
-        MEDIA_KEYERR_HARDWARECHANGE_CODE: 105;
-        MEDIA_KEYERR_OUTPUT_CODE: 104;
-        MEDIA_KEYERR_SERVICE_CODE: 103;
-        MEDIA_KEYERR_UNKNOWN_CODE: 101;
-        MEDIA_KEY_MESSAGE_ERROR_CODE: 107;
-        MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE: 114;
-        MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE: 108;
-        MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE: 111;
-        MSS_NO_TFRF_CODE: 200;
-        MSS_UNSUPPORTED_CODEC_CODE: 201;
-        OFFLINE_ERROR: 11000;
-        REMOVE_ERROR_CODE: 21;
-        SEGMENT_BASE_LOADER_ERROR_CODE: 15;
-        SERVER_CERTIFICATE_UPDATED_ERROR_CODE: 109;
-        TIMED_TEXT_ERROR_ID_PARSE_CODE: 33;
-        TIME_SYNC_FAILED_ERROR_CODE: 16;
-        URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE: 19;
-        XLINK_LOADER_LOADING_FAILURE_ERROR_CODE: 12;
-    }
+}
 
-    interface MediaPlayerEvents {
-        AST_IN_FUTURE: 'astInFuture';
-        BASE_URLS_UPDATED: 'baseUrlsUpdated';
-        BUFFER_EMPTY: 'bufferStalled';
-        BUFFER_LOADED: 'bufferLoaded';
-        BUFFER_LEVEL_STATE_CHANGED: 'bufferStateChanged';
-        BUFFER_LEVEL_UPDATED: 'bufferLevelUpdated';
-        CAN_PLAY: 'canPlay';
-        CAN_PLAY_THROUGH: 'canPlayThrough';
-        CAPTION_RENDERED: 'captionRendered';
-        CAPTION_CONTAINER_RESIZE: 'captionContainerResize';
-        CONFORMANCE_VIOLATION: 'conformanceViolation';
-        CUE_ENTER: 'cueEnter';
-        CUE_EXIT: 'cueExit';
-        DVB_FONT_DOWNLOAD_ADDED: 'dvbFontDownloadAdded';
-        DVB_FONT_DOWNLOAD_COMPLETE: 'dvbFontDownloadComplete';
-        DVB_FONT_DOWNLOAD_FAILED: 'dvbFontDownloadFailed';
-        DYNAMIC_TO_STATIC: 'dynamicToStatic';
-        ERROR: 'error';
-        EVENT_MODE_ON_RECEIVE: 'eventModeOnReceive';
-        EVENT_MODE_ON_START: 'eventModeOnStart';
-        FRAGMENT_LOADING_COMPLETED: 'fragmentLoadingCompleted';
-        FRAGMENT_LOADING_PROGRESS: 'fragmentLoadingProgress';
-        FRAGMENT_LOADING_STARTED: 'fragmentLoadingStarted';
-        FRAGMENT_LOADING_ABANDONED: 'fragmentLoadingAbandoned';
-        INBAND_PRFT_RECEIVED: 'inbandPrft';
-        KEY_ADDED: 'public_keyAdded';
-        KEY_ERROR: 'public_keyError';
-        KEY_MESSAGE: 'public_keyMessage';
-        KEY_SESSION_CLOSED: 'public_keySessionClosed';
-        KEY_SESSION_CREATED: 'public_keySessionCreated';
-        KEY_SESSION_REMOVED: 'public_keySessionRemoved';
-        KEY_STATUSES_CHANGED: 'public_keyStatusesChanged';
-        KEY_SYSTEM_SELECTED: 'public_keySystemSelected';
-        KEY_SYSTEM_ACCESS_COMPLETE: 'public_keySystemAccessComplete';
-        KEY_SESSION_UPDATED: 'public_keySessionUpdated';
-        LICENSE_REQUEST_COMPLETE: 'public_licenseRequestComplete';
-        LICENSE_REQUEST_SENDING: 'public_licenseRequestSending';
-        LOG: 'log';
-        MANIFEST_LOADED: 'manifestLoaded';
-        MANIFEST_LOADING_STARTED: 'manifestLoadingStarted';
-        MANIFEST_LOADING_FINISHED: 'manifestLoadingFinished';
-        MANIFEST_VALIDITY_CHANGED: 'manifestValidityChanged';
-        METRICS_CHANGED: 'metricsChanged';
-        METRIC_ADDED: 'metricAdded';
-        METRIC_CHANGED: 'metricChanged';
-        METRIC_UPDATED: 'metricUpdated';
-        OFFLINE_RECORD_FINISHED: 'public_offlineRecordFinished';
-        OFFLINE_RECORD_LOADEDMETADATA: 'public_offlineRecordLoadedmetadata';
-        OFFLINE_RECORD_STARTED: 'public_offlineRecordStarted';
-        OFFLINE_RECORD_STOPPED: 'public_offlineRecordStopped';
-        PERIOD_SWITCH_STARTED: 'periodSwitchStarted';
-        PERIOD_SWITCH_COMPLETED: 'periodSwitchCompleted';
-        ADAPTATION_SET_REMOVED_NO_CAPABILITIES: 'adaptationSetRemovedNoCapabilities';
-        PLAYBACK_ENDED: 'playbackEnded';
-        PLAYBACK_ERROR: 'playbackError';
-        PLAYBACK_LOADED_DATA: 'playbackLoadedData';
-        PLAYBACK_METADATA_LOADED: 'playbackMetaDataLoaded';
-        PLAYBACK_NOT_ALLOWED: 'playbackNotAllowed';
-        PLAYBACK_PAUSED: 'playbackPaused';
-        PLAYBACK_PLAYING: 'playbackPlaying';
-        PLAYBACK_PROGRESS: 'playbackProgress';
-        PLAYBACK_RATE_CHANGED: 'playbackRateChanged';
-        PLAYBACK_SEEKED: 'playbackSeeked';
-        PLAYBACK_SEEKING: 'playbackSeeking';
-        PLAYBACK_STALLED: 'playbackStalled';
-        PLAYBACK_STARTED: 'playbackStarted';
-        PLAYBACK_TIME_UPDATED: 'playbackTimeUpdated';
-        PLAYBACK_VOLUME_CHANGED: 'playbackVolumeChanged';
-        PLAYBACK_WAITING: 'playbackWaiting';
-        PROTECTION_CREATED: 'public_protectioncreated';
-        PROTECTION_DESTROYED: 'public_protectiondestroyed';
-        REPRESENTATION_SWITCH: 'representationSwitch';
-        TRACK_CHANGE_RENDERED: 'trackChangeRendered';
-        QUALITY_CHANGE_RENDERED: 'qualityChangeRendered';
-        QUALITY_CHANGE_REQUESTED: 'qualityChangeRequested';
-        STREAM_ACTIVATED: 'streamActivated'
-        STREAM_DEACTIVATED: 'streamDeactivated';
-        STREAM_INITIALIZED: 'streamInitialized';
-        STREAM_INITIALIZING: 'streamInitializing';
-        STREAM_TEARDOWN_COMPLETE: 'streamTeardownComplete';
-        STREAM_UPDATED: 'streamUpdated';
-        TEXT_TRACKS_ADDED: 'allTextTracksAdded';
-        TEXT_TRACK_ADDED: 'textTrackAdded';
-        THROUGHPUT_MEASUREMENT_STORED: 'throughputMeasurementStored';
-        TTML_PARSED: 'ttmlParsed';
-        TTML_TO_PARSE: 'ttmlToParse';
-    }
+export interface MediaPlayerErrors {
+    APPEND_ERROR_CODE: 20;
+    CAPABILITY_MEDIAKEYS_ERROR_CODE: 24;
+    CAPABILITY_MEDIASOURCE_ERROR_CODE: 23;
+    DATA_UPDATE_FAILED_ERROR_CODE: 22;
+    DOWNLOAD_ERROR_ID_CONTENT_CODE: 27;
+    DOWNLOAD_ERROR_ID_INITIALIZATION_CODE: 28;
+    DOWNLOAD_ERROR_ID_MANIFEST_CODE: 25;
+    DOWNLOAD_ERROR_ID_SIDX_CODE: 26;
+    DOWNLOAD_ERROR_ID_XLINK_CODE: 29;
+    FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE: 17;
+    FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE: 18;
+    INDEXEDDB_ABORT_ERROR: 11012;
+    INDEXEDDB_DATA_ERROR: 11006;
+    INDEXEDDB_INVALID_STATE_ERROR: 11002;
+    INDEXEDDB_NETWORK_ERROR: 11005;
+    INDEXEDDB_NOT_ALLOWED_ERROR: 11008;
+    INDEXEDDB_NOT_FOUND_ERROR: 11004;
+    INDEXEDDB_NOT_READABLE_ERROR: 11003;
+    INDEXEDDB_NOT_SUPPORTED_ERROR: 11009;
+    INDEXEDDB_QUOTA_EXCEED_ERROR: 11001;
+    INDEXEDDB_TIMEOUT_ERROR: 11011;
+    INDEXEDDB_TRANSACTION_INACTIVE_ERROR: 11007;
+    INDEXEDDB_UNKNOWN_ERROR: 11013;
+    INDEXEDDB_VERSION_ERROR: 11010;
+    KEY_SESSION_CREATED_ERROR_CODE: 113;
+    KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE: 110;
+    KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE: 112;
+    MANIFEST_ERROR_ID_MULTIPLEXED_CODE: 34;
+    MANIFEST_ERROR_ID_NOSTREAMS_CODE: 32;
+    MANIFEST_ERROR_ID_PARSE_CODE: 31;
+    MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE: 11;
+    MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE: 10;
+    MEDIASOURCE_TYPE_UNSUPPORTED_CODE: 35;
+    MEDIA_KEYERR_CLIENT_CODE: 102;
+    MEDIA_KEYERR_CODE: 100;
+    MEDIA_KEYERR_DOMAIN_CODE: 106;
+    MEDIA_KEYERR_HARDWARECHANGE_CODE: 105;
+    MEDIA_KEYERR_OUTPUT_CODE: 104;
+    MEDIA_KEYERR_SERVICE_CODE: 103;
+    MEDIA_KEYERR_UNKNOWN_CODE: 101;
+    MEDIA_KEY_MESSAGE_ERROR_CODE: 107;
+    MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE: 114;
+    MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE: 108;
+    MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE: 111;
+    MSS_NO_TFRF_CODE: 200;
+    MSS_UNSUPPORTED_CODEC_CODE: 201;
+    OFFLINE_ERROR: 11000;
+    REMOVE_ERROR_CODE: 21;
+    SEGMENT_BASE_LOADER_ERROR_CODE: 15;
+    SERVER_CERTIFICATE_UPDATED_ERROR_CODE: 109;
+    TIMED_TEXT_ERROR_ID_PARSE_CODE: 33;
+    TIME_SYNC_FAILED_ERROR_CODE: 16;
+    URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE: 19;
+    XLINK_LOADER_LOADING_FAILURE_ERROR_CODE: 12;
+}
 
-    export interface MediaPlayerEvent {
-        type: string
-    }
+export interface MediaPlayerEvents {
+    AST_IN_FUTURE: 'astInFuture';
+    BASE_URLS_UPDATED: 'baseUrlsUpdated';
+    BUFFER_EMPTY: 'bufferStalled';
+    BUFFER_LOADED: 'bufferLoaded';
+    BUFFER_LEVEL_STATE_CHANGED: 'bufferStateChanged';
+    BUFFER_LEVEL_UPDATED: 'bufferLevelUpdated';
+    CAN_PLAY: 'canPlay';
+    CAN_PLAY_THROUGH: 'canPlayThrough';
+    CAPTION_RENDERED: 'captionRendered';
+    CAPTION_CONTAINER_RESIZE: 'captionContainerResize';
+    CONFORMANCE_VIOLATION: 'conformanceViolation';
+    CUE_ENTER: 'cueEnter';
+    CUE_EXIT: 'cueExit';
+    DVB_FONT_DOWNLOAD_ADDED: 'dvbFontDownloadAdded';
+    DVB_FONT_DOWNLOAD_COMPLETE: 'dvbFontDownloadComplete';
+    DVB_FONT_DOWNLOAD_FAILED: 'dvbFontDownloadFailed';
+    DYNAMIC_TO_STATIC: 'dynamicToStatic';
+    ERROR: 'error';
+    EVENT_MODE_ON_RECEIVE: 'eventModeOnReceive';
+    EVENT_MODE_ON_START: 'eventModeOnStart';
+    FRAGMENT_LOADING_COMPLETED: 'fragmentLoadingCompleted';
+    FRAGMENT_LOADING_PROGRESS: 'fragmentLoadingProgress';
+    FRAGMENT_LOADING_STARTED: 'fragmentLoadingStarted';
+    FRAGMENT_LOADING_ABANDONED: 'fragmentLoadingAbandoned';
+    INBAND_PRFT_RECEIVED: 'inbandPrft';
+    KEY_ADDED: 'public_keyAdded';
+    KEY_ERROR: 'public_keyError';
+    KEY_MESSAGE: 'public_keyMessage';
+    KEY_SESSION_CLOSED: 'public_keySessionClosed';
+    KEY_SESSION_CREATED: 'public_keySessionCreated';
+    KEY_SESSION_REMOVED: 'public_keySessionRemoved';
+    KEY_STATUSES_CHANGED: 'public_keyStatusesChanged';
+    KEY_SYSTEM_SELECTED: 'public_keySystemSelected';
+    KEY_SYSTEM_ACCESS_COMPLETE: 'public_keySystemAccessComplete';
+    KEY_SESSION_UPDATED: 'public_keySessionUpdated';
+    LICENSE_REQUEST_COMPLETE: 'public_licenseRequestComplete';
+    LICENSE_REQUEST_SENDING: 'public_licenseRequestSending';
+    LOG: 'log';
+    MANIFEST_LOADED: 'manifestLoaded';
+    MANIFEST_LOADING_STARTED: 'manifestLoadingStarted';
+    MANIFEST_LOADING_FINISHED: 'manifestLoadingFinished';
+    MANIFEST_VALIDITY_CHANGED: 'manifestValidityChanged';
+    METRICS_CHANGED: 'metricsChanged';
+    METRIC_ADDED: 'metricAdded';
+    METRIC_CHANGED: 'metricChanged';
+    METRIC_UPDATED: 'metricUpdated';
+    OFFLINE_RECORD_FINISHED: 'public_offlineRecordFinished';
+    OFFLINE_RECORD_LOADEDMETADATA: 'public_offlineRecordLoadedmetadata';
+    OFFLINE_RECORD_STARTED: 'public_offlineRecordStarted';
+    OFFLINE_RECORD_STOPPED: 'public_offlineRecordStopped';
+    PERIOD_SWITCH_STARTED: 'periodSwitchStarted';
+    PERIOD_SWITCH_COMPLETED: 'periodSwitchCompleted';
+    ADAPTATION_SET_REMOVED_NO_CAPABILITIES: 'adaptationSetRemovedNoCapabilities';
+    PLAYBACK_ENDED: 'playbackEnded';
+    PLAYBACK_ERROR: 'playbackError';
+    PLAYBACK_LOADED_DATA: 'playbackLoadedData';
+    PLAYBACK_METADATA_LOADED: 'playbackMetaDataLoaded';
+    PLAYBACK_NOT_ALLOWED: 'playbackNotAllowed';
+    PLAYBACK_PAUSED: 'playbackPaused';
+    PLAYBACK_PLAYING: 'playbackPlaying';
+    PLAYBACK_PROGRESS: 'playbackProgress';
+    PLAYBACK_RATE_CHANGED: 'playbackRateChanged';
+    PLAYBACK_SEEKED: 'playbackSeeked';
+    PLAYBACK_SEEKING: 'playbackSeeking';
+    PLAYBACK_STALLED: 'playbackStalled';
+    PLAYBACK_STARTED: 'playbackStarted';
+    PLAYBACK_TIME_UPDATED: 'playbackTimeUpdated';
+    PLAYBACK_VOLUME_CHANGED: 'playbackVolumeChanged';
+    PLAYBACK_WAITING: 'playbackWaiting';
+    PROTECTION_CREATED: 'public_protectioncreated';
+    PROTECTION_DESTROYED: 'public_protectiondestroyed';
+    REPRESENTATION_SWITCH: 'representationSwitch';
+    TRACK_CHANGE_RENDERED: 'trackChangeRendered';
+    QUALITY_CHANGE_RENDERED: 'qualityChangeRendered';
+    QUALITY_CHANGE_REQUESTED: 'qualityChangeRequested';
+    STREAM_ACTIVATED: 'streamActivated'
+    STREAM_DEACTIVATED: 'streamDeactivated';
+    STREAM_INITIALIZED: 'streamInitialized';
+    STREAM_INITIALIZING: 'streamInitializing';
+    STREAM_TEARDOWN_COMPLETE: 'streamTeardownComplete';
+    STREAM_UPDATED: 'streamUpdated';
+    TEXT_TRACKS_ADDED: 'allTextTracksAdded';
+    TEXT_TRACK_ADDED: 'textTrackAdded';
+    THROUGHPUT_MEASUREMENT_STORED: 'throughputMeasurementStored';
+    TTML_PARSED: 'ttmlParsed';
+    TTML_TO_PARSE: 'ttmlToParse';
+}
 
-    export interface AstInFutureEvent extends MediaPlayerEvent {
-        delay: number;
-        type: MediaPlayerEvents['AST_IN_FUTURE'];
-    }
+export interface MediaPlayerEvent {
+    type: string
+}
 
-    export interface BufferEvent extends MediaPlayerEvent {
-        mediaType: MediaType;
-        type: MediaPlayerEvents['BUFFER_EMPTY' | 'BUFFER_LOADED'];
-    }
+export interface AstInFutureEvent extends MediaPlayerEvent {
+    delay: number;
+    type: MediaPlayerEvents['AST_IN_FUTURE'];
+}
 
-    export interface BufferStateChangedEvent extends MediaPlayerEvent {
-        mediaType: MediaType;
-        sender: object;
-        state: 'bufferStalled' | 'bufferLoaded';
-        streamInfo: StreamInfo;
-        type: MediaPlayerEvents['BUFFER_LEVEL_STATE_CHANGED'];
-    }
+export interface BufferEvent extends MediaPlayerEvent {
+    mediaType: MediaType;
+    type: MediaPlayerEvents['BUFFER_EMPTY' | 'BUFFER_LOADED'];
+}
 
-    export interface GenericErrorEvent extends MediaPlayerEvent {
-        error: 'capability' | 'mediasource' | 'key_session' | 'key_message';
-        event: string;
-        type: MediaPlayerEvents['ERROR'];
-    }
+export interface BufferStateChangedEvent extends MediaPlayerEvent {
+    mediaType: MediaType;
+    sender: object;
+    state: 'bufferStalled' | 'bufferLoaded';
+    streamInfo: StreamInfo;
+    type: MediaPlayerEvents['BUFFER_LEVEL_STATE_CHANGED'];
+}
 
-    export interface DownloadErrorEvent extends MediaPlayerEvent {
-        error: 'download';
-        event: {
-            id: string;
-            url: string;
-            request: XMLHttpRequest;
-        };
-        type: MediaPlayerEvents['ERROR'];
-    }
+export interface GenericErrorEvent extends MediaPlayerEvent {
+    error: 'capability' | 'mediasource' | 'key_session' | 'key_message';
+    event: string;
+    type: MediaPlayerEvents['ERROR'];
+}
 
-    export interface ManifestErrorEvent extends MediaPlayerEvent {
-        error: 'manifestError';
-        event: {
-            id: string;
-            message: string;
-            manifest?: object;
-            event?: string;
-        };
-        type: MediaPlayerEvents['ERROR'];
-    }
+export interface DownloadErrorEvent extends MediaPlayerEvent {
+    error: 'download';
+    event: {
+        id: string;
+        url: string;
+        request: XMLHttpRequest;
+    };
+    type: MediaPlayerEvents['ERROR'];
+}
 
-    export interface TimedTextErrorEvent extends MediaPlayerEvent {
-        error: 'cc';
-        event: {
-            id: string;
-            message: string;
-            cc: string;
-        };
-        type: MediaPlayerEvents['ERROR'];
-    }
+export interface ManifestErrorEvent extends MediaPlayerEvent {
+    error: 'manifestError';
+    event: {
+        id: string;
+        message: string;
+        manifest?: object;
+        event?: string;
+    };
+    type: MediaPlayerEvents['ERROR'];
+}
 
-    export interface MediaPlayerErrorEvent extends MediaPlayerEvent {
-        error: {
-            code: MediaPlayerErrors['MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE'] |
-                MediaPlayerErrors['MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE'] |
-                MediaPlayerErrors['XLINK_LOADER_LOADING_FAILURE_ERROR_CODE'] |
-                MediaPlayerErrors['SEGMENT_BASE_LOADER_ERROR_CODE'] |
-                MediaPlayerErrors['TIME_SYNC_FAILED_ERROR_CODE'] |
-                MediaPlayerErrors['FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE'] |
-                MediaPlayerErrors['FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE'] |
-                MediaPlayerErrors['URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE'] |
-                MediaPlayerErrors['APPEND_ERROR_CODE'] |
-                MediaPlayerErrors['REMOVE_ERROR_CODE'] |
-                MediaPlayerErrors['DATA_UPDATE_FAILED_ERROR_CODE'] |
-                MediaPlayerErrors['CAPABILITY_MEDIASOURCE_ERROR_CODE'] |
-                MediaPlayerErrors['CAPABILITY_MEDIAKEYS_ERROR_CODE'] |
-                MediaPlayerErrors['DOWNLOAD_ERROR_ID_MANIFEST_CODE'] |
-                MediaPlayerErrors['DOWNLOAD_ERROR_ID_CONTENT_CODE'] |
-                MediaPlayerErrors['DOWNLOAD_ERROR_ID_INITIALIZATION_CODE'] |
-                MediaPlayerErrors['DOWNLOAD_ERROR_ID_XLINK_CODE'] |
-                MediaPlayerErrors['MANIFEST_ERROR_ID_PARSE_CODE'] |
-                MediaPlayerErrors['MANIFEST_ERROR_ID_NOSTREAMS_CODE'] |
-                MediaPlayerErrors['TIMED_TEXT_ERROR_ID_PARSE_CODE'] |
-                MediaPlayerErrors['MANIFEST_ERROR_ID_MULTIPLEXED_CODE'] |
-                MediaPlayerErrors['MEDIASOURCE_TYPE_UNSUPPORTED_CODE'] |
-                // Protection errors
-                MediaPlayerErrors['MEDIA_KEYERR_CODE'] |
-                MediaPlayerErrors['MEDIA_KEYERR_UNKNOWN_CODE'] |
-                MediaPlayerErrors['MEDIA_KEYERR_CLIENT_CODE'] |
-                MediaPlayerErrors['MEDIA_KEYERR_SERVICE_CODE'] |
-                MediaPlayerErrors['MEDIA_KEYERR_OUTPUT_CODE'] |
-                MediaPlayerErrors['MEDIA_KEYERR_HARDWARECHANGE_CODE'] |
-                MediaPlayerErrors['MEDIA_KEYERR_DOMAIN_CODE'] |
-                MediaPlayerErrors['MEDIA_KEY_MESSAGE_ERROR_CODE'] |
-                MediaPlayerErrors['MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE'] |
-                MediaPlayerErrors['SERVER_CERTIFICATE_UPDATED_ERROR_CODE'] |
-                MediaPlayerErrors['KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE'] |
-                MediaPlayerErrors['MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE'] |
-                MediaPlayerErrors['KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE'] |
-                MediaPlayerErrors['KEY_SESSION_CREATED_ERROR_CODE'] |
-                MediaPlayerErrors['MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE'] |
-                // Offline errors
-                MediaPlayerErrors['OFFLINE_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_QUOTA_EXCEED_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_INVALID_STATE_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_NOT_READABLE_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_NOT_FOUND_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_NETWORK_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_DATA_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_TRANSACTION_INACTIVE_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_NOT_ALLOWED_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_NOT_SUPPORTED_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_VERSION_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_TIMEOUT_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_ABORT_ERROR'] |
-                MediaPlayerErrors['INDEXEDDB_UNKNOWN_ERROR'] |
-                // MSS errors
-                MediaPlayerErrors['MSS_NO_TFRF_CODE'] |
-                MediaPlayerErrors['MSS_UNSUPPORTED_CODEC_CODE'],
-            message: string,
-            data: object,
-        }
-        type: MediaPlayerEvents['ERROR'];
-    }
+export interface TimedTextErrorEvent extends MediaPlayerEvent {
+    error: 'cc';
+    event: {
+        id: string;
+        message: string;
+        cc: string;
+    };
+    type: MediaPlayerEvents['ERROR'];
+}
 
-    export type ErrorEvent =
-        GenericErrorEvent
-        | DownloadErrorEvent
-        | ManifestErrorEvent
-        | TimedTextErrorEvent
-        | MediaPlayerErrorEvent;
-
-    export interface CaptionRenderedEvent extends MediaPlayerEvent {
-        captionDiv: HTMLDivElement;
-        currentTrackIdx: number;
-        type: MediaPlayerEvents['CAPTION_RENDERED'];
-    }
+export interface MediaPlayerErrorEvent extends MediaPlayerEvent {
+    error: {
+        code: MediaPlayerErrors['MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE'] |
+            MediaPlayerErrors['MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE'] |
+            MediaPlayerErrors['XLINK_LOADER_LOADING_FAILURE_ERROR_CODE'] |
+            MediaPlayerErrors['SEGMENT_BASE_LOADER_ERROR_CODE'] |
+            MediaPlayerErrors['TIME_SYNC_FAILED_ERROR_CODE'] |
+            MediaPlayerErrors['FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE'] |
+            MediaPlayerErrors['FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE'] |
+            MediaPlayerErrors['URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE'] |
+            MediaPlayerErrors['APPEND_ERROR_CODE'] |
+            MediaPlayerErrors['REMOVE_ERROR_CODE'] |
+            MediaPlayerErrors['DATA_UPDATE_FAILED_ERROR_CODE'] |
+            MediaPlayerErrors['CAPABILITY_MEDIASOURCE_ERROR_CODE'] |
+            MediaPlayerErrors['CAPABILITY_MEDIAKEYS_ERROR_CODE'] |
+            MediaPlayerErrors['DOWNLOAD_ERROR_ID_MANIFEST_CODE'] |
+            MediaPlayerErrors['DOWNLOAD_ERROR_ID_CONTENT_CODE'] |
+            MediaPlayerErrors['DOWNLOAD_ERROR_ID_INITIALIZATION_CODE'] |
+            MediaPlayerErrors['DOWNLOAD_ERROR_ID_XLINK_CODE'] |
+            MediaPlayerErrors['MANIFEST_ERROR_ID_PARSE_CODE'] |
+            MediaPlayerErrors['MANIFEST_ERROR_ID_NOSTREAMS_CODE'] |
+            MediaPlayerErrors['TIMED_TEXT_ERROR_ID_PARSE_CODE'] |
+            MediaPlayerErrors['MANIFEST_ERROR_ID_MULTIPLEXED_CODE'] |
+            MediaPlayerErrors['MEDIASOURCE_TYPE_UNSUPPORTED_CODE'] |
+            // Protection errors
+            MediaPlayerErrors['MEDIA_KEYERR_CODE'] |
+            MediaPlayerErrors['MEDIA_KEYERR_UNKNOWN_CODE'] |
+            MediaPlayerErrors['MEDIA_KEYERR_CLIENT_CODE'] |
+            MediaPlayerErrors['MEDIA_KEYERR_SERVICE_CODE'] |
+            MediaPlayerErrors['MEDIA_KEYERR_OUTPUT_CODE'] |
+            MediaPlayerErrors['MEDIA_KEYERR_HARDWARECHANGE_CODE'] |
+            MediaPlayerErrors['MEDIA_KEYERR_DOMAIN_CODE'] |
+            MediaPlayerErrors['MEDIA_KEY_MESSAGE_ERROR_CODE'] |
+            MediaPlayerErrors['MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE'] |
+            MediaPlayerErrors['SERVER_CERTIFICATE_UPDATED_ERROR_CODE'] |
+            MediaPlayerErrors['KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE'] |
+            MediaPlayerErrors['MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE'] |
+            MediaPlayerErrors['KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE'] |
+            MediaPlayerErrors['KEY_SESSION_CREATED_ERROR_CODE'] |
+            MediaPlayerErrors['MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE'] |
+            // Offline errors
+            MediaPlayerErrors['OFFLINE_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_QUOTA_EXCEED_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_INVALID_STATE_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_NOT_READABLE_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_NOT_FOUND_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_NETWORK_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_DATA_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_TRANSACTION_INACTIVE_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_NOT_ALLOWED_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_NOT_SUPPORTED_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_VERSION_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_TIMEOUT_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_ABORT_ERROR'] |
+            MediaPlayerErrors['INDEXEDDB_UNKNOWN_ERROR'] |
+            // MSS errors
+            MediaPlayerErrors['MSS_NO_TFRF_CODE'] |
+            MediaPlayerErrors['MSS_UNSUPPORTED_CODEC_CODE'],
+        message: string,
+        data: object,
+    }
+    type: MediaPlayerEvents['ERROR'];
+}
 
-    export interface CaptionContainerResizeEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['CAPTION_CONTAINER_RESIZE'];
-    }
+export type ErrorEvent =
+    GenericErrorEvent
+    | DownloadErrorEvent
+    | ManifestErrorEvent
+    | TimedTextErrorEvent
+    | MediaPlayerErrorEvent;
+
+export interface CaptionRenderedEvent extends MediaPlayerEvent {
+    captionDiv: HTMLDivElement;
+    currentTrackIdx: number;
+    type: MediaPlayerEvents['CAPTION_RENDERED'];
+}
 
-    export interface dvbFontDownloadAdded extends MediaPlayerEvent {
-        font: FontInfo;
-        type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_ADDED'];
-    }
+export interface CaptionContainerResizeEvent extends MediaPlayerEvent {
+    type: MediaPlayerEvents['CAPTION_CONTAINER_RESIZE'];
+}
 
-    export interface dvbFontDownloadComplete extends MediaPlayerEvent {
-        font: FontInfo;
-        type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_COMPLETE'];
-    }
+export interface dvbFontDownloadAdded extends MediaPlayerEvent {
+    font: FontInfo;
+    type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_ADDED'];
+}
 
-    export interface dvbFontDownloadFailed extends MediaPlayerEvent {
-        font: FontInfo;
-        type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_FAILED'];
-    }
+export interface dvbFontDownloadComplete extends MediaPlayerEvent {
+    font: FontInfo;
+    type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_COMPLETE'];
+}
 
-    export interface DynamicToStaticEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['DYNAMIC_TO_STATIC'];
-    }
+export interface dvbFontDownloadFailed extends MediaPlayerEvent {
+    font: FontInfo;
+    type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_FAILED'];
+}
 
-    export interface FragmentLoadingCompletedEvent extends MediaPlayerEvent {
-        request: FragmentRequest;
-        response: ArrayBuffer;
-        sender: object;
-        type: MediaPlayerEvents['FRAGMENT_LOADING_COMPLETED'];
-    }
+export interface DynamicToStaticEvent extends MediaPlayerEvent {
+    type: MediaPlayerEvents['DYNAMIC_TO_STATIC'];
+}
 
-    export interface FragmentLoadingAbandonedEvent extends MediaPlayerEvent {
-        mediaType: MediaType;
-        request: object;
-        streamProcessor: object;
-        type: MediaPlayerEvents['FRAGMENT_LOADING_ABANDONED'];
-    }
+export interface FragmentLoadingCompletedEvent extends MediaPlayerEvent {
+    request: FragmentRequest;
+    response: ArrayBuffer;
+    sender: object;
+    type: MediaPlayerEvents['FRAGMENT_LOADING_COMPLETED'];
+}
 
-    export interface InbandPrftReceivedEvent extends MediaPlayerEvent {
-        data: object
-        mediaType: MediaType;
-        streamInfo: StreamInfo;
-        type: MediaPlayerEvents['INBAND_PRFT_RECEIVED'];
-    }
+export interface FragmentLoadingAbandonedEvent extends MediaPlayerEvent {
+    mediaType: MediaType;
+    request: object;
+    streamProcessor: object;
+    type: MediaPlayerEvents['FRAGMENT_LOADING_ABANDONED'];
+}
 
-    export interface KeyErrorEvent extends MediaPlayerEvent {
-        error: DashJSError;
-        type: MediaPlayerEvents['KEY_ERROR'];
-    }
+export interface InbandPrftReceivedEvent extends MediaPlayerEvent {
+    data: object
+    mediaType: MediaType;
+    streamInfo: StreamInfo;
+    type: MediaPlayerEvents['INBAND_PRFT_RECEIVED'];
+}
 
-    export interface KeyMessageEvent extends MediaPlayerEvent {
-        data: KeyMessage;
-        type: MediaPlayerEvents['KEY_MESSAGE'];
-    }
+export interface KeyErrorEvent extends MediaPlayerEvent {
+    error: DashJSError;
+    type: MediaPlayerEvents['KEY_ERROR'];
+}
 
-    export interface KeySessionClosedEvent extends MediaPlayerEvent {
-        data: string | null;
-        error?: string;
-        type: MediaPlayerEvents['KEY_SESSION_CLOSED' | 'KEY_SESSION_REMOVED'];
-    }
+export interface KeyMessageEvent extends MediaPlayerEvent {
+    data: KeyMessage;
+    type: MediaPlayerEvents['KEY_MESSAGE'];
+}
 
-    export interface KeySessionEvent extends MediaPlayerEvent {
-        data: SessionToken | null;
-        error?: DashJSError;
-        type: MediaPlayerEvents['KEY_SESSION_CREATED'];
-    }
+export interface KeySessionClosedEvent extends MediaPlayerEvent {
+    data: string | null;
+    error?: string;
+    type: MediaPlayerEvents['KEY_SESSION_CLOSED' | 'KEY_SESSION_REMOVED'];
+}
 
-    export interface KeyStatusesChangedEvent extends MediaPlayerEvent {
-        data: SessionToken;
-        error?: DashJSError;
-        type: MediaPlayerEvents['KEY_STATUSES_CHANGED'];
-    }
+export interface KeySessionEvent extends MediaPlayerEvent {
+    data: SessionToken | null;
+    error?: DashJSError;
+    type: MediaPlayerEvents['KEY_SESSION_CREATED'];
+}
 
-    export interface KeySystemSelectedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['KEY_SYSTEM_SELECTED'];
-        data: object | null;
-        error?: DashJSError;
-    }
+export interface KeyStatusesChangedEvent extends MediaPlayerEvent {
+    data: SessionToken;
+    error?: DashJSError;
+    type: MediaPlayerEvents['KEY_STATUSES_CHANGED'];
+}
 
-    export interface LicenseRequestCompleteEvent extends MediaPlayerEvent {
-        data: {
-            sessionToken: SessionToken;
-            messageType: string;
-        };
-        error?: DashJSError;
-        type: MediaPlayerEvents['LICENSE_REQUEST_COMPLETE'];
-    }
+export interface KeySystemSelectedEvent extends MediaPlayerEvent {
+    type: MediaPlayerEvents['KEY_SYSTEM_SELECTED'];
+    data: object | null;
+    error?: DashJSError;
+}
 
-    export interface LogEvent extends MediaPlayerEvent {
-        message: string;
-        type: MediaPlayerEvents['LOG'];
-    }
+export interface LicenseRequestCompleteEvent extends MediaPlayerEvent {
+    data: {
+        sessionToken: SessionToken;
+        messageType: string;
+    };
+    error?: DashJSError;
+    type: MediaPlayerEvents['LICENSE_REQUEST_COMPLETE'];
+}
 
-    export interface ManifestLoadedEvent extends MediaPlayerEvent {
-        data: object;
-        type: MediaPlayerEvents['MANIFEST_LOADED'];
-    }
+export interface LogEvent extends MediaPlayerEvent {
+    message: string;
+    type: MediaPlayerEvents['LOG'];
+}
 
-    export interface MetricEvent extends MediaPlayerEvent {
-        mediaType: MediaType;
-        metric: MetricType;
-        type: MediaPlayerEvents['METRIC_ADDED' | 'METRIC_UPDATED'];
-        value: object;
-    }
+export interface ManifestLoadedEvent extends MediaPlayerEvent {
+    data: object;
+    type: MediaPlayerEvents['MANIFEST_LOADED'];
+}
 
-    export interface MetricChangedEvent extends MediaPlayerEvent {
-        mediaType: MediaType;
-        type: MediaPlayerEvents['METRIC_CHANGED'];
-    }
+export interface MetricEvent extends MediaPlayerEvent {
+    mediaType: MediaType;
+    metric: MetricType;
+    type: MediaPlayerEvents['METRIC_ADDED' | 'METRIC_UPDATED'];
+    value: object;
+}
 
-    export interface OfflineRecordEvent extends MediaPlayerEvent {
-        id: string;
-        type: MediaPlayerEvents['OFFLINE_RECORD_FINISHED' | 'OFFLINE_RECORD_STARTED' | 'OFFLINE_RECORD_STOPPED'];
-    }
+export interface MetricChangedEvent extends MediaPlayerEvent {
+    mediaType: MediaType;
+    type: MediaPlayerEvents['METRIC_CHANGED'];
+}
 
-    export interface OfflineRecordLoadedmetadataEvent extends MediaPlayerEvent {
-        mediaInfos: MediaInfo[];
-        type: MediaPlayerEvents['OFFLINE_RECORD_LOADEDMETADATA'];
-    }
+export interface OfflineRecordEvent extends MediaPlayerEvent {
+    id: string;
+    type: MediaPlayerEvents['OFFLINE_RECORD_FINISHED' | 'OFFLINE_RECORD_STARTED' | 'OFFLINE_RECORD_STOPPED'];
+}
 
-    export interface PeriodSwitchEvent extends MediaPlayerEvent {
-        fromStreamInfo?: StreamInfo | null;
-        toStreamInfo: StreamInfo | null;
-        type: MediaPlayerEvents['PERIOD_SWITCH_COMPLETED' | 'PERIOD_SWITCH_STARTED'];
-    }
+export interface OfflineRecordLoadedmetadataEvent extends MediaPlayerEvent {
+    mediaInfos: MediaInfo[];
+    type: MediaPlayerEvents['OFFLINE_RECORD_LOADEDMETADATA'];
+}
+
+export interface PeriodSwitchEvent extends MediaPlayerEvent {
+    fromStreamInfo?: StreamInfo | null;
+    toStreamInfo: StreamInfo | null;
+    type: MediaPlayerEvents['PERIOD_SWITCH_COMPLETED' | 'PERIOD_SWITCH_STARTED'];
+}
 
-    export interface PlaybackErrorEvent extends MediaPlayerEvent {
-        error: MediaError;
-        type: MediaPlayerEvents['PLAYBACK_ERROR'];
-    }
+export interface PlaybackErrorEvent extends MediaPlayerEvent {
+    error: MediaError;
+    type: MediaPlayerEvents['PLAYBACK_ERROR'];
+}
 
-    export interface PlaybackPausedEvent extends MediaPlayerEvent {
-        ended: boolean | null;
-        type: MediaPlayerEvents['PLAYBACK_PAUSED'];
-    }
+export interface PlaybackPausedEvent extends MediaPlayerEvent {
+    ended: boolean | null;
+    type: MediaPlayerEvents['PLAYBACK_PAUSED'];
+}
 
-    export interface PlaybackPlayingEvent extends MediaPlayerEvent {
-        playingTime: number | null;
-        type: MediaPlayerEvents['PLAYBACK_PLAYING'];
-    }
+export interface PlaybackPlayingEvent extends MediaPlayerEvent {
+    playingTime: number | null;
+    type: MediaPlayerEvents['PLAYBACK_PLAYING'];
+}
 
-    export interface PlaybackRateChangedEvent extends MediaPlayerEvent {
-        playbackRate: number | null;
-        type: MediaPlayerEvents['PLAYBACK_RATE_CHANGED'];
-    }
+export interface PlaybackRateChangedEvent extends MediaPlayerEvent {
+    playbackRate: number | null;
+    type: MediaPlayerEvents['PLAYBACK_RATE_CHANGED'];
+}
 
-    export interface PlaybackSeekingEvent extends MediaPlayerEvent {
-        seekTime: number | null;
-        type: MediaPlayerEvents['PLAYBACK_SEEKING'];
-    }
+export interface PlaybackSeekingEvent extends MediaPlayerEvent {
+    seekTime: number | null;
+    type: MediaPlayerEvents['PLAYBACK_SEEKING'];
+}
 
-    export interface PlaybackStartedEvent extends MediaPlayerEvent {
-        startTime: number | null;
-        type: MediaPlayerEvents['PLAYBACK_STARTED'];
-    }
+export interface PlaybackStartedEvent extends MediaPlayerEvent {
+    startTime: number | null;
+    type: MediaPlayerEvents['PLAYBACK_STARTED'];
+}
 
-    export interface PlaybackTimeUpdatedEvent extends MediaPlayerEvent {
-        time: number | null;
-        timeToEnd: number;
-        type: MediaPlayerEvents['PLAYBACK_TIME_UPDATED'];
-    }
+export interface PlaybackTimeUpdatedEvent extends MediaPlayerEvent {
+    time: number | null;
+    timeToEnd: number;
+    type: MediaPlayerEvents['PLAYBACK_TIME_UPDATED'];
+}
 
-    export interface PlaybackWaitingEvent extends MediaPlayerEvent {
-        playingTime: number | null;
-        type: MediaPlayerEvents['PLAYBACK_WAITING'];
-    }
+export interface PlaybackWaitingEvent extends MediaPlayerEvent {
+    playingTime: number | null;
+    type: MediaPlayerEvents['PLAYBACK_WAITING'];
+}
 
-    export interface ProtectionCreatedEvent extends MediaPlayerEvent {
-        controller: object;
-        type: MediaPlayerEvents['PROTECTION_CREATED'];
-    }
+export interface ProtectionCreatedEvent extends MediaPlayerEvent {
+    controller: object;
+    type: MediaPlayerEvents['PROTECTION_CREATED'];
+}
 
-    export interface ProtectionDestroyedEvent extends MediaPlayerEvent {
-        data: string;
-        type: MediaPlayerEvents['PROTECTION_DESTROYED'];
-    }
+export interface ProtectionDestroyedEvent extends MediaPlayerEvent {
+    data: string;
+    type: MediaPlayerEvents['PROTECTION_DESTROYED'];
+}
 
-    export interface TrackChangeRenderedEvent extends MediaPlayerEvent {
-        mediaType: MediaType;
-        newMediaInfo: MediaInfo;
-        oldMediaInfo: MediaInfo;
-        type: MediaPlayerEvents['TRACK_CHANGE_RENDERED'];
-    }
+export interface TrackChangeRenderedEvent extends MediaPlayerEvent {
+    mediaType: MediaType;
+    newMediaInfo: MediaInfo;
+    oldMediaInfo: MediaInfo;
+    type: MediaPlayerEvents['TRACK_CHANGE_RENDERED'];
+}
 
-    export interface QualityChangeRenderedEvent extends MediaPlayerEvent {
-        mediaType: MediaType;
-        newRepresentation: Representation;
-        oldRepresentation: Representation;
-        streamId: string;
-        type: MediaPlayerEvents['QUALITY_CHANGE_RENDERED'];
-    }
+export interface QualityChangeRenderedEvent extends MediaPlayerEvent {
+    mediaType: MediaType;
+    newRepresentation: Representation;
+    oldRepresentation: Representation;
+    streamId: string;
+    type: MediaPlayerEvents['QUALITY_CHANGE_RENDERED'];
+}
 
-    export interface QualityChangeRequestedEvent extends MediaPlayerEvent {
-        mediaType: MediaType;
-        newRepresentation: Representation;
-        oldRepresentation: Representation;
-        reason: {
-            name?: string;
-            droppedFrames?: number;
-        } | null;
-        streamInfo: StreamInfo | null;
-        isAdaptationSetSwitch: boolean;
-        type: MediaPlayerEvents['QUALITY_CHANGE_REQUESTED'];
-    }
+export interface QualityChangeRequestedEvent extends MediaPlayerEvent {
+    mediaType: MediaType;
+    newRepresentation: Representation;
+    oldRepresentation: Representation;
+    reason: {
+        name?: string;
+        droppedFrames?: number;
+    } | null;
+    streamInfo: StreamInfo | null;
+    isAdaptationSetSwitch: boolean;
+    type: MediaPlayerEvents['QUALITY_CHANGE_REQUESTED'];
+}
 
-    export interface StreamInitializedEvent extends MediaPlayerEvent {
-        error: Error | null;
-        streamInfo: StreamInfo;
-        type: MediaPlayerEvents['STREAM_INITIALIZED'];
-    }
+export interface StreamInitializedEvent extends MediaPlayerEvent {
+    error: Error | null;
+    streamInfo: StreamInfo;
+    type: MediaPlayerEvents['STREAM_INITIALIZED'];
+}
 
-    export interface TextTracksAddedEvent extends MediaPlayerEvent {
-        enabled: boolean;
-        index: number;
-        tracks: TextTrackInfo[];
-        type: MediaPlayerEvents['TEXT_TRACKS_ADDED'];
-    }
+export interface TextTracksAddedEvent extends MediaPlayerEvent {
+    enabled: boolean;
+    index: number;
+    tracks: TextTrackInfo[];
+    type: MediaPlayerEvents['TEXT_TRACKS_ADDED'];
+}
 
-    export interface TtmlParsedEvent extends MediaPlayerEvent {
-        ttmlDoc: object;
-        ttmlString: string;
-        type: MediaPlayerEvents['TTML_PARSED'];
-    }
+export interface TtmlParsedEvent extends MediaPlayerEvent {
+    ttmlDoc: object;
+    ttmlString: string;
+    type: MediaPlayerEvents['TTML_PARSED'];
+}
 
-    export interface TtmlToParseEvent extends MediaPlayerEvent {
-        content: object;
-        type: MediaPlayerEvents['TTML_TO_PARSE'];
-    }
+export interface TtmlToParseEvent extends MediaPlayerEvent {
+    content: object;
+    type: MediaPlayerEvents['TTML_TO_PARSE'];
+}
 
-    export interface CueEnterEvent extends MediaPlayerEvent {
-        end: number
-        id: string,
-        start: number,
-        text: string,
-        type: MediaPlayerEvents['CUE_ENTER'];
-    }
+export interface CueEnterEvent extends MediaPlayerEvent {
+    end: number
+    id: string,
+    start: number,
+    text: string,
+    type: MediaPlayerEvents['CUE_ENTER'];
+}
 
-    export interface CueExitEvent extends MediaPlayerEvent {
-        id: string,
-        type: MediaPlayerEvents['CUE_EXIT'];
-    }
+export interface CueExitEvent extends MediaPlayerEvent {
+    id: string,
+    type: MediaPlayerEvents['CUE_EXIT'];
+}
 
-    export interface AdaptationSetRemovedNoCapabilitiesEvent extends MediaPlayerEvent {
-        adaptationSet: object;
-        type: MediaPlayerEvents['ADAPTATION_SET_REMOVED_NO_CAPABILITIES'];
-    }
+export interface AdaptationSetRemovedNoCapabilitiesEvent extends MediaPlayerEvent {
+    adaptationSet: object;
+    type: MediaPlayerEvents['ADAPTATION_SET_REMOVED_NO_CAPABILITIES'];
+}
 
-    export interface MediaSettings {
-        accessibility?: DescriptorType | string;
-        audioChannelConfiguration?: DescriptorType | string;
-        lang?: RegExp | string;
-        role?: DescriptorType | string;
-        viewpoint?: DescriptorType | string;
-    }
+export interface MediaSettings {
+    accessibility?: any;
+    audioChannelConfiguration?: any[];
+    lang?: string;
+    role?: string;
+    viewpoint?: any;
+}
 
-    export class serviceDescriptions {
-        contentSteering: ContentSteering | null;
-        id: number;
-        latency: number | null;
-        playbackrate: number;
-        schemeIdUri: string;
-    }
+export class serviceDescriptions {
+    contentSteering: ContentSteering | null;
+    id: number;
+    latency: number | null;
+    playbackrate: number;
+    schemeIdUri: string;
+}
 
-    export interface ICurrentRepresentationSwitch {
-        mt: number;
-        t: Date;
-        to: string;
-        lto: string;
-    }
+export interface ICurrentRepresentationSwitch {
+    mt: number;
+    t: Date;
+    to: string;
+    lto: string;
+}
 
-    export interface IBufferState {
-        state: string;
-        target: number;
-    }
+export interface IBufferState {
+    state: string;
+    target: number;
+}
 
-    /**
-     * Streaming - Constants
-     **/
-
-    export interface conformanceViolationConstants {
-        LEVELS: {
-            SUGGESTION: 'Suggestion',
-            WARNING: 'Warning',
-            ERROR: 'Error'
+/**
+ * Streaming - Constants
+ **/
+
+export interface conformanceViolationConstants {
+    LEVELS: {
+        SUGGESTION: 'Suggestion',
+        WARNING: 'Warning',
+        ERROR: 'Error'
+    },
+    EVENTS: {
+        NO_UTC_TIMING_ELEMENT: {
+            key: 'NO_UTC_TIMING_ELEMENT',
+            message: 'No UTCTiming element is present in the manifest. You may experience playback failures. For a detailed validation use https://conformance.dashif.org/'
         },
-        EVENTS: {
-            NO_UTC_TIMING_ELEMENT: {
-                key: 'NO_UTC_TIMING_ELEMENT',
-                message: 'No UTCTiming element is present in the manifest. You may experience playback failures. For a detailed validation use https://conformance.dashif.org/'
-            },
-            NON_COMPLIANT_SMPTE_IMAGE_ATTRIBUTE: {
-                key: 'NON_COMPLIANT_SMPTE_IMAGE_ATTRIBUTE',
-                message: 'SMPTE 2052-1:2013 defines the attribute name as "imageType" and does not define "imagetype"'
-            },
-            INVALID_DVR_WINDOW: {
-                key: 'INVALID_DVR_WINDOW',
-                message: 'No valid segment found when applying a specification compliant DVR window calculation. Using SegmentTimeline entries as a fallback.'
-            }
+        NON_COMPLIANT_SMPTE_IMAGE_ATTRIBUTE: {
+            key: 'NON_COMPLIANT_SMPTE_IMAGE_ATTRIBUTE',
+            message: 'SMPTE 2052-1:2013 defines the attribute name as "imageType" and does not define "imagetype"'
+        },
+        INVALID_DVR_WINDOW: {
+            key: 'INVALID_DVR_WINDOW',
+            message: 'No valid segment found when applying a specification compliant DVR window calculation. Using SegmentTimeline entries as a fallback.'
         }
     }
+}
 
-    export interface Constants {
-        STREAM: 'stream',
-        VIDEO: 'video',
-        AUDIO: 'audio',
-        TEXT: 'text',
-        MUXED: 'muxed',
-        IMAGE: 'image',
-        STPP: 'stpp',
-        TTML: 'ttml',
-        VTT: 'vtt',
-        WVTT: 'wvtt',
-        CONTENT_STEERING: 'contentSteering',
-        LIVE_CATCHUP_MODE_DEFAULT: 'liveCatchupModeDefault',
-        LIVE_CATCHUP_MODE_LOLP: 'liveCatchupModeLoLP',
-        MOVING_AVERAGE_SLIDING_WINDOW: 'slidingWindow',
-        MOVING_AVERAGE_EWMA: 'ewma',
-        BAD_ARGUMENT_ERROR: 'Invalid Arguments',
-        MISSING_CONFIG_ERROR: 'Missing config parameter(s)',
-        TRACK_SWITCH_MODE_ALWAYS_REPLACE: 'alwaysReplace',
-        TRACK_SWITCH_MODE_NEVER_REPLACE: 'neverReplace',
-        TRACK_SELECTION_MODE_FIRST_TRACK: 'firstTrack',
-        TRACK_SELECTION_MODE_HIGHEST_BITRATE: 'highestBitrate',
-        TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY: 'highestEfficiency',
-        TRACK_SELECTION_MODE_WIDEST_RANGE: 'widestRange',
-        CMCD_MODE_QUERY: 'query',
-        CMCD_MODE_HEADER: 'header',
-        CMCD_AVAILABLE_KEYS: ['br', 'd', 'ot', 'tb', 'bl', 'dl', 'mtp', 'nor', 'nrr', 'su', 'bs', 'rtp', 'cid', 'pr', 'sf', 'sid', 'st', 'v'],
-        CMCD_V2_AVAILABLE_KEYS: ['msd', 'ltc'],
-        CMCD_AVAILABLE_REQUESTS: ['segment', 'mpd', 'xlink', 'steering', 'other'],
-        INITIALIZE: 'initialize',
-        TEXT_SHOWING: 'showing',
-        TEXT_HIDDEN: 'hidden',
-        TEXT_DISABLED: 'disabled',
-        ACCESSIBILITY_CEA608_SCHEME: 'urn:scte:dash:cc:cea-608:2015',
-        CC1: 'CC1',
-        CC3: 'CC3',
-        UTF8: 'utf-8',
-        SCHEME_ID_URI: 'schemeIdUri',
-        START_TIME: 'starttime',
-        SERVICE_DESCRIPTION_DVB_LL_SCHEME: 'urn:dvb:dash:lowlatency:scope:2019',
-        SUPPLEMENTAL_PROPERTY_DVB_LL_SCHEME: 'urn:dvb:dash:lowlatency:critical:2019',
-        CTA_5004_2023_SCHEME: 'urn:mpeg:dash:cta-5004:2023',
-        THUMBNAILS_SCHEME_ID_URIS: ['http://dashif.org/thumbnail_tile', 'http://dashif.org/guidelines/thumbnail_tile'],
-        FONT_DOWNLOAD_DVB_SCHEME: 'urn:dvb:dash:fontdownload:2014',
-        COLOUR_PRIMARIES_SCHEME_ID_URI: 'urn:mpeg:mpegB:cicp:ColourPrimaries',
-        URL_QUERY_INFO_SCHEME: 'urn:mpeg:dash:urlparam:2014',
-        EXT_URL_QUERY_INFO_SCHEME: 'urn:mpeg:dash:urlparam:2016',
-        MATRIX_COEFFICIENTS_SCHEME_ID_URI: 'urn:mpeg:mpegB:cicp:MatrixCoefficients',
-        TRANSFER_CHARACTERISTICS_SCHEME_ID_URI: 'urn:mpeg:mpegB:cicp:TransferCharacteristics',
-        HDR_METADATA_FORMAT_SCHEME_ID_URI: 'urn:dvb:dash:hdr-dmi',
-        HDR_METADATA_FORMAT_VALUES: {
-            ST2094_10: 'ST2094-10',
-            SL_HDR2: 'SL-HDR2',
-            ST2094_40: 'ST2094-40'
-        },
-        MEDIA_CAPABILITIES_API: {
-            COLORGAMUT: {
-                SRGB: 'srgb',
-                P3: 'p3',
-                REC2020: 'rec2020'
-            },
-            TRANSFERFUNCTION: {
-                SRGB: 'srgb',
-                PQ: 'pq',
-                HLG: 'hlg'
-            },
-            HDR_METADATATYPE: {
-                SMPTE_ST_2094_10: 'smpteSt2094-10',
-                SLHDR2: 'slhdr2',
-                SMPTE_ST_2094_40: 'smpteSt2094-40'
-            }
-        },
-        XML: 'XML',
-        ARRAY_BUFFER: 'ArrayBuffer',
-        DVB_REPORTING_URL: 'dvb:reportingUrl',
-        DVB_PROBABILITY: 'dvb:probability',
-        OFF_MIMETYPE: 'application/font-sfnt',
-        WOFF_MIMETYPE: 'application/font-woff',
-        VIDEO_ELEMENT_READY_STATES: {
-            HAVE_NOTHING: 0,
-            HAVE_METADATA: 1,
-            HAVE_CURRENT_DATA: 2,
-            HAVE_FUTURE_DATA: 3,
-            HAVE_ENOUGH_DATA: 4
-        },
-        FILE_LOADER_TYPES: {
-            FETCH: 'fetch_loader',
-            XHR: 'xhr_loader'
-        },
-        THROUGHPUT_TYPES: {
-            LATENCY: 'throughput_type_latency',
-            BANDWIDTH: 'throughput_type_bandwidth'
-        },
-        THROUGHPUT_CALCULATION_MODES: {
-            EWMA: 'throughputCalculationModeEwma',
-            ZLEMA: 'throughputCalculationModeZlema',
-            ARITHMETIC_MEAN: 'throughputCalculationModeArithmeticMean',
-            BYTE_SIZE_WEIGHTED_ARITHMETIC_MEAN: 'throughputCalculationModeByteSizeWeightedArithmeticMean',
-            DATE_WEIGHTED_ARITHMETIC_MEAN: 'throughputCalculationModeDateWeightedArithmeticMean',
-            HARMONIC_MEAN: 'throughputCalculationModeHarmonicMean',
-            BYTE_SIZE_WEIGHTED_HARMONIC_MEAN: 'throughputCalculationModeByteSizeWeightedHarmonicMean',
-            DATE_WEIGHTED_HARMONIC_MEAN: 'throughputCalculationModeDateWeightedHarmonicMean',
+export interface Constants {
+    STREAM: 'stream',
+    VIDEO: 'video',
+    AUDIO: 'audio',
+    TEXT: 'text',
+    MUXED: 'muxed',
+    IMAGE: 'image',
+    STPP: 'stpp',
+    TTML: 'ttml',
+    VTT: 'vtt',
+    WVTT: 'wvtt',
+    CONTENT_STEERING: 'contentSteering',
+    LIVE_CATCHUP_MODE_DEFAULT: 'liveCatchupModeDefault',
+    LIVE_CATCHUP_MODE_LOLP: 'liveCatchupModeLoLP',
+    MOVING_AVERAGE_SLIDING_WINDOW: 'slidingWindow',
+    MOVING_AVERAGE_EWMA: 'ewma',
+    BAD_ARGUMENT_ERROR: 'Invalid Arguments',
+    MISSING_CONFIG_ERROR: 'Missing config parameter(s)',
+    TRACK_SWITCH_MODE_ALWAYS_REPLACE: 'alwaysReplace',
+    TRACK_SWITCH_MODE_NEVER_REPLACE: 'neverReplace',
+    TRACK_SELECTION_MODE_FIRST_TRACK: 'firstTrack',
+    TRACK_SELECTION_MODE_HIGHEST_BITRATE: 'highestBitrate',
+    TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY: 'highestEfficiency',
+    TRACK_SELECTION_MODE_WIDEST_RANGE: 'widestRange',
+    CMCD_MODE_QUERY: 'query',
+    CMCD_MODE_HEADER: 'header',
+    CMCD_AVAILABLE_KEYS: ['br', 'd', 'ot', 'tb', 'bl', 'dl', 'mtp', 'nor', 'nrr', 'su', 'bs', 'rtp', 'cid', 'pr', 'sf', 'sid', 'st', 'v'],
+    CMCD_V2_AVAILABLE_KEYS: ['msd', 'ltc'],
+    CMCD_AVAILABLE_REQUESTS: ['segment', 'mpd', 'xlink', 'steering', 'other'],
+    INITIALIZE: 'initialize',
+    TEXT_SHOWING: 'showing',
+    TEXT_HIDDEN: 'hidden',
+    TEXT_DISABLED: 'disabled',
+    ACCESSIBILITY_CEA608_SCHEME: 'urn:scte:dash:cc:cea-608:2015',
+    CC1: 'CC1',
+    CC3: 'CC3',
+    UTF8: 'utf-8',
+    SCHEME_ID_URI: 'schemeIdUri',
+    START_TIME: 'starttime',
+    SERVICE_DESCRIPTION_DVB_LL_SCHEME: 'urn:dvb:dash:lowlatency:scope:2019',
+    SUPPLEMENTAL_PROPERTY_DVB_LL_SCHEME: 'urn:dvb:dash:lowlatency:critical:2019',
+    CTA_5004_2023_SCHEME: 'urn:mpeg:dash:cta-5004:2023',
+    THUMBNAILS_SCHEME_ID_URIS: ['http://dashif.org/thumbnail_tile', 'http://dashif.org/guidelines/thumbnail_tile'],
+    FONT_DOWNLOAD_DVB_SCHEME: 'urn:dvb:dash:fontdownload:2014',
+    COLOUR_PRIMARIES_SCHEME_ID_URI: 'urn:mpeg:mpegB:cicp:ColourPrimaries',
+    URL_QUERY_INFO_SCHEME: 'urn:mpeg:dash:urlparam:2014',
+    EXT_URL_QUERY_INFO_SCHEME: 'urn:mpeg:dash:urlparam:2016',
+    MATRIX_COEFFICIENTS_SCHEME_ID_URI: 'urn:mpeg:mpegB:cicp:MatrixCoefficients',
+    TRANSFER_CHARACTERISTICS_SCHEME_ID_URI: 'urn:mpeg:mpegB:cicp:TransferCharacteristics',
+    HDR_METADATA_FORMAT_SCHEME_ID_URI: 'urn:dvb:dash:hdr-dmi',
+    HDR_METADATA_FORMAT_VALUES: {
+        ST2094_10: 'ST2094-10',
+        SL_HDR2: 'SL-HDR2',
+        ST2094_40: 'ST2094-40'
+    },
+    MEDIA_CAPABILITIES_API: {
+        COLORGAMUT: {
+            SRGB: 'srgb',
+            P3: 'p3',
+            REC2020: 'rec2020'
         },
-        LOW_LATENCY_DOWNLOAD_TIME_CALCULATION_MODE: {
-            MOOF_PARSING: 'lowLatencyDownloadTimeCalculationModeMoofParsing',
-            DOWNLOADED_DATA: 'lowLatencyDownloadTimeCalculationModeDownloadedData',
-            AAST: 'lowLatencyDownloadTimeCalculationModeAast',
+        TRANSFERFUNCTION: {
+            SRGB: 'srgb',
+            PQ: 'pq',
+            HLG: 'hlg'
         },
-        RULES_TYPES: {
-            QUALITY_SWITCH_RULES: 'qualitySwitchRules',
-            ABANDON_FRAGMENT_RULES: 'abandonFragmentRules'
-        },
-        QUALITY_SWITCH_RULES: {
-            BOLA_RULE: 'BolaRule',
-            THROUGHPUT_RULE: 'ThroughputRule',
-            INSUFFICIENT_BUFFER_RULE: 'InsufficientBufferRule',
-            SWITCH_HISTORY_RULE: 'SwitchHistoryRule',
-            DROPPED_FRAMES_RULE: 'DroppedFramesRule',
-            LEARN_TO_ADAPT_RULE: 'L2ARule',
-            LOL_PLUS_RULE: 'LoLPRule'
-        },
-        ABANDON_FRAGMENT_RULES: {
-            ABANDON_REQUEST_RULE: 'AbandonRequestsRule'
-        },
-
-        /**
-         *  @constant {string} ID3_SCHEME_ID_URI specifies scheme ID URI for ID3 timed metadata
-         *  @memberof Constants#
-         *  @static
-         */
-        ID3_SCHEME_ID_URI: 'https://aomedia.org/emsg/ID3',
-        COMMON_ACCESS_TOKEN_HEADER: 'common-access-token',
-        DASH_ROLE_SCHEME_ID: 'urn:mpeg:dash:role:2011',
-        CODEC_FAMILIES: {
-            MP3: 'mp3',
-            AAC: 'aac',
-            AC3: 'ac3',
-            EC3: 'ec3',
-            DTSX: 'dtsx',
-            DTSC: 'dtsc',
-            AVC: 'avc',
-            HEVC: 'hevc'
+        HDR_METADATATYPE: {
+            SMPTE_ST_2094_10: 'smpteSt2094-10',
+            SLHDR2: 'slhdr2',
+            SMPTE_ST_2094_40: 'smpteSt2094-40'
         }
-    }
+    },
+    XML: 'XML',
+    ARRAY_BUFFER: 'ArrayBuffer',
+    DVB_REPORTING_URL: 'dvb:reportingUrl',
+    DVB_PROBABILITY: 'dvb:probability',
+    OFF_MIMETYPE: 'application/font-sfnt',
+    WOFF_MIMETYPE: 'application/font-woff',
+    VIDEO_ELEMENT_READY_STATES: {
+        HAVE_NOTHING: 0,
+        HAVE_METADATA: 1,
+        HAVE_CURRENT_DATA: 2,
+        HAVE_FUTURE_DATA: 3,
+        HAVE_ENOUGH_DATA: 4
+    },
+    FILE_LOADER_TYPES: {
+        FETCH: 'fetch_loader',
+        XHR: 'xhr_loader'
+    },
+    THROUGHPUT_TYPES: {
+        LATENCY: 'throughput_type_latency',
+        BANDWIDTH: 'throughput_type_bandwidth'
+    },
+    THROUGHPUT_CALCULATION_MODES: {
+        EWMA: 'throughputCalculationModeEwma',
+        ZLEMA: 'throughputCalculationModeZlema',
+        ARITHMETIC_MEAN: 'throughputCalculationModeArithmeticMean',
+        BYTE_SIZE_WEIGHTED_ARITHMETIC_MEAN: 'throughputCalculationModeByteSizeWeightedArithmeticMean',
+        DATE_WEIGHTED_ARITHMETIC_MEAN: 'throughputCalculationModeDateWeightedArithmeticMean',
+        HARMONIC_MEAN: 'throughputCalculationModeHarmonicMean',
+        BYTE_SIZE_WEIGHTED_HARMONIC_MEAN: 'throughputCalculationModeByteSizeWeightedHarmonicMean',
+        DATE_WEIGHTED_HARMONIC_MEAN: 'throughputCalculationModeDateWeightedHarmonicMean',
+    },
+    LOW_LATENCY_DOWNLOAD_TIME_CALCULATION_MODE: {
+        MOOF_PARSING: 'lowLatencyDownloadTimeCalculationModeMoofParsing',
+        DOWNLOADED_DATA: 'lowLatencyDownloadTimeCalculationModeDownloadedData',
+        AAST: 'lowLatencyDownloadTimeCalculationModeAast',
+    },
+    RULES_TYPES: {
+        QUALITY_SWITCH_RULES: 'qualitySwitchRules',
+        ABANDON_FRAGMENT_RULES: 'abandonFragmentRules'
+    },
+    QUALITY_SWITCH_RULES: {
+        BOLA_RULE: 'BolaRule',
+        THROUGHPUT_RULE: 'ThroughputRule',
+        INSUFFICIENT_BUFFER_RULE: 'InsufficientBufferRule',
+        SWITCH_HISTORY_RULE: 'SwitchHistoryRule',
+        DROPPED_FRAMES_RULE: 'DroppedFramesRule',
+        LEARN_TO_ADAPT_RULE: 'L2ARule',
+        LOL_PLUS_RULE: 'LoLPRule'
+    },
+    ABANDON_FRAGMENT_RULES: {
+        ABANDON_REQUEST_RULE: 'AbandonRequestsRule'
+    },
 
-    export interface MetricsConstants {
-        TCP_CONNECTION: 'TcpList',
-        HTTP_REQUEST: 'HttpList',
-        TRACK_SWITCH: 'RepSwitchList',
-        BUFFER_LEVEL: 'BufferLevel',
-        BUFFER_LOADED: 'bufferLoaded',
-        ABANDON_LOAD: 'abandonload',
-        ALLOW_LOAD: 'allowload',
-        BUFFER_EMPTY: 'bufferStalled',
-        BUFFER_STATE: 'BufferState',
-        DVR_INFO: 'DVRInfo',
-        DROPPED_FRAMES: 'DroppedFrames',
-        SCHEDULING_INFO: 'SchedulingInfo',
-        REQUESTS_QUEUE: 'RequestsQueue',
-        MANIFEST_UPDATE: 'ManifestUpdate',
-        MANIFEST_UPDATE_STREAM_INFO: 'ManifestUpdatePeriodInfo',
-        MANIFEST_UPDATE_TRACK_INFO: 'ManifestUpdateRepresentationInfo',
-        PLAY_LIST: 'PlayList',
-        DVB_ERRORS: 'DVBErrors',
-        HTTP_REQUEST_DVB_REPORTING_TYPE: 'DVBReporting',
+    /**
+     *  @constant {string} ID3_SCHEME_ID_URI specifies scheme ID URI for ID3 timed metadata
+     *  @memberof Constants#
+     *  @static
+     */
+    ID3_SCHEME_ID_URI: 'https://aomedia.org/emsg/ID3',
+    COMMON_ACCESS_TOKEN_HEADER: 'common-access-token',
+    DASH_ROLE_SCHEME_ID: 'urn:mpeg:dash:role:2011',
+    CODEC_FAMILIES: {
+        MP3: 'mp3',
+        AAC: 'aac',
+        AC3: 'ac3',
+        EC3: 'ec3',
+        DTSX: 'dtsx',
+        DTSC: 'dtsc',
+        AVC: 'avc',
+        HEVC: 'hevc'
     }
+}
 
-    export interface ProtectionConstants {
-        CLEARKEY_KEYSTEM_STRING: 'org.w3.clearkey',
-        WIDEVINE_KEYSTEM_STRING: 'com.widevine.alpha',
-        PLAYREADY_KEYSTEM_STRING: 'com.microsoft.playready',
-        PLAYREADY_RECOMMENDATION_KEYSTEM_STRING: 'com.microsoft.playready.recommendation',
-        WIDEVINE_UUID: 'edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
-        PLAYREADY_UUID: '9a04f079-9840-4286-ab92-e65be0885f95',
-        CLEARKEY_UUID: 'e2719d58-a985-b3c9-781a-b030af78d30e',
-        W3C_CLEARKEY_UUID: '1077efec-c0b2-4d02-ace3-3c1e52e2fb4b',
-        INITIALIZATION_DATA_TYPE_CENC: 'cenc',
-        INITIALIZATION_DATA_TYPE_KEYIDS: 'keyids',
-        INITIALIZATION_DATA_TYPE_WEBM: 'webm',
-        ENCRYPTION_SCHEME_CENC: 'cenc',
-        ENCRYPTION_SCHEME_CBCS: 'cbcs',
-        MEDIA_KEY_MESSAGE_TYPES: {
-            LICENSE_REQUEST: 'license-request',
-            LICENSE_RENEWAL: 'license-renewal',
-            LICENSE_RELEASE: 'license-release',
-            INDIVIDUALIZATION_REQUEST: 'individualization-request',
-        },
-        ROBUSTNESS_STRINGS: {
-            WIDEVINE: {
-                SW_SECURE_CRYPTO: 'SW_SECURE_CRYPTO',
-                SW_SECURE_DECODE: 'SW_SECURE_DECODE',
-                HW_SECURE_CRYPTO: 'HW_SECURE_CRYPTO',
-                HW_SECURE_DECODE: 'HW_SECURE_DECODE',
-                HW_SECURE_ALL: 'HW_SECURE_ALL'
-            }
-        },
-        MEDIA_KEY_STATUSES: {
-            USABLE: 'usable',
-            EXPIRED: 'expired',
-            RELEASED: 'released',
-            OUTPUT_RESTRICTED: 'output-restricted',
-            OUTPUT_DOWNSCALED: 'output-downscaled',
-            STATUS_PENDING: 'status-pending',
-            INTERNAL_ERROR: 'internal-error',
+export interface MetricsConstants {
+    TCP_CONNECTION: 'TcpList',
+    HTTP_REQUEST: 'HttpList',
+    TRACK_SWITCH: 'RepSwitchList',
+    BUFFER_LEVEL: 'BufferLevel',
+    BUFFER_LOADED: 'bufferLoaded',
+    ABANDON_LOAD: 'abandonload',
+    ALLOW_LOAD: 'allowload',
+    BUFFER_EMPTY: 'bufferStalled',
+    BUFFER_STATE: 'BufferState',
+    DVR_INFO: 'DVRInfo',
+    DROPPED_FRAMES: 'DroppedFrames',
+    SCHEDULING_INFO: 'SchedulingInfo',
+    REQUESTS_QUEUE: 'RequestsQueue',
+    MANIFEST_UPDATE: 'ManifestUpdate',
+    MANIFEST_UPDATE_STREAM_INFO: 'ManifestUpdatePeriodInfo',
+    MANIFEST_UPDATE_TRACK_INFO: 'ManifestUpdateRepresentationInfo',
+    PLAY_LIST: 'PlayList',
+    DVB_ERRORS: 'DVBErrors',
+    HTTP_REQUEST_DVB_REPORTING_TYPE: 'DVBReporting',
+}
+
+export interface ProtectionConstants {
+    CLEARKEY_KEYSTEM_STRING: 'org.w3.clearkey',
+    WIDEVINE_KEYSTEM_STRING: 'com.widevine.alpha',
+    PLAYREADY_KEYSTEM_STRING: 'com.microsoft.playready',
+    PLAYREADY_RECOMMENDATION_KEYSTEM_STRING: 'com.microsoft.playready.recommendation',
+    WIDEVINE_UUID: 'edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
+    PLAYREADY_UUID: '9a04f079-9840-4286-ab92-e65be0885f95',
+    CLEARKEY_UUID: 'e2719d58-a985-b3c9-781a-b030af78d30e',
+    W3C_CLEARKEY_UUID: '1077efec-c0b2-4d02-ace3-3c1e52e2fb4b',
+    INITIALIZATION_DATA_TYPE_CENC: 'cenc',
+    INITIALIZATION_DATA_TYPE_KEYIDS: 'keyids',
+    INITIALIZATION_DATA_TYPE_WEBM: 'webm',
+    ENCRYPTION_SCHEME_CENC: 'cenc',
+    ENCRYPTION_SCHEME_CBCS: 'cbcs',
+    MEDIA_KEY_MESSAGE_TYPES: {
+        LICENSE_REQUEST: 'license-request',
+        LICENSE_RENEWAL: 'license-renewal',
+        LICENSE_RELEASE: 'license-release',
+        INDIVIDUALIZATION_REQUEST: 'individualization-request',
+    },
+    ROBUSTNESS_STRINGS: {
+        WIDEVINE: {
+            SW_SECURE_CRYPTO: 'SW_SECURE_CRYPTO',
+            SW_SECURE_DECODE: 'SW_SECURE_DECODE',
+            HW_SECURE_CRYPTO: 'HW_SECURE_CRYPTO',
+            HW_SECURE_DECODE: 'HW_SECURE_DECODE',
+            HW_SECURE_ALL: 'HW_SECURE_ALL'
         }
+    },
+    MEDIA_KEY_STATUSES: {
+        USABLE: 'usable',
+        EXPIRED: 'expired',
+        RELEASED: 'released',
+        OUTPUT_RESTRICTED: 'output-restricted',
+        OUTPUT_DOWNSCALED: 'output-downscaled',
+        STATUS_PENDING: 'status-pending',
+        INTERNAL_ERROR: 'internal-error',
     }
+}
 
-    /**
-     * Streaming - Controllers
-     **/
-
-    export interface AbrController {
-        checkPlaybackQuality(type: string, streamId: string | number): boolean;
-
-        clearDataForStream(streamId: string): void;
+/**
+ * Streaming - Controllers
+ **/
 
-        getAbandonmentStateFor(streamId: string, type: string): any | null;
+export interface AbrController {
+    checkPlaybackQuality(type: string, streamId: string | number): boolean;
 
-        getInitialBitrateFor(type: string): number;
+    clearDataForStream(streamId: string): void;
 
-        getOptimalRepresentationForBitrate(mediaInfo: MediaInfo, bitrateInKbit: number, includeCompatibleMediaInfos: boolean): Representation | null;
+    getAbandonmentStateFor(streamId: string, type: string): any | null;
 
-        getPossibleVoRepresentations(mediaInfo: MediaInfo, includeCompatibleMediaInfos: boolean): Representation[] | null;
+    getInitialBitrateFor(type: string): number;
 
-        getPossibleVoRepresentationsFilteredBySettings(mediaInfo: MediaInfo, includeCompatibleMediaInfos: boolean): Representation[] | null;
+    getOptimalRepresentationForBitrate(mediaInfo: MediaInfo, bitrateInKbit: number, includeCompatibleMediaInfos: boolean): Representation | null;
 
-        getRepresentationByAbsoluteIndex(absoluteIndex: number, mediaInfo: MediaInfo, includeCompatibleMediaInfos: boolean): Representation | null;
+    getPossibleVoRepresentations(mediaInfo: MediaInfo, includeCompatibleMediaInfos: boolean): Representation[] | null;
 
-        handleNewMediaInfo(mediaInfo: MediaInfo): void;
+    getPossibleVoRepresentationsFilteredBySettings(mediaInfo: MediaInfo, includeCompatibleMediaInfos: boolean): Representation[] | null;
 
-        initialize(): void;
+    getRepresentationByAbsoluteIndex(absoluteIndex: number, mediaInfo: MediaInfo, includeCompatibleMediaInfos: boolean): Representation | null;
 
-        isPlayingAtLowestQuality(representation: Representation): boolean;
+    handleNewMediaInfo(mediaInfo: MediaInfo): void;
 
-        isPlayingAtTopQuality(representation: Representation): boolean;
+    initialize(): void;
 
-        registerStreamType(type: object, streamProcessor: object): void;
+    isPlayingAtLowestQuality(representation: Representation): boolean;
 
-        reset(): void;
+    isPlayingAtTopQuality(representation: Representation): boolean;
 
-        setConfig(config: object): void;
+    registerStreamType(type: object, streamProcessor: object): void;
 
-        setPlaybackQuality(type: string, streamInfo: StreamInfo, representation: Representation, reason: object): void;
+    reset(): void;
 
-        setWindowResizeEventCalled(value: any): void;
+    setConfig(config: object): void;
 
-        unRegisterStreamType(streamId: string, type: string): void;
-    }
+    setPlaybackQuality(type: string, streamInfo: StreamInfo, representation: Representation, reason: object): void;
 
-    export interface BaseURLController {
-        setConfig(config: object): void;
+    setWindowResizeEventCalled(value: any): void;
 
-        update(manifest: object): void;
+    unRegisterStreamType(streamId: string, type: string): void;
+}
 
-        resolve(path: any): BaseURL;
+export interface BaseURLController {
+    setConfig(config: object): void;
 
-        reset(): void;
+    update(manifest: object): void;
 
-        getBaseUrls(manifest: any): BaseURL[];
+    resolve(path: any): BaseURL;
 
-        initialize(data: any): void;
-    }
+    reset(): void;
 
-    export interface BlacklistController {
-        contains(query: any): boolean;
+    getBaseUrls(manifest: any): BaseURL[];
 
-        add(entry: any): void;
+    initialize(data: any): void;
+}
 
-        remove(entry: any): void;
+export interface BlacklistController {
+    contains(query: any): boolean;
 
-        reset(): void;
-    }
+    add(entry: any): void;
 
-    export interface BufferController {
-        appendInitSegmentFromCache(representationId: string): boolean;
+    remove(entry: any): void;
 
-        clearBuffers(ranges: Range[]): Promise<any>;
+    reset(): void;
+}
 
-        createBufferSink(mediaInfo: MediaInfo, oldBufferSinks?: any[]): Promise<any>;
+export interface BufferController {
+    appendInitSegmentFromCache(representationId: string): boolean;
 
-        dischargePreBuffer(): void;
+    clearBuffers(ranges: Range[]): Promise<any>;
 
-        getAllRangesWithSafetyFactor(seekTime: number): { start: number, end: number }[];
+    createBufferSink(mediaInfo: MediaInfo, oldBufferSinks?: any[]): Promise<any>;
 
-        getBuffer(): SourceBufferSink;
+    dischargePreBuffer(): void;
 
-        getBufferControllerType(): string;
+    getAllRangesWithSafetyFactor(seekTime: number): { start: number, end: number }[];
 
-        getBufferLevel(): number;
+    getBuffer(): SourceBufferSink;
 
-        getContinuousBufferTimeForTargetTime(targetTime: number): number;
+    getBufferControllerType(): string;
 
-        getIsBufferingCompleted(): boolean;
+    getBufferLevel(): number;
 
-        getIsPruningInProgress(): boolean;
+    getContinuousBufferTimeForTargetTime(targetTime: number): number;
 
-        getMediaSource(): MediaSource;
+    getIsBufferingCompleted(): boolean;
 
-        getRangeAt(time: number, tolerance: number): Range | null;
+    getIsPruningInProgress(): boolean;
 
-        getStreamId(): string;
+    getMediaSource(): MediaSource;
 
-        getType(): string;
+    getRangeAt(time: number, tolerance: number): Range | null;
 
-        hasBufferAtTime(time: number): boolean;
+    getStreamId(): string;
 
-        initialize(mediaSource: MediaSource): void;
+    getType(): string;
 
-        prepareForFastQualitySwitch(newRepresentation: Representation, oldRepresentation: Representation): Promise<any>;
+    hasBufferAtTime(time: number): boolean;
 
-        prepareForForceReplacementQualitySwitch(voRepresentation: Representation): Promise<any>;
+    initialize(mediaSource: MediaSource): void;
 
-        prepareForNonReplacementTrackSwitch(codec: string): Promise<any>;
+    prepareForFastQualitySwitch(newRepresentation: Representation, oldRepresentation: Representation): Promise<any>;
 
-        prepareForPlaybackSeek(): any;
+    prepareForForceReplacementQualitySwitch(voRepresentation: Representation): Promise<any>;
 
-        prepareForReplacementTrackSwitch(codec: string): Promise<any>;
+    prepareForNonReplacementTrackSwitch(codec: string): Promise<any>;
 
-        prepareForabandonQualitySwitch(newRepresentation: Representation, oldRepresentation: Representation): Promise<any>;
+    prepareForPlaybackSeek(): any;
 
-        pruneAllSafely(): Promise<any>;
+    prepareForReplacementTrackSwitch(codec: string): Promise<any>;
 
-        pruneBuffer(): void;
+    prepareForabandonQualitySwitch(newRepresentation: Representation, oldRepresentation: Representation): Promise<any>;
 
-        reset(errored: any, keepBuffers: boolean): void;
+    pruneAllSafely(): Promise<any>;
 
-        segmentRequestingCompleted(segmentIndex: number): void;
+    pruneBuffer(): void;
 
-        setIsBufferingCopleted(value: object): void;
+    reset(errored: any, keepBuffers: boolean): void;
 
-        setMediaSource(value: object, mediaInfo: MediaInfo | null): void;
+    segmentRequestingCompleted(segmentIndex: number): void;
 
-        setSeekTarget(value: object): void;
+    setIsBufferingCopleted(value: object): void;
 
-        updateAppendWindow(): Promise<any>;
+    setMediaSource(value: object, mediaInfo: MediaInfo | null): void;
 
-        updateBufferTimestampOffset(voRepresentation: Representation): Promise<any>;
-    }
+    setSeekTarget(value: object): void;
 
-    export interface CatchupController {
-        initialize(): void;
+    updateAppendWindow(): Promise<any>;
 
-        reset(): void;
+    updateBufferTimestampOffset(voRepresentation: Representation): Promise<any>;
+}
 
-        setConfig(config: any): void;
-    }
+export interface CatchupController {
+    initialize(): void;
 
-    export interface ClientDataReportingController {
-        isAdaptationsIncluded(adaptationSet: AdaptationSet): boolean;
+    reset(): void;
 
-        isServiceLocationIncluded(requestType: string, serviceLocation: any): boolean;
+    setConfig(config: any): void;
+}
 
-        setConfig(config: any): void;
-    }
+export interface ClientDataReportingController {
+    isAdaptationsIncluded(adaptationSet: AdaptationSet): boolean;
 
-    export interface CommonAccessTokenController {
-        getCommonAccessTokenForUrl(url: URL): any;
+    isServiceLocationIncluded(requestType: string, serviceLocation: any): boolean;
 
-        processResponseHeaders(httpResponse: object): void;
+    setConfig(config: any): void;
+}
 
-        reset(): void;
-    }
+export interface CommonAccessTokenController {
+    getCommonAccessTokenForUrl(url: URL): any;
 
-    export interface EventController {
-        addInbandEvents(values: object[], periodId: string | number): void;
+    processResponseHeaders(httpResponse: object): void;
 
-        addInlineEvents(values: object[], periodId: string | number): void;
+    reset(): void;
+}
 
-        getInbandEvents(): object;
+export interface EventController {
+    addInbandEvents(values: object[], periodId: string | number): void;
 
-        getInlineEvents(): object;
+    addInlineEvents(values: object[], periodId: string | number): void;
 
-        reset(): void;
+    getInbandEvents(): object;
 
-        setConfig(config: object): void;
+    getInlineEvents(): object;
 
-        start(): void;
-    }
+    reset(): void;
 
-    export interface ExtUrlQueryInfoController {
-        createFinalQueryStrings(manifest: object): void;
+    setConfig(config: object): void;
 
-        getFinalQueryString(request: HTTPRequest): any;
-    }
+    start(): void;
+}
 
-    export interface FragmentController {
-        getModel(type: string): any;
+export interface ExtUrlQueryInfoController {
+    createFinalQueryStrings(manifest: object): void;
 
-        getStreamId(): string;
+    getFinalQueryString(request: HTTPRequest): any;
+}
 
-        reset(): void;
-    }
+export interface FragmentController {
+    getModel(type: string): any;
 
-    export interface GapController {
-        initialize(): void;
+    getStreamId(): string;
 
-        reset(): void;
+    reset(): void;
+}
 
-        setConfig(config: object): void;
-    }
+export interface GapController {
+    initialize(): void;
 
-    export interface MediaController {
-        addTrack(track: MediaInfo): void;
+    reset(): void;
 
-        areTracksEqual(t1: MediaInfo, t2: MediaInfo): boolean;
+    setConfig(config: object): void;
+}
 
-        clearDataForStream(streamId: string): void;
+export interface MediaController {
+    addTrack(track: MediaInfo): void;
 
-        getCurrentTrackFor(type: string, streamId: string): MediaInfo;
+    areTracksEqual(t1: MediaInfo, t2: MediaInfo): boolean;
 
-        getInitialSettings(type: string): object | null;
+    clearDataForStream(streamId: string): void;
 
-        getTracksFor(type: string, streamId: string): MediaInfo[];
+    getCurrentTrackFor(type: string, streamId: string): MediaInfo;
 
-        getTracksWithHighestBitrate(trackArr: MediaInfo[]): MediaInfo[];
+    getInitialSettings(type: string): object | null;
 
-        getTracksWithHighestEfficiency(trackArr: MediaInfo[]): MediaInfo[];
+    getTracksFor(type: string, streamId: string): MediaInfo[];
 
-        getTracksWithHighestSelectionPriority(trackArr: MediaInfo[]): MediaInfo[];
+    getTracksWithHighestBitrate(trackArr: MediaInfo[]): MediaInfo[];
 
-        getTracksWithWidestRange(trackArr: MediaInfo[]): MediaInfo[];
+    getTracksWithHighestEfficiency(trackArr: MediaInfo[]): MediaInfo[];
 
-        initialize(): void;
+    getTracksWithHighestSelectionPriority(trackArr: MediaInfo[]): MediaInfo[];
 
-        isCurrentTrack(track: MediaInfo): boolean;
+    getTracksWithWidestRange(trackArr: MediaInfo[]): MediaInfo[];
 
-        matchSettings(settings: object, track: MediaInfo, isTrackActive?: boolean): any;
+    initialize(): void;
 
-        matchSettingsAccessibility(settings: object, track: MediaInfo): any;
+    isCurrentTrack(track: MediaInfo): boolean;
 
-        matchSettingsAudioChannelConfig(settings: object, track: MediaInfo): any;
+    matchSettings(settings: object, track: MediaInfo, isTrackActive?: boolean): any;
 
-        matchSettingsCodec(settings: object, track: MediaInfo): any;
+    matchSettingsAccessibility(settings: object, track: MediaInfo): any;
 
-        matchSettingsIndex(settings: object, track: MediaInfo): any;
+    matchSettingsAudioChannelConfig(settings: object, track: MediaInfo): any;
 
-        matchSettingsLang(settings: object, track: MediaInfo): any;
+    matchSettingsCodec(settings: object, track: MediaInfo): any;
 
-        matchSettingsRole(settings: object, track: MediaInfo): any;
+    matchSettingsIndex(settings: object, track: MediaInfo): any;
 
-        matchSettingsViewPoint(settings: object, track: MediaInfo): any;
+    matchSettingsLang(settings: object, track: MediaInfo): any;
 
-        reset(): void;
+    matchSettingsRole(settings: object, track: MediaInfo): any;
 
-        saveTextSettingsDisabled(): void;
+    matchSettingsViewPoint(settings: object, track: MediaInfo): any;
 
-        selectInitialTrack(type: string, tracks: MediaInfo[]): MediaInfo;
+    reset(): void;
 
-        setConfig(config: object): void;
+    saveTextSettingsDisabled(): void;
 
-        setInitialMediaSettingsForType(type: string, streamInfo: StreamInfo): void;
+    selectInitialTrack(type: string, tracks: MediaInfo[]): MediaInfo;
 
-        setInitialSettings(type: string, value: object): void;
+    setConfig(config: object): void;
 
-        setTrack(track: MediaInfo, options: object): void;
-    }
+    setInitialMediaSettingsForType(type: string, streamInfo: StreamInfo): void;
 
-    export interface MediaSourceController {
-        attachMediaSource(videoModel: object): string;
+    setInitialSettings(type: string, value: object): void;
 
-        createMediaSource(): MediaSource;
+    setTrack(track: MediaInfo, options: object): void;
+}
 
-        detachMediaSource(videoModel: object): void;
+export interface MediaSourceController {
+    attachMediaSource(videoModel: object): string;
 
-        setDuration(value: object): void;
+    createMediaSource(): MediaSource;
 
-        setSeekable(start: number, end: number): void;
+    detachMediaSource(videoModel: object): void;
 
-        signalEndOfStream(source: any): void;
-    }
+    setDuration(value: object): void;
 
-    export interface PlaybackController {
-        computeAndSetLiveDelay(fragmentDuration: number, manifestInfo: IManifestInfo): number;
+    setSeekable(start: number, end: number): void;
 
-        getAvailabilityStartTime(): number;
+    signalEndOfStream(source: any): void;
+}
 
-        getBufferLevel(filterList?: any[]): number | null;
+export interface PlaybackController {
+    computeAndSetLiveDelay(fragmentDuration: number, manifestInfo: IManifestInfo): number;
 
-        getCurrentLiveLatency(): number;
+    getAvailabilityStartTime(): number;
 
-        getEnded(): boolean | null;
+    getBufferLevel(filterList?: any[]): number | null;
 
-        getInitialCatchupModeActivated(): boolean;
+    getCurrentLiveLatency(): number;
 
-        getIsDynamic(): boolean;
+    getEnded(): boolean | null;
 
-        getIsManifestUpdateInProgress(): boolean;
+    getInitialCatchupModeActivated(): boolean;
 
-        getLiveDelay(): number;
+    getIsDynamic(): boolean;
 
-        getLowLatencyModeEnabled(): boolean;
+    getIsManifestUpdateInProgress(): boolean;
 
-        getOriginalLiveDelay(): number;
+    getLiveDelay(): number;
 
-        getPlaybackRate(): number | null;
+    getLowLatencyModeEnabled(): boolean;
 
-        getPlaybackStalled(): boolean;
+    getOriginalLiveDelay(): number;
 
-        getPlayedRanges(): TimeRanges | null;
+    getPlaybackRate(): number | null;
 
-        getStreamController(): object;
+    getPlaybackStalled(): boolean;
 
-        getStreamEndTime(sInfo: StreamInfo): number;
+    getPlayedRanges(): TimeRanges | null;
 
-        getTime(): number | null;
+    getStreamController(): object;
 
-        getTimeToStreamEnd(sInfo?: StreamInfo): number;
+    getStreamEndTime(sInfo: StreamInfo): number;
 
-        initialize(sInfo: StreamInfo, periodSwitch: boolean): void;
+    getTime(): number | null;
 
-        isPaused(): boolean | null;
+    getTimeToStreamEnd(sInfo?: StreamInfo): number;
 
-        isProgressing(): Promise<any>;
+    initialize(sInfo: StreamInfo, periodSwitch: boolean): void;
 
-        isSeeking(): boolean | null;
+    isPaused(): boolean | null;
 
-        isStalled(): boolean | null;
+    isProgressing(): Promise<any>;
 
-        pause(): void;
+    isSeeking(): boolean | null;
 
-        play(): void;
+    isStalled(): boolean | null;
 
-        reset(): void;
+    pause(): void;
 
-        seek(time: number, stickToBuffered: boolean, internal: boolean): void;
+    play(): void;
 
-        seekToCurrentLive(stickToBuffered?: boolean, internal?: boolean, adjustLiveDelay?: boolean): void;
+    reset(): void;
 
-        seekToOriginalLive(stickToBuffered?: boolean, internal?: boolean, adjustLiveDelay?: boolean): void;
+    seek(time: number, stickToBuffered: boolean, internal: boolean): void;
 
-        setConfig(config: object): void;
+    seekToCurrentLive(stickToBuffered?: boolean, internal?: boolean, adjustLiveDelay?: boolean): void;
 
-        updateCurrentTime(mediaType?: MediaType): void;
-    }
+    seekToOriginalLive(stickToBuffered?: boolean, internal?: boolean, adjustLiveDelay?: boolean): void;
 
-    export interface ScheduleController {
-        clearScheduleTimer(): void;
+    setConfig(config: object): void;
 
-        getBufferTarget(): number;
+    updateCurrentTime(mediaType?: MediaType): void;
+}
 
-        getStreamId(): string;
+export interface ScheduleController {
+    clearScheduleTimer(): void;
 
-        getSwitchTrack(): any;
+    getBufferTarget(): number;
 
-        getTimeToLoadDelay(): number;
+    getStreamId(): string;
 
-        getType(): string;
+    getSwitchTrack(): any;
 
-        initialize(_hasVideoTrack: boolean): void;
+    getTimeToLoadDelay(): number;
 
-        reset(): void;
+    getType(): string;
 
-        setCheckPlaybackQuality(value: object): void;
+    initialize(_hasVideoTrack: boolean): void;
 
-        setInitSegmentRequired(value: object): void;
+    reset(): void;
 
-        setLastInitializedRepresentationId(value: number): void;
+    setCheckPlaybackQuality(value: object): void;
 
-        setSwitchTrack(value: object): void;
+    setInitSegmentRequired(value: object): void;
 
-        setTimeToLoadDelay(value: object): void;
+    setLastInitializedRepresentationId(value: number): void;
 
-        startScheduleTimer(value: object): void;
-    }
+    setSwitchTrack(value: object): void;
 
-    export interface StreamController {
-        addDVRMetric(): void;
+    setTimeToLoadDelay(value: object): void;
 
-        getActiveStream(): object;
+    startScheduleTimer(value: object): void;
+}
 
-        getActiveStreamInfo(): StreamInfo | null;
+export interface StreamController {
+    addDVRMetric(): void;
 
-        getActiveStreamProcessors(): any[];
+    getActiveStream(): object;
 
-        getAutoPlay(): boolean;
+    getActiveStreamInfo(): StreamInfo | null;
 
-        getHasMediaOrInitialisationError(): boolean;
+    getActiveStreamProcessors(): any[];
 
-        getInitialPlayback(): any;
+    getAutoPlay(): boolean;
 
-        getIsStreamSwitchInProgress(): boolean;
+    getHasMediaOrInitialisationError(): boolean;
 
-        getStreamById(id: string): object | null;
+    getInitialPlayback(): any;
 
-        getStreamForTime(time: number): object | null;
+    getIsStreamSwitchInProgress(): boolean;
 
-        getStreams(): any[];
+    getStreamById(id: string): object | null;
 
-        getTimeRelativeToStreamId(time: number, id: string): number | null;
+    getStreamForTime(time: number): object | null;
 
-        hasAudioTrack(): void;
+    getStreams(): any[];
 
-        hasVideoTrack(): void;
+    getTimeRelativeToStreamId(time: number, id: string): number | null;
 
-        initialize(autoPl: any, protData: object): void;
+    hasAudioTrack(): void;
 
-        load(url: string, startTime?: number): void;
+    hasVideoTrack(): void;
 
-        loadWithManifest(manifest: object): void;
+    initialize(autoPl: any, protData: object): void;
 
-        refreshManifest(): void;
+    load(url: string, startTime?: number): void;
 
-        reset(): void;
+    loadWithManifest(manifest: object): void;
 
-        setConfig(config: object): void;
+    refreshManifest(): void;
 
-        setProtectionData(protData: object): void;
+    reset(): void;
 
-        switchToVideoElement(seekTime: number): void;
-    }
+    setConfig(config: object): void;
 
-    export interface ThroughputController {
-        getArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
+    setProtectionData(protData: object): void;
 
-        getAverageLatency(mediaType: MediaType, calculationMode: string, sampleSize: number): number
+    switchToVideoElement(seekTime: number): void;
+}
 
-        getAverageThroughput(mediaType: MediaType, calculationMode: string, sampleSize: number): number
+export interface ThroughputController {
+    getArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
 
-        getByteSizeWeightedArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
+    getAverageLatency(mediaType: MediaType, calculationMode: string, sampleSize: number): number
 
-        getByteSizeWeightedHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
+    getAverageThroughput(mediaType: MediaType, calculationMode: string, sampleSize: number): number
 
-        getDateWeightedArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
+    getByteSizeWeightedArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
 
-        getDateWeightedHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
+    getByteSizeWeightedHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
 
-        getEwma(dict: ThroughputEwmaDictEntry[], halfLife: object, useMin: boolean): number
+    getDateWeightedArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
 
-        getHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
+    getDateWeightedHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
 
-        getRawThroughputData(mediaType: MediaType): number
+    getEwma(dict: ThroughputEwmaDictEntry[], halfLife: object, useMin: boolean): number
 
-        getSafeAverageThroughput(mediaType: MediaType, calculationMode: string, sampleSize: number): number
+    getHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
 
-        getZlema(dict: ThroughputDictEntry[], sampleSize: number): number
+    getRawThroughputData(mediaType: MediaType): number
 
-        initialize(): void;
+    getSafeAverageThroughput(mediaType: MediaType, calculationMode: string, sampleSize: number): number
 
-        reset(): void;
+    getZlema(dict: ThroughputDictEntry[], sampleSize: number): number
 
-        setConfig(config: object): void;
-    }
+    initialize(): void;
 
-    export interface TimeSyncController {
-        attemptSync(tSources: number[], isDynamic: boolean): void;
+    reset(): void;
 
-        initialize(): void;
+    setConfig(config: object): void;
+}
 
-        setConfig(config: object): void;
+export interface TimeSyncController {
+    attemptSync(tSources: number[], isDynamic: boolean): void;
 
-        reset(): void;
-    }
+    initialize(): void;
 
-    export interface XlinkController {
-        reset(): void;
+    setConfig(config: object): void;
 
-        resolveManifestOnLoad(mpd: Mpd): void;
+    reset(): void;
+}
 
-        setParser(value: object): void;
-    }
+export interface XlinkController {
+    reset(): void;
 
-    /**
-     * Streaming - Metrics - Controllers
-     **/
+    resolveManifestOnLoad(mpd: Mpd): void;
 
-    export interface MetricsCollectionController {
-        reset(): void;
-    }
+    setParser(value: object): void;
+}
 
-    export interface MetricsController {
-        initialize(metricsEntry: object): void;
+/**
+ * Streaming - Metrics - Controllers
+ **/
 
-        reset(): void;
-    }
+export interface MetricsCollectionController {
+    reset(): void;
+}
 
-    export interface MetricsHandlersController {
-        initialize(metrics: object[], reportingController: ReportingController): void;
+export interface MetricsController {
+    initialize(metricsEntry: object): void;
 
-        reset(): void;
-    }
+    reset(): void;
+}
 
-    export interface RangeController {
-        initialize(rs: object[]): void;
+export interface MetricsHandlersController {
+    initialize(metrics: object[], reportingController: ReportingController): void;
 
-        isEnabled(): boolean;
+    reset(): void;
+}
 
-        reset(): void;
-    }
+export interface RangeController {
+    initialize(rs: object[]): void;
 
-    export interface ReportingController {
-        initialize(rangeController: RangeController): void;
+    isEnabled(): boolean;
 
-        report(type: string, vos: any[]): void;
+    reset(): void;
+}
 
-        reset(): void;
-    }
+export interface ReportingController {
+    initialize(rangeController: RangeController): void;
 
-    /**
-     * Streaming - Metrics - Metrics - Handlers
-     **/
+    report(type: string, vos: any[]): void;
 
-    export interface BufferLevelHandler {
-        initialize(basename: string, rc: RangeController, n_ms: string): void;
+    reset(): void;
+}
 
-        handleNewMetric(metric: any, vo: any, type: string): void;
+/**
+ * Streaming - Metrics - Metrics - Handlers
+ **/
 
-        reset(): void;
-    }
+export interface BufferLevelHandler {
+    initialize(basename: string, rc: RangeController, n_ms: string): void;
 
-    export interface DVBErrorsHandler {
-        initialize(unused: any, rc: RangeController): void; //unused does nothing
+    handleNewMetric(metric: any, vo: any, type: string): void;
 
-        handleNewMetric(metric: any, vo: any): void;
+    reset(): void;
+}
 
-        reset(): void;
-    }
+export interface DVBErrorsHandler {
+    initialize(unused: any, rc: RangeController): void; //unused does nothing
 
-    export interface GenericMetricHandler {
-        initialize(name: string, rc: RangeController): void;
+    handleNewMetric(metric: any, vo: any): void;
 
-        handleNewMetric(metric: any, vo: any): void;
+    reset(): void;
+}
 
-        reset(): void;
-    }
+export interface GenericMetricHandler {
+    initialize(name: string, rc: RangeController): void;
 
-    export interface HttpListHandler {
-        initialize(basename: string, rc: RangeController, n_ms: string, requestType: string): void;
+    handleNewMetric(metric: any, vo: any): void;
 
-        handleNewMetric(metric: any, vo: any): void;
+    reset(): void;
+}
 
-        reset(): void;
-    }
+export interface HttpListHandler {
+    initialize(basename: string, rc: RangeController, n_ms: string, requestType: string): void;
 
-    /**
-     * Streaming - Metrics - Metrics
-     **/
+    handleNewMetric(metric: any, vo: any): void;
 
-    export interface MetricsHandlerFactory {
-        create(listType: string, reportingController: ReportingController): void;
+    reset(): void;
+}
 
-        register(key: string, handler: object): void;
+/**
+ * Streaming - Metrics - Metrics
+ **/
 
-        unregister(key: string): void;
-    }
+export interface MetricsHandlerFactory {
+    create(listType: string, reportingController: ReportingController): void;
 
-    /**
-     * Streaming - Metrics - Reporting - Reporters
-     **/
+    register(key: string, handler: object): void;
 
-    export interface DVBReporting {
-        initialize(entry: object, rc: RangeController): void;
+    unregister(key: string): void;
+}
 
-        report(type: string, vos: any[]): void;
+/**
+ * Streaming - Metrics - Reporting - Reporters
+ **/
 
-        reset(): void;
-    }
+export interface DVBReporting {
+    initialize(entry: object, rc: RangeController): void;
 
-    /**
-     * Streaming - Metrics - Reporting
-     **/
+    report(type: string, vos: any[]): void;
 
-    export interface ReportingFactory {
-        create(entry: object, reportingController: ReportingController): void;
+    reset(): void;
+}
 
-        register(schemeIdUri: string, moduleName: string): void;
+/**
+ * Streaming - Metrics - Reporting
+ **/
 
-        unregister(schemeIdUri: string): void;
-    }
+export interface ReportingFactory {
+    create(entry: object, reportingController: ReportingController): void;
 
-    /**
-     * Streaming - Metrics - utils
-     **/
+    register(schemeIdUri: string, moduleName: string): void;
 
-    export interface DVBErrorsTranslator {
-        initialize(): void;
+    unregister(schemeIdUri: string): void;
+}
 
-        reset(): void;
-    }
+/**
+ * Streaming - Metrics - utils
+ **/
 
-    export interface HandlerHelpers {
-        // Exports nothing
-    }
+export interface DVBErrorsTranslator {
+    initialize(): void;
 
-    export interface ManifestParsing {
-        getMetrics(manifest: object): object[];
-    }
+    reset(): void;
+}
 
-    export interface MetricSerialiser {
-        serialise(metric: object): string;
-    }
+export interface HandlerHelpers {
+    // Exports nothing
+}
 
-    export interface RNG {
-        random(min: number, max: number): number;
-    }
+export interface ManifestParsing {
+    getMetrics(manifest: object): object[];
+}
 
-    /**
-     * Streaming - Metrics - Vo
-     **/
-
-    export class DVBErrors {
-        errorcode: string | null;
-        ipaddress: string | null;
-        mpdurl: string | null;
-        servicelocation: string | null;
-        terror: Date | null;
-        url: string | null;
-
-        BASE_URL_CHANGED: 'F00';
-        BECAME_REPORTER: 'S00';
-        CONNECTION_ERROR: 'C03';
-        CONNECTION_REFUSED: 'C02';
-        CORRUPT_MEDIA_ISOBMFF: 'M00';
-        CORRUPT_MEDIA_OTHER: 'M01';
-        DNS_RESOLUTION_FAILED: 'C00';
-        HOST_UNREACHABLE: 'C01';
-        SSL_CONNECTION_FAILED_PREFIX: 'SSL';
-    }
+export interface MetricSerialiser {
+    serialise(metric: object): string;
+}
 
-    export interface Metrics {
-        metrics: string;
-        Range: any[];
-        Reporting: any[];
-    }
+export interface RNG {
+    random(min: number, max: number): number;
+}
 
-    export interface Range {
-        _useWallClockTime: boolean;
-        duration: number;
-        starttime: number;
-    }
+/**
+ * Streaming - Metrics - Vo
+ **/
+
+export class DVBErrors {
+    errorcode: string | null;
+    ipaddress: string | null;
+    mpdurl: string | null;
+    servicelocation: string | null;
+    terror: Date | null;
+    url: string | null;
+
+    BASE_URL_CHANGED: 'F00';
+    BECAME_REPORTER: 'S00';
+    CONNECTION_ERROR: 'C03';
+    CONNECTION_REFUSED: 'C02';
+    CORRUPT_MEDIA_ISOBMFF: 'M00';
+    CORRUPT_MEDIA_OTHER: 'M01';
+    DNS_RESOLUTION_FAILED: 'C00';
+    HOST_UNREACHABLE: 'C01';
+    SSL_CONNECTION_FAILED_PREFIX: 'SSL';
+}
 
-    export interface Reporting {
-        DEFAULT_DVB_PROBABILITY: 1000;
+export interface Metrics {
+    metrics: string;
+    Range: any[];
+    Reporting: any[];
+}
 
-        dvbProbability: number;
-        dvbReportingUrl: string;
-        schemeIdUri: string;
-        value: string;
-    }
+export interface Range {
+    _useWallClockTime: boolean;
+    duration: number;
+    starttime: number;
+}
 
-    /**
-     * Streaming - Metrics
-     **/
+export interface Reporting {
+    DEFAULT_DVB_PROBABILITY: 1000;
 
-    export interface MetricsReporting {
-        createMetricsReporting(config: object): void;
+    dvbProbability: number;
+    dvbReportingUrl: string;
+    schemeIdUri: string;
+    value: string;
+}
 
-        getMetricsHandlerFactory(): MetricsHandlerFactory;
+/**
+ * Streaming - Metrics
+ **/
 
-        getReportingFactory(): ReportingFactory;
-    }
+export interface MetricsReporting {
+    createMetricsReporting(config: object): void;
 
-    export class MetricsReportingEvents extends EventsBase {
-        BECAME_REPORTING_PLAYER: 'internal_becameReportingPlayer';
-        CMCD_DATA_GENERATED: 'cmcdDataGenerated';
-        METRICS_INITIALISATION_COMPLETE: 'internal_metricsReportingInitialized';
-    }
+    getMetricsHandlerFactory(): MetricsHandlerFactory;
 
-    /**
-     * Streaming - Models
-     **/
+    getReportingFactory(): ReportingFactory;
+}
 
-    export interface AastLowLatencyThroughputModel {
-        addMeasurement(request: HTTPRequest, chunkMeasurements: any[], requestTimeMs: number, throughputCapacityDelayMS: number): void;
+export class MetricsReportingEvents extends EventsBase {
+    BECAME_REPORTING_PLAYER: 'internal_becameReportingPlayer';
+    CMCD_DATA_GENERATED: 'cmcdDataGenerated';
+    METRICS_INITIALISATION_COMPLETE: 'internal_metricsReportingInitialized';
+}
 
-        getEstimatedDownloadDurationMS(request: HTTPRequest): number;
+/**
+ * Streaming - Models
+ **/
 
-        getThroughputCapacityDelayMS(request: HTTPRequest, currentBufferLevelMS: number): number;
+export interface AastLowLatencyThroughputModel {
+    addMeasurement(request: HTTPRequest, chunkMeasurements: any[], requestTimeMs: number, throughputCapacityDelayMS: number): void;
 
-        setup(): void;
-    }
+    getEstimatedDownloadDurationMS(request: HTTPRequest): number;
 
-    export interface BaseURLTreeModel {
-        getBaseUrls(root: any): BaseURL[];
+    getThroughputCapacityDelayMS(request: HTTPRequest, currentBufferLevelMS: number): number;
 
-        getForPath(path: any): any;
+    setup(): void;
+}
 
-        invalidateSelectedIndexes(serviceLocation: string): void;
+export interface BaseURLTreeModel {
+    getBaseUrls(root: any): BaseURL[];
 
-        reset(): void;
+    getForPath(path: any): any;
 
-        setConfig(config: object): void;
+    invalidateSelectedIndexes(serviceLocation: string): void;
 
-        update(manifest: object): void;
-    }
+    reset(): void;
 
-    export interface CmcdModel {
-        getCmcdData(request: HTTPRequest): object;
+    setConfig(config: object): void;
 
-        getCmcdParametersFromManifest(): CMCDParameters;
+    update(manifest: object): void;
+}
 
-        getHeaderParameters(request: HTTPRequest): object | null;
+export interface CmcdModel {
+    getCmcdData(request: HTTPRequest): object;
 
-        getQueryParameter(request: HTTPRequest): { key: string, finalPayloadString: string } | null;
+    getCmcdParametersFromManifest(): CMCDParameters;
 
-        initialize(): void;
+    getHeaderParameters(request: HTTPRequest): object | null;
 
-        isCmcdEnabled(): boolean;
+    getQueryParameter(request: HTTPRequest): { key: string, finalPayloadString: string } | null;
 
-        reset(): void;
+    initialize(): void;
 
-        setConfig(config: object): void;
-    }
+    isCmcdEnabled(): boolean;
 
-    export interface CmsdModel {
-        getEstimatedThroughput(type: string): number;
+    reset(): void;
 
-        getMaxBitrate(type: string): number;
+    setConfig(config: object): void;
+}
 
-        getResponseDelay(type: string): number;
+export interface CmsdModel {
+    getEstimatedThroughput(type: string): number;
 
-        getRoundTripTime(type: string): number;
+    getMaxBitrate(type: string): number;
 
-        initialize(): void; // NOT IMPLEMENTED!
-        parseResponseHeader(responseHeaders: object, mediaType: MediaType): void;
+    getResponseDelay(type: string): number;
 
-        reset(): void;
+    getRoundTripTime(type: string): number;
 
-        setConfig(): void; // NOT IMPLEMENTED!
-    }
+    addExternalSubtitle(externalSubtitleObj: object): void;
 
-    export interface CustomParametersModel {
-        addAbrCustomRule(type: string, rulename: string, rule: object): void;
+    addRequestInterceptor(interceptor: Function): void;
 
-        addExternalSubtitle(externalSubtitleObj: object): void;
+    initialize(): void; // NOT IMPLEMENTED!
 
-        addRequestInterceptor(interceptor: Function): void;
+    parseResponseHeader(responseHeaders: object, mediaType: MediaType): void;
 
-        addResponseInterceptor(interceptor: Function): void;
+    reset(): void;
 
-        addUTCTimingSource(schemeIdUri: string, value: string): void;
+    setConfig(): void; // NOT IMPLEMENTED!
+}
 
-        clearDefaultUTCTimingSources(): void;
+export interface CustomParametersModel {
+    addAbrCustomRule(type: string, rulename: string, rule: object): void;
 
-        getAbrCustomRules(): Array<object>;
+    addRequestInterceptor(interceptor: Function): void;
 
-        getCustomCapabilitiesFilters(): Array<CapabilitiesFilterFunction>;
+    addResponseInterceptor(interceptor: Function): void;
 
-        getCustomInitialTrackSelectionFunction(): Function;
+    addUTCTimingSource(schemeIdUri: string, value: string): void;
 
-        getExternalSubtitles(): Array<ExternalSubtitle>
+    getExternalSubtitles(): Array<ExternalSubtitle>
 
-        getLicenseRequestFilters(): Array<Function>;
+    clearDefaultUTCTimingSources(): void;
 
-        getLicenseResponseFilters(): Array<Function>;
+    getAbrCustomRules(): Array<object>;
 
-        getRequestInterceptors(): void;
+    getCustomCapabilitiesFilters(): Array<CapabilitiesFilterFunction>;
 
-        getResponseInterceptors(): void;
+    getCustomInitialTrackSelectionFunction(): Function;
 
-        getUTCTimingSources(): Array<object>;
+    getLicenseRequestFilters(): Array<Function>;
 
-        getXHRWithCredentialsForType(type: string): any;
+    getLicenseResponseFilters(): Array<Function>;
 
-        registerCustomCapabilitiesFilter(filter: CapabilitiesFilterFunction): void;
+    getRequestInterceptors(): void;
 
-        registerLicenseRequestFilter(filter: Function): void;
+    getResponseInterceptors(): void;
 
-        registerLicenseResponseFilter(filter: Function): void;
+    getUTCTimingSources(): Array<object>;
 
-        removeAbrCustomRule(ruleName: string): void;
+    getXHRWithCredentialsForType(type: string): any;
 
-        removeAllAbrCustomRule(): void;
+    registerCustomCapabilitiesFilter(filter: CapabilitiesFilterFunction): void;
 
-        removeExternalSubtitleById(id: string): void;
+    removeExternalSubtitleById(id: string): void;
 
-        removeExternalSubtitleByUrl(url: string): void;
+    removeExternalSubtitleByUrl(url: string): void;
 
-        removeRequestInterceptor(interceptor: Function): void;
+    registerLicenseRequestFilter(filter: Function): void;
 
-        removeResponseInterceptor(interceptor: Function): void;
+    registerLicenseResponseFilter(filter: Function): void;
 
-        removeUTCTimingSource(schemeIdUri: string, value: string): void;
+    removeAbrCustomRule(ruleName: string): void;
 
-        reset(): void;
+    removeAllAbrCustomRule(): void;
 
-        resetCustomInitialTrackSelectionFunction(): void;
+    removeRequestInterceptor(interceptor: Function): void;
 
-        restoreDefaultUTCTimingSources(): void;
+    removeResponseInterceptor(interceptor: Function): void;
 
-        setConfig(): void; // NOT IMPLEMENTED
-        setCustomInitialTrackSelectionFunction(customFunc: Function): void;
+    removeUTCTimingSource(schemeIdUri: string, value: string): void;
 
-        setXHRWithCredentialsForType(type: string, value: string): void;
+    reset(): void;
 
-        unregisterCustomCapabilitiesFilter(filter: CapabilitiesFilterFunction): void;
+    resetCustomInitialTrackSelectionFunction(): void;
 
-        unregisterLicenseRequestFilter(filter: Function): void;
+    restoreDefaultUTCTimingSources(): void;
 
-        unregisterLicenseResponseFilter(filter: Function): void
-    }
+    setConfig(): void; // NOT IMPLEMENTED
+    setCustomInitialTrackSelectionFunction(customFunc: Function): void;
 
-    export interface FragmentModel {
-        abortRequests(): void;
+    setXHRWithCredentialsForType(type: string, value: string): void;
 
-        executeRequest(request: HTTPRequest): void;
+    unregisterCustomCapabilitiesFilter(filter: CapabilitiesFilterFunction): void;
 
-        getRequests(filter: any): HTTPRequest[];
+    unregisterLicenseRequestFilter(filter: Function): void;
 
-        getStreamId(): string;
+    unregisterLicenseResponseFilter(filter: Function): void
+}
 
-        getType(): string;
+export interface FragmentModel {
+    abortRequests(): void;
 
-        isFragmentLoaded(request: HTTPRequest): boolean;
+    executeRequest(request: HTTPRequest): void;
 
-        isFragmentLoadedOrPending(request: HTTPRequest): boolean;
+    getRequests(filter: any): HTTPRequest[];
 
-        removeExecutedRequestAfterTime(time: number): boolean;
+    getStreamId(): string;
 
-        removeExecutedRequestsBeforeTime(time: number): boolean;
+    getType(): string;
 
-        reset(): void;
+    isFragmentLoaded(request: HTTPRequest): boolean;
 
-        resetInitialSettings(): void;
+    isFragmentLoadedOrPending(request: HTTPRequest): boolean;
 
-        syncExecutedRequestsWithBufferedRange(bufferedRanges: Range[], streamDuration: number): void;
-    }
+    removeExecutedRequestAfterTime(time: number): boolean;
 
-    export interface ManifestModel {
-        getValue(): object;
+    removeExecutedRequestsBeforeTime(time: number): boolean;
 
-        setValue(value: object): void;
-    }
+    reset(): void;
 
-    export interface MediaPlayerModel {
-        getAbrBitrateParameter(field: string, mediaType: string): object | -1;
+    resetInitialSettings(): void;
 
-        getBufferTimeDefault(): number;
+    syncExecutedRequestsWithBufferedRange(bufferedRanges: Range[], streamDuration: number): void;
+}
 
-        getCatchupMaxDrift(): number;
+export interface ManifestModel {
+    getValue(): object;
 
-        getCatchupModeEnabled(): boolean;
+    setValue(value: object): void;
+}
 
-        getCatchupPlaybackRates(log: any): number;
+export interface MediaPlayerModel {
+    getAbrBitrateParameter(field: string, mediaType: string): object | -1;
 
-        getFastSwitchEnabled(): boolean;
+    getBufferTimeDefault(): number;
 
-        getInitialBufferLevel(): number;
+    getCatchupMaxDrift(): number;
 
-        getRetryAttemptsForType(type: string): number;
+    getCatchupModeEnabled(): boolean;
 
-        getRetryIntervalsForType(type: string): any;
+    getCatchupPlaybackRates(log: any): number;
 
-        reset(): void;
+    getFastSwitchEnabled(): boolean;
 
-        setConfig(config: object): void;
-    }
+    getInitialBufferLevel(): number;
 
-    export interface MetricsModel {
-        config: object;
+    getRetryAttemptsForType(type: string): number;
 
-        addBufferLevel(mediaType: MediaType, t: Date, level: number): void;
+    getRetryIntervalsForType(type: string): any;
 
-        addBufferState(mediaType: MediaType, state: string, target: number): void;
+    reset(): void;
 
-        addDVBErrors(vo: any): void;
+    setConfig(config: object): void;
+}
 
-        addDVRInfo(mediaType: MediaType, currentTime: number, mpd: Mpd, range: Range): void;
+export interface MetricsModel {
+    config: object;
 
-        addDroppedFrames(mediaType: MediaType, quality: number): void;
+    addBufferLevel(mediaType: MediaType, t: Date, level: number): void;
 
-        addHttpRequest(request: HTTPRequest, response: object, traces: object, cmsd: object): void;
+    addBufferState(mediaType: MediaType, state: string, target: number): void;
 
-        addManifestUpdate(mediaType: MediaType, type: string, requestTime: number, fetchTime: number): void;
+    addDVBErrors(vo: any): void;
 
-        addManifestUpdateRepresentationInfo(manifestUpdate: ManifestUpdate, representation: Representation, mediaType: MediaType): void;
+    addDVRInfo(mediaType: MediaType, currentTime: number, mpd: Mpd, range: Range): void;
 
-        addManifestUpdateStreamInfo(manifestUpdate: ManifestUpdate, id: string, index: number, start: number, duration: number): void;
+    addDroppedFrames(mediaType: MediaType, quality: number): void;
 
-        addPlayList(vo: any): void;
+    addHttpRequest(request: HTTPRequest, response: object, traces: object, cmsd: object): void;
 
-        addRepresentationSwitch(mediaType: MediaType, t: Date, mt: Date, to: string, lto: string): void;
+    addManifestUpdate(mediaType: MediaType, type: string, requestTime: number, fetchTime: number): void;
 
-        addRequestsQueue(mediaType: MediaType, loadingRequests: any[], executedRequests: any[]): void;
+    addManifestUpdateRepresentationInfo(manifestUpdate: ManifestUpdate, representation: Representation, mediaType: MediaType): void;
 
-        addSchedulingInfo(mediaType: MediaType, t: number, startTime: number, availabilityStartTime: number, duration: number, quality: number, range: Range, state: string): void;
+    addManifestUpdateStreamInfo(manifestUpdate: ManifestUpdate, id: string, index: number, start: number, duration: number): void;
 
-        clearAllCurrentMetrics(): void;
+    addPlayList(vo: any): void;
 
-        clearCurrentMetricsForType(type: string): void;
+    addRepresentationSwitch(mediaType: MediaType, t: Date, mt: Date, to: string, lto: string): void;
 
-        getMetricsFor(type: string, readOnly: boolean): object;
+    addRequestsQueue(mediaType: MediaType, loadingRequests: any[], executedRequests: any[]): void;
 
-        updateManifestUpdateInfo(manifestUpdate: ManifestUpdate, updatedFields: any[]): void;
-    }
+    addSchedulingInfo(mediaType: MediaType, t: number, startTime: number, availabilityStartTime: number, duration: number, quality: number, range: Range, state: string): void;
 
-    export interface ThroughputModel {
-        addEntry(mediaType: MediaType, httpRequest: HTTPRequest): void;
+    clearAllCurrentMetrics(): void;
 
-        getThroughputDict(mediaType: MediaType): ThroughputDictEntry;
+    clearCurrentMetricsForType(type: string): void;
 
-        getEwmaThroughputDict(mediaType: MediaType): ThroughputEwmaDictEntry;
+    getMetricsFor(type: string, readOnly: boolean): object;
 
-        getEwmaLatencyDict(mediaType: MediaType): ThroughputEwmaDictEntry;
+    updateManifestUpdateInfo(manifestUpdate: ManifestUpdate, updatedFields: any[]): void;
+}
 
-        getEwmaHalfLife(mediaType: MediaType): object;
+export interface ThroughputModel {
+    addEntry(mediaType: MediaType, httpRequest: HTTPRequest): void;
 
-        getLatencyDict(mediaType: MediaType): ThroughputDictEntry;
+    getThroughputDict(mediaType: MediaType): ThroughputDictEntry;
 
-        reset(): void;
-    }
+    getEwmaThroughputDict(mediaType: MediaType): ThroughputEwmaDictEntry;
 
-    export interface URIFragmentModel {
-        getURIFragmentData(): URIFragmentData;
+    getEwmaLatencyDict(mediaType: MediaType): ThroughputEwmaDictEntry;
 
-        initialize(uri: string): void;
-    }
+    getEwmaHalfLife(mediaType: MediaType): object;
 
-    interface VideoModel {
-        addEventListener(): void;
+    getLatencyDict(mediaType: MediaType): ThroughputDictEntry;
 
-        addTextTrack(kind: TextTrackType, label: string | number | undefined, isTTML: boolean, isEmbedded: boolean): TextTrackInfo;
+    reset(): void;
+}
 
-        appendChild(childElement: any): void;
+export interface URIFragmentModel {
+    getURIFragmentData(): URIFragmentData;
 
-        getBufferRange(): TimeRanges | null;
+    initialize(uri: string): void;
+}
 
-        getClientHeight(): number;
+export interface VideoModel {
+    addEventListener(): void;
 
-        getClientWidth(): number;
+    addTextTrack(kind: TextTrackType, label: string | number | undefined, isTTML: boolean, isEmbedded: boolean): TextTrackInfo;
 
-        getElement(): HTMLVideoElement | HTMLAudioElement;
+    appendChild(childElement: any): void;
 
-        getEnded(): boolean | null;
+    getBufferRange(): TimeRanges | null;
 
-        getPlaybackQuality(): number;
+    getClientHeight(): number;
 
-        getPlaybackRate(): number | null;
+    getClientWidth(): number;
 
-        getPlayedRanges(): TimeRanges | null;
+    getElement(): HTMLVideoElement | HTMLAudioElement;
 
-        getReadyState(): number;
+    getEnded(): boolean | null;
 
-        getSource(): string | null;
+    getPlaybackQuality(): number;
 
-        getTTMLRenderingDiv(): HTMLDivElement | null;
+    getPlaybackRate(): number | null;
 
-        getTextTrack(kind: TextTrackType, label: string | number | undefined, isTTML: boolean, isEmbedded: boolean): TextTrackInfo | null;
+    getPlayedRanges(): TimeRanges | null;
 
-        getTextTracks(): TextTrackList[];
+    getReadyState(): number;
 
-        getTime(): number | null;
+    getSource(): string | null;
 
-        getVideoHeight(): number;
+    getTTMLRenderingDiv(): HTMLDivElement | null;
 
-        getVideoRelativeOffsetLeft(): number;
+    getTextTrack(kind: TextTrackType, label: string | number | undefined, isTTML: boolean, isEmbedded: boolean): TextTrackInfo | null;
 
-        getVideoRelativeOffsetTop(): number;
+    getTextTracks(): TextTrackList[];
 
-        getVideoWidth(): number;
+    getTime(): number | null;
 
-        getVttRenderingDiv(): HTMLDivElement | null;
+    getVideoHeight(): number;
 
-        initialize(): void;
+    getVideoRelativeOffsetLeft(): number;
 
-        isPaused(): void;
+    getVideoRelativeOffsetTop(): number;
 
-        isSeeking(): void;
+    getVideoWidth(): number;
 
-        isStalled(): boolean;
+    getVttRenderingDiv(): HTMLDivElement | null;
 
-        onPlaying(): void;
+    initialize(): void;
 
-        pause(): void;
+    isPaused(): void;
 
-        play(): void;
+    isSeeking(): void;
 
-        removeChild(childElement: any): void;
+    isStalled(): boolean;
 
-        removeEventListener(): void;
+    onPlaying(): void;
 
-        reset(): void;
+    pause(): void;
 
-        setDisableRemotePlayback(value: boolean): void;
+    play(): void;
 
-        setElement(value: HTMLVideoElement | HTMLAudioElement): void;
+    removeChild(childElement: any): void;
 
-        setPlaybackRate(value: number, ignoreReadyState?: boolean): void;
+    removeEventListener(): void;
 
-        setSource(source: string): void;
+    reset(): void;
 
-        setStallState(type: MediaType, state: boolean): void;
+    setDisableRemotePlayback(value: boolean): void;
 
-        setTTMLRenderingDiv(div: HTMLDivElement): void;
+    setElement(value: HTMLVideoElement | HTMLAudioElement): void;
 
-        setVttRenderingDiv(div: HTMLDivElement): void;
+    setPlaybackRate(value: number, ignoreReadyState?: boolean): void;
 
-        setcurrentTime(currentTime: number, stickToBuffered: boolean): void;
+    setSource(source: string): void;
 
-        stallStream(type: MediaType, isStalled: boolean): void;
+    setStallState(type: MediaType, state: boolean): void;
 
-        waitForReadyState(targetReadyState: number, callback: () => any): void;
+    setTTMLRenderingDiv(div: HTMLDivElement): void;
 
-    }
+    setVttRenderingDiv(div: HTMLDivElement): void;
 
-    /**
-     * Streaming - Net
-     **/
+    setcurrentTime(currentTime: number, stickToBuffered: boolean): void;
 
-    export interface FetchLoader {
-        abort(): void;
+    stallStream(type: MediaType, isStalled: boolean): void;
 
-        calculateDownloadedTime(downloadedData: any, bytesReceived: any): number | null;
+    waitForReadyState(targetReadyState: number, callback: () => any): void;
 
-        load(httpRequest: HTTPRequest, httpResponse: object): void;
+}
 
-        reset(): void;
+/**
+ * Streaming - Net
+ **/
 
-        setup(cfg: object): void;
-    }
+export interface FetchLoader {
+    abort(): void;
 
-    export interface HTTPLoader {
-        cfg: object;
+    calculateDownloadedTime(downloadedData: any, bytesReceived: any): number | null;
 
-        abort(): void;
+    load(httpRequest: HTTPRequest, httpResponse: object): void;
 
-        load(config: object): void;
+    reset(): void;
 
-        reset(): void;
+    setup(cfg: object): void;
+}
 
-        resetInitialSettings(): void;
+export interface HTTPLoader {
+    cfg: object;
 
-        setConfig(config: object): void;
-    }
+    abort(): void;
 
-    export interface SchemeLoaderFactory {
-        getLoader(url: string): HTTPLoader;
+    load(config: object): void;
 
-        registerLoader(scheme: string, loader: any): void;
+    reset(): void;
 
-        reset(): void;
+    resetInitialSettings(): void;
 
-        unregisterAllLoader(): void;
+    setConfig(config: object): void;
+}
 
-        unregisterLoader(scheme: string): void;
-    }
+export interface SchemeLoaderFactory {
+    getLoader(url: string): HTTPLoader;
 
-    export interface URLLoader {
-        abort(): void;
+    registerLoader(scheme: string, loader: any): void;
 
-        load(config: object): any;
+    reset(): void;
 
-        reset(): void;
+    unregisterAllLoader(): void;
 
-        resetInitialSettings(): void;
-    }
+    unregisterLoader(scheme: string): void;
+}
 
-    export interface XHRLoader {
-        abort(request: HTTPRequest): void;
+export interface URLLoader {
+    abort(): void;
 
-        getXhr(httpRequest: CommonMediaRequest, httpResponse: CommonMediaResponse): boolean;
+    load(config: object): any;
 
-        load(httpRequest: HTTPRequest): HTTPRequest;
+    reset(): void;
 
-        reset(): void;
+    resetInitialSettings(): void;
+}
 
-        resetInitialSettings(): void;
-    }
+export interface XHRLoader {
+    abort(request: HTTPRequest): void;
 
-    /**
-     * Streaming - Protection - Controllers
-     **/
+    getXhr(httpRequest: CommonMediaRequest, httpResponse: CommonMediaResponse): boolean;
 
-    interface ProtectionController {
-        areKeyIdsExpired(normalizedKeyIds: Array<string | number>): boolean;
+    load(httpRequest: HTTPRequest): HTTPRequest;
 
-        areKeyIdsUsable(normalizedKeyIds: Array<string | number>): boolean;
+    reset(): void;
 
-        clearMediaInfoArray(): void;
+    resetInitialSettings(): void;
+}
 
-        closeKeySession(sessionToken: SessionToken): void;
+/**
+ * Streaming - Protection - Controllers
+ **/
 
-        createKeySession(keySystemInfo: KeySystemInfo): void;
+interface ProtectionController {
+    areKeyIdsExpired(normalizedKeyIds: Array<string | number>): boolean;
 
-        getKeySystems(): any[];
+    areKeyIdsUsable(normalizedKeyIds: Array<string | number>): boolean;
 
-        getSupportedKeySystemMetadataFromContentProtection(cps: object[]): object[];
+    clearMediaInfoArray(): void;
 
-        handleKeySystemFromManifest(): void;
+    closeKeySession(sessionToken: SessionToken): void;
 
-        initializeForMedia(mediaInfo: MediaInfo): void;
+    createKeySession(keySystemInfo: KeySystemInfo): void;
 
-        loadKeySession(keySystemInfo: KeySystemInfo): void;
+    getKeySystems(): any[];
 
-        removeKeySession(sessionToken: SessionToken): void;
+    getSupportedKeySystemMetadataFromContentProtection(cps: object[]): object[];
 
-        reset(): void;
+    handleKeySystemFromManifest(): void;
 
-        setKeySystems(keySystems: KeySystem[]): void;
+    initializeForMedia(mediaInfo: MediaInfo): void;
 
-        setMediaElement(element: HTMLMediaElement): void;
+    loadKeySession(keySystemInfo: KeySystemInfo): void;
 
-        setProtectionData(data: object): void;
+    removeKeySession(sessionToken: SessionToken): void;
 
-        setRobustnessLevel(level: string): void;
+    reset(): void;
 
-        setServerCertificate(serverCertificate: ArrayBuffer): void;
+    setKeySystems(keySystems: KeySystem[]): void;
 
-        setSessionType(value: string): void;
+    setMediaElement(element: HTMLMediaElement): void;
 
-        stop(): void;
+    setProtectionData(data: object): void;
 
-        updateKeyStatusesMap(e: object): void;
-    }
+    setRobustnessLevel(level: string): void;
 
-    export interface ProtectionKeyController {
-        getKeySystemBySystemString(systemString: string): KeySystem | null;
+    setServerCertificate(serverCertificate: ArrayBuffer): void;
 
-        getKeySystems(): KeySystem[];
+    setSessionType(value: string): void;
 
-        getLicenseServerModelInstance(keySystem: KeySystem, protData: ProtectionData, messageType: string): any | null;
+    stop(): void;
 
-        getSupportedKeySystemMetadataFromContentProtection(cps: object[], protDataSet: ProtectionDataSet, sessionType: string): object[];
+    updateKeyStatusesMap(e: object): void;
+}
 
-        getSupportedKeySystemMetadataFromSegmentPssh(initData: ArrayBuffer, protDataSet: ProtectionDataSet, sessionType: string): object[];
+export interface ProtectionKeyController {
+    getKeySystemBySystemString(systemString: string): KeySystem | null;
 
-        initDataEquals(initData1: ArrayBuffer, initData2: ArrayBuffer): boolean;
+    getKeySystems(): KeySystem[];
 
-        initialize(): void;
+    getLicenseServerModelInstance(keySystem: KeySystem, protData: ProtectionData, messageType: string): any | null;
 
-        isClearKey(keySystem: KeySystem): boolean;
+    getSupportedKeySystemMetadataFromContentProtection(cps: object[], protDataSet: ProtectionDataSet, sessionType: string): object[];
 
-        processClearKeyLicenseRequest(clearKeySystem: KeySystem, ProtectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet | null;
+    getSupportedKeySystemMetadataFromSegmentPssh(initData: ArrayBuffer, protDataSet: ProtectionDataSet, sessionType: string): object[];
 
-        setConfig(config: object): void;
+    initDataEquals(initData1: ArrayBuffer, initData2: ArrayBuffer): boolean;
 
-        setKeySystems(newKeySystems: KeySystem[]): void;
+    initialize(): void;
 
-        setProtectionData(protectionDataSet: ProtectionDataSet): ProtectionData;
-    }
+    isClearKey(keySystem: KeySystem): boolean;
 
-    /**
-     * Streaming - Protection - Drm
-     **/
+    processClearKeyLicenseRequest(clearKeySystem: KeySystem, ProtectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet | null;
 
-    export interface KeySystem {
-        schemeIdURI: string;
-        systemString: string;
-        uuid: string;
+    setConfig(config: object): void;
 
-        getCDMData(cdmData: string | null): ArrayBuffer | null;
+    setKeySystems(newKeySystems: KeySystem[]): void;
 
-        getInitData(cp: object, cencContentProtection: object | null): ArrayBuffer | null;
+    setProtectionData(protectionDataSet: ProtectionDataSet): ProtectionData;
+}
 
-        getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
+/**
+ * Streaming - Protection - Drm
+ **/
 
-        getLicenseServerURLFromInitData(initData: ArrayBuffer): string | null;
+export interface KeySystem {
+    schemeIdURI: string;
+    systemString: string;
+    uuid: string;
 
-        getRequestHeadersFromMessage(message: ArrayBuffer): object | null;
+    getCDMData(cdmData: string | null): ArrayBuffer | null;
 
-        getSessionId(): string | null;
-    }
+    getInitData(cp: object, cencContentProtection: object | null): ArrayBuffer | null;
 
-    export interface KeySystemClearKey {
-        uuid: string;
-        schemeIdURI: string;
-        systemString: string;
+    getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
-        getCDMData(): null;
+    getLicenseServerURLFromInitData(initData: ArrayBuffer): string | null;
 
-        getClearKeysFromProtectionData(protectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet;
+    getRequestHeadersFromMessage(message: ArrayBuffer): object | null;
 
-        getInitData(cp: object, cencContentProtection: object | null): ArrayBuffer | null;
+    getSessionId(): string | null;
+}
 
-        getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
+export interface KeySystemClearKey {
+    uuid: string;
+    schemeIdURI: string;
+    systemString: string;
 
-        getLicenseServerURLFromInitData(): null;
+    getCDMData(): null;
 
-        getRequestHeadersFromMessage(): object;
-    }
+    getClearKeysFromProtectionData(protectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet;
 
-    export interface KeySystemPlayReady {
-        uuid: string;
-        schemeIdURI: string;
-        systemString: string;
+    getInitData(cp: object, cencContentProtection: object | null): ArrayBuffer | null;
 
-        getCDMData(cdmData: string | null): ArrayBuffer | null;
+    getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
-        getInitData(cpData: object): ArrayBuffer;
+    getLicenseServerURLFromInitData(): null;
 
-        getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
+    getRequestHeadersFromMessage(): object;
+}
 
-        getLicenseServerURLFromInitData(initData: ArrayBuffer): string | null;
+export interface KeySystemPlayReady {
+    uuid: string;
+    schemeIdURI: string;
+    systemString: string;
 
-        getRequestHeadersFromMessage(message: ArrayBuffer): object;
+    getCDMData(cdmData: string | null): ArrayBuffer | null;
 
-        setPlayReadyMessageFormat(format: string): void;
-    }
+    getInitData(cpData: object): ArrayBuffer;
 
-    export interface KeySystemW3CClearKey {
-        uuid: string;
-        systemString: string;
-        schemeIdURI: string;
+    getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
-        getCDMData(): null;
+    getLicenseServerURLFromInitData(initData: ArrayBuffer): string | null;
 
-        getClearKeysFromProtectionData(protectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet;
+    getRequestHeadersFromMessage(message: ArrayBuffer): object;
 
-        getInitData(cp: object): ArrayBuffer | null;
+    setPlayReadyMessageFormat(format: string): void;
+}
 
-        getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
+export interface KeySystemW3CClearKey {
+    uuid: string;
+    systemString: string;
+    schemeIdURI: string;
 
-        getLicenseServerURLFromInitData(): null;
+    getCDMData(): null;
 
-        getRequestHeadersFromMessage(): null;
-    }
+    getClearKeysFromProtectionData(protectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet;
 
-    export interface KeySystemWidevine {
-        uuid: string;
-        schemeIdURI: string;
-        systemString: string;
+    getInitData(cp: object): ArrayBuffer | null;
 
-        getCDMData(): null;
+    getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
-        getInitData(cp: object): ArrayBuffer | null;
+    getLicenseServerURLFromInitData(): null;
 
-        getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
+    getRequestHeadersFromMessage(): null;
+}
 
-        getLicenseServerURLFromInitData(): null;
+export interface KeySystemWidevine {
+    uuid: string;
+    schemeIdURI: string;
+    systemString: string;
 
-        getRequestHeadersFromMessage(): null;
-    }
+    getCDMData(): null;
 
-    /**
-     * Streaming - Protection - Errors
-     **/
-
-    interface ProtectionErrors {
-        KEY_SESSION_CREATED_ERROR_CODE: 113;
-        KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE: 110;
-        KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE: 112;
-        MEDIA_KEYERR_CLIENT_CODE: 102;
-        MEDIA_KEYERR_CODE: 100;
-        MEDIA_KEYERR_DOMAIN_CODE: 106;
-        MEDIA_KEYERR_HARDWARECHANGE_CODE: 105;
-        MEDIA_KEYERR_OUTPUT_CODE: 104;
-        MEDIA_KEYERR_SERVICE_CODE: 103;
-        MEDIA_KEYERR_UNKNOWN_CODE: 101;
-        MEDIA_KEY_MESSAGE_ERROR_CODE: 107;
-        MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE: 114;
-        MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE: 108;
-        MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE: 111;
-        SERVER_CERTIFICATE_UPDATED_ERROR_CODE: 109;
-
-        KEY_SESSION_CREATED_ERROR_MESSAGE: 'DRM: unable to create session! --';
-        KEY_STATUS_CHANGED_EXPIRED_ERROR_MESSAGE: 'DRM: KeyStatusChange error! -- License has expired';
-        KEY_SYSTEM_ACCESS_DENIED_ERROR_MESSAGE: 'DRM: KeySystem Access Denied! -- ';
-        MEDIA_KEYERR_CLIENT_MESSAGE: 'The Key System could not be installed or updated.';
-        MEDIA_KEYERR_DOMAIN_MESSAGE: 'An error occurred in a multi-device domain licensing configuration. The most common error is a failure to join the domain.';
-        MEDIA_KEYERR_HARDWARECHANGE_MESSAGE: 'A hardware configuration change caused a content protection error.';
-        MEDIA_KEYERR_OUTPUT_MESSAGE: 'There is no available output device with the required characteristics for the content protection system.';
-        MEDIA_KEYERR_SERVICE_MESSAGE: 'The message passed into update indicated an error from the license service.';
-        MEDIA_KEYERR_UNKNOWN_MESSAGE: 'An unspecified error occurred. This value is used for errors that don\'t match any of the other codes.';
-        MEDIA_KEY_MESSAGE_ERROR_MESSAGE: 'Multiple key sessions were creates with a user-agent that does not support sessionIDs!! Unpredictable behavior ahead!';
-        MEDIA_KEY_MESSAGE_LICENSER_ERROR_MESSAGE: 'DRM: licenser error! --';
-        MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_MESSAGE: 'DRM: Empty key message from CDM';
-        MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_MESSAGE: 'DRM: No license server URL specified!';
-        SERVER_CERTIFICATE_UPDATED_ERROR_MESSAGE: 'Error updating server certificate -- ';
-    }
+    getInitData(cp: object): ArrayBuffer | null;
 
-    /**
-     * Streaming - Protection - Models
-     **/
+    getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
-    export interface DefaultProtectionModel {
-        closeKeySession(sessionToken: SessionToken): void;
+    getLicenseServerURLFromInitData(): null;
 
-        createKeySession(ksInfo: KeySystemInfo): any;
+    getRequestHeadersFromMessage(): null;
+}
 
-        getAllInitData(): ArrayBuffer[];
+/**
+ * Streaming - Protection - Errors
+ **/
+
+export interface ProtectionErrors {
+    KEY_SESSION_CREATED_ERROR_CODE: 113;
+    KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE: 110;
+    KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE: 112;
+    MEDIA_KEYERR_CLIENT_CODE: 102;
+    MEDIA_KEYERR_CODE: 100;
+    MEDIA_KEYERR_DOMAIN_CODE: 106;
+    MEDIA_KEYERR_HARDWARECHANGE_CODE: 105;
+    MEDIA_KEYERR_OUTPUT_CODE: 104;
+    MEDIA_KEYERR_SERVICE_CODE: 103;
+    MEDIA_KEYERR_UNKNOWN_CODE: 101;
+    MEDIA_KEY_MESSAGE_ERROR_CODE: 107;
+    MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE: 114;
+    MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_CODE: 108;
+    MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE: 111;
+    SERVER_CERTIFICATE_UPDATED_ERROR_CODE: 109;
+
+    KEY_SESSION_CREATED_ERROR_MESSAGE: 'DRM: unable to create session! --';
+    KEY_STATUS_CHANGED_EXPIRED_ERROR_MESSAGE: 'DRM: KeyStatusChange error! -- License has expired';
+    KEY_SYSTEM_ACCESS_DENIED_ERROR_MESSAGE: 'DRM: KeySystem Access Denied! -- ';
+    MEDIA_KEYERR_CLIENT_MESSAGE: 'The Key System could not be installed or updated.';
+    MEDIA_KEYERR_DOMAIN_MESSAGE: 'An error occurred in a multi-device domain licensing configuration. The most common error is a failure to join the domain.';
+    MEDIA_KEYERR_HARDWARECHANGE_MESSAGE: 'A hardware configuration change caused a content protection error.';
+    MEDIA_KEYERR_OUTPUT_MESSAGE: 'There is no available output device with the required characteristics for the content protection system.';
+    MEDIA_KEYERR_SERVICE_MESSAGE: 'The message passed into update indicated an error from the license service.';
+    MEDIA_KEYERR_UNKNOWN_MESSAGE: 'An unspecified error occurred. This value is used for errors that don\'t match any of the other codes.';
+    MEDIA_KEY_MESSAGE_ERROR_MESSAGE: 'Multiple key sessions were creates with a user-agent that does not support sessionIDs!! Unpredictable behavior ahead!';
+    MEDIA_KEY_MESSAGE_LICENSER_ERROR_MESSAGE: 'DRM: licenser error! --';
+    MEDIA_KEY_MESSAGE_NO_CHALLENGE_ERROR_MESSAGE: 'DRM: Empty key message from CDM';
+    MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_MESSAGE: 'DRM: No license server URL specified!';
+    SERVER_CERTIFICATE_UPDATED_ERROR_MESSAGE: 'Error updating server certificate -- ';
+}
 
-        getSessionTokens(): any[];
+/**
+ * Streaming - Protection - Models
+ **/
 
-        loadKeySession(ksInfo: KeySystemInfo): void;
+export interface DefaultProtectionModel {
+    closeKeySession(sessionToken: SessionToken): void;
 
-        removeKeySession(sessionToken: SessionToken): void;
+    createKeySession(ksInfo: KeySystemInfo): any;
 
-        requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
+    getAllInitData(): ArrayBuffer[];
 
-        reset(): void;
+    getSessionTokens(): any[];
 
-        selectKeySystem(keySystemAccess: KeySystemAccess): Promise<any>;
+    loadKeySession(ksInfo: KeySystemInfo): void;
 
-        setMediaElement(mediaElement: HTMLMediaElement): void;
+    removeKeySession(sessionToken: SessionToken): void;
 
-        setServerCertificate(serverCertificate: ArrayBuffer): void;
+    requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
 
-        stop(): void;
+    reset(): void;
 
-        updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
-    }
+    selectKeySystem(keySystemAccess: KeySystemAccess): Promise<any>;
 
-    export interface ProtectionModel_01b {
-        closeKeySession(sessionToken: SessionToken): void;
+    setMediaElement(mediaElement: HTMLMediaElement): void;
 
-        createKeySession(ksInfo: KeySystemInfo): any;
+    setServerCertificate(serverCertificate: ArrayBuffer): void;
 
-        getAllInitData(): ArrayBuffer[];
+    stop(): void;
 
-        getSessionTokens(): any[];
+    updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
+}
 
-        loadKeySession(): void;
+export interface ProtectionModel_01b {
+    closeKeySession(sessionToken: SessionToken): void;
 
-        removeKeySession(): void;
+    createKeySession(ksInfo: KeySystemInfo): any;
 
-        requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
+    getAllInitData(): ArrayBuffer[];
 
-        reset(): void;
+    getSessionTokens(): any[];
 
-        selectKeySystem(keySystemAccess: any): Promise<any>;
+    loadKeySession(): void;
 
-        setMediaElement(mediaElement: HTMLMediaElement): void;
+    removeKeySession(): void;
 
-        setServerCertificate(): void;
+    requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
 
-        stop(): void;
+    reset(): void;
 
-        updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
-    }
+    selectKeySystem(keySystemAccess: any): Promise<any>;
 
-    export interface ProtectionModel_3Fe2014 {
-        closeKeySession(sessionToken: SessionToken): void;
+    setMediaElement(mediaElement: HTMLMediaElement): void;
 
-        createKeySession(ksInfo: KeySystemInfo): any;
+    setServerCertificate(): void;
 
-        getAllInitData(): ArrayBuffer[];
+    stop(): void;
 
-        getSessionTokens(): any[];
+    updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
+}
 
-        loadKeySession(): void;
+export interface ProtectionModel_3Fe2014 {
+    closeKeySession(sessionToken: SessionToken): void;
 
-        removeKeySession(): void;
+    createKeySession(ksInfo: KeySystemInfo): any;
 
-        requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
+    getAllInitData(): ArrayBuffer[];
 
-        reset(): void;
+    getSessionTokens(): any[];
 
-        selectKeySystem(keySystemAccess: any): Promise<any>;
+    loadKeySession(): void;
 
-        setMediaElement(mediaElement: HTMLMediaElement): void;
+    removeKeySession(): void;
 
-        setServerCertificate(): void;
+    requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
 
-        stop(): void;
+    reset(): void;
 
-        updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
-    }
+    selectKeySystem(keySystemAccess: any): Promise<any>;
 
-    export interface ProtectionModel {
-        closeKeySession(sessionToken: SessionToken): void;
+    setMediaElement(mediaElement: HTMLMediaElement): void;
 
-        createKeySession(initData: ArrayBuffer, protData: ProtectionData, sessionType: string): void;
+    setServerCertificate(): void;
 
-        getAllInitData(): ArrayBuffer[];
+    stop(): void;
 
-        loadKeySession(sessionId: string, initData: ArrayBuffer): void;
+    updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
+}
 
-        removeKeySession(sessionToken: SessionToken): void;
+export interface ProtectionModel {
+    closeKeySession(sessionToken: SessionToken): void;
 
-        requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
+    createKeySession(initData: ArrayBuffer, protData: ProtectionData, sessionType: string): void;
 
-        reset(): void;
+    getAllInitData(): ArrayBuffer[];
 
-        selectKeySystem(keySystemAccess: KeySystemAccess): Promise<any>;
+    loadKeySession(sessionId: string, initData: ArrayBuffer): void;
 
-        setMediaElement(mediaElement: HTMLMediaElement): void;
+    removeKeySession(sessionToken: SessionToken): void;
 
-        setServerCertificate(serverCertificate: ArrayBuffer): void;
+    requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
 
-        stop(): void;
+    reset(): void;
 
-        updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
-    }
+    selectKeySystem(keySystemAccess: KeySystemAccess): Promise<any>;
 
-    /**
-     * Streaming - Protection - Server
-     **/
+    setMediaElement(mediaElement: HTMLMediaElement): void;
 
-    export interface ClearKey {
-        getErrorResponse(serverResponse: object): string;
+    setServerCertificate(serverCertificate: ArrayBuffer): void;
 
-        getHTTPMethod(): 'POST';
+    stop(): void;
 
-        getLicenseMessage(serverResponse: object): ClearKeyKeySet;
+    updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
+}
 
-        getResponseType(): 'json';
+/**
+ * Streaming - Protection - Server
+ **/
 
-        getServerURLFromMessage(url: string): string;
-    }
+export interface ClearKey {
+    getErrorResponse(serverResponse: object): string;
 
-    export interface DRMToday {
-        getErrorResponse(serverResponse: object): string;
+    getHTTPMethod(): 'POST';
 
-        getHTTPMethod(): 'POST';
+    getLicenseMessage(serverResponse: object): ClearKeyKeySet;
 
-        getLicenseMessage(serverResponse: object, keySystemStr: string): any;
+    getResponseType(): 'json';
 
-        getResponseType(keySystemStr: string): string;
+    getServerURLFromMessage(url: string): string;
+}
 
-        getServerURLFromMessage(url: string): string;
-    }
+export interface DRMToday {
+    getErrorResponse(serverResponse: object): string;
 
-    export interface LicenseServer {
-        getErrorResponse(serverResponse: object): string;
+    getHTTPMethod(): 'POST';
 
-        getHTTPMethod(messageType: string): string;
+    getLicenseMessage(serverResponse: object, keySystemStr: string): any;
 
-        getLicenseMessage(serverResponse: object, keySystemStr: string): ArrayBuffer | null;
+    getResponseType(keySystemStr: string): string;
 
-        getResponseType(keySystemStr: string, messageType: string): string;
+    getServerURLFromMessage(url: string): string;
+}
 
-        getServerURLFromMessage(url: string, message: ArrayBuffer, messageType: string): string;
-    }
+export interface LicenseServer {
+    getErrorResponse(serverResponse: object): string;
 
-    export interface PlayReady {
-        getErrorResponse(serverResponse: object): string;
+    getHTTPMethod(messageType: string): string;
 
-        getHTTPMethod(): 'POST';
+    getLicenseMessage(serverResponse: object, keySystemStr: string): ArrayBuffer | null;
 
-        getLicenseMessage(serverResponse: object): any;
+    getResponseType(keySystemStr: string, messageType: string): string;
 
-        getResponseType(): 'arraybuffer';
+    getServerURLFromMessage(url: string, message: ArrayBuffer, messageType: string): string;
+}
 
-        getServerURLFromMessage(url: string): string;
-    }
+export interface PlayReady {
+    getErrorResponse(serverResponse: object): string;
 
-    export interface Widevine {
-        getErrorResponse(serverResponse: object): string;
+    getHTTPMethod(): 'POST';
 
-        getHTTPMethod(): 'POST';
+    getLicenseMessage(serverResponse: object): any;
 
-        getLicenseMessage(serverResponse: object): object;
+    getResponseType(): 'arraybuffer';
 
-        getResponseType(): 'arraybuffer';
+    getServerURLFromMessage(url: string): string;
+}
 
-        getServerURLFromMessage(url: string): string;
-    }
+export interface Widevine {
+    getErrorResponse(serverResponse: object): string;
 
-    /**
-     * Streaming - Protection - Vo
-     **/
+    getHTTPMethod(): 'POST';
 
-    export interface ClearKeyKeySet {
-        keyPairs: KeyPair[];
-        type: string;
-    }
+    getLicenseMessage(serverResponse: object): object;
 
-    export class KeyMessage {
-        constructor(sessionToken: SessionToken, message: ArrayBuffer, defaultURL: string, messageType?: string);
+    getResponseType(): 'arraybuffer';
 
-        defaultURL: string;
-        message: ArrayBuffer;
-        messageType: string;
-        sessionToken: SessionToken;
-    }
+    getServerURLFromMessage(url: string): string;
+}
 
-    export class KeyPair {
-        constructor(keyId: string, key: string)
+/**
+ * Streaming - Protection - Vo
+ **/
 
-        keyId: string;
-        key: string;
-    }
+export interface ClearKeyKeySet {
+    keyPairs: KeyPair[];
+    type: string;
+}
 
-    export class KeySystemAccess {
-        constructor(keySystem: KeySystem, ksConfiguration: KeySystemConfiguration)
+export class KeyMessage {
+    constructor(sessionToken: SessionToken, message: ArrayBuffer, defaultURL: string, messageType?: string);
 
-        keySystem: KeySystem;
-        ksConfiguration: KeySystemConfiguration;
-        nativeMediaKeySystemAccessObject: object | null;
-        selectedSystemString: string | null;
-    }
+    defaultURL: string;
+    message: ArrayBuffer;
+    messageType: string;
+    sessionToken: SessionToken;
+}
 
-    export class KeySystemConfiguration {
-        constructor(audioCapabilities: MediaCapability[], videoCapabilities: MediaCapability[], distinctiveIdentifier: string, persistentState: string, sessionTypes: string[])
+export class KeyPair {
+    constructor(keyId: string, key: string)
 
-        audioCapabilities: MediaCapability[];
-        distinctiveIdentifier: string;
-        persistentState: string;
-        sessionTypes: string[];
-        videoCapabilities: MediaCapability[];
-    }
+    keyId: string;
+    key: string;
+}
 
-    export class KeySystemMetadata {
-        constructor(config: object);
+export class KeySystemAccess {
+    constructor(keySystem: KeySystem, ksConfiguration: KeySystemConfiguration)
 
-        config: object;
-    }
+    keySystem: KeySystem;
+    ksConfiguration: KeySystemConfiguration;
+    nativeMediaKeySystemAccessObject: object | null;
+    selectedSystemString: string | null;
+}
 
-    export class LicenseRequest {
-        constructor(url: string, method: string, responseType: string, headers: {
-            [key: string]: string
-        }, withCredentials: boolean, messageType: string, sessionId: string, data: ArrayBuffer)
+export class KeySystemConfiguration {
+    constructor(audioCapabilities: MediaCapability[], videoCapabilities: MediaCapability[], distinctiveIdentifier: string, persistentState: string, sessionTypes: string[])
 
-        data: ArrayBuffer;
-        headers: { [key: string]: string };
-        messageType: string;
-        method: string;
-        responseType: string;
-        sessionId: string;
-        url: string;
-        withCredentials: boolean;
-    }
+    audioCapabilities: MediaCapability[];
+    distinctiveIdentifier: string;
+    persistentState: string;
+    sessionTypes: string[];
+    videoCapabilities: MediaCapability[];
+}
 
-    export class LicenseRequestComplete {
-        constructor(message: Uint8Array, sessionToken: SessionToken, messageType: string)
+export class KeySystemMetadata {
+    constructor(config: object);
 
-        message: Uint8Array;
-        messageType: string;
-        sessionToken: SessionToken;
-    }
+    config: object;
+}
 
-    export class LicenseResponse {
-        constructor(url: string, headers: object, data: ArrayBuffer)
+export class LicenseRequest {
+    constructor(url: string, method: string, responseType: string, headers: {
+        [key: string]: string
+    }, withCredentials: boolean, messageType: string, sessionId: string, data: ArrayBuffer)
+
+    data: ArrayBuffer;
+    headers: { [key: string]: string };
+    messageType: string;
+    method: string;
+    responseType: string;
+    sessionId: string;
+    url: string;
+    withCredentials: boolean;
+}
 
-        data: ArrayBuffer;
-        headers: object;
-        url: string;
-    }
+export class LicenseRequestComplete {
+    constructor(message: Uint8Array, sessionToken: SessionToken, messageType: string)
 
-    export class MediaCapability {
-        constructor(contentType: string, robustness: string)
+    message: Uint8Array;
+    messageType: string;
+    sessionToken: SessionToken;
+}
 
-        contentType: string;
-        robustness: string;
-    }
+export class LicenseResponse {
+    constructor(url: string, headers: object, data: ArrayBuffer)
 
-    export class NeedKey {
-        constructor(initData: ArrayBuffer, initDataType: string)
+    data: ArrayBuffer;
+    headers: object;
+    url: string;
+}
 
-        initData: ArrayBuffer;
-        initDataType: string;
-    }
+export class MediaCapability {
+    constructor(contentType: string, robustness: string)
 
-    export interface ProtectionDataSet {
-        [keySystemName: string]: ProtectionData;
-    }
+    contentType: string;
+    robustness: string;
+}
 
-    export interface ProtectionData {
-        /**
-         * A license server URL to use with this key system.
-         * When specified as a string, a single URL will be used regardless of message type.
-         * When specified as an object, the object will have property names for each message
-         * type with the corresponding property value being the URL to use for
-         * messages of that type
-         */
-        serverURL?: string | { [P in MediaKeyMessageType]: string };
+export class NeedKey {
+    constructor(initData: ArrayBuffer, initDataType: string)
 
-        /** HTTP headers to add to the license request */
-        httpRequestHeaders?: object;
+    initData: ArrayBuffer;
+    initDataType: string;
+}
 
-        /** Wether license request is made using credentials */
-        withCredentials?: Boolean;
+export interface ProtectionDataSet {
+    [keySystemName: string]: ProtectionData;
+}
 
-        /** Timeout (in ms) for the license requests */
-        httpTimeout?: number;
+export interface ProtectionData {
+    /**
+     * A license server URL to use with this key system.
+     * When specified as a string, a single URL will be used regardless of message type.
+     * When specified as an object, the object will have property names for each message
+     * type with the corresponding property value being the URL to use for
+     * messages of that type
+     */
+    serverURL?: string | { [P in MediaKeyMessageType]: string };
 
-        /** The licenser server certificate as a BASE64 string representation of the binary stream (see https://www.w3.org/TR/encrypted-media/#dom-mediakeys-setservercertificate) */
-        serverCertificate?: string;
+    /** HTTP headers to add to the license request */
+    httpRequestHeaders?: object;
 
-        /** The audio robustness level (see https://www.w3.org/TR/encrypted-media/#dom-mediakeysystemmediacapability-robustness) */
-        audioRobustness?: string;
+    /** Wether license request is made using credentials */
+    withCredentials?: Boolean;
 
-        /** The video robustness level (see https://www.w3.org/TR/encrypted-media/#dom-mediakeysystemmediacapability-robustness) */
-        videoRobustness?: string;
+    /** Timeout (in ms) for the license requests */
+    httpTimeout?: number;
 
-        /** Distinctive identifier (see https://www.w3.org/TR/encrypted-media/#dom-mediakeysystemconfiguration-distinctiveidentifier) */
-        distinctiveIdentifier?: string;
+    /** The licenser server certificate as a BASE64 string representation of the binary stream (see https://www.w3.org/TR/encrypted-media/#dom-mediakeys-setservercertificate) */
+    serverCertificate?: string;
 
-        /** The session type (see https://www.w3.org/TR/encrypted-media/#dom-mediakeysessiontype) */
-        sessionType?: string;
+    /** The audio robustness level (see https://www.w3.org/TR/encrypted-media/#dom-mediakeysystemmediacapability-robustness) */
+    audioRobustness?: string;
 
-        /** The session id (see https://www.w3.org/TR/encrypted-media/#session-id) */
-        sessionId?: string;
+    /** The video robustness level (see https://www.w3.org/TR/encrypted-media/#dom-mediakeysystemmediacapability-robustness) */
+    videoRobustness?: string;
 
-        /**
-         * Defines a set of clear keys that are available to the key system.
-         * Object properties are base64-encoded keyIDs (with no padding).
-         * Corresponding property values are keys, base64-encoded (no padding).
-         */
-        clearkeys?: { [key: string]: string };
+    /** Distinctive identifier (see https://www.w3.org/TR/encrypted-media/#dom-mediakeysystemconfiguration-distinctiveidentifier) */
+    distinctiveIdentifier?: string;
 
-        /** Priority level of the key system to be selected (0 is the highest prority, -1 for undefined priority) */
-        priority?: number;
-    }
+    /** The session type (see https://www.w3.org/TR/encrypted-media/#dom-mediakeysessiontype) */
+    sessionType?: string;
 
-    export interface SessionToken {
-        session: MediaKeySession;
-        initData: any;
+    /** The session id (see https://www.w3.org/TR/encrypted-media/#session-id) */
+    sessionId?: string;
 
-        getExpirationTime(): number;
+    /**
+     * Defines a set of clear keys that are available to the key system.
+     * Object properties are base64-encoded keyIDs (with no padding).
+     * Corresponding property values are keys, base64-encoded (no padding).
+     */
+    clearkeys?: { [key: string]: string };
 
-        getKeyStatuses(): MediaKeyStatusMap;
+    /** Priority level of the key system to be selected (0 is the highest prority, -1 for undefined priority) */
+    priority?: number;
+}
 
-        getSessionId(): string;
+export interface SessionToken {
+    session: MediaKeySession;
+    initData: any;
 
-        getSessionType(): string;
-    }
+    getExpirationTime(): number;
 
-    /**
-     * Streaming - Protection
-     **/
-
-    export interface ProtectionEvents extends EventsBase {
-        KEY_ADDED: 'public_keyAdded';
-        KEY_ERROR: 'public_keyError';
-        KEY_MESSAGE: 'public_keyMessage';
-        KEY_SESSION_CLOSED: 'public_keySessionClosed';
-        KEY_SESSION_CREATED: 'public_keySessionCreated';
-        KEY_SESSION_REMOVED: 'public_keySessionRemoved';
-        KEY_SESSION_UPDATED: 'public_keySessionUpdated';
-        KEY_STATUSES_CHANGED: 'public_keyStatusesChanged';
-        KEY_SYSTEM_ACCESS_COMPLETE: 'public_keySystemAccessComplete';
-        KEY_SYSTEM_SELECTED: 'public_keySystemSelected';
-        LICENSE_REQUEST_COMPLETE: 'public_licenseRequestComplete';
-        LICENSE_REQUEST_SENDING: 'public_licenseRequestSending';
-        NEED_KEY: 'needkey';
-        PROTECTION_CREATED: 'public_protectioncreated';
-        PROTECTION_DESTROYED: 'public_protectiondestroyed';
-        SERVER_CERTIFICATE_UPDATED: 'serverCertificateUpdated';
-        TEARDOWN_COMPLETE: 'protectionTeardownComplete';
-        VIDEO_ELEMENT_SELECTED: 'videoElementSelected';
-    }
+    getKeyStatuses(): MediaKeyStatusMap;
 
-    export interface CommonEncryption {
-        // Does not export anything
-    }
+    getSessionId(): string;
 
-    export interface Protection {
-        createProtectionSystem(config: object): void;
-    }
+    getSessionType(): string;
+}
 
-    export namespace Protection {
-        export const events: ProtectionEvents;
-        export const errors: ProtectionErrors;
-    }
+/**
+ * Streaming - Protection
+ **/
+
+export interface ProtectionEvents extends EventsBase {
+    KEY_ADDED: 'public_keyAdded';
+    KEY_ERROR: 'public_keyError';
+    KEY_MESSAGE: 'public_keyMessage';
+    KEY_SESSION_CLOSED: 'public_keySessionClosed';
+    KEY_SESSION_CREATED: 'public_keySessionCreated';
+    KEY_SESSION_REMOVED: 'public_keySessionRemoved';
+    KEY_SESSION_UPDATED: 'public_keySessionUpdated';
+    KEY_STATUSES_CHANGED: 'public_keyStatusesChanged';
+    KEY_SYSTEM_ACCESS_COMPLETE: 'public_keySystemAccessComplete';
+    KEY_SYSTEM_SELECTED: 'public_keySystemSelected';
+    LICENSE_REQUEST_COMPLETE: 'public_licenseRequestComplete';
+    LICENSE_REQUEST_SENDING: 'public_licenseRequestSending';
+    NEED_KEY: 'needkey';
+    PROTECTION_CREATED: 'public_protectioncreated';
+    PROTECTION_DESTROYED: 'public_protectiondestroyed';
+    SERVER_CERTIFICATE_UPDATED: 'serverCertificateUpdated';
+    TEARDOWN_COMPLETE: 'protectionTeardownComplete';
+    VIDEO_ELEMENT_SELECTED: 'videoElementSelected';
+}
 
-    /**
-     * Streaming - Rules - ABR - LolP
-     */
+export interface CommonEncryption {
+    // Does not export anything
+}
 
-    export interface LearningAbrController {
-        getNextQuality(mediaInfo: MediaInfo, throughput: number, latency: number, bufferSize: number, playbackRate: number, currentQualityIndex: number, dynamicWeightSelector: object): any | null;
+export interface Protection {
+    createProtectionSystem(config: object): void;
+}
 
-        reset(): void;
-    }
+export namespace Protection {
+    export const events: ProtectionEvents;
+    export const errors: ProtectionErrors;
+}
 
-    export interface LoLpQoEEvaluator {
-        calculateSingleUseQoe(segmentBitrate: number, segmentRebufferTime: number, currentLatency: number, currentPlaybackSpeed: number): number;
+/**
+ * Streaming - Rules - ABR - LolP
+ */
 
-        getPerSegmentQoe(): QoeInfo;
+export interface LearningAbrController {
+    getNextQuality(mediaInfo: MediaInfo, throughput: number, latency: number, bufferSize: number, playbackRate: number, currentQualityIndex: number, dynamicWeightSelector: object): any | null;
 
-        logSegmentMetrics(segmentBitrate: number, segmentRebufferTime: number, currentLatency: number, currentPlaybackSpeed: number): void;
+    reset(): void;
+}
 
-        reset(): void;
+export interface LoLpQoEEvaluator {
+    calculateSingleUseQoe(segmentBitrate: number, segmentRebufferTime: number, currentLatency: number, currentPlaybackSpeed: number): number;
 
-        setupPerSegmentQoe(sDuration: number, maxBrKbps: number, minBrKbs: number): void;
-    }
+    getPerSegmentQoe(): QoeInfo;
 
-    export interface LoLpRule {
-        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
+    logSegmentMetrics(segmentBitrate: number, segmentRebufferTime: number, currentLatency: number, currentPlaybackSpeed: number): void;
 
-        reset(): void;
-    }
+    reset(): void;
 
-    export interface LoLpWeightSelector {
-        findWeightVector(neurons: any[], currentLatency: number, currentBuffer: number, currentRebuffer: number, currentThroughput: number, playbackRate: number): number | null;
+    setupPerSegmentQoe(sDuration: number, maxBrKbps: number, minBrKbs: number): void;
+}
 
-        getMinBuffer(): number;
+export interface LoLpRule {
+    getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
-        getNextBuffer(currentBuffer: number, downloadTime: number): number;
+    reset(): void;
+}
 
-        getNextBufferWithBitrate(bitrateToDownload: number, currentBuffer: number, currentThroughput: number): number;
+export interface LoLpWeightSelector {
+    findWeightVector(neurons: any[], currentLatency: number, currentBuffer: number, currentRebuffer: number, currentThroughput: number, playbackRate: number): number | null;
 
-        getSegmentDuration(): number;
-    }
+    getMinBuffer(): number;
 
-    export class QoeInfo {
-        bitrateSwitchSum: number;
-        bitrateWSum: number;
-        lastBitrate: number | null;
-        latencyWSum: number;
-        playbackSpeedWSum: number;
-        rebufferWSum: number;
-        totalQoe: number;
-        type: string | null;
-        weights: {
-            bitrateReward: number | null,
-            bitrateSwitchPenalty: number | null,
-            rebufferPenalty: number | null,
-            latencyPenalty: number | null,
-            playbackSpeedPenalty: number | null
-        };
-    }
+    getNextBuffer(currentBuffer: number, downloadTime: number): number;
 
-    /**
-     * Streaming - Rules -Abr
-     **/
+    getNextBufferWithBitrate(bitrateToDownload: number, currentBuffer: number, currentThroughput: number): number;
 
-    export interface AbandonRequestsRule {
-        shouldAbandon(rulesContext: RulesContext): SwitchRequest;
+    getSegmentDuration(): number;
+}
 
-        reset(): void;
-    }
+export class QoeInfo {
+    bitrateSwitchSum: number;
+    bitrateWSum: number;
+    lastBitrate: number | null;
+    latencyWSum: number;
+    playbackSpeedWSum: number;
+    rebufferWSum: number;
+    totalQoe: number;
+    type: string | null;
+    weights: {
+        bitrateReward: number | null,
+        bitrateSwitchPenalty: number | null,
+        rebufferPenalty: number | null,
+        latencyPenalty: number | null,
+        playbackSpeedPenalty: number | null
+    };
+}
 
-    export interface ABRRulesCollection {
-        clearDataForStream(streamId: string | number): void;
+/**
+ * Streaming - Rules -Abr
+ **/
 
-        getAbandonFragmentRules(): object;
+export interface AbandonRequestsRule {
+    shouldAbandon(rulesContext: RulesContext): SwitchRequest;
 
-        getBestPossibleSwitchRequest(rulesContext: RulesContext): SwitchRequest;
+    reset(): void;
+}
 
-        getBolaState(mediaType: MediaType): string;
+export interface ABRRulesCollection {
+    clearDataForStream(streamId: string | number): void;
 
-        getMinSwitchRequest(srArray: any[]): SwitchRequest;
+    getAbandonFragmentRules(): object;
 
-        getQualitySwitchRules(): any[];
+    getBestPossibleSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
-        initialize(): void;
+    getBolaState(mediaType: MediaType): string;
 
-        reset(): void;
+    getMinSwitchRequest(srArray: any[]): SwitchRequest;
 
-        setBolaState(mediaType: MediaType, value: string): void;
+    getQualitySwitchRules(): any[];
 
-        shouldAbandonFragment(rulesContext: RulesContext, streamId: string): SwitchRequest;
-    }
+    initialize(): void;
 
-    export interface BolaRule {
-        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
+    reset(): void;
 
-        reset(): void;
-    }
+    setBolaState(mediaType: MediaType, value: string): void;
 
-    export interface DroppedFramesRule {
-        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
-    }
+    shouldAbandonFragment(rulesContext: RulesContext, streamId: string): SwitchRequest;
+}
 
-    export interface InsufficientBufferRule {
-        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
+export interface BolaRule {
+    getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
-        reset(): void;
-    }
+    reset(): void;
+}
 
-    export interface L2ARule {
-        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
+export interface DroppedFramesRule {
+    getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
+}
 
-        reset(): void;
-    }
+export interface InsufficientBufferRule {
+    getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
-    export interface SwitchHistoryRule {
-        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
-    }
+    reset(): void;
+}
 
-    export interface ThroughputRule {
-        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
+export interface L2ARule {
+    getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
-        reset(): void;
-    }
+    reset(): void;
+}
 
-    /**
-     * Streaming - Rules
-     **/
+export interface SwitchHistoryRule {
+    getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
+}
 
-    export interface DroppedFramesHistory {
-        clearDataForStream(streamId: string): void;
+export interface ThroughputRule {
+    getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
-        getFrameHistory(streamId: string): object;
+    reset(): void;
+}
 
-        push(streamId: string, index: number, playbackQuality: number): void;
+/**
+ * Streaming - Rules
+ **/
 
-        reset(): void;
-    }
+export interface DroppedFramesHistory {
+    clearDataForStream(streamId: string): void;
 
-    export interface RulesContext {
-        getAbrController(): AbrController;
+    getFrameHistory(streamId: string): object;
 
-        getCurrentRequest(): SwitchRequest;
+    push(streamId: string, index: number, playbackQuality: number): void;
 
-        getDroppedFramesHistory(): DroppedFramesHistory;
+    reset(): void;
+}
 
-        getMediaInfo(): MediaInfo;
+export interface RulesContext {
+    getAbrController(): AbrController;
 
-        getMediaType(): string;
+    getCurrentRequest(): SwitchRequest;
 
-        getRepresentation(): Representation;
+    getDroppedFramesHistory(): DroppedFramesHistory;
 
-        getScheduleController(): ScheduleController;
+    getMediaInfo(): MediaInfo;
 
-        getStreamInfo(): StreamInfo;
+    getMediaType(): string;
 
-        getSwitchHistory(): SwitchRequestHistory;
+    getRepresentation(): Representation;
 
-        getThroughputController(): ThroughputController;
+    getScheduleController(): ScheduleController;
 
-        getVideoModel(): VideoModel;
-    }
+    getStreamInfo(): StreamInfo;
 
-    export interface SwitchRequest {
-        priority: number | null;
-        reason: string | null;
-        representation: Representation;
-        rule: any
-    }
+    getSwitchHistory(): SwitchRequestHistory;
 
-    export interface SwitchRequestHistory {
-        clearForStream(streamId: string | number): object;
+    getThroughputController(): ThroughputController;
 
-        getSwitchRequests(): SwitchRequest[];
+    getVideoModel(): VideoModel;
+}
 
-        push(switchRequest: SwitchRequest): void;
+export interface SwitchRequest {
+    priority: number | null;
+    reason: string | null;
+    representation: Representation;
+    rule: any
+}
 
-        reset(): void;
-    }
+export interface SwitchRequestHistory {
+    clearForStream(streamId: string | number): object;
 
-    /**
-     * Streaming - Text
-     **/
+    getSwitchRequests(): SwitchRequest[];
 
-    export type TextTrackType = 'subtitles' | 'caption' | 'descriptions' | 'chapters' | 'metadata';
+    push(switchRequest: SwitchRequest): void;
 
-    export type FontDownloadStatus = 'unloaded' | 'loaded' | 'error';
+    reset(): void;
+}
 
-    export interface FontInfo {
-        fontFace: FontFace;
-        fontFamily: string;
-        isEssential: boolean;
-        mimeType: string;
-        status: FontDownloadStatus;
-        streamId: string;
-        trackId: number;
-        url: string;
-    }
+/**
+ * Streaming - Text
+ **/
 
-    export interface DVBFonts {
-        addFontsFromTracks(tracks: TextTrackInfo, streamId: string): void;
+export type TextTrackType = 'subtitles' | 'caption' | 'descriptions' | 'chapters' | 'metadata';
 
-        downloadFonts(): void;
+export type FontDownloadStatus = 'unloaded' | 'loaded' | 'error';
 
-        getFonts(): FontInfo[];
+export interface FontInfo {
+    fontFace: FontFace;
+    fontFamily: string;
+    isEssential: boolean;
+    mimeType: string;
+    status: FontDownloadStatus;
+    streamId: string;
+    trackId: number;
+    url: string;
+}
 
-        getFontsForTrackId(trackId: number): FontInfo[];
+export interface DVBFonts {
+    addFontsFromTracks(tracks: TextTrackInfo, streamId: string): void;
 
-        reset(): void;
-    }
+    downloadFonts(): void;
 
-    export interface EmbeddedTextHtmlRender {
-        createHTMLCaptionsFromScreen(videoElement: HTMLVideoElement, startTime: number, endTime: number, captionScreen: any): any[];
-    }
+    getFonts(): FontInfo[];
 
-    export interface NotFragmentTextBufferController {
-        appendInitSegmentFromCache(representationId: string): void;
+    getFontsForTrackId(trackId: number): FontInfo[];
 
-        clearBuffers(): Promise<any>;
+    reset(): void;
+}
 
-        createBufferSink(mediaInfo: MediaInfo): void;
+export interface EmbeddedTextHtmlRender {
+    createHTMLCaptionsFromScreen(videoElement: HTMLVideoElement, startTime: number, endTime: number, captionScreen: any): any[];
+}
 
-        dischargePreBuffer(): void;
+export interface NotFragmentTextBufferController {
+    appendInitSegmentFromCache(representationId: string): void;
 
-        getAllRangesWithSafetyFactor(): [];
+    clearBuffers(): Promise<any>;
 
-        getBuffer(): SourceBufferSink;
+    createBufferSink(mediaInfo: MediaInfo): void;
 
-        getBufferControllerType(): string;
+    dischargePreBuffer(): void;
 
-        getBufferLevel(): 0;
+    getAllRangesWithSafetyFactor(): [];
 
-        getContinuousBufferTimeForTargetTime(): number;
+    getBuffer(): SourceBufferSink;
 
-        getIsBufferingCompleted(): boolean;
+    getBufferControllerType(): string;
 
-        getIsPruningInProgress(): false;
+    getBufferLevel(): 0;
 
-        getMediaSource(): MediaSource;
+    getContinuousBufferTimeForTargetTime(): number;
 
-        getRangeAt(): null;
+    getIsBufferingCompleted(): boolean;
 
-        getStreamId(): string;
+    getIsPruningInProgress(): false;
 
-        getType(): string;
+    getMediaSource(): MediaSource;
 
-        hasBufferAtTime(): boolean;
+    getRangeAt(): null;
 
-        initialize(source: MediaSource): void;
+    getStreamId(): string;
 
-        prepareForPlaybackSeek(): Promise<any>;
+    getType(): string;
 
-        prepareForReplacementTrackSwitch(): Promise<any>;
+    hasBufferAtTime(): boolean;
 
-        pruneAllSafely(): Promise<any>;
+    initialize(source: MediaSource): void;
 
-        pruneBuffer(): void;
+    prepareForPlaybackSeek(): Promise<any>;
 
-        reset(): void;
+    prepareForReplacementTrackSwitch(): Promise<any>;
 
-        segmentRequestingCompleted(): void
+    pruneAllSafely(): Promise<any>;
 
-        setIsBufferingCompleted(value: boolean): void;
+    pruneBuffer(): void;
 
-        setMediaSource(value: MediaSource): void;
+    reset(): void;
 
-        setSeekTarget(): void;
+    segmentRequestingCompleted(): void
 
-        updateAppendWindow(): Promise<any>;
+    setIsBufferingCompleted(value: boolean): void;
 
-        updateBufferTimestampOffset(): Promise<any>;
-    }
+    setMediaSource(value: MediaSource): void;
 
-    export interface TextController {
-        addEmbeddedTrack(streamInfo: StreamInfo, mediaInfo: MediaInfo): void;
+    setSeekTarget(): void;
 
-        addMediaInfosToBuffer(streamInfo: StreamInfo, mInfos: MediaInfo[], mimeType: string | null, fragmentModel?: FragmentModel): void;
+    updateAppendWindow(): Promise<any>;
 
-        createTracks(streamInfo: StreamInfo): void;
+    updateBufferTimestampOffset(): Promise<any>;
+}
 
-        deactivateStream(streamInfo: StreamInfo): void;
+export interface TextController {
+    addEmbeddedTrack(streamInfo: StreamInfo, mediaInfo: MediaInfo): void;
 
-        enableForcedTextStreaming(enable: boolean): void;
+    addMediaInfosToBuffer(streamInfo: StreamInfo, mInfos: MediaInfo[], mimeType: string | null, fragmentModel?: FragmentModel): void;
 
-        enableText(streamId: string, enable: boolean): void;
+    createTracks(streamInfo: StreamInfo): void;
 
-        getAllTracksAreDisabled(): boolean;
+    deactivateStream(streamInfo: StreamInfo): void;
 
-        getCurrentTrackIdx(streamId: string): number;
+    enableForcedTextStreaming(enable: boolean): void;
 
-        getTextSourceBuffer(streamInfo: StreamInfo): TextSourceBuffer;
+    enableText(streamId: string, enable: boolean): void;
 
-        initialize(): void;
+    getAllTracksAreDisabled(): boolean;
 
-        initializeForStream(streamInfo: StreamInfo): void;
+    getCurrentTrackIdx(streamId: string): number;
 
-        isTextEnabled(): boolean;
+    getTextSourceBuffer(streamInfo: StreamInfo): TextSourceBuffer;
 
-        reset(): void;
+    initialize(): void;
 
-        setTextTrack(streamId: string, idx: number): void;
-    }
+    initializeForStream(streamInfo: StreamInfo): void;
 
-    export interface TextSourceBuffer {
-        abort(): void;
+    isTextEnabled(): boolean;
 
-        addEmbeddedTrack(mediaInfo: MediaInfo): void;
+    reset(): void;
 
-        addMediaInfos(type: string, mInfos: MediaInfo[], fModel: FragmentModel): void;
+    setTextTrack(streamId: string, idx: number): void;
+}
 
-        append(bytes: number[], chunk: DataChunk): void;
+export interface TextSourceBuffer {
+    abort(): void;
 
-        getConfig(): object;
+    addEmbeddedTrack(mediaInfo: MediaInfo): void;
 
-        getStreamId(): string;
+    addMediaInfos(type: string, mInfos: MediaInfo[], fModel: FragmentModel): void;
 
-        initialize(): void;
+    append(bytes: number[], chunk: DataChunk): void;
 
-        remove(start?: number, end?: number): void;
+    getConfig(): object;
 
-        reset(): void;
+    getStreamId(): string;
 
-        resetEmbedded(): void;
+    initialize(): void;
 
-        resetMediaInfos(): void;
+    remove(start?: number, end?: number): void;
 
-        setCurrentFragmentedTrackIdx(idx: number): void;
-    }
+    reset(): void;
 
-    export interface TextTracks {
-        addCaptions(trackIdx: number, timeOffset: number, captionData: object): void;
+    resetEmbedded(): void;
 
-        addTextTrack(textTrackInfoVO: TextTrackInfo): void;
+    resetMediaInfos(): void;
 
-        createTracks(): void;
+    setCurrentFragmentedTrackIdx(idx: number): void;
+}
 
-        deleteAllTextTracks(): void;
+export interface TextTracks {
+    addCaptions(trackIdx: number, timeOffset: number, captionData: object): void;
 
-        deleteCuesFromTrackIdx(trackIdx: number, start: number, end: number): void;
+    addTextTrack(textTrackInfoVO: TextTrackInfo): void;
 
-        disableManualTracks(): void;
+    createTracks(): void;
 
-        getCurrentTrackIdx(): number;
+    deleteAllTextTracks(): void;
 
-        getCurrentTrackInfo(): TextTrackInfo;
+    deleteCuesFromTrackIdx(trackIdx: number, start: number, end: number): void;
 
-        getStreamId(): string;
+    disableManualTracks(): void;
 
-        getTrackByIdx(idx: number): object;
+    getCurrentTrackIdx(): number;
 
-        getTrackIdxForId(trackId: string): number;
+    getCurrentTrackInfo(): TextTrackInfo;
 
-        initialize(): void;
+    getStreamId(): string;
 
-        manualProcessing(time: number): void;
+    getTrackByIdx(idx: number): object;
 
-        setCurrentTrackIdx(idx: number): void;
+    getTrackIdxForId(trackId: string): number;
 
-        setModeForTrackIdx(idx: number, mode: string): void;
-    }
+    initialize(): void;
 
-    /**
-     * Streaming - Thumbnail
-     **/
+    manualProcessing(time: number): void;
 
-    export interface ThumbnailController {
-        getCurrentTrack(): object;
+    setCurrentTrackIdx(idx: number): void;
 
-        getCurrentTrackIndex(): number;
+    setModeForTrackIdx(idx: number, mode: string): void;
+}
 
-        getPossibleVoRepresentations(): Representation[];
+/**
+ * Streaming - Thumbnail
+ **/
 
-        getStreamId(): string;
+export interface ThumbnailController {
+    getCurrentTrack(): object;
 
-        initialize(): void;
+    getCurrentTrackIndex(): number;
 
-        provide(time: number, callback: Function): void;
+    getPossibleVoRepresentations(): Representation[];
 
-        reset(): void;
+    getStreamId(): string;
 
-        setTrackById(id: number): void;
+    initialize(): void;
 
-        setTrackByIndex(index: number): void;
-    }
+    provide(time: number, callback: Function): void;
 
-    export interface ThumbnailTracks {
-        addTracks(): void;
+    reset(): void;
 
-        getCurrentTrack(): any | null;
+    setTrackById(id: number): void;
 
-        getCurrentTrackIndex(): number;
+    setTrackByIndex(index: number): void;
+}
 
-        getRepresentations(): Representation[];
+export interface ThumbnailTracks {
+    addTracks(): void;
 
-        getThumbnailRequestForTime(time: number): Request;
+    getCurrentTrack(): any | null;
 
-        getTracks(): any[];
+    getCurrentTrackIndex(): number;
 
-        reset(): void;
+    getRepresentations(): Representation[];
 
-        setTrackById(id: number): void;
+    getThumbnailRequestForTime(time: number): Request;
 
-        setTrackByIndex(index: number): void;
-    }
+    getTracks(): any[];
 
-    /**
-     * Streaming - Utils - baseUrlResolution
-     **/
+    reset(): void;
 
-    export interface BasicSelector {
-        select(baseURLs: BaseURL[]): BaseURL;
-    }
+    setTrackById(id: number): void;
 
-    export interface ContentSteeringSelector {
-        setConfig(config: object): void;
+    setTrackByIndex(index: number): void;
+}
 
-        selectBaseUrlIndex(data: any): number;
+/**
+ * Streaming - Utils - baseUrlResolution
+ **/
 
-        reset(): void;
-    }
+export interface BasicSelector {
+    select(baseURLs: BaseURL[]): BaseURL;
+}
 
-    export interface DVBSelector {
-        select(baseURLs: BaseURL[]): BaseURL[];
-    }
+export interface ContentSteeringSelector {
+    setConfig(config: object): void;
 
-    /**
-     * Streaming - Utils
-     **/
+    selectBaseUrlIndex(data: any): number;
 
-    export interface BaseURLSelector {
-        chooseSelector(isDVB: boolean): void;
+    reset(): void;
+}
 
-        reset(): void;
+export interface DVBSelector {
+    select(baseURLs: BaseURL[]): BaseURL[];
+}
 
-        select(data: ArrayBuffer): void;
+/**
+ * Streaming - Utils
+ **/
 
-        setConfig(config: object): void;
-    }
+export interface BaseURLSelector {
+    chooseSelector(isDVB: boolean): void;
 
-    export interface BoxParser {
-        findInitRange(data: ArrayBuffer): Range;
+    reset(): void;
 
-        findLastTopIsoBoxCompleted(types: string[], buffer: ArrayBuffer | Uint8Array, offset: number): IsoBoxSearchInfo;
+    select(data: ArrayBuffer): void;
 
-        getMediaTimescaleFromMoov(ab: ArrayBuffer): number;
+    setConfig(config: object): void;
+}
 
-        getSamplesInfo(ab: ArrayBuffer): object;
+export interface BoxParser {
+    findInitRange(data: ArrayBuffer): Range;
 
-        parse(data: ArrayBuffer): IsoFile | null;
+    findLastTopIsoBoxCompleted(types: string[], buffer: ArrayBuffer | Uint8Array, offset: number): IsoBoxSearchInfo;
 
-        parsePayload(types: string[], buffer: ArrayBuffer, offset: number): IsoBoxSearchInfo;
-    }
+    getMediaTimescaleFromMoov(ab: ArrayBuffer): number;
 
-    export interface Capabilities {
-        areKeyIdsExpired(mediaInfo: MediaInfo): boolean;
+    getSamplesInfo(ab: ArrayBuffer): object;
 
-        areKeyIdsUsable(mediaInfo: MediaInfo): boolean;
+    parse(data: ArrayBuffer): IsoFile | null;
 
-        codecRootCompatibleWithCodec(codec1: string, codec2: string): boolean;
+    parsePayload(types: string[], buffer: ArrayBuffer, offset: number): IsoBoxSearchInfo;
+}
 
-        isCodecSupportedBasedOnTestedConfigurations(basicConfiguration: object, type: string): boolean;
+export interface Capabilities {
+    areKeyIdsExpired(mediaInfo: MediaInfo): boolean;
 
-        isProtectionCompatible(previousStreamInfo: StreamInfo, newStreamInfo: StreamInfo): boolean;
+    areKeyIdsUsable(mediaInfo: MediaInfo): boolean;
 
-        runCodecSupportCheck(basicConfiguration: object, type: string): Promise<void>;
+    codecRootCompatibleWithCodec(codec1: string, codec2: string): boolean;
 
-        setConfig(config: object): void;
+    isCodecSupportedBasedOnTestedConfigurations(basicConfiguration: object, type: string): boolean;
 
-        setEncryptedMediaSupported(value: boolean): void;
+    isProtectionCompatible(previousStreamInfo: StreamInfo, newStreamInfo: StreamInfo): boolean;
 
-        setProtectionController(data: any): void;
+    runCodecSupportCheck(basicConfiguration: object, type: string): Promise<void>;
 
-        supportsChangeType(): boolean;
+    setConfig(config: object): void;
 
-        supportsEncryptedMedia(): boolean;
+    setEncryptedMediaSupported(value: boolean): void;
 
-        supportsEssentialProperty(ep: object): boolean;
+    setProtectionController(data: any): void;
 
-        supportsMediaSource(): boolean;
-    }
+    supportsChangeType(): boolean;
 
-    export type CapabilitiesFilterFunction = (representation: Representation) => boolean;
+    supportsEncryptedMedia(): boolean;
 
-    export interface CapabilitiesFilter {
-        filterUnsupportedFeatures(manifest: object): Promise<any>;
+    supportsEssentialProperty(ep: object): boolean;
 
-        setConfig(config: object): void;
-    }
+    supportsMediaSource(): boolean;
+}
 
-    export interface CustomTimeRanges {
-        customTimeRangeArray: any[];
-        length: number;
+export type CapabilitiesFilterFunction = (representation: Representation) => boolean;
 
-        add(start: number, end: number): void;
+export interface CapabilitiesFilter {
+    filterUnsupportedFeatures(manifest: object): Promise<any>;
 
-        clear(): void;
+    setConfig(config: object): void;
+}
 
-        end(index: number): number;
+export interface CustomTimeRanges {
+    customTimeRangeArray: any[];
+    length: number;
 
-        mergeRanges(rangeIndex1: number, rangeIndex2: number): boolean;
+    add(start: number, end: number): void;
 
-        remove(start: number, end: number): void;
+    clear(): void;
 
-        start(index: number): number;
-    }
+    end(index: number): number;
 
-    export interface DefaultURLUtils {
-        isHTTPS(url: string): boolean;
+    mergeRanges(rangeIndex1: number, rangeIndex2: number): boolean;
 
-        isHTTPURL(url: string): boolean;
+    remove(start: number, end: number): void;
 
-        isPathAbsolute(url: string): boolean;
+    start(index: number): number;
+}
 
-        isRelative(url: string): boolean;
+export interface DefaultURLUtils {
+    isHTTPS(url: string): boolean;
 
-        isSchemeRelative(url: string): boolean;
+    isHTTPURL(url: string): boolean;
 
-        parseBaseUrl(url: string): string;
+    isPathAbsolute(url: string): boolean;
 
-        parseOrigin(url: string): string;
+    isRelative(url: string): boolean;
 
-        parseScheme(url: string): string;
+    isSchemeRelative(url: string): boolean;
 
-        removeHostname(url: string): string;
+    parseBaseUrl(url: string): string;
 
-        resolve(url: string, baseUrl: BaseURL): string;
-    }
+    parseOrigin(url: string): string;
 
-    export interface DOMStorage {
-        getSavedBitrateSettings(type: string): number;
+    parseScheme(url: string): string;
 
-        getSavedMediaSettings(type: string): object;
+    removeHostname(url: string): string;
 
-        setSavedBitrateSettings(type: string, bitrate: number): void;
+    resolve(url: string, baseUrl: BaseURL): string;
+}
 
-        setSavedMediaSettings(type: string, value: any): void;
-    }
+export interface DOMStorage {
+    getSavedBitrateSettings(type: string): number;
 
-    export interface EBMLParser {
-        consumeTag(tag: object, test: boolean): boolean;
+    getSavedMediaSettings(type: string): object;
 
-        consumeTagAndSize(tag: object, test: boolean): boolean;
+    setSavedBitrateSettings(type: string, bitrate: number): void;
 
-        getMatroskaCodedNum(retainMSB: boolean): number;
+    setSavedMediaSettings(type: string, value: any): void;
+}
 
-        getMatroskaFloat(size: number): number;
+export interface EBMLParser {
+    consumeTag(tag: object, test: boolean): boolean;
 
-        getMatroskaUint(size: number): number;
+    consumeTagAndSize(tag: object, test: boolean): boolean;
 
-        getPos(): number;
+    getMatroskaCodedNum(retainMSB: boolean): number;
 
-        moreData(): boolean;
+    getMatroskaFloat(size: number): number;
 
-        parseTag(tag: object): boolean;
+    getMatroskaUint(size: number): number;
 
-        setPos(value: number): void;
+    getPos(): number;
 
-        skipOverElement(tag: object, test: boolean): boolean;
-    }
+    moreData(): boolean;
 
-    export interface ErrorHandler {
-        error(err: any): void;
-    }
+    parseTag(tag: object): boolean;
 
-    export interface InitCache {
-        extract(streamId: string, representationId: string): any | null;
+    setPos(value: number): void;
 
-        save(chunk: DataChunk): void;
+    skipOverElement(tag: object, test: boolean): boolean;
+}
 
-        reset(): void;
-    }
+export interface ErrorHandler {
+    error(err: any): void;
+}
 
-    export interface IsoFile {
-        getBox(type: string): IsoBox;
+export interface InitCache {
+    extract(streamId: string, representationId: string): any | null;
 
-        getBoxes(type: string): IsoBox[];
+    save(chunk: DataChunk): void;
 
-        getLastBox(): IsoBox | null;
+    reset(): void;
+}
 
-        setData(value: string): void;
-    }
+export interface IsoFile {
+    getBox(type: string): IsoBox;
 
-    export interface LocationSelector { // DOUBLED UP?
-        selectBaseUrlIndex(data: any): number;
+    getBoxes(type: string): IsoBox[];
 
-        setConfig(config: object): void;
-    }
+    getLastBox(): IsoBox | null;
 
-    export interface LocationSelector {
-        reset(): void;
+    setData(value: string): void;
+}
 
-        select(mpdLocations: MpdLocation[]): MpdLocation | null;
+export interface LocationSelector { // DOUBLED UP?
+    selectBaseUrlIndex(data: any): number;
 
-        setConfig(config: object): void;
-    }
+    setConfig(config: object): void;
+}
 
-    export interface ObjectUtils {
-        areEqual(obj1: object, obj2: object): boolean;
-    }
+export interface LocationSelector {
+    reset(): void;
 
-    export interface SupervisorTools { // BASE FILE DIFFERENT LAYOUT FROM ALL OTHERS
-        checkInteger(parameter: any): void;
+    select(mpdLocations: MpdLocation[]): MpdLocation | null;
 
-        checkIsVideoOrAudioType(type: string): void;
+    setConfig(config: object): void;
+}
 
-        checkParameterType(parameter: any, type: string): void;
+export interface ObjectUtils {
+    areEqual(obj1: object, obj2: object): boolean;
+}
 
-        checkRange(parameter: any, min: number, max: number): void;
-    }
+export interface SupervisorTools { // BASE FILE DIFFERENT LAYOUT FROM ALL OTHERS
+    checkInteger(parameter: any): void;
 
-    export interface TimeUtils {
-        ntpToUTC(ntpTimeStamp: number): number;
-    }
+    checkIsVideoOrAudioType(type: string): void;
 
-    export interface TTMLParser {
-        parse(data: string, offsetTime: number, startTimeSegment: number, endTimeSegment: number, images: any[]): {
-            start: number,
-            end: number,
-            type: string,
-            cueID: string,
-            isd: any,
-            images: any[],
-            embeddedImages: any[]
-        }[];
-    }
+    checkParameterType(parameter: any, type: string): void;
 
-    export interface URLUtils {
-        isHTTPS(url: string): boolean;
+    checkRange(parameter: any, min: number, max: number): void;
+}
 
-        isHTTPURL(url: string): boolean;
+export interface TimeUtils {
+    ntpToUTC(ntpTimeStamp: number): number;
+}
 
-        isPathAbsolute(url: string): boolean;
+export interface TTMLParser {
+    parse(data: string, offsetTime: number, startTimeSegment: number, endTimeSegment: number, images: any[]): {
+        start: number,
+        end: number,
+        type: string,
+        cueID: string,
+        isd: any,
+        images: any[],
+        embeddedImages: any[]
+    }[];
+}
 
-        isRelative(url: string): boolean;
+export interface URLUtils {
+    isHTTPS(url: string): boolean;
 
-        isSchemeRelative(url: string): boolean;
+    isHTTPURL(url: string): boolean;
 
-        parseBaseUrl(url: string): string;
+    isPathAbsolute(url: string): boolean;
 
-        parseOrigin(url: string): string;
+    isRelative(url: string): boolean;
 
-        parseScheme(url: string): string;
+    isSchemeRelative(url: string): boolean;
 
-        registerUrlRegex(regex: RegExp, utils: object): void;
+    parseBaseUrl(url: string): string;
 
-        removeHostname(url: string): string;
+    parseOrigin(url: string): string;
 
-        resolve(url: string, baseUrl: BaseURL): string;
-    }
+    parseScheme(url: string): string;
 
-    export interface VttCsutomRenderingParser {
-        parse(data: any): any[];
-    }
+    registerUrlRegex(regex: RegExp, utils: object): void;
 
-    export interface VTTParser {
-        getCaptionStyles(arr: Array<any>): object;
+    removeHostname(url: string): string;
 
-        parse(data: ArrayBuffer): { start: number, end: number, data: string, styles: any };
-    }
+    resolve(url: string, baseUrl: BaseURL): string;
+}
 
-    /**
-     * Streaming - Vo - Metrics
-     **/
+export interface VttCsutomRenderingParser {
+    parse(data: any): any[];
+}
 
-    export interface BufferLevel {
-        level: number;
-        t: Date;
-    }
+export interface VTTParser {
+    getCaptionStyles(arr: Array<any>): object;
 
-    export interface BufferState {
-        state: string;
-        target: number;
-    }
+    parse(data: ArrayBuffer): { start: number, end: number, data: string, styles: any };
+}
 
-    export interface DroppedFrames {
-        droppedFrames: number;
-        time: Date;
-    }
+/**
+ * Streaming - Vo - Metrics
+ **/
 
-    export interface DVRInfo {
-        manifestInfo: IManifestInfo;
-        range: Range;
-        time: number;
-    }
+export interface BufferLevel {
+    level: number;
+    t: Date;
+}
 
-    export interface HTTPRequest {
-        _fileLoaderType: string;
-        _mediaduration: number | null;
-        _quality: number | null;
-        _resourceTimingValues: object;
-        _responseHeaders: any[] | null;
-        _serviceLocation: string | null;
-        _stream: MediaType;
-        _tfinish: Date | null;
-        actualurl: string | null;
-        cmsd: object;
-        interval: number | null;
-        range: any[];
-        responsecode: number | null;
-        tcpid: string | null;
-        trace: any[];
-        trequest: Date | null;
-        tresponse: Date | null;
-        type?: string | null;
-        url: string | null;
-    }
+export interface BufferState {
+    state: string;
+    target: number;
+}
 
-    export interface ManifestUpdate {
-        availabilityStartTime: number | null;
-        buffered: object | null;
-        clientTimeOffset: number;
-        currentTime: number | null;
-        fetchTime: number | null;
-        latency: number;
-        mediaType: MediaType | null;
-        presentationStartTime: number;
-        representationInfo: ManifestUpdateRepresentationInfo[];
-        requestTime: number | null;
-        streamInfo: StreamInfo[];
-        type: string | null;
-    }
+export interface DroppedFrames {
+    droppedFrames: number;
+    time: Date;
+}
 
-    export interface ManifestUpdateRepresentationInfo {
-        id: string | null;
-        index: number | null;
-        mediaType: MediaType | null;
-        presentationTimeOffset: number | null;
-        startNumber: number | null;
-    }
+export interface DVRInfo {
+    manifestInfo: IManifestInfo;
+    range: Range;
+    time: number;
+}
 
-    export interface PlayList {
-        mstart: number | null;
-        start: number | null;
-        starttype: string | null;
-        trace: any[];
-    }
+export interface HTTPRequest {
+    _fileLoaderType: string;
+    _mediaduration: number | null;
+    _quality: number | null;
+    _resourceTimingValues: object;
+    _responseHeaders: any[] | null;
+    _serviceLocation: string | null;
+    _stream: MediaType;
+    _tfinish: Date | null;
+    actualurl: string | null;
+    cmsd: object;
+    interval: number | null;
+    range: any[];
+    responsecode: number | null;
+    tcpid: string | null;
+    trace: any[];
+    trequest: Date | null;
+    tresponse: Date | null;
+    type?: string | null;
+    url: string | null;
+}
 
-    export interface RepresentationSwitch {
-        lto: number | null;
-        mt: number | null;
-        t: number | null;
-        to: number | null;
-    }
+export interface ManifestUpdate {
+    availabilityStartTime: number | null;
+    buffered: object | null;
+    clientTimeOffset: number;
+    currentTime: number | null;
+    fetchTime: number | null;
+    latency: number;
+    mediaType: MediaType | null;
+    presentationStartTime: number;
+    representationInfo: ManifestUpdateRepresentationInfo[];
+    requestTime: number | null;
+    streamInfo: StreamInfo[];
+    type: string | null;
+}
 
-    export interface PlayListTrace {
-        duration: number | null;
-        mstart: number | null;
-        playbackspeed: number | null;
-        representationid: string | null;
-        start: number | null;
-        stopreason: string | null;
-        subreplevel: number | null;
-    }
+export interface ManifestUpdateRepresentationInfo {
+    id: string | null;
+    index: number | null;
+    mediaType: MediaType | null;
+    presentationTimeOffset: number | null;
+    startNumber: number | null;
+}
 
-    export interface RequestSwitch {
-        lto: string | null;
-        mt: number | null;
-        t: number | null;
-        to: string | null;
-    }
+export interface PlayList {
+    mstart: number | null;
+    start: number | null;
+    starttype: string | null;
+    trace: any[];
+}
 
-    export class RequestsQueue {
-        /**
-         * Array of all of the requests that have begun to load.
-         * This request may not make it into the executed queue if it is abandon due to ABR rules for example.
-         */
-        loadingRequests: any[];
-        /**
-         * Array of the the requests that have completed
-         */
-        executedRequests: any[];
-    }
+export interface RepresentationSwitch {
+    lto: number | null;
+    mt: number | null;
+    t: number | null;
+    to: number | null;
+}
 
-    //eg. duration initialized with null; should be NaN?
-    export interface SchedulingInfo {
-        availabilityStartTime: number | null;
-        duration: number | null;
-        mediaType: MediaType | null;
-        quality: number | null;
-        range: Range | null;
-        startTime: number | null;
-        state: string | null;
-        t: number | null;
-        type: string | null;
-    }
+export interface PlayListTrace {
+    duration: number | null;
+    mstart: number | null;
+    playbackspeed: number | null;
+    representationid: string | null;
+    start: number | null;
+    stopreason: string | null;
+    subreplevel: number | null;
+}
 
-    export interface TCPConnection {
-        dest: string | null;
-        tclose: number | null;
-        tconnect: number | null
-        tcpid: string | null;
-        topen: number | null;
-    }
+export interface RequestSwitch {
+    lto: string | null;
+    mt: number | null;
+    t: number | null;
+    to: string | null;
+}
 
+export class RequestsQueue {
     /**
-     * Streaming - Vo
+     * Array of all of the requests that have begun to load.
+     * This request may not make it into the executed queue if it is abandon due to ABR rules for example.
      */
+    loadingRequests: any[];
+    /**
+     * Array of the the requests that have completed
+     */
+    executedRequests: any[];
+}
 
-    export class BitrateInfo {
-        bitrate: number;
-        height: number;
-        mediaType: MediaType;
-        qualityIndex: number;
-        scanType: string;
-        width: number;
-    }
+//eg. duration initialized with null; should be NaN?
+export interface SchedulingInfo {
+    availabilityStartTime: number | null;
+    duration: number | null;
+    mediaType: MediaType | null;
+    quality: number | null;
+    range: Range | null;
+    startTime: number | null;
+    state: string | null;
+    t: number | null;
+    type: string | null;
+}
 
-    interface DashJSError {
-        code: number | null;
-        data: unknown | null;
-        message: string | null;
-    }
+export interface TCPConnection {
+    dest: string | null;
+    tclose: number | null;
+    tconnect: number | null
+    tcpid: string | null;
+    topen: number | null;
+}
 
-    export interface DataChunk {
-        bytes: number[] | null;
-        duration: number;
-        end: number;
-        endFragment: object | null;
-        index: number;
-        mediaInfo: MediaInfo | null;
-        quality: number;
-        representationId: string | null;
-        segmentType: string | null;
-        start: number;
-        streamId: string | null;
-    }
+/**
+ * Streaming - Vo
+ */
+
+export class BitrateInfo {
+    bitrate: number;
+    height: number;
+    mediaType: MediaType;
+    qualityIndex: number;
+    scanType: string;
+    width: number;
+}
 
-    export class ExternalSubtitle {
-        constructor(externalSubtitleObject: object);
+export class ExternalSubtitle {
+    constructor(externalSubtitleObject: object);
 
-        id: string;
-        url: string;
-        language: string;
-        mimeType: string;
-        bandwidth: number;
-        periodId: string | null;
+    id: string;
+    url: string;
+    language: string;
+    mimeType: string;
+    bandwidth: number;
+    periodId: string | null;
 
-        serializeToMpdParserFormat(): object;
-    }
+    serializeToMpdParserFormat(): object;
+}
 
-    export class FragmentRequest {
-        constructor(url: string);
-
-        action: string;
-        availabilityEndTime: number;
-        availabilityStartTime: number;
-        bytesLoaded: number;
-        bytesTotal: number;
-        delayLoadingTime: number;
-        duration: number;
-        firstByteDate: Date;
-        index: number;
-        mediaInfo: MediaInfo;
-        mediaStartTime: number;
-        mediaType: MediaType;
-        quality: number;
-        representationId: string;
-        requestEndDate: Date | null;
-        responseType: string;
-        serviceLocation: string;
-        startDate: Date;
-        startTime: number;
-        timescale: number;
-        type: 'InitializationSegment' | 'MediaSegment' | null;
-        url: string | null;
-        wallStartTime: number | null;
-    }
+export interface DashJSError {
+    code: number | null;
+    data: unknown | null;
+    message: string | null;
+}
+
+export interface DataChunk {
+    bytes: number[] | null;
+    duration: number;
+    end: number;
+    endFragment: object | null;
+    index: number;
+    mediaInfo: MediaInfo | null;
+    quality: number;
+    representationId: string | null;
+    segmentType: string | null;
+    start: number;
+    streamId: string | null;
+}
 
-    export class HeadRequest extends FragmentRequest {
-        constructor(url: string);
+export class FragmentRequest {
+    constructor(url: string);
+
+    action: string;
+    availabilityEndTime: number;
+    availabilityStartTime: number;
+    bytesLoaded: number;
+    bytesTotal: number;
+    delayLoadingTime: number;
+    duration: number;
+    firstByteDate: Date;
+    index: number;
+    mediaInfo: MediaInfo;
+    mediaStartTime: number;
+    mediaType: MediaType;
+    quality: number;
+    representationId: string;
+    requestEndDate: Date | null;
+    responseType: string;
+    serviceLocation: string;
+    startDate: Date;
+    startTime: number;
+    timescale: number;
+    type: 'InitializationSegment' | 'MediaSegment' | null;
+    url: string | null;
+    wallStartTime: number | null;
+}
 
-        checkforExistenceOnly: boolean;
-    }
+export class HeadRequest extends FragmentRequest {
+    constructor(url: string);
 
-    export class HttpLoaderRequest {
-        headers: object;
-        loader: object;
-        method: string;
-        onerror: Function;
-        onload: Function;
-        onloadend: Function;
-        ontimeout: Function;
-        progress: Function;
-        reader: object;
-        request: FragmentRequest;
-        response: object;
-        timeout: number;
-        url: string;
-        withCredentials: boolean;
-    }
+    checkforExistenceOnly: boolean;
+}
 
-    export class IsoBox {
-        constructor(boxData: object);
-    }
+export class HttpLoaderRequest {
+    headers: object;
+    loader: object;
+    method: string;
+    onerror: Function;
+    onload: Function;
+    onloadend: Function;
+    ontimeout: Function;
+    progress: Function;
+    reader: object;
+    request: FragmentRequest;
+    response: object;
+    timeout: number;
+    url: string;
+    withCredentials: boolean;
+}
 
-    export class IsoBoxSearchInfo {
-        constructor(found: boolean,
-                    sizeOfLastCompletedBox: number,
-                    sizeOfLastFoundTargetBox: number,
-                    startOffsetOfLastCompletedBox: number,
-                    startOffsetOfLastFoundTargetBox: number,
-                    typeOfLastCompletedBox: string,
-                    typeOfLastTargetBox: string);
-
-        found: boolean;
-        sizeOfLastCompletedBox: number;
-        sizeOfLastFoundTargetBox: number;
-        startOffsetOfLastCompletedBox: number;
-        startOffsetOfLastFoundTargetBox: number;
-        typeOfLastCompletedBox: string | null;
-        typeOfLastTargetBox: string | null;
-    }
+export class IsoBox {
+    constructor(boxData: object);
+}
 
-    export class MetricsList {
-        BufferLevel: BufferLevel[];
-        BufferState: BufferState[];
-        DVBErrors: DVBErrors[];
-        DVRInfo: DVRInfo[];
-        DroppedFrames: DroppedFrames[];
-        HttpList: any[];
-        ManifestUpdate: ManifestUpdate[];
-        PlayList: PlayList[];
-        RepSwitchList: RequestSwitch[];
-        RequestsQueue: RequestsQueue | null;
-        SchedulingInfo: SchedulingInfo;
-        TcpList: TCPConnection[];
-    }
+export class IsoBoxSearchInfo {
+    constructor(found: boolean,
+                sizeOfLastCompletedBox: number,
+                sizeOfLastFoundTargetBox: number,
+                startOffsetOfLastCompletedBox: number,
+                startOffsetOfLastFoundTargetBox: number,
+                typeOfLastCompletedBox: string,
+                typeOfLastTargetBox: string);
+
+    found: boolean;
+    sizeOfLastCompletedBox: number;
+    sizeOfLastFoundTargetBox: number;
+    startOffsetOfLastCompletedBox: number;
+    startOffsetOfLastFoundTargetBox: number;
+    typeOfLastCompletedBox: string | null;
+    typeOfLastTargetBox: string | null;
+}
 
-    export class MediaInfoSelectionInput {
-        newMediaInfo: MediaInfo;
-        newRepresentation: Representation | null
-        previouslySelectedRepresentation: Representation | null;
-    }
+export class MetricsList {
+    BufferLevel: BufferLevel[];
+    BufferState: BufferState[];
+    DVBErrors: DVBErrors[];
+    DVRInfo: DVRInfo[];
+    DroppedFrames: DroppedFrames[];
+    HttpList: any[];
+    ManifestUpdate: ManifestUpdate[];
+    PlayList: PlayList[];
+    RepSwitchList: RequestSwitch[];
+    RequestsQueue: RequestsQueue | null;
+    SchedulingInfo: SchedulingInfo;
+    TcpList: TCPConnection[];
+}
 
-    export class TextRequest extends FragmentRequest {
-        constructor(url: string, type: string);
+export class MediaInfoSelectionInput {
+    newMediaInfo: MediaInfo;
+    newRepresentation: Representation | null
+    previouslySelectedRepresentation: Representation | null;
+}
 
-        mediaType: MediaType;
-        responseType: string;
-        type: 'InitializationSegment' | 'MediaSegment' | null;
-        url: string | null;
-    }
+export class TextRequest extends FragmentRequest {
+    constructor(url: string, type: string);
 
-    export class TextTrackInfo extends MediaInfo {
-        captionData: CaptionData[] | null;
-        defaultTrack: boolean;
-        isEmbedded: boolean;
-        isFragmented: boolean;
-        isTTML: boolean;
-        kind: string;
-        label: string | null;
-    }
+    mediaType: MediaType;
+    responseType: string;
+    type: 'InitializationSegment' | 'MediaSegment' | null;
+    url: string | null;
+}
 
-    export interface Thumbnail {
-        height: number;
-        url: string;
-        width: number;
-        x: number;
-        y: number;
-    }
+export class TextTrackInfo extends MediaInfo {
+    captionData: CaptionData[] | null;
+    defaultTrack: boolean;
+    isEmbedded: boolean;
+    isFragmented: boolean;
+    isTTML: boolean;
+    kind: string;
+    label: string | null;
+}
 
-    export interface ThumbnailTrackInfo {
-        bitrate: number;
-        height: number;
-        heightPerTile: number;
-        id: string;
-        segmentDuration: number;
-        startNumber: number;
-        templateUrl: string;
-        tilesHor: number;
-        tilesVert: number;
-        timescale: number;
-        width: number;
-        widthPerTile: number;
-    }
+export interface Thumbnail {
+    height: number;
+    url: string;
+    width: number;
+    x: number;
+    y: number;
+}
 
-    export interface URIFragmentData {
-        id: string | null;
-        r: any | null;
-        s: any | null;
-        t: number | null;
-        track: any | null;
-        xywh: any | null;
-    }
+export interface ThumbnailTrackInfo {
+    bitrate: number;
+    height: number;
+    heightPerTile: number;
+    id: string;
+    segmentDuration: number;
+    startNumber: number;
+    templateUrl: string;
+    tilesHor: number;
+    tilesVert: number;
+    timescale: number;
+    width: number;
+    widthPerTile: number;
+}
 
-    /**
-     * Streaming
-     **/
+export interface URIFragmentData {
+    id: string | null;
+    r: any | null;
+    s: any | null;
+    t: number | null;
+    track: any | null;
+    xywh: any | null;
+}
 
-    export interface FragmentLoader {
-        abort(): void;
+/**
+ * Streaming
+ **/
 
-        checkForExistence(request: Request): void;
+export interface FragmentLoader {
+    abort(): void;
 
-        load(request: Request): void;
+    checkForExistence(request: Request): void;
 
-        reset(): void;
+    load(request: Request): void;
 
-        resetInitialSettings(): void;
-    }
+    reset(): void;
 
-    export interface FragmentSink {
-        abort(): void;
+    resetInitialSettings(): void;
+}
 
-        append(chunk: DataChunk): void;
+export interface FragmentSink {
+    abort(): void;
 
-        getAllBufferRanges(): any[];
+    append(chunk: DataChunk): void;
 
-        remove(start?: number, end?: number): void;
+    getAllBufferRanges(): any[];
 
-        reset(): void;
-    }
+    remove(start?: number, end?: number): void;
 
-    export interface ManifestLoader {
-        load(url: string, serviceLocation: string | null, queryParams: object | null): void;
+    reset(): void;
+}
 
-        reset(): void;
-    }
+export interface ManifestLoader {
+    load(url: string, serviceLocation: string | null, queryParams: object | null): void;
 
-    export interface ManifestUpdater {
-        getIsUpdating(): boolean;
+    reset(): void;
+}
 
-        initialize(): void;
+export interface ManifestUpdater {
+    getIsUpdating(): boolean;
 
-        refreshManifest(ignorePatch?: boolean): void;
+    initialize(): void;
 
-        reset(): void;
+    refreshManifest(ignorePatch?: boolean): void;
 
-        setConfig(config: object): void;
+    reset(): void;
 
-        setManifest(manifest: object): void;
-    }
+    setConfig(config: object): void;
 
-    export namespace MediaPlayer {
-        export const events: MediaPlayerEvents;
-        export const errors: MediaPlayerErrors;
-    }
+    setManifest(manifest: object): void;
+}
 
-    export interface MediaPlayerFactory {
-        create(): MediaPlayerClass;
-    }
+export namespace MediaPlayer {
+    export const events: MediaPlayerEvents;
+    export const errors: MediaPlayerErrors;
+}
 
-    export function MediaPlayer(): MediaPlayerFactory;
+export interface MediaPlayerFactory {
+    create(): MediaPlayerClass;
+}
 
-    export interface PreBufferSink {
-        abort(): void;
+export function MediaPlayer(): MediaPlayerFactory;
 
-        append(chunk: DataChunk): void;
+export interface PreBufferSink {
+    abort(): void;
 
-        discharge(start?: number, end?: number): void;
+    append(chunk: DataChunk): void;
 
-        getAllBufferRanges(): TimeRanges;
+    discharge(start?: number, end?: number): void;
 
-        getBuffer(): PreBufferSink;
+    getAllBufferRanges(): TimeRanges;
 
-        remove(start: number, end: number): void;
+    getBuffer(): PreBufferSink;
 
-        reset(): void;
+    remove(start: number, end: number): void;
 
-        updateTimestampOffset(): void;
+    reset(): void;
 
-        waitForUpdateEnd(callback: Function): void;
-    }
+    updateTimestampOffset(): void;
 
-    export interface SourceBufferSink {
-        abort(): Promise<any>;
+    waitForUpdateEnd(callback: Function): void;
+}
 
-        append(chunk: DataChunk, request?: Request): Promise<any>;
+export interface SourceBufferSink {
+    abort(): Promise<any>;
 
-        changeType(codec: string): Promise<any>;
+    append(chunk: DataChunk, request?: Request): Promise<any>;
 
-        getAllBufferRanges(): object;
+    changeType(codec: string): Promise<any>;
 
-        getBuffer(): Buffer;
+    getAllBufferRanges(): object;
 
-        getSessionType(): string;
+    getBuffer(): SourceBuffer | TextSourceBuffer;
 
-        getType(): string;
+    getSessionType(): string;
 
-        getUsable(): boolean;
+    getType(): string;
 
-        initializeForFirstUse(streamInfo: StreamInfo, mInfo: MediaInfo, selectedRepresentation: Representation): void;
+    getUsable(): boolean;
 
-        initializeForStreamSwitch(mInfo: MediaInfo, selectedRepresentation: Representation, oldSourceBufferSink: SourceBufferSink): Promise<any>;
+    initializeForFirstUse(streamInfo: StreamInfo, mInfo: MediaInfo, selectedRepresentation: Representation): void;
 
-        remove(range: Range): Promise<any>;
+    initializeForStreamSwitch(mInfo: MediaInfo, selectedRepresentation: Representation, oldSourceBufferSink: SourceBufferSink): Promise<any>;
 
-        reset(): void;
+    remove(range: Range): Promise<any>;
 
-        updateAppendWindow(sInfo: StreamInfo): void;
+    reset(): void;
 
-        updateTimestampOffset(mseTimeOffset: number): void;
-    }
+    updateAppendWindow(sInfo: StreamInfo): void;
 
-    export interface Stream {
-        activate(mediaSource: MediaSource, previousBufferSinks: any[]): void;
+    updateTimestampOffset(mseTimeOffset: number): void;
+}
 
-        checkAndHandleCompletedBuffering(): void;
+export interface Stream {
+    activate(mediaSource: MediaSource, previousBufferSinks: any[]): void;
 
-        deactivate(keepBuffers: boolean): void;
+    checkAndHandleCompletedBuffering(): void;
 
-        getAdapter(): DashAdapter
+    deactivate(keepBuffers: boolean): void;
 
-        getDuration(): number;
+    getAdapter(): DashAdapter
 
-        getHasAudioTrack(): boolean;
+    getDuration(): number;
 
-        getHasFinishedBuffering(): boolean
+    getHasAudioTrack(): boolean;
 
-        getHasVideoTrack(): boolean;
+    getHasFinishedBuffering(): boolean
 
-        getId(): string;
+    getHasVideoTrack(): boolean;
 
-        getIsActive(): boolean;
+    getId(): string;
 
-        getIsEndedEventSignaled(): boolean
+    getIsActive(): boolean;
 
-        getPreloaded(): boolean
+    getIsEndedEventSignaled(): boolean
 
-        getStartTime(): number;
+    getPreloaded(): boolean
 
-        getStreamId(): string;
+    getStartTime(): number;
 
-        getStreamInfo(): StreamInfo | null;
+    getStreamId(): string;
 
-        getStreamProcessors(): any[];
+    getStreamInfo(): StreamInfo | null;
 
-        getThumbnailController(): object;
+    getStreamProcessors(): any[];
 
-        initialize(streamInfo: StreamInfo, protectionController: ProtectionController): void;
+    getThumbnailController(): object;
 
-        isMediaCodecCompatible(newStream: Stream, previousStream: Stream | null): boolean;
+    initialize(streamInfo: StreamInfo, protectionController: ProtectionController): void;
 
-        isProtectionCompatible(newStream: Stream): boolean
+    isMediaCodecCompatible(newStream: Stream, previousStream: Stream | null): boolean;
 
-        prepareQualityChange(e: object): void
+    isProtectionCompatible(newStream: Stream): boolean
 
-        prepareTrackChange(e: object): void
+    prepareQualityChange(e: object): void
 
-        reset(): void;
+    prepareTrackChange(e: object): void
 
-        setIsEndedEventSignaled(value: boolean): void
+    reset(): void;
 
-        setMediaSource(mediaSource: MediaSource): void;
+    setIsEndedEventSignaled(value: boolean): void
 
-        startPreloading(mediaSource: MediaSource, previousBuffers: any[], representationsFromPreviousPeriod: Representation[]): void;
+    setMediaSource(mediaSource: MediaSource): void;
 
-        startScheduleControllers(): void
+    startPreloading(mediaSource: MediaSource, previousBuffers: any[], representationsFromPreviousPeriod: Representation[]): void;
 
-        updateData(updatedStreamInfo: StreamInfo): void;
-    }
+    startScheduleControllers(): void
 
-    export interface StreamProcessor {
-        addMediaInfo(newMediaInfo: MediaInfo): void;
+    updateData(updatedStreamInfo: StreamInfo): void;
+}
 
-        checkAndHandleCompletedBuffering(): void;
+export interface StreamProcessor {
+    addMediaInfo(newMediaInfo: MediaInfo): void;
 
-        clearMediaInfoArray(): void;
+    checkAndHandleCompletedBuffering(): void;
 
-        createBufferSinks(previousBufferSinks: any[]): Promise<any>;
+    clearMediaInfoArray(): void;
 
-        finalisePlayList(time: number, reason: string): void;
+    createBufferSinks(previousBufferSinks: any[]): Promise<any>;
 
-        getBuffer(): Buffer;
+    finalisePlayList(time: number, reason: string): void;
 
-        getBufferController(): BufferController;
+    getBuffer(): SourceBuffer | TextSourceBuffer;
 
-        getBufferLevel(): number;
+    getBufferController(): BufferController;
 
-        getFragmentModel(): FragmentModel;
+    getBufferLevel(): number;
 
-        getMediaInfo(): MediaInfo;
+    getFragmentModel(): FragmentModel;
 
-        getMediaSource(): MediaSource;
+    getMediaInfo(): MediaInfo;
 
-        getRepresentationController(): RepresentationController;
+    getMediaSource(): MediaSource;
 
-        getScheduleController(): ScheduleController;
+    getRepresentationController(): RepresentationController;
 
-        getStreamId(): string;
+    getScheduleController(): ScheduleController;
 
-        getStreamInfo(): StreamInfo;
+    getStreamId(): string;
 
-        getType(): string;
+    getStreamInfo(): StreamInfo;
 
-        handleNewMediaInfo(mediaInfo: MediaInfo): void;
+    getType(): string;
 
-        initialize(mediaSource: MediaSource, hasVideoTrack: boolean, isFragmented: boolean): void;
+    handleNewMediaInfo(mediaInfo: MediaInfo): void;
 
-        isBufferingCompleted(): boolean;
+    initialize(mediaSource: MediaSource, hasVideoTrack: boolean, isFragmented: boolean): void;
 
-        isUpdating(): boolean;
+    isBufferingCompleted(): boolean;
 
-        prepareInnerPeriodPlaybackSeeking(e: object): Promise<any>;
+    isUpdating(): boolean;
 
-        prepareOuterPeriodPlaybackSeeking(): Promise<unknown>;
+    prepareInnerPeriodPlaybackSeeking(e: object): Promise<any>;
 
-        prepareQualityChange(e: object): void;
+    prepareOuterPeriodPlaybackSeeking(): Promise<unknown>;
 
-        prepareTrackSwitch(previousBufferSinks: any[]): Promise<any>;
+    prepareQualityChange(e: object): void;
 
-        probeNextRequest(): Request;
+    prepareTrackSwitch(previousBufferSinks: any[]): Promise<any>;
 
-        reset(errored: boolean, keepBuffers: boolean): void;
+    probeNextRequest(): Request;
 
-        selectMediaInfo(selectionInput: object): Promise<any>;
+    reset(errored: boolean, keepBuffers: boolean): void;
 
-        setExplicitBufferingTime(value: number): void;
+    selectMediaInfo(selectionInput: object): Promise<any>;
 
-        setMediaSource(mediaSource: MediaSource): void;
+    setExplicitBufferingTime(value: number): void;
 
-        updateStreamInfo(newStreamInfo: StreamInfo): Promise<any>;
-    }
+    setMediaSource(mediaSource: MediaSource): void;
 
-    export interface XlinkLoader {
-        load(url: string, element: any, resolveObject: object): void;
+    updateStreamInfo(newStreamInfo: StreamInfo): Promise<any>;
+}
 
-        reset(): void;
-    }
+export interface XlinkLoader {
+    load(url: string, element: any, resolveObject: object): void;
 
-    export interface CaptionData {
-        cueID?: string;
-        data?: string;
-        embeddedImages?: { [id: string]: string };
-        end: number;
-        images?: string[];
-        isd?: object;
-        start: number;
-        styles?: {
-            align?: string;
-            line?: string;
-            position?: string;
-            size?: string;
-        };
-        type?: string;
-    }
+    reset(): void;
+}
 
-    export type MetricType = 'ManifestUpdate' | 'RequestsQueue';
-    export type TrackSwitchMode = 'alwaysReplace' | 'neverReplace';
-    export type TrackSelectionMode =
-        'highestSelectionPriority'
-        | 'highestBitrate'
-        | 'firstTrack'
-        | 'highestEfficiency'
-        | 'widestRange';
+export interface CaptionData {
+    cueID?: string;
+    data?: string;
+    embeddedImages?: { [id: string]: string };
+    end: number;
+    images?: string[];
+    isd?: object;
+    start: number;
+    styles?: {
+        align?: string;
+        line?: string;
+        position?: string;
+        size?: string;
+    };
+    type?: string;
+}
 
-    export function supportsMediaSource(): boolean;
+export type MetricType = 'ManifestUpdate' | 'RequestsQueue';
+export type TrackSwitchMode = 'alwaysReplace' | 'neverReplace';
+export type TrackSelectionMode =
+    'highestSelectionPriority'
+    | 'highestBitrate'
+    | 'firstTrack'
+    | 'highestEfficiency'
+    | 'widestRange';
 
-    export interface ClassConstructor {
-        __dashjs_factory_name: string
-    }
+export function supportsMediaSource(): boolean;
 
-    export type Factory = (context: object) => {
-        create: () => any
-    }
+export interface ClassConstructor {
+    __dashjs_factory_name: string
+}
 
-    export type SingletonFactory = (context: object) => {
-        getInstance: () => any
-    }
+export type Factory = (context: object) => {
+    create: () => any
+}
 
-    export interface Range {
-        start: number;
-        end: number;
-    }
+export type SingletonFactory = (context: object) => {
+    getInstance: () => any
+}
 
-    export interface KeySystemInfo {
-        cdmData?: ArrayBuffer;
-        initData?: ArrayBuffer;
-        keyId?: string,
-        ks: KeySystem;
-        protData?: ProtectionData
-        sessionId?: string,
-        sessionType?: string,
-    }
+export interface Range {
+    start: number;
+    end: number;
+}
 
-    export type RequestFilter = (request: LicenseRequest) => Promise<any>;
-    export type ResponseFilter = (response: LicenseResponse) => Promise<any>;
+export interface KeySystemInfo {
+    cdmData?: ArrayBuffer;
+    initData?: ArrayBuffer;
+    keyId?: string,
+    ks: KeySystem;
+    protData?: ProtectionData
+    sessionId?: string,
+    sessionType?: string,
 }
 
+export type RequestFilter = (request: LicenseRequest) => Promise<any>;
+export type ResponseFilter = (response: LicenseResponse) => Promise<any>;
+
+