diff --git a/index.d.ts b/index.d.ts
index 41827d0357..52b7d2f9b3 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -10,6 +10,224 @@ export as namespace dashjs;
 
 declare namespace dashjs {
 
+    /**
+     * Core - Errors
+     */
+
+    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';
+    }
+
+    class ErrorsBase {
+        extend(errors: any, config: any): void;
+    }
+
+    /**
+     * Core - Events
+     */
+
+    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';
+    }
+
+    class Events extends CoreEvents {
+
+    }
+
+    class EventsBase {
+        extend(events: any, config: any): void;
+    }
+
     /**
      * Core
      */
@@ -116,39 +334,6 @@ declare namespace dashjs {
         initialize(): void
     }
 
-    export interface ThroughputController {
-
-        initialize(): void;
-
-        setConfig(config: object): void;
-
-        getArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
-
-        getByteSizeWeightedArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
-
-        getDateWeightedArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
-
-        getHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
-
-        getByteSizeWeightedHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
-
-        getDateWeightedHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
-
-        getEwma(dict: ThroughputEwmaDictEntry[], halfLife: object, useMin: boolean): number
-
-        getZlema(dict: ThroughputDictEntry[], sampleSize: number): number
-
-        getAverageThroughput(mediaType: MediaType, calculationMode: string, sampleSize: number): number
-
-        getSafeAverageThroughput(mediaType: MediaType, calculationMode: string, sampleSize: number): number
-
-        getAverageLatency(mediaType: MediaType, calculationMode: string, sampleSize: number): number
-
-        getRawThroughputData(mediaType: MediaType): number
-
-        reset(): void;
-    }
-
     export interface RepresentationController {
         getStreamId(): string;
 
@@ -160,8 +345,6 @@ declare namespace dashjs {
 
         updateData(newRealAdaptation: object, availableRepresentations: object[], type: string, isFragmented: boolean, quality: number): any;
 
-        //Promise.all(iterable) can be solved promise, asynchronous promise, pending promise
-
         getCurrentRepresentation(): object;
 
         getCurrentRepresentation(): Representation;
@@ -202,131 +385,144 @@ declare namespace dashjs {
      **/
 
     export interface DashManifestModel {
-        getIsTypeOf(adaptation: object, type: string): boolean;
+        getAccessibilityForAdaptation(adaptation: object): DescriptorType[];
 
-        getIsFragmented(adaptation: object): boolean;
+        getAdaptationForId(id: string, manifest: object, periodIndex: number): any;
 
-        getIsAudio(adaptation: object): boolean;
+        getAdaptationForIndex(index: number, manifest: object, periodIndex: number): any;
 
-        getIsVideo(adaptation: object): boolean;
+        getAdaptationsForPeriod(voPeriod: Period): AdaptationSet[];
 
-        getIsText(adaptation: object): boolean;
+        getAdaptationsForType(manifest: object, periodIndex: number, type: string): any[];
 
-        getIsMuxed(adaptation: object): boolean;
+        getAudioChannelConfigurationForAdaptation(adaptation: object): DescriptorType[];
 
-        getIsImage(adaptation: object): boolean;
+        getAudioChannelConfigurationForRepresentation(adaptation: object): DescriptorType[];
 
-        getLanguageForAdaptation(adaptation: object): string;
+        getAvailabilityStartTime(mpd: Mpd): any;
 
-        getViewpointForAdaptation(adaptation: object): DescriptorType[];
+        getBandwidth(representation: object): number;
 
-        getRolesForAdaptation(adaptation: object): DescriptorType[];
+        getBaseURLsFromElement(node: object): BaseURL[];
 
-        getAccessibilityForAdaptation(adaptation: object): DescriptorType[];
+        getBitrateListForAdaptation(realAdaptation: object): {
+            bandwidth: number,
+            width: number,
+            height: number,
+            scanType: string | null,
+            id: string | null
+        };
 
-        getAudioChannelConfigurationForAdaptation(adaptation: object): DescriptorType[];
+        getCodec(adaptation: object, representationIndex: number, addResolutionInfo: boolean): string;
 
-        getAudioChannelConfigurationForRepresentation(adaptation: object): DescriptorType[];
+        getContentProtectionByAdaptation(adaptation: object): any;
 
-        getRepresentationSortFunction(): (a: object, b: object) => number;
+        getContentProtectionByManifest(manifest: object): any[];
 
-        processAdaptation(realAdaptation: object): object;
+        getContentProtectionByPeriod(period: Period): any;
 
-        getRealAdaptations(manifest: object, periodIndex: number): any[];
+        getContentSteering(manifest: object): ContentSteering | undefined;
 
-        getRealPeriods(manifest: object): any[];
+        getDuration(manifest: object): number;
 
-        getRealPeriodForIndex(index: number, manifest: object): any;
+        getEndTimeForLastPeriod(voPeriod: Period): number;
 
-        getAdaptationForId(id: string, manifest: object, periodIndex: number): any;
+        getEssentialPropertiesForRepresentation(realRepresentation: object): { schemeIdUri: string, value: string }
 
-        getAdaptationForIndex(index: number, manifest: object, periodIndex: number): any;
+        getEventStreamForAdaptationSet(manifest: object, adaptation: object): EventStream[];
+
+        getEventStreamForRepresentation(manifest: object, representation: Representation): EventStream[];
+
+        getEventStreams(inbandStreams: EventStream[], representation: Representation): EventStream[];
+
+        getEventsForPeriod(period: Period): any[];
+
+        getId(manifest: object): string;
 
         getIndexForAdaptation(realAdaptation: object, manifest: object, periodIndex: number): number;
 
-        getAdaptationsForType(manifest: object, periodIndex: number, type: string): any[];
+        getIsAudio(adaptation: object): boolean;
 
-        getCodec(adaptation: object, representationIndex: number, addResolutionInfo: boolean): string;
+        getIsDynamic(manifest: object): boolean;
 
-        getMimeType(adaptation: object): object;
+        getIsFragmented(adaptation: object): boolean;
+
+        getIsImage(adaptation: object): boolean;
+
+        getIsMuxed(adaptation: object): boolean;
+
+        getIsText(adaptation: object): boolean;
+
+        getIsTypeOf(adaptation: object, type: string): boolean;
+
+        getIsVideo(adaptation: object): boolean;
 
-        // MimeType is deprecated as a type
         getKID(adaptation: object): any;
 
         getLabelsForAdaptation(adaptation: object): any[];
 
-        getContentProtectionData(adaptation: object): any[];
+        getLanguageForAdaptation(adaptation: object): string;
 
-        getIsDynamic(manifest: object): boolean;
+        getLoction(manifest: object): MpdLocation | [];
 
-        getId(manifest: object): string;
+        getManifestUpdatePeriod(manifest: object, latencyOfLastUpdate?: number): number;
 
-        hasProfile(manifest: object, profile: object): boolean;
+        getMimeType(adaptation: object): object;
 
-        getDuration(manifest: object): number;
+        getMpd(manifest: object): Mpd;
 
-        getBandwidth(representation: object): number;
+        getPeriodId(realPeriod: Period, i: number): string;
 
-        getManifestUpdatePeriod(manifest: object, latencyOfLastUpdate?: number): number;
+        getProducerReferenceTimesForAdaptation(adaptation: object): any[];
 
         getPublishTime(manifest: object): Date | null;
 
-        getRepresentationCount(adaptation: object): number;
+        getRealAdaptationFor(voAdaptation: object): object;
 
-        getBitrateListForAdaptation(realAdaptation: object): {
-            bandwidth: number,
-            width: number,
-            height: number,
-            scanType: string | null,
-            id: string | null
-        };
+        getRealAdaptations(manifest: object, periodIndex: number): any[];
 
-        getSelectionPriority(realAdaptation: object): number;
+        getRealPeriodForIndex(index: number, manifest: object): any;
 
-        getEssentialPropertiesForRepresentation(realRepresentation: object): { schemeIdUri: string, value: string }
+        getRealPeriods(manifest: object): any[];
+
+        getRegularPeriods(mpd: Mpd): Period[];
+
+        getRepresentationCount(adaptation: object): number;
 
         getRepresentationFor(index: number, adaptation: object): object;
 
-        getRealAdaptationFor(voAdaptation: object): object;
+        getRepresentationSortFunction(): (a: object, b: object) => number;
 
         getRepresentationsForAdaptation(voAdaptation: object): object[];
 
-        getAdaptationsForPeriod(voPeriod: Period): AdaptationSet[];
-
-        getRegularPeriods(mpd: Mpd): Period[];
+        getRolesForAdaptation(adaptation: object): DescriptorType[];
 
-        getPeriodId(realPeriod: Period, i: number): string;
+        getSegmentAlignment(adaptation: object): boolean;
 
-        getMpd(manifest: object): Mpd;
+        getSelectionPriority(realAdaptation: object): number;
 
-        getEndTimeForLastPeriod(voPeriod: Period): number;
+        getServiceDescriptions(manifest: object): serviceDescriptions;
 
-        getEventsForPeriod(period: Period): any[];
+        getSubSegmentAlignment(adaptation: object): boolean;
 
-        getEventStreams(inbandStreams: EventStream[], representation: Representation): EventStream[];
+        getSuggestedPresentationDelay(mpd: Mpd): any;
 
-        getEventStreamForAdaptationSet(manifest: object, adaptation: object): EventStream[];
+        getSupplementalPropertiesForAdaptation(adaptation: object): DescriptorType | [];
 
-        getEventStreamForRepresentation(manifest: object, representation: Representation): EventStream[];
+        getSupplementalPropertiesForRepresentation(representation: Representation): DescriptorType | [];
 
         getUTCTimingSources(manifest: object): any[];
 
-        getBaseURLsFromElement(node: object): BaseURL[];
+        getViewpointForAdaptation(adaptation: object): DescriptorType[];
 
-        getLoction(manifest: object): string | undefined;
+        hasProfile(manifest: object, profile: object): boolean;
 
-        getSuggestedPresentationDelay(mpd: Mpd): number;
+        isPeriodEncrypted(period: any): boolean;
 
-        getAvailabilityStartTime(mpd: Mpd): number;
+        processAdaptation(realAdaptation: object): object;
 
-        getServiceDescriptions(manifest: object): serviceDescriptions;
-
-        getSupplementalProperties(adaptation: object): object;
-
-        getSegmentAlignment(adaptation: object): boolean;
-
-        getSubSegmentAlignment(adaptation: object): boolean;
-    }
+        setConfig(config: any): void;
+    }
 
     export interface PatchManifestModel {
         getIsPatch(patch: object): boolean;
@@ -372,11 +568,15 @@ declare namespace dashjs {
 
     }
 
-    export class NumericMatcher extends BaseMatcher {
+    export class DurationMatcher extends BaseMatcher {
+
+    }
+
+    export class LangMatcher extends BaseMatcher {
 
     }
 
-    export class StringMatcher extends BaseMatcher {
+    export class NumericMatcher extends BaseMatcher {
 
     }
 
@@ -385,11 +585,11 @@ declare namespace dashjs {
      **/
 
     export interface DashParser {
-        getMatchers(): any;
-
         getIron(): any;
 
         parse(data: any): any;
+
+        parseXml(data: any): any;
     }
 
     export interface objectiron {
@@ -400,6 +600,18 @@ declare namespace dashjs {
      * Dash - Utils
      **/
 
+    export interface ListSegmentsGetter {
+        getMediaFinishedInformation(representation: Representation): MediaFinishedInformation;
+
+        getSegmentByIndex(representation: Representation, index: number): any;
+
+        getSegmentByTime(representation: Representation, requestedTime: number): any;
+    }
+
+    export interface Round10 {
+        round10(value: number, exp: number): number;
+    }
+
     export interface SegmentBaseGetter {
         getMediaFinishedInformation(representation: Representation): MediaFinishedInformation;
 
@@ -423,6 +635,8 @@ declare namespace dashjs {
 
         setClientTimeOffset(): number;
 
+        getClientReferenceTime(): number;
+
         calcAvailabilityStartTimeFromPresentationTime(presentationEndTime: number, representation: Representation, isDynamic: boolean): number;
 
         calcAvailabilityEndTimeFromPresentationTime(presentationEndTime: number, representation: Representation, isDynamic: boolean, trueBool?: boolean): number;
@@ -461,122 +675,255 @@ declare namespace dashjs {
     }
 
     export interface ThroughputDictEntry {
-
         downloadTimeInMs: number;
-
         downloadedBytes: number;
-
         latencyInMs: number;
-
         serviceLocation: string;
-
         value: number;
     }
 
     export interface ThroughputEwmaDictEntry {
-
         fastEstimate: number;
-
         slowEstimate: number;
-
         totalWeight: number;
     }
 
     export interface BaseURL {
-        url: string;
-        serviceLocation: string;
+        availabilityTimeComplete: boolean;
+        availabilityTimeOffset: number;
         dvbPriority: number;
         dvbWeight: number;
-        availabilityTimeOffset: number;
-        availabilityTimeComplete: boolean;
         queryParams: object;
+        serviceLocation: string;
+        url: string;
     }
 
-    export class MpdLocation {
-        url: string;
-        serviceLocation: string;
-        queryParams: object;
+    export interface ClientDataReporting {
+        adaptationSets: AdaptationSet;
+        adaptationSetsArray: Array<AdaptationSet>;
+        cmcdParameters: CMCDParameters;
+        serviceLocations: any;
+        serviceLocationsArray: Array<any>;
     }
 
-    export class PatchLocation {
+    export class CMCDParameters extends DescriptorType {
+        contentID: string;
+        keys: Array<string>;
+        mode: string;
+        schemeIdUri: string;
+        sessionID: string;
+        version: number;
+    }
+
+    export class ContentProtection extends DescriptorType {
+        cencDefaultKid: any;
+        keyId: any;
+        laUrl: string;
+        pro: any;
+        pssh: any;
+        ref: any;
+        refId: any;
+        robustness: any;
+
+        init(data: any): void;
+
+        mergeAttributesFromReference(reference: any): any;
+    }
+
+    export class ContentSteering {
+        clientRequirement: boolean;
+        defaultServiceLocation: string;
+        defaultServiceLocationArray: string[];
+        queryBeforeStart: boolean;
+        serverUrl: string;
+    }
+
+    export class ContentSteeringRequest {
+        constructor(url: any);
+
         url: string;
-        serviceLocation: string;
+    }
+
+    export class ContentSteeringResponse {
+        pathwayClones: object[];
+        pathwayPriority: string[];
+        reloadUri: string;
         ttl: number;
-        queryParams: object;
+        version: number;
+    }
+
+    export class DescriptorType {
+        dvbFontFamily?: string;
+        dvbMimeType?: string;
+        dvbUrl?: string;
+        id: string;
+        schemeIdUri: string;
+        value: string;
     }
 
     export interface Event {
-        type: string;
         duration: number;
-        presentationTime: number;
+        eventStream: EventStream;
         id: number;
         messageData: string;
-        eventStream: EventStream;
+        parsedMessageData: any;
+        presentationTime: number;
         presentationTimeDelta: number;
+        type: string;
     }
 
     export interface EventStream {
         adaptationSet: AdaptationSet | null;
-        representation: Representation | null;
         period: Period | null;
+        presentationTimeOffset: number;
+        representation: Representation | null;
+        schemeIdUri: string;
         timescale: number;
         value: string;
-        schemeIdUri: string;
-        presentationTimeOffset: number;
     }
 
     export interface IManifestInfo {
-        dvrWindowSize: number;
         availableFrom: Date;
         duration: number;
+        dvrWindowSize: number;
         isDynamic: boolean;
         loadedTime: Date;
         maxFragmentDuration: number;
         minBufferTime: number;
-        serviceDescriptions: serviceDescriptions[]
         protocol?: string;
+        serviceDescriptions: serviceDescriptions[]
+    }
+
+    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 interface IRole { // same content as UTCTiming ?
+        schemeIdUri: string;
+        value: string;
+    }
+
+    export interface ISegmentTemplate {
+        SegmentTimeline: ISegmentTimeline | ISegmentTimeline[];
+        timescale: number;
+        initialization: string;
+        media: string;
+    }
+
+    export interface ISegmentTimeline {
+        S: ISegmentTimelineProperty | ISegmentTimelineProperty[];
+    }
+
+    export interface ISegmentTimelineProperty {
+        d?: number;
+        r?: number;
+        t?: number;
+    }
+
+    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[];
+    }
+
+    export interface IContentProtection {
+        keyId: string;
+        schemeIdUri: string;
+        "cenc:default_KID"?: string;
+        value?: string;
+        pssh?: IPssh | IPssh[];
+    }
+
+    export interface IPssh {
+        __prefix: string;
+        __text: string;
     }
 
     export class MediaInfo {
-        id: string | null;
-        index: number | null;
-        type: MediaType | null;
-        streamInfo: StreamInfo | null;
-        representationCount: number;
-        labels: { text: string, lang?: string }[];
-        lang: string | null;
-        viewpoint: DescriptorType[] | null;
+        KID: any | null;
         accessibility: DescriptorType[] | null;
         audioChannelConfiguration: DescriptorType[] | null;
-        roles: DescriptorType[] | null;
+        bitrateList: Bitrate[];
         codec: string | null;
-        mimeType: string | null;
         contentProtection: any | null;
-        isText: boolean;
-        KID: any | null;
-        bitrateList: Bitrate[];
-        isFragmented: any | null;
-        isEmbedded: any | null;
-        selectionPriority: number;
-        supplementalProperties: object;
         essentialProperties: object;
+        id: string | null;
+        index: number | null;
+        isEmbedded: any | null;
+        isFragmented: any | null;
+        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 Mpd {
-        manifest: object;
-        suggestedPresentationDelay: number;
-        availabiliyStartTime: number | null;
         availabilityEndTime: number;
-        timeShiftBufferDepth: number;
+        availabilityStartTime: number | null;
+        manifest: object;
         maxSegmentDuration: number;
-        publishTime: number | null;
-        minimumUpdatePeriod: number;
         mediaPresentationDuration: number;
+        minimumUpdatePeriod: number;
+        publishTime: number | null;
+        suggestedPresentationDelay: number;
+        timeShiftBufferDepth: number;
+    }
+
+    export class MpdLocation {
+        constructor(url: string, serviceLocation: string | null);
+
+        url: string;
+        serviceLocation: string | null;
+        queryParams: object;
+    }
+
+    export class PatchLocation {
+        constructor(url: string, serviceLocation: string, ttl: number);
+
+        url: string;
+        serviceLocation: string;
+        ttl: number;
+        queryParams: object;
     }
 
     export class PatchOperation {
+        constructor(action: any, xpath: any, value: string);
+
         action: any;
         xpath: any;
         value: string;
@@ -586,20 +933,34 @@ declare namespace dashjs {
     }
 
     export interface Period {
+        duration: number;
         id: string | null;
         index: number;
-        duration: number;
-        start: number;
+        isEncrypted: boolean;
         mpd: Mpd;
         nextPeriodId: string | null;
+        start: number;
+    }
+
+    export interface ProducerReferenceTime {
+        UTCTiming: any;
+        applicationSchme: any;
+        id: any;
+        inband: boolean;
+        presentationTime: number;
+        type: 'encoder';
+        wallClockTime: any;
     }
 
     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;
@@ -614,31 +975,34 @@ declare namespace dashjs {
         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;
-        segments: any[];
+        supplementalProperties: Array<any>;
         startNumber: number;
         timescale: number;
         width: number;
     }
 
     export interface Segment {
-        indexRange: any;
+        availabilityEndTime: number;
+        availabilityStartTime: number;
+        duration: number;
         index: number | null;
-        mediaRange: any;
+        indexRange: any;
         media: any;
-        duration: number;
-        replacementTime: number;
-        replacementNumber: number;
+        mediaRange: any;
         mediaStartTime: number;
         presentationStartTime: number;
-        availabilityStartTime: number;
-        availabilityEndTime: number;
-        wallStartTime: number;
+        replacementNumber: number;
+        replacementTime: number;
         representation: Representation | null;
+        wallStartTime: number;
     }
 
     export class SimpleXPath {
@@ -646,12 +1010,13 @@ declare namespace dashjs {
     }
 
     export class StreamInfo {
+        duration: number;
         id: string;
         index: number;
-        start: number;
-        duration: number;
-        manifestInfo: IManifestInfo;
+        isEncrypted: boolean;
         isLast: boolean;
+        manifestInfo: IManifestInfo;
+        start: number;
     }
 
     export class UTCTiming {
@@ -659,124 +1024,90 @@ declare namespace dashjs {
         value: string;
     }
 
-    export class DescriptorType {
-        schemeIdUri: string;
-        value: string;
-        id: string;
-        dvbUrl?: string;
-        dvbMimeType?: string;
-        dvbFontFamily?: string;
-    }
+    /**
+     * Dash
+     **/
 
-    export class ContentSteeringResponse {
-        version: number;
-        ttl: number;
-        reloadUri: string;
-        pathwayPriority: string[];
-        pathwayClones: object[];
-    }
+    export interface DashAdapter {
+        applyPatchToManifest(manifest: object, patch: object): void;
 
-    export class ContentSteering {
-        defaultServiceLocation: string;
-        defaultServiceLocationArray: string[];
-        queryBeforeStart: boolean;
-        serverUrl: string;
-        clientRequirement: boolean;
-    }
+        areMediaInfosEqual(mInfoOne: MediaInfo, mInfoTwo: MediaInfo): boolean;
 
-    export class HttpLoaderRequest {
-        url: string;
-        method: string;
-        withCredentials: boolean;
-        request: FragmentRequest;
-        onload: Function;
-        onloadend: Function;
-        onerror: Function;
-        progress: Function;
-        ontimeout: Function;
-        loader: object;
-        timeout: number;
-        headers: object;
-        response: object;
-        reader: object;
-    }
+        getMainAdaptationForType(periodIndex: number, type: MediaType, streamInfo: object): IAdaptation | null;
 
-    /**
-     * Dash
-     **/
+        getAllMediaInfoForType(streamInfo: object, type: MediaType, externalManifest?: object | null): any[];
 
-    export interface DashAdapter {
-        getMediaInfoForType(streamInfo: object, type: MediaType): MediaInfo | null;
+        getAvailabilityStartTime(externalManifest?: object): number;
 
-        getIsMain(adaptation: object): boolean;
+        getBandwidthForRepresentation(representationId: string, periodIdx: number): number;
 
-        getAdaptationForType(periodIndex: number, type: MediaType, streamInfo: object): object | null;
+        getBaseURLsFromElement(node: object): BaseURL[];
 
-        areMediaInfosEqual(mInfoOne: MediaInfo, mInfoTwo: MediaInfo): boolean;
+        getCodec(adaptation: object, representationIndex: number, addResolutionInfo: boolean): string;
 
-        getAllMediaInfoForType(streamInfo: object, type: MediaType, externalManifest?: object | null): any[];
+        getContentSteering(manifest: object): object;
 
-        getRealAdaptation(streamInfo: StreamInfo, mediaInfo: MediaInfo): object;
+        getDuration(externalManifest?: object): number;
 
-        getEssentialPropertiesForRepresentation(representation: Representation): any[];
+        getEssentialPropertiesAdaptationSet(adaptationSet: AdaptationSet): object | [];
 
-        getRealPeriodByIndex(index: number): object;
+        getEssentialPropertiesForRepresentation(representation: Representation): any[];
 
-        getVoRepresentation(mediaInfo: MediaInfo): Representation[];
+        getEvent(eventBox: object, eventStreams: object, mediaStartTime: number, voRepresentation: object): null | Event;
 
-        getUTCTimingSources(): any[];
+        getEventsFor(info: object, voRepresentation: object): Array<Event>;
 
-        getSuggestedPresentationDelay(): string;
+        getIndexForRepresentation(representationId: string, periodIdx: number): number;
 
-        getAvailabilityStartTime(externalManifest?: object): number;
+        getIsDVB(manifest: object): boolean;
 
         getIsDynamic(externalManifest?: object): boolean;
 
-        getDuration(externalManifest?: object): number;
+        getIsMain(adaptation: object): boolean;
 
-        getRegularPeriods(externalManifest?: object): any[];
+        getIsPatch(manifest: object): boolean;
 
-        getMpd(externalManifest?: object): Mpd;
+        getIsTextTrack(adaptation: object): boolean;
+
+        getIsTypeOf(adaptation: object, type: string): boolean;
 
         getLocation(manifest: object): MpdLocation[];
 
         getManifestUpdatePeriod(manifest: object, latencyOfLastUpdate?: number): number;
 
-        getPublishTime(manifest: object): number | null;
+        getMediaInfoForType(streamInfo: object, type: MediaType): MediaInfo | null;
+
+        getMpd(externalManifest?: object): Mpd;
 
         getPatchLocation(manifest: object): PatchLocation[];
 
-        getIsDVB(manifest: object): boolean;
+        getPeriodById(id: string): Period | null;
 
-        getIsPatch(manifest: object): boolean;
+        getProducerReferenceTime(streamInfo: StreamInfo, mediaInfo: MediaInfo): object | [];
 
-        getBaseURLsFromElement(node: object): BaseURL[];
+        getPublishTime(manifest: object): number | null;
 
-        getRepresentationSortFunction(): (a: object, b: object) => number;
+        getRealAdaptation(streamInfo: StreamInfo, mediaInfo: MediaInfo): object;
 
-        getCodec(adaptation: object, representationIndex: number, addResolutionInfo: boolean): string;
+        getRealPeriodByIndex(index: number): object;
 
-        getBandwidthForRepresentation(representationId: string, periodIdx: number): number;
+        getRegularPeriods(externalManifest?: object): any[];
 
-        getIndexForRepresentation(representationId: string, periodIdx: number): number;
+        getRepresentationSortFunction(): (a: object, b: object) => number;
 
-        /**
-         * This method returns the current max index based on what is defined in the MPD.
-         *
-         * @param bufferType String 'audio' or 'video',
-         * @param periodIdx Make sure this is the period index not id
-         */
-        getMaxIndexForBufferType(bufferType: MediaType, periodIdx: number): number;
+        getStreamsInfo(externalManifest: object, maxStreamsInfo: number): Array<any>;
 
-        getPeriodbyId(id: string): object | null;
+        getSuggestedPresentationDelay(): string;
 
-        getIsTypeOf(adaptation: object, type: string): boolean;
+        getSupplementalCodex(representation: Representation): Array<any>;
 
-        reset(): void;
+        getUTCTimingSources(): any[];
+
+        getVoRepresentation(mediaInfo: MediaInfo): Representation[];
 
         isPatchValid(manifest: object, patch: object): boolean;
 
-        applyPatchToManifest(manifest: object, patch: object): void;
+        reset(): void;
     }
 
     export interface DashHandler {
@@ -808,119 +1139,118 @@ declare namespace dashjs {
     }
 
     export interface DashMetrics {
-        getCurrentRepresentationSwitch(type: MediaType): ICurrentRepresentationSwitch;
-
-        addRepresentationSwitch(mediaType: MediaType, t: Date, mt: Date, to: string, lto: string): void;
-
-        getCurrentBufferState(type: MediaType): IBufferState;
 
-        getCurrentBufferLevel(type: MediaType): number;
 
         addBufferLevel(mediaType: MediaType, t: number, level: number): void;
 
         addBufferState(mediaType: MediaType, state: string, target: number): void;
 
-        clearAllCurrentMetrics(): void;
+        addDVBErrors(errors: object): void;
 
-        getCurrentHttpRequest(type: MediaType): object;
+        addDVRInfo(mediaType: MediaType, currentTime: Date, mpd: Mpd, range: Range): void;
 
-        getHttpRequests(type: MediaType): object[];
+        addDroppedFrames(quality: number): void;
 
-        addRequestsQueue(mediaType: MediaType, loadingRequests: any[], executedRequests: any[]): void;
+        addHttpRequest(request: HTTPRequest, responseURL: string, responseStatus: number, responseHeaders: object, traces: object): void;
 
-        getCurrent(metrics: MetricsList, metricName: string): IDroppedFrames;
+        addManifestUpdate(request: ManifestUpdate): void;
 
-        getCurrentDroppedFrames(): IDroppedFrames;
+        addManifestUpdateRepresentationInfo(representation: Representation, mediaType: MediaType): void;
 
-        addDroppedFrames(quality: number): void;
+        addManifestUpdateStreamInfo(streamInfo: StreamInfo): void;
 
-        getCurrentSchedulingInfo(type: MediaType): object;
+        addPlayList(): void;
 
-        addSchedulingInfo(request: SchedulingInfo, state: string): void;
+        addRepresentationSwitch(mediaType: MediaType, t: Date, mt: Date, to: string, lto: string): void;
 
-        getCurrentDVRInfo(type?: MediaType): IDVRInfo;
+        addRequestsQueue(mediaType: MediaType, loadingRequests: any[], executedRequests: any[]): void;
 
-        addDVRInfo(mediaType: MediaType, currentTime: Date, mpd: Mpd, range: Range): void;
+        addSchedulingInfo(request: SchedulingInfo, state: string): void;
 
-        getCurrentManifestUpdate(): any;
+        clearAllCurrentMetrics(): void;
 
-        updateManifestUpdateInfo(updateFields: any[]): void;
+        createPlaylistMetrics(mediaStartTime: number, startReason: string): void;
 
-        addManifestUpdateStreamInfo(streamInfo: StreamInfo): void;
+        createPlaylistTraceMetrics(representationId: number, mediaStartTime: number, speed: number): void;
 
-        addManifestUpdate(request: ManifestUpdate): void;
+        getCurrent(metrics: MetricsList, metricName: string): DroppedFrames;
 
-        addHttpRequest(request: HTTPRequest, responseURL: string, responseStatus: number, responseHeaders: object, traces: object): void;
+        getCurrentBufferLevel(type: MediaType): number;
 
-        addManifestUpdateRepresentationInfo(representation: Representation, mediaType: MediaType): void;
+        getCurrentBufferState(type: MediaType): IBufferState;
 
-        getCurrentLiveLatency(): number;
+        getCurrentDVRInfo(type?: MediaType): DVRInfo;
 
-        getLatestFragmentRequestHeaderValueByID(id: string): string;
+        getCurrentDroppedFrames(): DroppedFrames;
 
-        addPlayList(): void;
+        getCurrentHttpRequest(type: MediaType): object;
 
-        createPlaylistMetrics(mediaStartTime: number, startReason: string): void;
+        getCurrentManifestUpdate(): any;
 
-        createPlaylistTraceMetrics(representationId: number, mediaStartTime: number, speed: number): void;
+        getCurrentRepresentationSwitch(type: MediaType): ICurrentRepresentationSwitch;
 
-        updatePlayListTraceMetrics(traceToUpdate: object): void;
+        getCurrentSchedulingInfo(type: MediaType): object;
 
-        pushPlaylistTraceMetrics(endTime: number, reason: string): void;
+        getHttpRequests(type: MediaType): object[];
 
-        addDVBErrors(errors: object): void;
+        getLatestFragmentRequestHeaderValueByID(id: string): string;
 
         getLatestMPDRequestHeaderValueByID(type: MediaType, id: string): string;
 
-        resetInitialSettings(): void;
+        pushPlaylistTraceMetrics(endTime: number, reason: string): void;
+
+        updateManifestUpdateInfo(updateFields: any[]): void;
+
+        updatePlayListTraceMetrics(traceToUpdate: object): void;
     }
 
     export interface SegmentBaseLoader {
         initialize(): void;
 
-        setConfig(config: object): void;
-
         loadInitialization(representation: Representation, mediaType: MediaType): Promise<any>;
 
         loadSegments(representation: Representation, mediaType: MediaType, range: Range): Promise<any>;
 
         reset(): any;
+
+        setConfig(config: object): void;
     }
 
     export interface WebSegmentBaseLoader {
         initialize(): void;
 
-        setConfig(config: object): void;
-
         loadInitialization(representation: Representation, mediaType: MediaType): Promise<any>;
 
         loadSegments(representation: Representation, mediaType: MediaType, range: Range): Promise<any>;
 
         reset(): any;
+
+        setConfig(config: object): void;
     }
 
     /**
-     * MSS - Parser
+     * MSS - Errors
      **/
 
-    export interface MssParser {
-        setup(): void;
-
-        getAttributeAsBoolean(node: object, attrName: string): boolean;
-
-        // mapPeriod(smoothStreamingMedia: HTMLElement, timescale: number): Period;
+    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';
+    }
 
-        // mapAdaptationSet(streamIndex: HTMLElement, timescale: number): AdaptationSet;
+    /**
+     * MSS - Parser
+     **/
 
-        // mapRepresentation(qualityLevel: HTMLElement, streamIndex: HTMLElement): Representation;
+    export interface MssParser {
+        getIron(): null;
 
         parse(data: any): object;
 
-        getMatchers(): null; //Entire function consists of "return null"
-
-        getIron(): null;
-
         reset(): void;
+
+        setup(): void;
     }
 
     /**
@@ -928,23 +1258,25 @@ declare namespace dashjs {
      **/
 
     export interface MssFragmentInfoController {
-        initialize(): void;
-
-        start(): void;
-
-        reset(): void; //Calls stop()
+        controllerType: 'MssFragmentInfoController';
 
         fragmentInfoLoaded(e: object): void;
 
         getType(): string;
+
+        initialize(): void;
+
+        reset(): void;
+
+        start(): void;
     }
 
     export interface MssFragmentMoofProcessor {
         convertFragment(e: object, streamProcessor: any): void;
 
-        updateSegmentList(e: object, streamProcessor: any): void;
-
         getType(): string;
+
+        updateSegmentList(e: object, streamProcessor: any): void;
     }
 
     export interface MssFragmentMoovProcessor {
@@ -958,91 +1290,334 @@ declare namespace dashjs {
     }
 
     export interface MssHandler {
-        reset(): void;
+        createMssFragmentProcessor(): void;
 
         createMssParser(): void;
 
         registerEvents(): void;
+
+        reset(): void;
     }
 
     /**
-     * Offline
+     * 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;
+    }
+
+    /**
+     * Offline - Controllers
+     */
+
     export interface OfflineRecord {
         id: string;
-        progress: number;
-        url: string;
         originalUrl: string;
+        progress: number;
         status: string;
+        url: string;
     }
 
     interface OfflineController {
-        // // Download List Functions
-        // getDownloadFromId(id: string): object;
-
-        // createDownloadFromId(id: string): object;
-
-        // createDownloadFromStorage(offline: any): object;
+        createRecord(manifestURL: string): Promise<string>;
 
-        // removeDownloadFromId(id: string): void;
+        deleteRecord(id: string): void;
 
-        // generateManifestId(): number;
+        getAllRecords(): OfflineRecord[];
 
-        // OfflineControllerAPI
+        getRecordProgression(id: string): number;
 
         loadRecordsFromStorage(): Promise<void>;
 
-        getAllRecords(): OfflineRecord[];
+        reset(): void;
 
-        createRecord(manifestURL: string): Promise<string>;
+        resetRecords(): void;
+
+        resumeRecord(id: string): void;
 
         startRecord(id: string, mediaInfos: MediaInfo[]): void;
 
         stopRecord(id: string): void;
+    }
 
-        resumeRecord(id: string): void;
+    interface OfflineStoreController {
+        createFragmentStore(manifestId: number | string, storeName: string): void;
 
-        deleteRecord(id: string): void;
+        createOfflineManifest(manifest: object): object;
 
-        getRecordProgression(id: string): number;
+        deleteDownloadById(manifestId: number | string): object;
 
-        resetRecords(): void;
+        getAllManifests(): object;
 
-        reset(): void;
+        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;
     }
 
-    export interface Bitrate {
-        id?: string;
-        width?: number;
-        height?: number;
-        bandwidth?: number;
-        scanType?: string;
+    /**
+     * Offline - Errors
+     */
+
+    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;
     }
 
-    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 OfflineEvents extends EventsBase {
+        /**
+         * Triggered when all mediaInfo has been loaded
+         * @event OfflineEvents#OFFLINE_RECORD_LOADEDMETADATA
+         */
+        OFFLINE_RECORD_LOADEDMETADATA: 'public_offlineRecordLoadedmetadata';
 
-    export class ProtectionMediaInfo {
-        codec: string | null;
-        contentProtection: any | null;
+        /**
+         * 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';
     }
 
-    export class MediaPlayerSettingClass {
-        debug?: {
+    /**
+     * Offline - Net
+     */
+
+    export class IndexDBOfflineLoader {
+        abort(): void;
+
+        config: object | {};
+
+        load(config: object | {}): void;
+    }
+
+    /**
+     * Offline - Storage
+     */
+
+    export class IndexDBStore {
+        createFragmentStore(storeName: string): void;
+
+        deleteDownloadById(manifestId: number): Promise<string | any>;
+
+        dropAll(): Promise<any>;
+
+        dropFragmentStore(storeName: string): void;
+
+        getAllManifests(): Promise<Object[] | String | Error>;
+
+        getCurrentHigherManifestId(): Promise<number>;
+
+        getFragmentByKey(manifestId: number, key: number): Promise<any>;
+
+        getManifestById(id: number): Promise<Object[] | String | Error>;
+
+        getRepresentationCurrentState(manifestId: number, state: number): Promise<number | Error>;
+
+        saveSelectedRepresentation(manifest: object, selected: object): Promise<string | Error>;
+
+        setDownloadingStatus(manifestId: number, newStatus: number): Promise<string | Error>;
+
+        setRepresentationCurrentState(manifestId: number, representationId: string, state: number): Promise<string | Error>;
+
+        storeFragment(manifestI: number, fragmentId: string, fragmentData: object): Promise<string | Error>;
+
+        storeManifest(manifest: object): Object[];
+
+        updateManifest(manifest: object): Promise<Object[] | Error>;
+    }
+
+    /**
+     * Offline - Parser
+     */
+
+    export class OfflineIndexDBManifestParser {
+        config: object;
+
+        parse(XMLDoc: string, representation: object): Promise<any>;
+    }
+
+    export class OfflineUrlUtils {
+        getRegex(): RegExp | undefined;
+
+        isRelative(): boolean;
+
+        removeHostName(url: string): string;
+
+        resolve(url: string, baseUrl: string): string;
+    }
+
+    /**
+     * Offline - Vo
+     */
+
+    export class OfflineDownload {
+        id: object;
+        originalUrl: object;
+        progress: object;
+        status: object;
+        url: object;
+    }
+
+    /**
+     * Offline
+     */
+
+    export interface OfflineDownload {
+        config: object | {};
+
+        deleteDownload(): void;
+
+        downloadFromUrl(url: string): object;
+
+        getDownloadProgression(): number;
+
+        getId(): number;
+
+        getManifestUrl(): string;
+
+        getMediaInfos(): void;
+
+        getStatus(): number;
+
+        initDownload(): void;
+
+        isDownloading(): boolean;
+
+        reset(): void;
+
+        resetDownload(): void;
+
+        resumeDownload(): void;
+
+        setInitialState(state: object): void;
+
+        startDownload(mediaInfos: MediaInfo[]): any;
+
+        stopDownload(): void;
+    }
+
+    export class OfflineStream {
+        getMediaInfos(): MediaInfo[];
+
+        getStreamId(): string;
+
+        getStreamInfo(): StreamInfo;
+
+        initialize(initStreamInfo: StreamInfo): void;
+
+        initializeAllMediaInfoList(mediaInfoList: object): void;
+
+        reset(): void;
+
+        startOfflineStreamProcessors(): void;
+
+        stopOfflineStreamProcessors(): void;
+    }
+
+    export class OfflineStreamProcessor {
+        config: object | void;
+
+        getAvailableSegmentsNumber(): number;
+
+        getMediaInfo(): MediaInfo;
+
+        getRepresentationController(): RepresentationController;
+
+        getRepresentationId(): number | string;
+
+        getType(): any;
+
+        initialize(_mediaInfo: MediaInfo): void;
+
+        isUpdating(): boolean;
+
+        removeExecutedRequestsBeforeTime(time: any): void;
+
+        reset(): void;
+
+        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;
         };
@@ -1061,7 +1636,12 @@ declare namespace dashjs {
             enableManifestTimescaleMismatchFix?: boolean,
             capabilities?: {
                 filterUnsupportedEssentialProperties?: boolean,
-                useMediaCapabilitiesApi?: boolean
+                supportedEssentialProperties?: [
+                    { schemeIdUri?: string, value?: RegExp }
+                ],
+                useMediaCapabilitiesApi?: boolean,
+                filterHDRMetadataFormatEssentialProperties?: boolean,
+                filterVideoColometryEssentialProperties?: boolean
             },
             timeShiftBuffer?: {
                 calcFromSegmentTimeline?: boolean
@@ -1204,6 +1784,7 @@ declare namespace dashjs {
             abr?: {
                 limitBitrateByPortal?: boolean;
                 usePixelRatioInLimitBitrateByPortal?: boolean;
+                enableSupplementalPropertyAdaptationSetSwitching?: boolean,
                 rules?: {
                     throughputRule?: {
                         active?: boolean
@@ -1212,16 +1793,33 @@ declare namespace dashjs {
                         active?: boolean
                     },
                     insufficientBufferRule?: {
-                        active?: boolean
+                        active?: boolean,
+                        parameters?: {
+                            throughputSafetyFactor?: number,
+                            segmentIgnoreCount?: number
+                        }
                     },
                     switchHistoryRule?: {
-                        active?: boolean
+                        active?: boolean,
+                        parameters?: {
+                            sampleSize?: number,
+                            switchPercentageThreshold?: number
+                        }
                     },
                     droppedFramesRule?: {
-                        active?: boolean
+                        active?: boolean,
+                        parameters?: {
+                            minimumSampleSize?: number,
+                            droppedFramesPercentageThreshold?: number
+                        }
                     },
                     abandonRequestsRule?: {
-                        active?: boolean
+                        active?: boolean,
+                        parameters?: {
+                            abandonDurationMultiplier?: number,
+                            minSegmentDownloadTimeThresholdInMs?: number,
+                            minThroughputSamplesThreshold?: number
+                        }
                     }
                     l2ARule?: {
                         active?: boolean
@@ -1253,7 +1851,8 @@ declare namespace dashjs {
                         throughputSlowHalfLifeSeconds?: number,
                         throughputFastHalfLifeSeconds?: number,
                         latencySlowHalfLifeCount?: number,
-                        latencyFastHalfLifeCount?: number
+                        latencyFastHalfLifeCount?: number,
+                        weightDownloadTmeMultiplicationFactor?: number
                     }
                 }
                 maxBitrate?: {
@@ -1291,6 +1890,12 @@ declare namespace dashjs {
                     applyMb: boolean,
                     etpWeightRatio?: number
                 }
+            },
+            defaultSchemeIdUri?: {
+                viewpoint?: string,
+                audioChannelConfiguration?: string,
+                role?: string,
+                accessibility?: string
             }
         };
         errors?: {
@@ -1301,18 +1906,18 @@ declare namespace dashjs {
     }
 
     export interface MediaFinishedInformation {
-        numberOfSegments: number,
         mediaTimeOfLastSignaledSegment: number
+        numberOfSegments: number,
     }
 
     export type TrackSelectionFunction = (tracks: MediaInfo[]) => MediaInfo[];
 
     export interface DvrWindow {
-        start: number;
         end: number;
-        startAsUtc: number;
         endAsUtc: number;
         size: number;
+        start: number;
+        startAsUtc: number;
     }
 
     export interface MediaPlayerClass {
@@ -1362,7 +1967,7 @@ declare namespace dashjs {
 
         on(type: OfflineRecordEvent['type'], listener: (e: OfflineRecordEvent) => void, scope?: object): void;
 
-        on(type: OfflineRecordLoademetadataEvent['type'], listener: (e: OfflineRecordLoademetadataEvent) => 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;
 
@@ -1402,265 +2007,271 @@ declare namespace dashjs {
 
         off(type: string, listener: (e: any) => void, scope?: object): void;
 
-        extend(parentNameString: string, childInstance: object, override: boolean): void;
+        addABRCustomRule(type: string, rulename: string, rule: object): void;
+
+        addRequestInterceptor(interceptor: RequestInterceptor): void;
+
+        addResponseInterceptor(interceptor: ResponseInterceptor): void;
 
-        attachView(element: HTMLElement): void;
+        addUTCTimingSource(schemeIdUri: string, value: string): void;
+
+        attachProtectionController(value: ProtectionController): void;
 
         attachSource(urlOrManifest: string | object, startTime?: number | string): void;
 
-        refreshManifest(callback: (manifest: object | null, error: unknown) => void): void;
+        attachTTMLRenderingDiv(div: HTMLDivElement): void;
 
-        isReady(): boolean;
+        attachView(element: HTMLMediaElement): void;
 
-        preload(): void;
+        clearDefaultUTCTimingSources(): void;
 
-        play(): void;
+        convertToTimeCode(value: number): string;
 
-        isPaused(): boolean;
+        destroy(): void;
 
-        pause(): void;
+        duration(): number;
 
-        isSeeking(): boolean;
+        enableForcedTextStreaming(enable: boolean): boolean;
 
-        isDynamic(): boolean;
+        enableText(enable: boolean): boolean;
 
-        seek(value: number): void;
+        extend(parentNameString: string, childInstance: object, override: boolean): void;
 
-        seekToPresentationTime(value: number): void;
+        formatUTC(time: number, locales: string, hour12: boolean, withDate?: boolean): string;
 
-        seekToOriginalLive(): void;
+        getABRCustomRules(): any[];
 
-        setPlaybackRate(value: number): void;
+        getActiveStream(): Stream | null;
 
-        getPlaybackRate(): number;
+        getAutoPlay(): boolean;
 
-        setMute(value: boolean): void;
+        getAvailableBaseUrls(): BaseURL[];
 
-        isMuted(): boolean;
+        getAvailableLocations(): MpdLocation[];
 
-        setVolume(value: number): void;
+        getAverageThroughput(type: MediaType, calculationMode?: string | null, sampleSize?: number): number;
 
-        getVolume(): number;
+        getBufferLength(type: MediaType): number;
 
-        time(streamId?: string): number;
+        getCurrentLiveLatency(): number;
 
-        timeInDvrWindow(): number;
+        getCurrentRepresentationForType(type: MediaType): Representation | null;
 
-        getDvrWindow(): DvrWindow;
+        getCurrentSteeringResponseData(): object;
 
-        duration(): number;
+        getCurrentTextTrackIndex(): number;
 
-        timeAsUTC(): number;
+        getCurrentTrackFor(type: MediaType): MediaInfo | null;
 
-        getActiveStream(): Stream | null;
+        getDashAdapter(): DashAdapter;
+
+        getDashMetrics(): DashMetrics;
+
+        getDebug(): Debug;
 
         getDvrSeekOffset(value: number): number;
 
-        getTargetLiveDelay(): number;
+        getDvrWindow(): DvrWindow;
 
-        convertToTimeCode(value: number): string;
+        getInitialMediaSettingsFor(type: MediaType): MediaSettings;
 
-        formatUTC(time: number, locales: string, hour12: boolean, withDate?: boolean): string;
+        getLowLatencyModeEnabled(): boolean;
 
-        getVersion(): string;
+        getManifest(): object;
 
-        getDebug(): Debug;
+        getOfflineController(): OfflineController;
 
-        getBufferLength(type: MediaType): number;
+        getPlaybackRate(): number;
 
-        getVideoModel(): VideoModel;
+        getProtectionController(): ProtectionController;
 
-        getTTMLRenderingDiv(): HTMLDivElement | null;
+        getRepresentationsByType(type: MediaType, streamId?: string | null): Representation[];
 
-        getVideoElement(): HTMLVideoElement;
+        getSettings(): MediaPlayerSettingClass;
 
         getSource(): string | object;
 
-        updateSource(urlOrManifest: string | object): void;
+        getStreamsFromManifest(manifest: object): StreamInfo[];
 
-        getCurrentLiveLatency(): number;
+        getTTMLRenderingDiv(): HTMLDivElement | null;
 
-        getTopBitrateInfoFor(type: MediaType): BitrateInfo;
+        getTargetLiveDelay(): number;
 
-        setAutoPlay(value: boolean): void;
+        getTracksFor(type: MediaType): MediaInfo[];
 
-        getAutoPlay(): boolean;
+        getTracksForTypeFromManifest(type: MediaType, manifest: object, streamInfo: StreamInfo): MediaInfo[];
 
-        getDashMetrics(): DashMetrics;
+        getVersion(): string;
+
+        getVideoElement(): HTMLVideoElement;
 
-        getQualityFor(type: MediaType): number;
+        getVolume(): number;
 
-        setQualityFor(type: MediaType, value: number, replace?: boolean): void;
+        getXHRWithCredentialsForType(type: string): boolean;
 
-        updatePortalSize(): void;
+        initialize(view: HTMLVideoElement, source: string, autoPlay: boolean, startTime: number | string): void;
 
-        enableText(enable: boolean): boolean;
+        isDynamic(): boolean;
 
-        enableForcedTextStreaming(value: boolean): boolean;
+        isMuted(): boolean;
+
+        isPaused(): boolean;
+
+        isReady(): boolean;
+
+        isSeeking(): boolean;
 
         isTextEnabled(): boolean;
 
-        setTextTrack(idx: number): void;
+        off(type: string, listener: (e: any) => void, scope?: object): void;
 
-        getRepresentationsByType(type: MediaType): Representation[];
+        on(type: string, listener: (e: any) => void, scope?: object, options?: object): void;
 
-        getStreamsFromManifest(manifest: object): StreamInfo[];
+        pause(): void;
 
-        getTracksFor(type: MediaType): MediaInfo[];
+        play(): void;
 
-        getTracksForTypeFromManifest(type: MediaType, manifest: object, streamInfo: StreamInfo): MediaInfo[];
+        preload(): void;
 
-        getCurrentTrackFor(type: MediaType): MediaInfo | null;
+        provideThumbnail(time: number, callback: (thumbnail: Thumbnail | null) => void): void;
 
-        setInitialMediaSettingsFor(type: MediaType, value: MediaSettings): void;
+        refreshManifest(callback: (manifest: object | null, error: unknown) => void): void;
 
-        getInitialMediaSettingsFor(type: MediaType): MediaSettings;
+        registerCustomCapabilitiesFilter(filter: CapabilitiesFilter): void;
 
-        setCurrentTrack(track: MediaInfo, noSettingsSave?: boolean): void;
+        registerLicenseRequestFilter(filter: RequestFilter): void;
 
-        addABRCustomRule(type: string, rulename: string, rule: object): void;
+        registerLicenseResponseFilter(filter: ResponseFilter): void;
 
         removeABRCustomRule(rulename: string): void;
 
         removeAllABRCustomRule(): void;
 
-        getAverageThroughput(type: MediaType): number;
-
-        retrieveManifest(url: string, callback: (manifest: object | null, error: any) => void): void;
+        removeRequestInterceptor(interceptor: RequestInterceptor): void;
 
-        addUTCTimingSource(schemeIdUri: string, value: string): void;
+        removeResponseInterceptor(interceptor: ResponseInterceptor): void;
 
         removeUTCTimingSource(schemeIdUri: string, value: string): void;
 
-        clearDefaultUTCTimingSources(): void;
+        reset(): void;
 
-        restoreDefaultUTCTimingSources(): void;
+        resetCustomInitialTrackSelectionFunction(fn: TrackSelectionFunction): void;
 
-        setXHRWithCredentialsForType(type: string, value: boolean): void;
+        resetSettings(): void;
 
-        getXHRWithCredentialsForType(type: string): boolean;
+        restoreDefaultUTCTimingSources(): void;
 
-        getProtectionController(): ProtectionController;
+        retrieveManifest(url: string, callback: (manifest: object | null, error: any) => void): void;
 
-        attachProtectionController(value: ProtectionController): void;
+        seek(value: number): void;
 
-        setProtectionData(value: ProtectionDataSet): void;
+        seekToOriginalLive(): void;
 
-        addRequestInterceptor(interceptor: RequestInterceptor): void;
+        seekToPresentationTime(value: number): void;
 
-        removeRequestInterceptor(interceptor: RequestInterceptor): void;
+        setAutoPlay(value: boolean): void;
 
-        addResponseInterceptor(interceptor: ResponseInterceptor): void;
+        setConfig(config: object): void;
 
-        removeResponseInterceptor(interceptor: ResponseInterceptor): void;
+        setCurrentTrack(track: MediaInfo, noSettingsSave?: boolean): void;
 
-        registerLicenseRequestFilter(filter: RequestFilter): void;
+        setCustomInitialTrackSelectionFunction(fn: TrackSelectionFunction): void;
 
-        registerLicenseResponseFilter(filter: ResponseFilter): void;
+        setInitialMediaSettingsFor(type: MediaType, value: MediaSettings): void;
 
-        unregisterLicenseRequestFilter(filter: RequestFilter): void;
+        setMute(value: boolean): void;
 
-        unregisterLicenseResponseFilter(filter: ResponseFilter): void;
+        setPlaybackRate(value: number): void;
 
-        registerCustomCapabilitiesFilter(filter: CapabilitiesFilter): void;
+        setProtectionData(value: ProtectionDataSet): void;
 
-        unregisterCustomCapabilitiesFilter(filter: CapabilitiesFilter): void;
+        setRepresentationForTypeById(type: MediaType, id: number, forceReplace?: boolean): void;
 
-        unregisterFilter(filters: any[], filter: any): void;
+        setRepresentationForTypeByIndex(type: MediaType, index: number, forceReplace?: boolean): void;
 
-        setCustomInitialTrackSelectionFunction(fn: TrackSelectionFunction): void;
+        setTextTrack(idx: number): void;
 
-        resetCustomInitialTrackSelectionFunction(fn: TrackSelectionFunction): void;
+        setVolume(value: number): void;
 
-        attachTTMLRenderingDiv(div: HTMLDivElement): void;
+        setXHRWithCredentialsForType(type: string, value: boolean): void;
 
-        getCurrentTextTrackIndex(): number;
+        time(periodId?: string): number;
 
-        provideThumbnail(time: number, callback: (thumbnail: Thumbnail | null) => void): void;
+        timeAsUTC(): number;
 
-        getDashAdapter(): DashAdapter;
+        timeInDvrWindow(): number;
 
-        getOfflineController(): OfflineController;
+        trigger(type: MediaPlayerEvent, payload: object, filters: object): void;
 
         triggerSteeringRequest(): Promise<any>;
 
-        getCurrentSteeringResponseData(): object;
-
-        getAvailableBaseUrls(): BaseURL[];
+        unregisterCustomCapabilitiesFilter(filter: CapabilitiesFilter): void;
 
-        getAvailableLocations(): MpdLocation[];
+        unregisterLicenseRequestFilter(filter: RequestFilter): void;
 
-        getSettings(): MediaPlayerSettingClass;
+        unregisterLicenseResponseFilter(filter: ResponseFilter): void;
 
         updateSettings(settings: MediaPlayerSettingClass): void;
 
-        resetSettings(): void;
-
-        reset(): void;
-
-        destroy(): void;
-
-        getManifest(): object;
+        updateSource(urlOrManifest: string | object): void;
 
     }
 
     interface MediaPlayerErrors {
-        MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE: 10;
-        MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE: 11;
-        XLINK_LOADER_LOADING_FAILURE_ERROR_CODE: 12;
-        SEGMENT_BASE_LOADER_ERROR_CODE: 15;
-        TIME_SYNC_FAILED_ERROR_CODE: 16;
-        FRAGMENT_LOADER_LOADING_FAILURE_ERROR_CODE: 17;
-        FRAGMENT_LOADER_NULL_REQUEST_ERROR_CODE: 18;
-        URL_RESOLUTION_FAILED_GENERIC_ERROR_CODE: 19;
         APPEND_ERROR_CODE: 20;
-        REMOVE_ERROR_CODE: 21;
-        DATA_UPDATE_FAILED_ERROR_CODE: 22;
-        CAPABILITY_MEDIASOURCE_ERROR_CODE: 23;
         CAPABILITY_MEDIAKEYS_ERROR_CODE: 24;
-        DOWNLOAD_ERROR_ID_MANIFEST_CODE: 25;
-        DOWNLOAD_ERROR_ID_SIDX_CODE: 26;
+        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;
-        MANIFEST_ERROR_ID_PARSE_CODE: 31;
-        MANIFEST_ERROR_ID_NOSTREAMS_CODE: 32;
-        TIMED_TEXT_ERROR_ID_PARSE_CODE: 33;
+        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_CODE: 100;
-        MEDIA_KEYERR_UNKNOWN_CODE: 101;
         MEDIA_KEYERR_CLIENT_CODE: 102;
-        MEDIA_KEYERR_SERVICE_CODE: 103;
-        MEDIA_KEYERR_OUTPUT_CODE: 104;
-        MEDIA_KEYERR_HARDWARECHANGE_CODE: 105;
+        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;
-        SERVER_CERTIFICATE_UPDATED_ERROR_CODE: 109;
-        KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE: 110;
         MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE: 111;
-        KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE: 112;
-        KEY_SESSION_CREATED_ERROR_CODE: 113;
-        MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE: 114;
-        // MSS errors
         MSS_NO_TFRF_CODE: 200;
         MSS_UNSUPPORTED_CODEC_CODE: 201;
-        // Offline errors
         OFFLINE_ERROR: 11000;
-        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;
+        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 {
@@ -1754,45 +2365,43 @@ declare namespace dashjs {
 
     export interface MediaPlayerEvent {
         type: string
-
     }
 
     export interface AstInFutureEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['AST_IN_FUTURE'];
         delay: number;
+        type: MediaPlayerEvents['AST_IN_FUTURE'];
     }
 
     export interface BufferEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['BUFFER_EMPTY' | 'BUFFER_LOADED'];
         mediaType: MediaType;
+        type: MediaPlayerEvents['BUFFER_EMPTY' | 'BUFFER_LOADED'];
     }
 
     export interface BufferStateChangedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['BUFFER_LEVEL_STATE_CHANGED'];
         mediaType: MediaType;
         sender: object;
         state: 'bufferStalled' | 'bufferLoaded';
         streamInfo: StreamInfo;
+        type: MediaPlayerEvents['BUFFER_LEVEL_STATE_CHANGED'];
     }
 
     export interface GenericErrorEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['ERROR'];
         error: 'capability' | 'mediasource' | 'key_session' | 'key_message';
         event: string;
+        type: MediaPlayerEvents['ERROR'];
     }
 
     export interface DownloadErrorEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['ERROR'];
         error: 'download';
         event: {
             id: string;
             url: string;
             request: XMLHttpRequest;
         };
+        type: MediaPlayerEvents['ERROR'];
     }
 
     export interface ManifestErrorEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['ERROR'];
         error: 'manifestError';
         event: {
             id: string;
@@ -1800,20 +2409,20 @@ declare namespace dashjs {
             manifest?: object;
             event?: string;
         };
+        type: MediaPlayerEvents['ERROR'];
     }
 
     export interface TimedTextErrorEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['ERROR'];
         error: 'cc';
         event: {
             id: string;
             message: string;
             cc: string;
         };
+        type: MediaPlayerEvents['ERROR'];
     }
 
     export interface MediaPlayerErrorEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['ERROR'];
         error: {
             code: MediaPlayerErrors['MANIFEST_LOADER_PARSING_FAILURE_ERROR_CODE'] |
                 MediaPlayerErrors['MANIFEST_LOADER_LOADING_FAILURE_ERROR_CODE'] |
@@ -1874,6 +2483,7 @@ declare namespace dashjs {
             message: string,
             data: object,
         }
+        type: MediaPlayerEvents['ERROR'];
     }
 
     export type ErrorEvent =
@@ -1884,9 +2494,9 @@ declare namespace dashjs {
         | MediaPlayerErrorEvent;
 
     export interface CaptionRenderedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['CAPTION_RENDERED'];
         captionDiv: HTMLDivElement;
         currentTrackIdx: number;
+        type: MediaPlayerEvents['CAPTION_RENDERED'];
     }
 
     export interface CaptionContainerResizeEvent extends MediaPlayerEvent {
@@ -1894,18 +2504,18 @@ declare namespace dashjs {
     }
 
     export interface dvbFontDownloadAdded extends MediaPlayerEvent {
-        type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_ADDED'];
         font: FontInfo;
+        type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_ADDED'];
     }
 
     export interface dvbFontDownloadComplete extends MediaPlayerEvent {
-        type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_COMPLETE'];
         font: FontInfo;
+        type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_COMPLETE'];
     }
 
     export interface dvbFontDownloadFailed extends MediaPlayerEvent {
-        type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_FAILED'];
         font: FontInfo;
+        type: MediaPlayerEvents['DVB_FONT_DOWNLOAD_FAILED'];
     }
 
     export interface DynamicToStaticEvent extends MediaPlayerEvent {
@@ -1913,61 +2523,52 @@ declare namespace dashjs {
     }
 
     export interface FragmentLoadingCompletedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['FRAGMENT_LOADING_COMPLETED'];
         request: FragmentRequest;
         response: ArrayBuffer;
         sender: object;
+        type: MediaPlayerEvents['FRAGMENT_LOADING_COMPLETED'];
     }
 
     export interface FragmentLoadingAbandonedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['FRAGMENT_LOADING_ABANDONED'];
-        streamProcessor: object;
-        request: object;
         mediaType: MediaType;
+        request: object;
+        streamProcessor: object;
+        type: MediaPlayerEvents['FRAGMENT_LOADING_ABANDONED'];
     }
 
     export interface InbandPrftReceivedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['INBAND_PRFT_RECEIVED'];
-        streamInfo: StreamInfo;
-        mediaType: MediaType;
         data: object
+        mediaType: MediaType;
+        streamInfo: StreamInfo;
+        type: MediaPlayerEvents['INBAND_PRFT_RECEIVED'];
     }
 
     export interface KeyErrorEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['KEY_ERROR'];
         error: DashJSError;
-    }
-
-    export class KeyMessage {
-        constructor(sessionToken: SessionToken, message: ArrayBuffer, defaultURL: string, messageType?: string);
-
-        sessionToken: SessionToken;
-        message: ArrayBuffer;
-        defaultURL: string;
-        messageType: string;
+        type: MediaPlayerEvents['KEY_ERROR'];
     }
 
     export interface KeyMessageEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['KEY_MESSAGE'];
         data: KeyMessage;
+        type: MediaPlayerEvents['KEY_MESSAGE'];
     }
 
     export interface KeySessionClosedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['KEY_SESSION_CLOSED' | 'KEY_SESSION_REMOVED'];
         data: string | null;
         error?: string;
+        type: MediaPlayerEvents['KEY_SESSION_CLOSED' | 'KEY_SESSION_REMOVED'];
     }
 
     export interface KeySessionEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['KEY_SESSION_CREATED'];
         data: SessionToken | null;
         error?: DashJSError;
+        type: MediaPlayerEvents['KEY_SESSION_CREATED'];
     }
 
     export interface KeyStatusesChangedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['KEY_STATUSES_CHANGED'];
         data: SessionToken;
         error?: DashJSError;
+        type: MediaPlayerEvents['KEY_STATUSES_CHANGED'];
     }
 
     export interface KeySystemSelectedEvent extends MediaPlayerEvent {
@@ -1977,195 +2578,431 @@ declare namespace dashjs {
     }
 
     export interface LicenseRequestCompleteEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['LICENSE_REQUEST_COMPLETE'];
         data: {
             sessionToken: SessionToken;
             messageType: string;
         };
         error?: DashJSError;
+        type: MediaPlayerEvents['LICENSE_REQUEST_COMPLETE'];
     }
 
     export interface LogEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['LOG'];
         message: string;
+        type: MediaPlayerEvents['LOG'];
     }
 
     export interface ManifestLoadedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['MANIFEST_LOADED'];
         data: object;
+        type: MediaPlayerEvents['MANIFEST_LOADED'];
     }
 
     export interface MetricEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['METRIC_ADDED' | 'METRIC_UPDATED'];
         mediaType: MediaType;
         metric: MetricType;
+        type: MediaPlayerEvents['METRIC_ADDED' | 'METRIC_UPDATED'];
         value: object;
     }
 
     export interface MetricChangedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['METRIC_CHANGED'];
         mediaType: MediaType;
+        type: MediaPlayerEvents['METRIC_CHANGED'];
     }
 
     export interface OfflineRecordEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['OFFLINE_RECORD_FINISHED' | 'OFFLINE_RECORD_STARTED' | 'OFFLINE_RECORD_STOPPED'];
         id: string;
+        type: MediaPlayerEvents['OFFLINE_RECORD_FINISHED' | 'OFFLINE_RECORD_STARTED' | 'OFFLINE_RECORD_STOPPED'];
     }
 
-    export interface OfflineRecordLoademetadataEvent extends MediaPlayerEvent {
+    export interface OfflineRecordLoadedmetadataEvent extends MediaPlayerEvent {
+        mediaInfos: MediaInfo[];
         type: MediaPlayerEvents['OFFLINE_RECORD_LOADEDMETADATA'];
-        madiaInfos: MediaInfo[];
     }
 
     export interface PeriodSwitchEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PERIOD_SWITCH_COMPLETED' | 'PERIOD_SWITCH_STARTED'];
-        toStreamInfo: StreamInfo | null;
         fromStreamInfo?: StreamInfo | null;
+        toStreamInfo: StreamInfo | null;
+        type: MediaPlayerEvents['PERIOD_SWITCH_COMPLETED' | 'PERIOD_SWITCH_STARTED'];
     }
 
     export interface PlaybackErrorEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PLAYBACK_ERROR'];
         error: MediaError;
+        type: MediaPlayerEvents['PLAYBACK_ERROR'];
     }
 
     export interface PlaybackPausedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PLAYBACK_PAUSED'];
         ended: boolean | null;
+        type: MediaPlayerEvents['PLAYBACK_PAUSED'];
     }
 
     export interface PlaybackPlayingEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PLAYBACK_PLAYING'];
         playingTime: number | null;
+        type: MediaPlayerEvents['PLAYBACK_PLAYING'];
     }
 
     export interface PlaybackRateChangedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PLAYBACK_RATE_CHANGED'];
         playbackRate: number | null;
+        type: MediaPlayerEvents['PLAYBACK_RATE_CHANGED'];
     }
 
     export interface PlaybackSeekingEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PLAYBACK_SEEKING'];
         seekTime: number | null;
+        type: MediaPlayerEvents['PLAYBACK_SEEKING'];
     }
 
     export interface PlaybackStartedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PLAYBACK_STARTED'];
         startTime: number | null;
+        type: MediaPlayerEvents['PLAYBACK_STARTED'];
     }
 
     export interface PlaybackTimeUpdatedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PLAYBACK_TIME_UPDATED'];
         time: number | null;
         timeToEnd: number;
+        type: MediaPlayerEvents['PLAYBACK_TIME_UPDATED'];
     }
 
     export interface PlaybackWaitingEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PLAYBACK_WAITING'];
         playingTime: number | null;
+        type: MediaPlayerEvents['PLAYBACK_WAITING'];
     }
 
     export interface ProtectionCreatedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PROTECTION_CREATED'];
         controller: object;
+        type: MediaPlayerEvents['PROTECTION_CREATED'];
     }
 
     export interface ProtectionDestroyedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['PROTECTION_DESTROYED'];
         data: string;
+        type: MediaPlayerEvents['PROTECTION_DESTROYED'];
     }
 
     export interface TrackChangeRenderedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['TRACK_CHANGE_RENDERED'];
         mediaType: MediaType;
-        oldMediaInfo: MediaInfo;
         newMediaInfo: MediaInfo;
+        oldMediaInfo: MediaInfo;
+        type: MediaPlayerEvents['TRACK_CHANGE_RENDERED'];
     }
 
     export interface QualityChangeRenderedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['QUALITY_CHANGE_RENDERED'];
         mediaType: MediaType;
-        oldQuality: number;
         newQuality: number;
+        oldQuality: number;
+        type: MediaPlayerEvents['QUALITY_CHANGE_RENDERED'];
     }
 
     export interface QualityChangeRequestedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['QUALITY_CHANGE_REQUESTED'];
         mediaType: MediaType;
-        oldQuality: number;
         newQuality: number;
-        streamInfo: StreamInfo | null;
+        oldQuality: number;
         reason: {
             name?: string;
             droppedFrames?: number;
         } | null;
+        streamInfo: StreamInfo | null;
+        type: MediaPlayerEvents['QUALITY_CHANGE_REQUESTED'];
     }
 
     export interface StreamInitializedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['STREAM_INITIALIZED'];
-        streamInfo: StreamInfo;
         error: Error | null;
+        streamInfo: StreamInfo;
+        type: MediaPlayerEvents['STREAM_INITIALIZED'];
     }
 
     export interface TextTracksAddedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['TEXT_TRACKS_ADDED'];
         enabled: boolean;
         index: number;
         tracks: TextTrackInfo[];
+        type: MediaPlayerEvents['TEXT_TRACKS_ADDED'];
     }
 
     export interface TtmlParsedEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['TTML_PARSED'];
-        ttmlString: string;
         ttmlDoc: object;
+        ttmlString: string;
+        type: MediaPlayerEvents['TTML_PARSED'];
     }
 
     export interface TtmlToParseEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['TTML_TO_PARSE'];
         content: object;
+        type: MediaPlayerEvents['TTML_TO_PARSE'];
     }
 
     export interface CueEnterEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['CUE_ENTER'];
+        end: number
         id: string,
-        text: string,
         start: number,
-        end: number
+        text: string,
+        type: MediaPlayerEvents['CUE_ENTER'];
     }
 
     export interface CueExitEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['CUE_EXIT'];
         id: string,
+        type: MediaPlayerEvents['CUE_EXIT'];
     }
 
     export interface AdaptationSetRemovedNoCapabilitiesEvent extends MediaPlayerEvent {
-        type: MediaPlayerEvents['ADAPTATION_SET_REMOVED_NO_CAPABILITIES'];
         adaptationSet: object;
+        type: MediaPlayerEvents['ADAPTATION_SET_REMOVED_NO_CAPABILITIES'];
     }
 
     export interface MediaSettings {
-        lang?: string;
-        viewpoint?: any;
-        audioChannelConfiguration?: any[];
         accessibility?: any;
+        audioChannelConfiguration?: any[];
+        lang?: string;
         role?: string;
+        viewpoint?: any;
     }
 
     export class serviceDescriptions {
+        contentSteering: ContentSteering | null;
         id: number;
-        schemeIdUri: string;
         latency: number | null;
         playbackrate: number;
-        contentSteering: ContentSteering | null;
+        schemeIdUri: string;
     }
 
     export interface ICurrentRepresentationSwitch {
-        mt: Date;
+        mt: number;
         t: Date;
+        to: string;
+        lto: string;
     }
 
     export interface IBufferState {
-        target: number;
         state: string;
+        target: number;
+    }
+
+    /**
+     * 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/'
+            },
+            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',
+        TRACK_SELECTION_MODE_HIGHEST_SELECTION_PRIORITY: 'highestSelectionPriority',
+        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',
+        },
+        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'
+        },
+
+        /**
+         *  @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 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',
+        }
     }
 
     /**
@@ -2175,7 +3012,7 @@ declare namespace dashjs {
     export interface AbrController {
         initialize(): void;
 
-        registerStreamType(type: string, streamProcessor: any): void;
+        registerStreamType(type: object, streamProcessor: object): void;
 
         unRegisterStreamType(streamId: string, type: string): void;
 
@@ -2183,47 +3020,43 @@ declare namespace dashjs {
 
         setConfig(config: object): void;
 
-        getMaxAllowedIndexFor(type: string, streamId: string): number | undefined;
+        getOptimalRepresentationForBitrate(mediaInfo: MediaInfo, bitrateInKbit: number, includeCompatibleMediaInfos: boolean): Representation | null;
 
-        getMinAllowedIndexFor(type: string, streamId: string): number | undefined;
+        getRepresentationByAbsoluteIndex(absoluteIndex: number, mediaInfo: MediaInfo, includeCompatibleMediaInfos: boolean): Representation | null;
 
-        getTopBitrateInfoFor(type: string, streamId?: string): BitrateInfo | null;
+        getPossibleVoRepresentations(mediaInfo: MediaInfo, includeCompatibleMediaInfos: boolean): Representation[] | null;
 
-        getInitialBitrateFor(type: string): number;
+        getPossibleVoRepresentationsFilteredBySettings(mediaInfo: MediaInfo, includeCompatibleMediaInfos: boolean): Representation[] | null;
 
-        checkPlaybackQuality(type: string, streamId: string): boolean;
+        getInitialBitrateFor(type: string): number;
 
-        getQualityFor(type: string, streamId?: string): number | any;
+        checkPlaybackQuality(type: string, streamId: string | number): boolean;
 
-        setPlaybackQuality(type: string, streamInfo: StreamInfo, newQuality: number, reason?: string): void;
+        setPlaybackQuality(type: string, streamInfo: StreamInfo, representation: Representation, reason: object): void;
 
         getAbandonmentStateFor(streamId: string, type: string): any | null;
 
-        getQualityForBitrate(mediaInfo: MediaInfo, bitrate: number, streamId: string, latency?: number | null): number;
-
-        getBitrateList(mediaInfo: MediaInfo): BitrateInfo[] | null;
-
-        updateTopQualityIndex(mediaInfo: MediaInfo): number;
+        isPlayingAtLowestQuality(representation: Representation): boolean;
 
-        isPlayingAtTopQuality(streamInfo: StreamInfo): boolean;
+        isPlayingAtTopQuality(representation: Representation): boolean;
 
         setWindowResizeEventCalled(value: any): void;
 
-        setElementSize(): void;
-
         clearDataForStream(streamId: string): void;
     }
 
     export interface BaseURLController {
+        setConfig(config: object): void;
+
+        update(manifest: object): void;
+
         resolve(path: any): BaseURL;
 
         reset(): void;
 
-        initialize(data: any): void;
-
         getBaseUrls(manifest: any): BaseURL[];
 
-        setConfig(config: object): void;
+        initialize(data: any): void;
     }
 
     export interface BlacklistController {
@@ -2231,140 +3064,198 @@ declare namespace dashjs {
 
         add(entry: any): void;
 
+        remove(entry: any): void;
+
         reset(): void;
     }
 
     export interface BufferController {
-        initialize(mediaSource: MediaSource): void;
+        appendInitSegmentFromCache(representationId: string): boolean;
 
-        getStreamId(): string;
+        clearBuffers(ranges: Range[]): Promise<any>;
 
-        getType(): string;
+        createBufferSink(mediaInfo: MediaInfo, oldBufferSinks?: any[]): Promise<any>;
+
+        dischargePreBuffer(): void;
+
+        getAllRangesWithSafetyFactor(seekTime: number): { start: number, end: number }[];
+
+        getBuffer(): SourceBufferSink;
 
         getBufferControllerType(): string;
 
-        setMediaSource(value: object): void;
+        getBufferLevel(): number;
 
-        createBufferSink(mediaInfo: MediaInfo, oldBufferSinks?: any[]): Promise<any>;
+        getContinuousBufferTimeForTargetTime(targetTime: number): number;
 
-        appendInitSegmentFromCache(representationId: string): boolean;
+        getIsBufferingCompleted(): boolean;
 
-        prepareForPlaybackSeek(): any;
+        getIsPruningInProgress(): boolean;
 
-        prepareForReplacementTrackSwitch(codec: string): Promise<any>;
+        getMediaSource(): MediaSource;
+
+        getRangeAt(time: number, tolerance: number): Range | null;
+
+        getStreamId(): string;
+
+        getType(): string;
+
+        hasBufferAtTime(time: number): boolean;
+
+        initialize(mediaSource: MediaSource): void;
+
+        prepareForFastQualitySwitch(newRepresentation: Representation, oldRepresentation: Representation): Promise<any>;
 
         prepareForForceReplacementQualitySwitch(voRepresentation: Representation): Promise<any>;
 
         prepareForNonReplacementTrackSwitch(codec: string): Promise<any>;
 
+        prepareForPlaybackSeek(): any;
+
+        prepareForReplacementTrackSwitch(codec: string): Promise<any>;
+
+        prepareForabandonQualitySwitch(newRepresentation: Representation, oldRepresentation: Representation): Promise<any>;
+
         pruneAllSafely(): Promise<any>;
 
-        getAllRangesWithSafetyFactor(seekTime: number): { start: number, end: number }[];
+        pruneBuffer(): void;
 
-        getRangeAt(time: number, tolerance: number): Range | null;
+        reset(errored: any, keepBuffers: boolean): void;
 
-        clearBuffers(ranges: Range[]): Promise<any>;
+        segmentRequestingCompleted(segmentIndex: number): void;
 
-        updateBufferTimestampOffset(voRepresentation: Representation): Promise<any>;
+        setIsBufferingCopleted(value: object): void;
+
+        setMediaSource(value: object, mediaInfo: MediaInfo | null): void;
+
+        setSeekTarget(value: object): void;
 
         updateAppendWindow(): Promise<any>;
 
-        segmentRequestingCompleted(segmentIndex: number): void;
+        updateBufferTimestampOffset(voRepresentation: Representation): Promise<any>;
+    }
 
-        getBuffer(): SourceBufferSink;
+    export interface CatchupController {
+        initialize(): void;
 
-        getBufferLevel(): number;
+        reset(): void;
 
-        getMediaSource(): MediaSource;
+        setConfig(config: any): void;
+    }
 
-        getIsBufferingCompleted(): boolean;
+    export interface ClientDataReportingController {
+        isAdaptationsIncluded(adaptationSet: AdaptationSet): boolean;
 
-        setIsBufferingCopleted(value: object): void;
+        isServiceLocationIncluded(requestType: string, serviceLocation: any): boolean;
 
-        getIsPruningInProgress(): boolean;
+        setConfig(config: any): void;
+    }
 
-        getContinuousBufferTimeForTargetTime(targetTime: number): number;
+    export interface CommonAccessTokenController {
+        getCommonAccessTokenForUrl(url: URL): any;
 
-        setSeekTarget(value: object): void;
+        processResponseHeaders(httpResponse: object): void;
 
-        reset(errored: any, keepBuffers: boolean): void;
+        reset(): void;
     }
 
     export interface EventController {
-        start(): void;
+        addInbandEvents(values: object[], periodId: string | number): void;
+
+        addInlineEvents(values: object[], periodId: string | number): void;
+
+        getInbandEvents(): object;
 
-        addInlineEvents(values: object[]): void;
+        getInlineEvents(): object;
 
-        addInbandEvents(values: object[]): void;
+        reset(): void;
 
         setConfig(config: object): void;
 
-        getInlineEvents(): object;
+        start(): void;
+    }
 
-        getInbandEvents(): object;
+    export interface ExtUrlQueryInfoController {
+        createFinalQueryStrings(manifest: object): void;
 
-        reset(): void;
+        getFinalQueryString(request: HTTPRequest): any;
     }
 
     export interface FragmentController {
-        getStreamId(): string;
+        getModel(type: string): any;
 
-        getModel(): any;
+        getStreamId(): string;
 
         reset(): void;
     }
 
     export interface GapController {
+        initialize(): void;
+
         reset(): void;
 
         setConfig(config: object): void;
-
-        initialize(): void;
     }
 
     export interface MediaController {
-        setInitialMediaSettingsForType(type: string, streamInfo: StreamInfo): void;
-
         addTrack(track: MediaInfo): void;
 
-        getTracksFor(type: string, streamId: string): MediaInfo[];
+        areTracksEqual(t1: MediaInfo, t2: MediaInfo): boolean;
 
-        isCurrentTrack(track: MediaInfo): boolean;
+        getCurrentTrackFor(type: string, streamId: string): MediaInfo;
 
-        setTrack(track: MediaInfo, options: object): void;
+        getInitialSettings(type: string): object | null;
 
-        setInitialSettings(type: string, value: object): void;
+        getTracksFor(type: string, streamId: string): MediaInfo[];
 
-        getInitialSettings(type: string): object | null;
+        getTracksWithHighestBitrate(trackArr: MediaInfo[]): MediaInfo[];
 
-        saveTextSettingsDisabled(): void;
+        getTracksWithHighestEfficiency(trackArr: MediaInfo[]): MediaInfo[];
 
-        areTracksEqual(t1: MediaInfo, t2: MediaInfo): boolean;
+        getTracksWithHighestSelectionPriority(trackArr: MediaInfo[]): MediaInfo[];
 
-        setConfig(config: object): void;
+        getTracksWithWidestRange(trackArr: MediaInfo[]): MediaInfo[];
 
-        reset(): void;
+        initialize(): void;
+
+        isCurrentTrack(track: MediaInfo): boolean;
 
         matchSettings(settings: object, track: MediaInfo, isTrackActive?: boolean): any;
 
-        getTracksWithHighestSelectionPriority(trackArr: MediaInfo[]): MediaInfo[];
+        matchSettingsAccessibility(settings: object, track: MediaInfo): any;
 
-        getTracksWithHighestBitrate(trackArr: MediaInfo[]): MediaInfo[];
+        matchSettingsAudioChannelConfig(settings: object, track: MediaInfo): any;
 
-        getTracksWithHighestEfficiency(trackArr: MediaInfo[]): MediaInfo[];
+        matchSettingsCodec(settings: object, track: MediaInfo): any;
 
-        getTracksWithHighestRange(trackArr: MediaInfo[]): MediaInfo[];
+        matchSettingsIndex(settings: object, track: MediaInfo): any;
 
-        setCustomInitialTrackSelectionFunction(customFunc: Function): void;
+        matchSettingsLang(settings: object, track: MediaInfo): any;
+
+        matchSettingsRole(settings: object, track: MediaInfo): any;
+
+        matchSettingsViewPoint(settings: object, track: MediaInfo): any;
+
+        reset(): void;
+
+        saveTextSettingsDisabled(): void;
 
         selectInitialTrack(type: string, tracks: MediaInfo[]): MediaInfo;
+
+        setConfig(config: object): void;
+
+        setInitialMediaSettingsForType(type: string, streamInfo: StreamInfo): void;
+
+        setInitialSettings(type: string, value: object): void;
+
+        setTrack(track: MediaInfo, options: object): void;
     }
 
     export interface MediaSourceController {
-        createMediaSource(): MediaSource;
-
         attachMediaSource(videoModel: object): string;
 
+        createMediaSource(): MediaSource;
+
         detachMediaSource(videoModel: object): void;
 
         setDuration(value: object): void;
@@ -2375,145 +3266,193 @@ declare namespace dashjs {
     }
 
     export interface PlaybackController {
-        initialize(sInfo: StreamInfo, periodSwitch: boolean): void;
+        computeAndSetLiveDelay(fragmentDuration: number, manifestInfo: IManifestInfo): number;
 
-        getTimeToStreamEnd(sInfo?: StreamInfo): number;
+        getAvailabilityStartTime(): number;
 
-        getStreamEndTime(sInfo: StreamInfo): number;
+        getBufferLevel(filterList?: any[]): number | null;
 
-        play(): void;
+        getCurrentLiveLatency(): number;
 
-        isPaused(): boolean;
+        getEnded(): boolean | null;
 
-        pause(): void;
+        getInitialCatchupModeActivated(): boolean;
 
-        isSeeking(): boolean;
+        getIsDynamic(): boolean;
 
-        seek(time: number, stickToBuffered: boolean, internal: boolean): void;
+        getIsManifestUpdateInProgress(): boolean;
 
-        getTime(): number;
+        getLiveDelay(): number;
 
-        getPlaybackRate(): number;
+        getLowLatencyModeEnabled(): boolean;
 
-        getPlayedRanges(): TimeRanges | null;
+        getOriginalLiveDelay(): number;
+
+        getPlaybackRate(): number | null;
 
-        getEnded(): number;
+        getPlaybackStalled(): boolean;
 
-        getIsDynamic(): boolean;
+        getPlayedRanges(): TimeRanges | null;
 
         getStreamController(): object;
 
-        getIsManifestUpdateInProgress(): boolean;
+        getStreamEndTime(sInfo: StreamInfo): number;
 
-        computeAndSetLiveDelay(fragmentDuration: number, manifestInfo: IManifestInfo): number;
+        getTime(): number | null;
 
-        getAvailabilityStartTime(): number;
+        getTimeToStreamEnd(sInfo?: StreamInfo): number;
 
-        getLiveDelay(): number;
+        initialize(sInfo: StreamInfo, periodSwitch: boolean): void;
 
-        getCurrentLiveLatency(): number;
+        isPaused(): boolean | null;
 
-        reset(): void;
+        isProgressing(): Promise<any>;
 
-        setConfig(config: object): void;
+        isSeeking(): boolean | null;
 
-        updateCurrentTime(mediaType?: MediaType): void;
+        isStalled(): boolean | null;
 
-        getBufferLevel(filterList?: any[]): number | null;
-    }
+        pause(): void;
 
-    export interface ScheduleController {
-        initialize(_hasVideoTrack: boolean): void;
+        play(): void;
 
-        getType(): string;
+        reset(): void;
 
-        getStreamId(): string;
+        seek(time: number, stickToBuffered: boolean, internal: boolean): void;
 
-        startScheduleTimer(value: object): void;
+        seekToCurrentLive(stickToBuffered?: boolean, internal?: boolean, adjustLiveDelay?: boolean): void;
 
+        seekToOriginalLive(stickToBuffered?: boolean, internal?: boolean, adjustLiveDelay?: boolean): void;
+
+        setConfig(config: object): void;
+
+        updateCurrentTime(mediaType?: MediaType): void;
+    }
+
+    export interface ScheduleController {
         clearScheduleTimer(): void;
 
         getBufferTarget(): number;
 
-        setSwitchTrack(value: object): void;
+        getStreamId(): string;
 
         getSwitchTrack(): any;
 
-        setTimeToLoadDelay(value: object): void;
-
         getTimeToLoadDelay(): number;
 
-        setCheckPlaybackQuality(value: object): void;
-
-        setInitSegmentRequired(value: object): void;
+        getType(): string;
 
-        setLastInitializedQuality(value: number): void;
+        initialize(_hasVideoTrack: boolean): void;
 
         reset(): void;
-    }
 
-    export interface StreamController {
-        initialize(autoPl: any, protData: object): void;
+        setCheckPlaybackQuality(value: object): void;
 
-        getStreamForTime(time: number): object | null;
+        setInitSegmentRequired(value: object): void;
+
+        setLastInitializedRepresentationId(value: number): void;
+
+        setSwitchTrack(value: object): void;
+
+        setTimeToLoadDelay(value: object): void;
+
+        startScheduleTimer(value: object): void;
+    }
 
+    export interface StreamController {
         addDVRMetric(): void;
 
-        getTimeRelativeToStreamId(time: number, id: string): number | null;
+        getActiveStream(): object;
+
+        getActiveStreamInfo(): StreamInfo | null;
 
         getActiveStreamProcessors(): any[];
 
-        getActiveStream(): object;
+        getAutoPlay(): boolean;
+
+        getHasMediaOrInitialisationError(): boolean;
 
         getInitialPlayback(): any;
 
-        getAutoPlay(): boolean;
+        getIsStreamSwitchInProgress(): boolean;
 
-        hasVideoTrack(): void;
+        getStreamById(id: string): object | null;
 
-        hasAudioTrack(): void;
+        getStreamForTime(time: number): object | null;
 
-        switchToVideoElement(seekTime: number): void;
+        getStreams(): any[];
 
-        getActiveStreamInfo(): StreamInfo | null;
+        getTimeRelativeToStreamId(time: number, id: string): number | null;
 
-        getIsStreamSwitchInProgress(): boolean;
+        hasAudioTrack(): void;
 
-        getHasMediaOrInitialisationError(): boolean;
+        hasVideoTrack(): void;
 
-        getStreamById(id: string): object | null;
+        initialize(autoPl: any, protData: object): void;
 
-        load(url: string): void;
+        load(url: string, startTime?: number): void;
 
         loadWithManifest(manifest: object): void;
 
+        refreshManifest(): void;
+
+        reset(): void;
+
         setConfig(config: object): void;
 
         setProtectionData(protData: object): void;
 
+        switchToVideoElement(seekTime: number): void;
+    }
+
+    export interface ThroughputController {
+        getArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
+
+        getAverageLatency(mediaType: MediaType, calculationMode: string, sampleSize: number): number
+
+        getAverageThroughput(mediaType: MediaType, calculationMode: string, sampleSize: number): number
+
+        getByteSizeWeightedArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
+
+        getByteSizeWeightedHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
+
+        getDateWeightedArithmeticMean(dict: ThroughputDictEntry[], sampleSize: number): number
+
+        getDateWeightedHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
+
+        getEwma(dict: ThroughputEwmaDictEntry[], halfLife: object, useMin: boolean): number
+
+        getHarmonicMean(dict: ThroughputDictEntry[], sampleSize: number): number
+
+        getRawThroughputData(mediaType: MediaType): number
+
+        getSafeAverageThroughput(mediaType: MediaType, calculationMode: string, sampleSize: number): number
+
+        getZlema(dict: ThroughputDictEntry[], sampleSize: number): number
+
+        initialize(): void;
+
         reset(): void;
 
-        getStreams(): any[];
+        setConfig(config: object): void;
     }
 
     export interface TimeSyncController {
-        initialize(): void;
-
         attemptSync(tSources: number[], isDynamic: boolean): void;
 
+        initialize(): void;
+
         setConfig(config: object): void;
 
         reset(): void;
     }
 
     export interface XlinkController {
-        resolveManifestOnLoad(mpd: Mpd): void;
-
-        setMatchers(value: object): void;
+        reset(): void;
 
-        setIron(value: object): void;
+        resolveManifestOnLoad(mpd: Mpd): void;
 
-        reset(): void;
+        setParser(value: object): void;
     }
 
     /**
@@ -2539,17 +3478,17 @@ declare namespace dashjs {
     export interface RangeController {
         initialize(rs: object[]): void;
 
-        reset(): void;
-
         isEnabled(): boolean;
+
+        reset(): void;
     }
 
     export interface ReportingController {
         initialize(rangeController: RangeController): void;
 
-        reset(): void;
-
         report(type: string, vos: any[]): void;
+
+        reset(): void;
     }
 
     /**
@@ -2559,33 +3498,33 @@ declare namespace dashjs {
     export interface BufferLevelHandler {
         initialize(basename: string, rc: RangeController, n_ms: string): void;
 
-        reset(): void;
-
         handleNewMetric(metric: any, vo: any, type: string): void;
+
+        reset(): void;
     }
 
     export interface DVBErrorsHandler {
         initialize(unused: any, rc: RangeController): void; //unused does nothing
 
-        reset(): void;
-
         handleNewMetric(metric: any, vo: any): void;
+
+        reset(): void;
     }
 
     export interface GenericMetricHandler {
         initialize(name: string, rc: RangeController): void;
 
-        reset(): void;
-
         handleNewMetric(metric: any, vo: any): void;
+
+        reset(): void;
     }
 
     export interface HttpListHandler {
         initialize(basename: string, rc: RangeController, n_ms: string, requestType: string): void;
 
-        reset(): void;
-
         handleNewMetric(metric: any, vo: any): void;
+
+        reset(): void;
     }
 
     /**
@@ -2605,10 +3544,10 @@ declare namespace dashjs {
      **/
 
     export interface DVBReporting {
-        report(type: string, vos: any[]): void;
-
         initialize(entry: object, rc: RangeController): void;
 
+        report(type: string, vos: any[]): void;
+
         reset(): void;
     }
 
@@ -2634,6 +3573,10 @@ declare namespace dashjs {
         reset(): void;
     }
 
+    export interface HandlerHelpers {
+        // Exports nothing
+    }
+
     export interface ManifestParsing {
         getMetrics(manifest: object): object[];
     }
@@ -2651,22 +3594,22 @@ declare namespace dashjs {
      **/
 
     export class DVBErrors {
-        mpdurl: string | null;
         errorcode: string | null;
-        terror: Date | null;
-        url: string | null;
         ipaddress: string | null;
+        mpdurl: string | null;
         servicelocation: string | null;
+        terror: Date | null;
+        url: string | null;
 
-        SSL_CONNECTION_FAILED_PREFIX: 'SSL';
-        DNS_RESOLUTION_FAILED: 'C00';
-        HOST_UNREACHABLE: 'C01';
-        CONNECTION_REFUSED: 'C02';
+        BASE_URL_CHANGED: 'F00';
+        BECAME_REPORTER: 'S00';
         CONNECTION_ERROR: 'C03';
+        CONNECTION_REFUSED: 'C02';
         CORRUPT_MEDIA_ISOBMFF: 'M00';
         CORRUPT_MEDIA_OTHER: 'M01';
-        BASE_URL_CHANGED: 'F00';
-        BECAME_REPORTER: 'S00';
+        DNS_RESOLUTION_FAILED: 'C00';
+        HOST_UNREACHABLE: 'C01';
+        SSL_CONNECTION_FAILED_PREFIX: 'SSL';
     }
 
     export interface Metrics {
@@ -2676,18 +3619,18 @@ declare namespace dashjs {
     }
 
     export interface Range {
-        starttime: number;
-        duration: number;
         _useWallClockTime: boolean;
+        duration: number;
+        starttime: number;
     }
 
     export interface Reporting {
         DEFAULT_DVB_PROBABILITY: 1000;
 
+        dvbProbability: number;
+        dvbReportingUrl: string;
         schemeIdUri: string;
         value: string;
-        dvbReportingUrl: string;
-        dvbProbability: number;
     }
 
     /**
@@ -2697,91 +3640,167 @@ declare namespace dashjs {
     export interface MetricsReporting {
         createMetricsReporting(config: object): void;
 
+        getMetricsHandlerFactory(): MetricsHandlerFactory;
+
         getReportingFactory(): ReportingFactory;
+    }
 
-        getMetricsHandlerFactory(): MetricsHandlerFactory;
+    export class MetricsReportingEvents extends EventsBase {
+        BECAME_REPORTING_PLAYER: 'internal_becameReportingPlayer';
+        CMCD_DATA_GENERATED: 'cmcdDataGenerated';
+        METRICS_INITIALISATION_COMPLETE: 'internal_metricsReportingInitialized';
     }
 
     /**
      * Streaming - Models
      **/
 
-    export interface BaseURLTreeModel {
-        reset(): void;
+    export interface AastLowLatencyThroughputModel {
+        addMeasurement(request: HTTPRequest, chunkMeasurements: any[], requestTimeMs: number, throughputCapacityDelayMS: number): void;
 
-        update(manifest: object): void;
+        getEstimatedDownloadDurationMS(request: HTTPRequest): number;
+
+        getThroughputCapacityDelayMS(request: HTTPRequest, currentBufferLevelMS: number): number;
+
+        setup(): void;
+    }
+
+    export interface BaseURLTreeModel {
+        getBaseUrls(root: any): BaseURL[];
 
         getForPath(path: any): any;
 
         invalidateSelectedIndexes(serviceLocation: string): void;
 
-        getBaseUrls(root: any): BaseURL[];
+        reset(): void;
 
         setConfig(config: object): void;
+
+        update(manifest: object): void;
     }
 
     export interface CmcdModel {
-        getQueryParameter(request: HTTPRequest): { key: string, finalPayloadString: string } | null;
+        getCmcdData(request: HTTPRequest): object;
+
+        getCmcdParametersFromManifest(): CMCDParameters;
 
         getHeaderParameters(request: HTTPRequest): object | null;
 
+        getQueryParameter(request: HTTPRequest): { key: string, finalPayloadString: string } | null;
+
+        initialize(): void;
+
+        isCmcdEnabled(): boolean;
+
+        reset(): void;
+
         setConfig(config: object): void;
+    }
+
+    export interface CmsdModel {
+        getEstimatedThroughput(type: string): number;
+
+        getMaxBitrate(type: string): number;
+
+        getResponseDelay(type: string): number;
+
+        getRoundTripTime(type: string): number;
+
+        initialize(): void; // NOT IMPLEMENTED!
+        parseResponseHeader(responseHeaders: object, mediaType: MediaType): void;
 
         reset(): void;
 
-        initialize(): void;
+        setConfig(): void; // NOT IMPLEMENTED!
     }
 
-    export interface FragmentModel {
-        getStreamId(): string;
+    export interface CustomParametersModel {
+        addAbrCustomRule(type: string, rulename: string, rule: object): void;
 
-        getType(): string;
+        addRequestInterceptor(interceptor: Function): void;
 
-        getRequests(filter: any): HTTPRequest[];
+        addResponseInterceptor(interceptor: Function): void;
 
-        isFragmentLoaded(request: HTTPRequest): boolean;
+        addUTCTimingSource(schemeIdUri: string, value: string): void;
 
-        isFragmentLoadedOrPending(request: HTTPRequest): boolean;
+        clearDefaultUTCTimingSources(): void;
 
-        removeExecutedRequestsBeforeTime(time: number): boolean;
+        getAbrCustomRules(): Array<object>;
 
-        removeExecutedRequestAfterTime(time: number): boolean;
+        getCustomCapabilitiesFilters(): Array<Function>;
 
-        syncExecutedRequestsWithBufferedRange(bufferedRanges: Range[], streamDuration: number): void;
+        getCustomInitialTrackSelectionFunction(): Function;
 
-        abortRequests(): void;
+        getLicenseRequestFilters(): Array<Function>;
 
-        executeRequest(request: HTTPRequest): void;
+        getLicenseResponseFilters(): Array<Function>;
+
+        getRequestInterceptors(): void;
+
+        getResponseInterceptors(): void;
+
+        getUTCTimingSources(): Array<object>;
+
+        getXHRWithCredentialsForType(type: string): any;
+
+        registerCustomCapabilitiesFilter(filter: Function): void;
+
+        registerLicenseRequestFilter(filter: Function): void;
+
+        registerLicenseResponseFilter(filter: Function): void;
+
+        removeAbrCustomRule(ruleName: string): void;
+
+        removeAllAbrCustomRule(): void;
+
+        removeRequestInterceptor(interceptor: Function): void;
+
+        removeResponseInterceptor(interceptor: Function): void;
+
+        removeUTCTimingSource(schemeIdUri: string, value: string): void;
 
         reset(): void;
 
-        resetInitialSettings(): void;
-    }
+        resetCustomInitialTrackSelectionFunction(): void;
 
-    export interface AastLowLatencyThroughputModel {
-        setup(): void;
+        restoreDefaultUTCTimingSources(): void;
+
+        setConfig(): void; // NOT IMPLEMENTED
+        setCustomInitialTrackSelectionFunction(customFunc: Function): void;
 
-        addMeasurement(request: HTTPRequest, fetchDownloadDurationMS: number, chunkMeasurements: object[], requestTimeMS: number, throughputCapacityDelayMS: number): void;
+        setXHRWithCredentialsForType(type: string, value: string): void;
 
-        getThroughputCapacityDelayMS(request: HTTPRequest, currentBufferLevel: number): number;
+        unregisterCustomCapabilitiesFilter(filter: Function): void;
 
-        getEstimatedDownloadDurationMS(request: HTTPRequest): number;
+        unregisterLicenseRequestFilter(filter: Function): void;
+
+        unregisterLicenseResponseFilter(filter: Function): void
     }
 
-    export interface ThroughputModel {
-        addEntry(mediaType: MediaType, httpRequest: HTTPRequest): void;
+    export interface FragmentModel {
+        abortRequests(): void;
 
-        getThroughputDict(mediaType: MediaType): ThroughputDictEntry;
+        executeRequest(request: HTTPRequest): void;
 
-        getEwmaThroughputDict(mediaType: MediaType): ThroughputEwmaDictEntry;
+        getRequests(filter: any): HTTPRequest[];
 
-        getEwmaLatencyDict(mediaType: MediaType): ThroughputEwmaDictEntry;
+        getStreamId(): string;
 
-        getEwmaHalfLife(mediaType: MediaType): object;
+        getType(): string;
 
-        getLatencyDict(mediaType: MediaType): ThroughputDictEntry;
+        isFragmentLoaded(request: HTTPRequest): boolean;
+
+        isFragmentLoadedOrPending(request: HTTPRequest): boolean;
+
+        removeExecutedRequestAfterTime(time: number): boolean;
+
+        removeExecutedRequestsBeforeTime(time: number): boolean;
 
         reset(): void;
+
+        resetInitialSettings(): void;
+
+        syncExecutedRequestsWithBufferedRange(bufferedRanges: Range[], streamDuration: number): void;
     }
 
     export interface ManifestModel {
@@ -2791,170 +3810,171 @@ declare namespace dashjs {
     }
 
     export interface MediaPlayerModel {
+        getAbrBitrateParameter(field: string, mediaType: string): object | -1;
 
-        addABRCustomRule(type: string, rulename: string, rule: any): void;
-
-        addUTCTimingSource(schemeIdUri: string, value: string): void;
-
-        clearDefaultUTCTimingSources(): void;
+        getBufferTimeDefault(): number;
 
-        getABRCustomRules(): object[];
+        getCatchupMaxDrift(): number;
 
-        getBufferTimeDefault(): number;
+        getCatchupModeEnabled(): boolean;
 
-        getDefaultUtcTimingSource(): UTCTiming;
+        getCatchupPlaybackRates(log: any): number;
 
         getFastSwitchEnabled(): boolean;
 
         getInitialBufferLevel(): number;
 
-        getLiveCatchupLatencyThreshold(): number;
-
-        getLiveDelay(): number;
-
         getRetryAttemptsForType(type: string): number;
 
         getRetryIntervalsForType(type: string): any;
 
-        getUTCTimingSources(): UTCTiming[];
-
-        getXHRWithCredentialsForType(type: string): object;
+        reset(): void;
 
-        removeABRCustomRule(rulename: string): void;
+        setConfig(config: object): void;
+    }
 
-        removeUTCTimingSource(schemeIdUri: string, value: string): void;
+    export interface MetricsModel {
+        config: object;
 
-        reset(): void;
+        addBufferLevel(mediaType: MediaType, t: Date, level: number): void;
 
-        restoreDefaultUTCTimingSources(): void;
+        addBufferState(mediaType: MediaType, state: string, target: number): void;
 
-        setXHRWithCredentialsForType(type: string, value: any): void;
-    }
+        addDVBErrors(vo: any): void;
 
-    export interface MetricsModel {
-        clearCurrentMetricsForType(type: string): void;
+        addDVRInfo(mediaType: MediaType, currentTime: number, mpd: Mpd, range: Range): void;
 
-        clearAllCurrentMetrics(): void;
+        addDroppedFrames(mediaType: MediaType, quality: number): void;
 
-        getMetricsFor(type: string, readOnly: boolean): object;
+        addHttpRequest(request: HTTPRequest, response: object, traces: object, cmsd: object): void;
 
-        addHttpRequest(mediaType: MediaType, tcpid: string, type: string, url: string, quality: number, actualurl: string, servicelocation: string, rage: Range, trequest: Date, tresponse: Date, tfinish: Date, responsecode: number, mediaduration: number, responseHeaders: any[], traces: object): void;
+        addManifestUpdate(mediaType: MediaType, type: string, requestTime: number, fetchTime: number): void;
 
-        addRepresentationSwitch(mediaType: MediaType, t: Date, mt: Date, to: string, lto: string): void;
+        addManifestUpdateRepresentationInfo(manifestUpdate: ManifestUpdate, representation: Representation, mediaType: MediaType): void;
 
-        addBufferLevel(mediaType: MediaType, t: Date, level: number): void;
+        addManifestUpdateStreamInfo(manifestUpdate: ManifestUpdate, id: string, index: number, start: number, duration: number): void;
 
-        addBufferState(mediaType: MediaType, state: string, target: number): void;
+        addPlayList(vo: any): void;
 
-        addDVRInfo(mediaType: MediaType, currentTime: number, mpd: Mpd, range: Range): void;
+        addRepresentationSwitch(mediaType: MediaType, t: Date, mt: Date, to: string, lto: string): void;
 
-        addDroppedFrames(mediaType: MediaType, quality: number): void;
+        addRequestsQueue(mediaType: MediaType, loadingRequests: any[], executedRequests: any[]): void;
 
         addSchedulingInfo(mediaType: MediaType, t: number, startTime: number, availabilityStartTime: number, duration: number, quality: number, range: Range, state: string): void;
 
-        addRequestsQueue(mediaType: MediaType, loadingRequests: any[], executedRequests: any[]): void;
+        clearAllCurrentMetrics(): void;
 
-        addManifestUpdate(mediaType: MediaType, type: string, requestTime: number, fetchTime: number): void;
+        clearCurrentMetricsForType(type: string): void;
+
+        getMetricsFor(type: string, readOnly: boolean): object;
 
         updateManifestUpdateInfo(manifestUpdate: ManifestUpdate, updatedFields: any[]): void;
+    }
 
-        addManifestUpdateStreamInfo(manifestUpdate: ManifestUpdate, id: string, index: number, start: number, duration: number): void;
+    export interface ThroughputModel {
+        addEntry(mediaType: MediaType, httpRequest: HTTPRequest): void;
 
-        addManifestUpdateRepresentationInfo(manifestUpdate: ManifestUpdate, representation: Representation, mediaType: MediaType): void;
+        getThroughputDict(mediaType: MediaType): ThroughputDictEntry;
 
-        addPlayList(vo: any): void;
+        getEwmaThroughputDict(mediaType: MediaType): ThroughputEwmaDictEntry;
 
-        addDVBErrors(vo: any): void;
+        getEwmaLatencyDict(mediaType: MediaType): ThroughputEwmaDictEntry;
+
+        getEwmaHalfLife(mediaType: MediaType): object;
+
+        getLatencyDict(mediaType: MediaType): ThroughputDictEntry;
+
+        reset(): void;
     }
 
     export interface URIFragmentModel {
-        initialize(uri: string): void;
-
         getURIFragmentData(): URIFragmentData;
+
+        initialize(uri: string): void;
     }
 
     interface VideoModel {
-        initialize(): void;
+        addEventListener(): void;
 
-        reset(): void;
+        addTextTrack(kind: TextTrackType, label: string | number | undefined, isTTML: boolean, isEmbedded: boolean): TextTrackInfo;
 
-        setPlaybackRate(value: number, ignoreReadyState?: boolean): void;
+        appendChild(childElement: any): void;
 
-        setcurrentTime(currentTime: number, stickToBuffered: boolean): void;
+        getBufferRange(): TimeRanges | null;
+
+        getClientHeight(): number;
 
-        stickTimeToBuffered(time: number): number;
+        getClientWidth(): number;
 
         getElement(): HTMLVideoElement | HTMLAudioElement;
 
-        setElement(value: HTMLVideoElement | HTMLAudioElement): void;
+        getEnded(): boolean | null;
 
-        setSource(source: string): void;
+        getPlaybackQuality(): number;
+
+        getPlaybackRate(): number | null;
+
+        getPlayedRanges(): TimeRanges | null;
+
+        getReadyState(): number;
 
         getSource(): string | null;
 
         getTTMLRenderingDiv(): HTMLDivElement | null;
 
-        setTTMLRenderingDiv(div: HTMLDivElement): void;
+        getTextTrack(kind: TextTrackType, label: string | number | undefined, isTTML: boolean, isEmbedded: boolean): TextTrackInfo | null;
 
-        setStallState(type: MediaType, state: boolean): void;
+        getTextTracks(): TextTrackList[];
 
-        isStalled(): boolean;
+        getTime(): number | null;
 
-        addStalledStream(type: MediaType): void;
+        getVideoHeight(): number;
 
-        removeStalledStream(type: MediaType): void;
+        getVideoRelativeOffsetLeft(): number;
 
-        stallStream(type: MediaType, isStalled: boolean): void;
+        getVideoRelativeOffsetTop(): number;
 
-        onPlaying(): void;
+        getVideoWidth(): number;
 
-        getPlaybackQuality(): number;
+        getVttRenderingDiv(): HTMLDivElement | null;
 
-        play(): void;
+        initialize(): void;
 
         isPaused(): void;
 
-        pause(): void;
-
         isSeeking(): void;
 
-        getTime(): number | null;
+        isStalled(): boolean;
 
-        getPlaybackRate(): number | null;
+        onPlaying(): void;
 
-        getPlayedRanges(): TimeRanges | null;
+        pause(): void;
 
-        getEnded(): boolean | null;
+        play(): void;
 
-        addEventListener(): void;
+        removeChild(childElement: any): void;
 
         removeEventListener(): void;
 
-        getReadyState(): number;
-
-        getBufferRange(): TimeRanges | null;
-
-        getClientWidth(): number;
-
-        getClientHeight(): number;
+        reset(): void;
 
-        getVideoWidth(): number;
+        setDisableRemotePlayback(value: boolean): void;
 
-        getVideoHeight(): number;
+        setElement(value: HTMLVideoElement | HTMLAudioElement): void;
 
-        getVideoRelativeOffsetTop(): number;
+        setPlaybackRate(value: number, ignoreReadyState?: boolean): void;
 
-        getVideoRelativeOffsetLeft(): number;
+        setSource(source: string): void;
 
-        getTextTracks(): TextTrackList[];
+        setStallState(type: MediaType, state: boolean): void;
 
-        getTextTrack(kind: TextTrackType, label: string | number | undefined, isTTML: boolean, isEmbedded: boolean): TextTrackInfo | null;
+        setTTMLRenderingDiv(div: HTMLDivElement): void;
 
-        addTextTrack(kind: TextTrackType, label: string | number | undefined, isTTML: boolean, isEmbedded: boolean): TextTrackInfo;
+        setVttRenderingDiv(div: HTMLDivElement): void;
 
-        appendChild(childElement: any): void;
+        setcurrentTime(currentTime: number, stickToBuffered: boolean): void;
 
-        removeChild(childElement: any): void;
+        stallStream(type: MediaType, isStalled: boolean): void;
 
         waitForReadyState(targetReadyState: number, callback: () => any): void;
 
@@ -2965,19 +3985,29 @@ declare namespace dashjs {
      **/
 
     export interface FetchLoader {
-        load(httpRequest: HTTPRequest): void;
-
-        abort(request: HTTPRequest): void;
+        abort(): void;
 
         calculateDownloadedTime(downloadedData: any, bytesReceived: any): number | null;
 
+        load(httpRequest: HTTPRequest, httpResponse: object): void;
+
+        reset(): void;
+
         setup(cfg: object): void;
     }
 
     export interface HTTPLoader {
-        load(config: object): void;
+        cfg: object;
 
         abort(): void;
+
+        load(config: object): void;
+
+        reset(): void;
+
+        resetInitialSettings(): void;
+
+        setConfig(config: object): void;
     }
 
     export interface SchemeLoaderFactory {
@@ -2985,95 +4015,105 @@ declare namespace dashjs {
 
         registerLoader(scheme: string, loader: any): void;
 
-        unregisterLoader(scheme: string): void;
+        reset(): void;
 
         unregisterAllLoader(): void;
 
-        reset(): void;
+        unregisterLoader(scheme: string): void;
     }
 
     export interface URLLoader {
+        abort(): void;
+
         load(config: object): any;
 
-        abort(): void;
+        reset(): void;
+
+        resetInitialSettings(): void;
     }
 
     export interface XHRLoader {
+        abort(request: HTTPRequest): void;
+
+        getXhr(httpRequest: CommonMediaRequest, httpResponse: CommonMediaResponse): boolean;
+
         load(httpRequest: HTTPRequest): HTTPRequest;
 
-        abort(request: HTTPRequest): void;
+        reset(): void;
+
+        resetInitialSettings(): void;
     }
 
-    /**
-     * Streaming - Protection - Controllers
-     **/
+    /**
+     * Streaming - Protection - Controllers
+     **/
+
+    interface ProtectionController {
+        areKeyIdsExpired(normalizedKeyIds: Array<string | number>): boolean;
+
+        areKeyIdsUsable(normalizedKeyIds: Array<string | number>): boolean;
+
+        clearMediaInfoArray(): void;
+
+        closeKeySession(sessionToken: SessionToken): void;
+
+        createKeySession(keySystemInfo: KeySystemInfo): void;
 
-    interface ProtectionController {
-        initializeForMedia(mediaInfo: MediaInfo): void;
+        getKeySystems(): any[];
 
-        clearMediaInfoArray(): void;
+        getSupportedKeySystemMetadataFromContentProtection(cps: object[]): object[];
 
         handleKeySystemFromManifest(): void;
 
-        createKeySession(keySystemInfo: KeySystemInfo): void;
+        initializeForMedia(mediaInfo: MediaInfo): void;
 
         loadKeySession(keySystemInfo: KeySystemInfo): void;
 
         removeKeySession(sessionToken: SessionToken): void;
 
-        closeKeySession(sessionToken: SessionToken): void;
+        reset(): void;
 
-        setServerCertificate(serverCertificate: ArrayBuffer): void;
+        setKeySystems(keySystems: KeySystem[]): void;
 
         setMediaElement(element: HTMLMediaElement): void;
 
-        setSessionType(value: string): void;
-
-        setRobustnessLevel(level: string): void;
-
         setProtectionData(data: object): void;
 
-        getSupportedKeySystemMetadataFromContentProtection(cps: object[]): object[];
-
-        getKeySystems(): any[];
-
-        setKeySystems(keySystems: KeySystem[]): void;
+        setRobustnessLevel(level: string): void;
 
-        setLicenseRequestFilters(filters: any[]): void;
+        setServerCertificate(serverCertificate: ArrayBuffer): void;
 
-        setLicenseResponseFilters(filters: any[]): void;
+        setSessionType(value: string): void;
 
         stop(): void;
 
-        reset(): void;
-
-        isKeyIdUsable(): boolean;
+        updateKeyStatusesMap(e: object): void;
     }
 
     export interface ProtectionKeyController {
-        initialize(): void;
-
-        setProtectionData(protectionDataSet: ProtectionDataSet): ProtectionData;
-
-        isClearKey(keySystem: KeySystem): boolean;
-
-        initDataEquals(initData1: ArrayBuffer, initData2: ArrayBuffer): boolean;
+        getKeySystemBySystemString(systemString: string): KeySystem | null;
 
         getKeySystems(): KeySystem[];
 
-        setKeySystems(newKeySystems: KeySystem[]): void;
-
-        getKeySystemBySystemString(systemString: string): KeySystem | null;
+        getLicenseServerModelInstance(keySystem: KeySystem, protData: ProtectionData, messageType: string): any | null;
 
-        getSupportedKeySystemMetadataFromContentProtection(cps: object[], protDataSet: ProtectionDataSet, sessionType: string): object[]; //it says protDataSet but param is marked as protData
+        getSupportedKeySystemMetadataFromContentProtection(cps: object[], protDataSet: ProtectionDataSet, sessionType: string): object[];
 
         getSupportedKeySystemsFromSegmentPssh(initData: ArrayBuffer, protDataSet: ProtectionDataSet, sessionType: string): object[];
 
-        getLicenseServerModelInstance(keySystem: KeySystem, protData: ProtectionData, messageType: string): any | null; // LicenseServer instead of any
+        initDataEquals(initData1: ArrayBuffer, initData2: ArrayBuffer): boolean;
+
+        initialize(): void;
+
+        isClearKey(keySystem: KeySystem): boolean;
 
         processClearKeyLicenseRequest(clearKeySystem: KeySystem, ProtectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet | null;
 
         setConfig(config: object): void;
+
+        setKeySystems(newKeySystems: KeySystem[]): void;
+
+        setProtectionData(protectionDataSet: ProtectionDataSet): ProtectionData;
     }
 
     /**
@@ -3081,39 +4121,39 @@ declare namespace dashjs {
      **/
 
     export interface KeySystem {
+        schemeIdURI: string;
         systemString: string;
         uuid: string;
-        schemeIdURI: string;
 
-        getInitData(cp: object, cencContentProtection: object | null): ArrayBuffer | null;
+        getCDMData(cdmData: string | null): ArrayBuffer | null;
 
-        getRequestHeadersFromMessage(message: ArrayBuffer): object | null;
+        getInitData(cp: object, cencContentProtection: object | null): ArrayBuffer | null;
 
         getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
         getLicenseServerURLFromInitData(initData: ArrayBuffer): string | null;
 
-        getCDMData(cdmData: string | null): ArrayBuffer | null;
+        getRequestHeadersFromMessage(message: ArrayBuffer): object | null;
 
         getSessionId(): string | null;
     }
 
     export interface KeySystemClearKey {
         uuid: string;
-        systemString: string;
         schemeIdURI: string;
+        systemString: string;
 
-        getInitData(cp: object, cencContentProtection: object | null): ArrayBuffer | null;
+        getCDMData(): null;
 
-        getRequestHeadersFromMessage(): object;
+        getClearKeysFromProtectionData(protectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet;
+
+        getInitData(cp: object, cencContentProtection: object | null): ArrayBuffer | null;
 
         getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
         getLicenseServerURLFromInitData(): null;
 
-        getCDMData(): null;
-
-        getClearKeysFromProtectionData(protectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet;
+        getRequestHeadersFromMessage(): object;
     }
 
     export interface KeySystemPlayReady {
@@ -3121,15 +4161,15 @@ declare namespace dashjs {
         schemeIdURI: string;
         systemString: string;
 
-        getInitData(cpData: object): ArrayBuffer;
+        getCDMData(cdmData: string | null): ArrayBuffer | null;
 
-        getRequestHeadersFromMessage(message: ArrayBuffer): object;
+        getInitData(cpData: object): ArrayBuffer;
 
         getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
         getLicenseServerURLFromInitData(initData: ArrayBuffer): string | null;
 
-        getCDMData(cdmData: string | null): ArrayBuffer | null;
+        getRequestHeadersFromMessage(message: ArrayBuffer): object;
 
         setPlayReadyMessageFormat(format: string): void;
     }
@@ -3139,17 +4179,17 @@ declare namespace dashjs {
         systemString: string;
         schemeIdURI: string;
 
-        getInitData(cp: object): ArrayBuffer | null;
+        getCDMData(): null;
 
-        getRequestHeadersFromMessage(): null;
+        getClearKeysFromProtectionData(protectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet;
+
+        getInitData(cp: object): ArrayBuffer | null;
 
         getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
         getLicenseServerURLFromInitData(): null;
 
-        getCDMData(): null;
-
-        getClearKeysFromProtectionData(protectionData: ProtectionData, message: ArrayBuffer): ClearKeyKeySet;
+        getRequestHeadersFromMessage(): null;
     }
 
     export interface KeySystemWidevine {
@@ -3157,15 +4197,15 @@ declare namespace dashjs {
         schemeIdURI: string;
         systemString: string;
 
-        getInitData(cp: object): ArrayBuffer | null;
+        getCDMData(): null;
 
-        getRequestHeadersFromMessage(): null;
+        getInitData(cp: object): ArrayBuffer | null;
 
         getLicenseRequestFromMessage(message: ArrayBuffer): Uint8Array | null;
 
         getLicenseServerURLFromInitData(): null;
 
-        getCDMData(): null;
+        getRequestHeadersFromMessage(): null;
     }
 
     /**
@@ -3173,175 +4213,150 @@ declare namespace dashjs {
      **/
 
     interface ProtectionErrors {
-        MEDIA_KEYERR_CODE: 100;
-        MEDIA_KEYERR_UNKNOWN_CODE: 101;
+        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_SERVICE_CODE: 103;
-        MEDIA_KEYERR_OUTPUT_CODE: 104;
-        MEDIA_KEYERR_HARDWARECHANGE_CODE: 105;
+        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;
-        SERVER_CERTIFICATE_UPDATED_ERROR_CODE: 109;
-        KEY_STATUS_CHANGED_EXPIRED_ERROR_CODE: 110;
         MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_CODE: 111;
-        KEY_SYSTEM_ACCESS_DENIED_ERROR_CODE: 112;
-        KEY_SESSION_CREATED_ERROR_CODE: 113;
-        MEDIA_KEY_MESSAGE_LICENSER_ERROR_CODE: 114;
+        SERVER_CERTIFICATE_UPDATED_ERROR_CODE: 109;
 
-        MEDIA_KEYERR_UNKNOWN_MESSAGE: 'An unspecified error occurred. This value is used for errors that don\'t match any of the other codes.';
+        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_SERVICE_MESSAGE: 'The message passed into update indicated an error from the license service.';
-        MEDIA_KEYERR_OUTPUT_MESSAGE: 'There is no available output device with the required characteristics for the content protection system.';
-        MEDIA_KEYERR_HARDWARECHANGE_MESSAGE: 'A hardware configuration change caused a content protection error.';
         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';
-        SERVER_CERTIFICATE_UPDATED_ERROR_MESSAGE: 'Error updating server certificate -- ';
-        KEY_STATUS_CHANGED_EXPIRED_ERROR_MESSAGE: 'DRM: KeyStatusChange error! -- License has expired';
         MEDIA_KEY_MESSAGE_NO_LICENSE_SERVER_URL_ERROR_MESSAGE: 'DRM: No license server URL specified!';
-        KEY_SYSTEM_ACCESS_DENIED_ERROR_MESSAGE: 'DRM: KeySystem Access Denied! -- ';
-        KEY_SESSION_CREATED_ERROR_MESSAGE: 'DRM: unable to create session! --';
-        MEDIA_KEY_MESSAGE_LICENSER_ERROR_MESSAGE: 'DRM: licenser error! --';
+        SERVER_CERTIFICATE_UPDATED_ERROR_MESSAGE: 'Error updating server certificate -- ';
     }
 
     /**
-     * Streaming - Protection - Events
+     * Streaming - Protection - Models
      **/
 
-    export interface ProtectionEvents {
-        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_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';
-        KEY_SESSION_UPDATED: 'public_keySessionUpdated';
-    }
+    export interface DefaultProtectionModel {
+        closeKeySession(sessionToken: SessionToken): void;
 
-    /**
-     * Streaming - Protection - Models
-     **/
+        createKeySession(ksInfo: KeySystemInfo): any;
 
-    export interface ProtectionModel_01b {
         getAllInitData(): ArrayBuffer[];
 
-        getSessionTokens(): any[]; // Is this MediaSession[] ?
+        getSessionTokens(): any[];
+
+        loadKeySession(ksInfo: KeySystemInfo): void;
+
+        removeKeySession(sessionToken: SessionToken): void;
 
         requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
 
-        selectKeySystem(keySystemAccess: any): Promise<any>;
+        reset(): void;
+
+        selectKeySystem(keySystemAccess: KeySystemAccess): Promise<any>;
 
         setMediaElement(mediaElement: HTMLMediaElement): void;
 
-        createKeySession(ksInfo: KeySystemInfo): any;
+        setServerCertificate(serverCertificate: ArrayBuffer): void;
+
+        stop(): void;
 
         updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
+    }
 
+    export interface ProtectionModel_01b {
         closeKeySession(sessionToken: SessionToken): void;
 
-        setServerCertificate(): void; // Not supproted
-
-        loadKeySession(): void; // Not supproted
-
-        removeKeySession(): void; // Not supproted
+        createKeySession(ksInfo: KeySystemInfo): any;
 
-        stop(): void;
+        getAllInitData(): ArrayBuffer[];
 
-        reset(): void;
-    }
+        getSessionTokens(): any[];
 
-    export interface ProtectionModel_3Fe2014 {
-        getAllInitData(): ArrayBuffer[];
+        loadKeySession(): void;
 
-        getSessionTokens(): any[]; // Is this MediaSession[] ?
+        removeKeySession(): void;
 
         requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
 
+        reset(): void;
+
         selectKeySystem(keySystemAccess: any): Promise<any>;
 
         setMediaElement(mediaElement: HTMLMediaElement): void;
 
-        createKeySession(ksInfo: KeySystemInfo): any;
+        setServerCertificate(): void;
+
+        stop(): void;
 
         updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
+    }
 
+    export interface ProtectionModel_3Fe2014 {
         closeKeySession(sessionToken: SessionToken): void;
 
-        setServerCertificate(): void; // Not supproted
-
-        loadKeySession(): void; // Not supproted
-
-        removeKeySession(): void; // Not supproted
+        createKeySession(ksInfo: KeySystemInfo): any;
 
-        stop(): void;
+        getAllInitData(): ArrayBuffer[];
 
-        reset(): void;
-    }
+        getSessionTokens(): any[];
 
-    export interface DefaultProtectionModel {
-        getAllInitData(): ArrayBuffer[];
+        loadKeySession(): void;
 
-        getSessionTokens(): any[]; // Is this MediaSession[] ?
+        removeKeySession(): void;
 
         requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
 
-        selectKeySystem(keySystemAccess: KeySystemAccess): Promise<any>;
+        reset(): void;
+
+        selectKeySystem(keySystemAccess: any): Promise<any>;
 
         setMediaElement(mediaElement: HTMLMediaElement): void;
 
-        createKeySession(ksInfo: KeySystemInfo): any;
+        setServerCertificate(): void;
+
+        stop(): void;
 
         updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
+    }
 
+    export interface ProtectionModel {
         closeKeySession(sessionToken: SessionToken): void;
 
-        setServerCertificate(serverCertificate: ArrayBuffer): void;
+        createKeySession(initData: ArrayBuffer, protData: ProtectionData, sessionType: string): void;
 
-        loadKeySession(ksInfo: KeySystemInfo): void;
+        getAllInitData(): ArrayBuffer[];
+
+        loadKeySession(sessionId: string, initData: ArrayBuffer): void;
 
         removeKeySession(sessionToken: SessionToken): void;
 
-        stop(): void;
+        requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
 
         reset(): void;
-    }
-
-    export interface ProtectionModel {
-        getAllInitData(): ArrayBuffer[];
-
-        requestKeySystemAccess(ksConfigurations: object[]): Promise<any>;
 
         selectKeySystem(keySystemAccess: KeySystemAccess): Promise<any>;
 
         setMediaElement(mediaElement: HTMLMediaElement): void;
 
-        createKeySession(initData: ArrayBuffer, protData: ProtectionData, sessionType: string): void;
-
-        updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
-
-        closeKeySession(sessionToken: SessionToken): void;
-
         setServerCertificate(serverCertificate: ArrayBuffer): void;
 
-        loadKeySession(sessionId: string, initData: ArrayBuffer): void;
-
-        removeKeySession(sessionToken: SessionToken): void;
-
         stop(): void;
 
-        reset(): void;
+        updateKeySession(sessionToken: SessionToken, message: ArrayBuffer): void;
     }
 
     /**
@@ -3349,63 +4364,63 @@ declare namespace dashjs {
      **/
 
     export interface ClearKey {
-        getServerURLFromMessage(url: string): string;
+        getErrorResponse(serverResponse: object): string;
 
         getHTTPMethod(): 'POST';
 
-        getResponseType(): 'json';
-
         getLicenseMessage(serverResponse: object): ClearKeyKeySet;
 
-        getErrorResponse(serverResponse: object): string;
+        getResponseType(): 'json';
+
+        getServerURLFromMessage(url: string): string;
     }
 
     export interface DRMToday {
-        getServerURLFromMessage(url: string): string;
+        getErrorResponse(serverResponse: object): string;
 
         getHTTPMethod(): 'POST';
 
-        getResponseType(keySystemStr: string): string;
-
         getLicenseMessage(serverResponse: object, keySystemStr: string): any;
 
-        getErrorResponse(serverResponse: object): string;
+        getResponseType(keySystemStr: string): string;
+
+        getServerURLFromMessage(url: string): string;
     }
 
     export interface LicenseServer {
-        getServerURLFromMessage(url: string, message: ArrayBuffer, messageType: string): string;
+        getErrorResponse(serverResponse: object): string;
 
         getHTTPMethod(messageType: string): string;
 
-        getResponseType(keySystemStr: string, messageType: string): string;
-
         getLicenseMessage(serverResponse: object, keySystemStr: string): ArrayBuffer | null;
 
-        getErrorResponse(serverResponse: object): string;
+        getResponseType(keySystemStr: string, messageType: string): string;
+
+        getServerURLFromMessage(url: string, message: ArrayBuffer, messageType: string): string;
     }
 
     export interface PlayReady {
-        getServerURLFromMessage(url: string): string;
+        getErrorResponse(serverResponse: object): string;
 
         getHTTPMethod(): 'POST';
 
-        getResponseType(): 'arraybuffer';
-
         getLicenseMessage(serverResponse: object): any;
 
-        getErrorResponse(serverResponse: object): string;
+        getResponseType(): 'arraybuffer';
+
+        getServerURLFromMessage(url: string): string;
     }
 
     export interface Widevine {
-        getServerURLFromMessage(url: string): string;
+        getErrorResponse(serverResponse: object): string;
 
         getHTTPMethod(): 'POST';
 
-        getResponseType(): 'arraybuffer';
-
         getLicenseMessage(serverResponse: object): object;
 
-        getErrorResponse(serverResponse: object): string;
+        getResponseType(): 'arraybuffer';
+
+        getServerURLFromMessage(url: string): string;
     }
 
     /**
@@ -3417,6 +4432,15 @@ declare namespace dashjs {
         type: string;
     }
 
+    export class KeyMessage {
+        constructor(sessionToken: SessionToken, message: ArrayBuffer, defaultURL: string, messageType?: string);
+
+        defaultURL: string;
+        message: ArrayBuffer;
+        messageType: string;
+        sessionToken: SessionToken;
+    }
+
     export class KeyPair {
         constructor(keyId: string, key: string)
 
@@ -3429,16 +4453,24 @@ declare namespace dashjs {
 
         keySystem: KeySystem;
         ksConfiguration: KeySystemConfiguration;
+        nativeMediaKeySystemAccessObject: object | null;
+        selectedSystemString: string | null;
     }
 
     export class KeySystemConfiguration {
         constructor(audioCapabilities: MediaCapability[], videoCapabilities: MediaCapability[], distinctiveIdentifier: string, persistentState: string, sessionTypes: string[])
 
         audioCapabilities: MediaCapability[];
-        videoCapabilities: MediaCapability[];
         distinctiveIdentifier: string;
         persistentState: string;
         sessionTypes: string[];
+        videoCapabilities: MediaCapability[];
+    }
+
+    export class KeySystemMetadata {
+        constructor(config: object);
+
+        config: object;
     }
 
     export class LicenseRequest {
@@ -3446,30 +4478,30 @@ declare namespace dashjs {
             [key: string]: string
         }, withCredentials: boolean, messageType: string, sessionId: string, data: ArrayBuffer)
 
-        url: string;
-        method: string;
-        responseType: string;
+        data: ArrayBuffer;
         headers: { [key: string]: string };
-        withCredentials: boolean;
         messageType: string;
+        method: string;
+        responseType: string;
         sessionId: string;
-        data: ArrayBuffer;
+        url: string;
+        withCredentials: boolean;
     }
 
     export class LicenseRequestComplete {
         constructor(message: Uint8Array, sessionToken: SessionToken, messageType: string)
 
         message: Uint8Array;
-        sessionToken: SessionToken;
         messageType: string;
+        sessionToken: SessionToken;
     }
 
     export class LicenseResponse {
         constructor(url: string, headers: object, data: ArrayBuffer)
 
-        url: string;
-        headers: object;
         data: ArrayBuffer;
+        headers: object;
+        url: string;
     }
 
     export class MediaCapability {
@@ -3542,12 +4574,12 @@ declare namespace dashjs {
         session: MediaKeySession;
         initData: any;
 
-        getSessionId(): string;
-
         getExpirationTime(): number;
 
         getKeyStatuses(): MediaKeyStatusMap;
 
+        getSessionId(): string;
+
         getSessionType(): string;
     }
 
@@ -3555,6 +4587,27 @@ declare namespace dashjs {
      * 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';
+    }
+
     export interface CommonEncryption {
         // Does not export anything
     }
@@ -3573,44 +4626,50 @@ declare namespace dashjs {
      */
 
     export interface LearningAbrController {
-        getNextoQuality(mediaInfo: MediaInfo, throughput: number, latency: number, bufferSize: number, playbackRate: number, currentQualityIndex: number, dynamicWeightSelector: object): any | null;
+        getNextQuality(mediaInfo: MediaInfo, throughput: number, latency: number, bufferSize: number, playbackRate: number, currentQualityIndex: number, dynamicWeightSelector: object): any | null;
 
         reset(): void;
     }
 
     export interface LoLpQoEEvaluator {
-        setupPerSegmentQoe(sDuration: number, maxBrKbps: number, minBrKbs: number): void;
-
-        logSegmentMetrics(segmentBitrate: number, segmentRebufferTime: number, currentLatency: number, currentPlaybackSpeed: number): void;
+        calculateSingleUseQoe(segmentBitrate: number, segmentRebufferTime: number, currentLatency: number, currentPlaybackSpeed: number): number;
 
         getPerSegmentQoe(): QoeInfo;
 
-        calculateSingleUseQoe(segmentBitrate: number, segmentRebufferTime: number, currentLatency: number, currentPlaybackSpeed: number): number;
+        logSegmentMetrics(segmentBitrate: number, segmentRebufferTime: number, currentLatency: number, currentPlaybackSpeed: number): void;
 
         reset(): void;
+
+        setupPerSegmentQoe(sDuration: number, maxBrKbps: number, minBrKbs: number): void;
     }
 
     export interface LoLpRule {
-        getMaxIndex(rulesContext: RulesContext): SwitchRequest;
+        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
         reset(): void;
     }
 
     export interface LoLpWeightSelector {
+        findWeightVector(neurons: any[], currentLatency: number, currentBuffer: number, currentRebuffer: number, currentThroughput: number, playbackRate: number): number | null;
+
         getMinBuffer(): number;
 
-        getSegmentDuration(): number;
+        getNextBuffer(currentBuffer: number, downloadTime: number): number;
 
         getNextBufferWithBitrate(bitrateToDownload: number, currentBuffer: number, currentThroughput: number): number;
 
-        getNextBuffer(currentBuffer: number, downloadTime: number): number;
-
-        findWeightVector(neurons: any[], currentLatency: number, currentBuffer: number, currentRebuffer: number, currentThroughput: number, playbackRate: number): number | null;
+        getSegmentDuration(): number;
     }
 
     export class QoeInfo {
-        type: string | null;
+        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,
@@ -3618,13 +4677,6 @@ declare namespace dashjs {
             latencyPenalty: number | null,
             playbackSpeedPenalty: number | null
         };
-        bitrateWSum: number;
-        bitrateSwitchSum: number;
-        rebufferWSum: number;
-        latencyWSum: number;
-        playbackSpeedWSum: number;
-        totalQoe: number;
-
     }
 
     /**
@@ -3638,47 +4690,55 @@ declare namespace dashjs {
     }
 
     export interface ABRRulesCollection {
-        initialize(): void;
+        clearDataForStream(streamId: string | number): void;
 
-        reset(): void;
+        getAbandonFragmentRules(): object;
 
-        getMaxQuality(rulesContext: RulesContext): number;
+        getBestPossibleSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
-        getMinSwitchRequest(srArray: any[]): SwitchRequest;
+        getBolaState(mediaType: MediaType): string;
 
-        shouldAbandonFragment(rulesContext: RulesContext, streamId: string): SwitchRequest;
+        getMinSwitchRequest(srArray: any[]): SwitchRequest;
 
         getQualitySwitchRules(): any[];
+
+        initialize(): void;
+
+        reset(): void;
+
+        setBolaState(mediaType: MediaType, value: string): void;
+
+        shouldAbandonFragment(rulesContext: RulesContext, streamId: string): SwitchRequest;
     }
 
     export interface BolaRule {
-        getMaxIndex(rulesContext: RulesContext): SwitchRequest;
+        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
         reset(): void;
     }
 
     export interface DroppedFramesRule {
-        getMaxIndex(rulesContext: RulesContext): SwitchRequest;
+        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
     }
 
     export interface InsufficientBufferRule {
-        getMaxIndex(rulesContext: RulesContext): SwitchRequest;
+        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
         reset(): void;
     }
 
     export interface L2ARule {
-        getMaxIndex(rulesContext: RulesContext): SwitchRequest;
+        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
         reset(): void;
     }
 
     export interface SwitchHistoryRule {
-        getMaxIndex(rulesContext: RulesContext): SwitchRequest;
+        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
     }
 
     export interface ThroughputRule {
-        getMaxIndex(rulesContext: RulesContext): SwitchRequest;
+        getSwitchRequest(rulesContext: RulesContext): SwitchRequest;
 
         reset(): void;
     }
@@ -3688,50 +4748,53 @@ declare namespace dashjs {
      **/
 
     export interface DroppedFramesHistory {
-        push(streamId: string, index: number, playbackQuality: number): void;
+        clearDataForStream(streamId: string): void;
 
         getFrameHistory(streamId: string): object;
 
-        clearDataForStream(streamId: string): void;
+        push(streamId: string, index: number, playbackQuality: number): void;
 
         reset(): void;
     }
 
     export interface RulesContext {
-        getMediaType(): string;
+        getAbrController(): AbrController;
 
-        getMediaInfo(): MediaInfo;
+        getCurrentRequest(): SwitchRequest;
 
         getDroppedFramesHistory(): DroppedFramesHistory;
 
-        getCurrentRequest(): SwitchRequest;
+        getMediaInfo(): MediaInfo;
 
-        getSwitchHistory(): SwitchRequestHistory; //pot. just Switch History
+        getMediaType(): string;
 
-        getStreamInfo(): StreamInfo;
+        getRepresentation(): Representation;
 
         getScheduleController(): ScheduleController;
 
-        getThroughputController(): ThroughputController;
+        getStreamInfo(): StreamInfo;
 
-        getAbrController(): AbrController;
+        getSwitchHistory(): SwitchRequestHistory;
 
-        getVoRepresentation(): Representation;
+        getThroughputController(): ThroughputController;
 
         getVideoModel(): VideoModel;
     }
 
     export interface SwitchRequest {
-        quality: number | undefined;
-        reason: string | null;
         priority: number | null;
+        reason: string | null;
+        representation: Representation;
+        rule: any
     }
 
     export interface SwitchRequestHistory {
-        push(switchRequest: SwitchRequest): void;
+        clearForStream(streamId: string | number): object;
 
         getSwitchRequests(): SwitchRequest[];
 
+        push(switchRequest: SwitchRequest): void;
+
         reset(): void;
     }
 
@@ -3744,14 +4807,14 @@ declare namespace dashjs {
     export type FontDownloadStatus = 'unloaded' | 'loaded' | 'error';
 
     export interface FontInfo {
+        fontFace: FontFace;
         fontFamily: string;
-        url: string;
-        mimeType: string;
-        trackId: number;
-        streamId: string;
         isEssential: boolean;
+        mimeType: string;
         status: FontDownloadStatus;
-        fontFace: FontFace;
+        streamId: string;
+        trackId: number;
+        url: string;
     }
 
     export interface DVBFonts {
@@ -3771,139 +4834,149 @@ declare namespace dashjs {
     }
 
     export interface NotFragmentTextBufferController {
-        initialize(source: MediaSource): void;
+        appendInitSegmentFromCache(representationId: string): void;
 
-        getStreamId(): string;
+        clearBuffers(): Promise<any>;
 
-        getType(): string;
+        createBufferSink(mediaInfo: MediaInfo): void;
 
-        getBufferControllerType(): string;
+        dischargePreBuffer(): void;
 
-        createBufferSink(mediaInfo: MediaInfo): void;
+        getAllRangesWithSafetyFactor(): [];
 
         getBuffer(): SourceBufferSink;
 
+        getBufferControllerType(): string;
+
         getBufferLevel(): 0;
 
+        getContinuousBufferTimeForTargetTime(): number;
+
+        getIsBufferingCompleted(): boolean;
+
+        getIsPruningInProgress(): false;
+
+        getMediaSource(): MediaSource;
+
         getRangeAt(): null;
 
-        getAllRangesWithSafetyFactor(): [];
+        getStreamId(): string;
 
-        getContinuousBufferTimeForTargetTime(): number;
+        getType(): string;
 
-        setMediaSource(value: MediaSource): void;
+        hasBufferAtTime(): boolean;
 
-        getMediaSource(): MediaSource;
+        initialize(source: MediaSource): void;
 
-        appendInitSegmentFromCache(representationId: string): void;
+        prepareForPlaybackSeek(): Promise<any>;
 
-        getIsBufferingCompleted(): boolean;
+        prepareForReplacementTrackSwitch(): Promise<any>;
 
-        setIsBufferingCompleted(value: boolean): void;
+        pruneAllSafely(): Promise<any>;
 
-        getIsPruningInProgress(): false;
+        pruneBuffer(): void;
 
         reset(): void;
 
-        clearBuffers(): Promise<any>;
+        segmentRequestingCompleted(): void
 
-        prepareForPlaybackSeek(): Promise<any>;
+        setIsBufferingCompleted(value: boolean): void;
 
-        prepareForReplacementTrackSwitch(): Promise<any>;
+        setMediaSource(value: MediaSource): void;
 
-        setSeekTarget(): void; // DECLARED AND EXPORTED BUT NOT IMPLEMENTED
+        setSeekTarget(): void;
 
         updateAppendWindow(): Promise<any>;
 
-        pruneAllSafely(): Promise<any>;
-
         updateBufferTimestampOffset(): Promise<any>;
-
-        segmentRequestingCompleted(): void // DECLARED AND EXPORTED BUT NOT IMPLEMENTED
     }
 
     export interface TextController {
-        deactivateStream(streamInfo: StreamInfo): void;
-
-        initialize(): void;
+        addEmbeddedTrack(streamInfo: StreamInfo, mediaInfo: MediaInfo): void;
 
-        initializeForStream(streamInfo: StreamInfo): void;
+        addMediaInfosToBuffer(streamInfo: StreamInfo, mInfos: MediaInfo[], mimeType: string | null, fragmentModel?: FragmentModel): void;
 
         createTracks(streamInfo: StreamInfo): void;
 
-        getTextSourceBuffer(streamInfo: StreamInfo): TextSourceBuffer;
-
-        getAllTracksAreDisabled(): boolean;
-
-        addEmbeddedTrack(streamInfo: StreamInfo, mediaInfo: MediaInfo): void;
+        deactivateStream(streamInfo: StreamInfo): void;
 
-        setInitialSettings(settings: object): void;
+        enableForcedTextStreaming(enable: boolean): void;
 
         enableText(streamId: string, enable: boolean): void;
 
-        isTextEnabled(): boolean;
-
-        setTextTrack(streamId: string, idx: number): void;
+        getAllTracksAreDisabled(): boolean;
 
         getCurrentTrackIdx(streamId: string): number;
 
-        enableForcedTextStreaming(enable: boolean): void;
+        getTextSourceBuffer(streamInfo: StreamInfo): TextSourceBuffer;
 
-        addMediaInfosToBuffer(streamInfo: StreamInfo, mInfos: MediaInfo[], mimeType: string | null, fragmentModel?: FragmentModel): void;
+        initialize(): void;
+
+        initializeForStream(streamInfo: StreamInfo): void;
+
+        isTextEnabled(): boolean;
 
         reset(): void;
+
+        setTextTrack(streamId: string, idx: number): void;
     }
 
     export interface TextSourceBuffer {
-        initialize(): void;
+        abort(): void;
+
+        addEmbeddedTrack(mediaInfo: MediaInfo): void;
 
         addMediaInfos(type: string, mInfos: MediaInfo[], fModel: FragmentModel): void;
 
-        resetMediaInfos(): void;
+        append(bytes: number[], chunk: DataChunk): void;
+
+        getConfig(): object;
 
         getStreamId(): string;
 
-        append(bytes: number[], chunk: DataChunk): void;
+        initialize(): void;
 
-        abort(): void; // DECLARED AND EXPORTED BUT NOT IMPLEMENTED
+        remove(start?: number, end?: number): void;
 
-        addEmbeddedTrack(mediaInfo: MediaInfo): void;
+        reset(): void;
 
         resetEmbedded(): void;
 
-        getConfig(): object;
+        resetMediaInfos(): void;
 
         setCurrentFragmentedTrackIdx(idx: number): void;
-
-        remove(start?: number, end?: number): void;
-
-        reset(): void;
     }
 
     export interface TextTracks {
-        initialize(): void;
-
-        getStreamId(): string;
+        addCaptions(trackIdx: number, timeOffset: number, captionData: object): void;
 
         addTextTrack(textTrackInfoVO: TextTrackInfo): void;
 
-        addCaptions(trackIdx: number, timeOffset: number, captionData: object): void;
-
         createTracks(): void;
 
+        deleteAllTextTracks(): void;
+
+        deleteCuesFromTrackIdx(trackIdx: number, start: number, end: number): void;
+
+        disableManualTracks(): void;
+
         getCurrentTrackIdx(): number;
 
-        setCurrentTrackIdx(idx: number): void;
+        getCurrentTrackInfo(): TextTrackInfo;
+
+        getStreamId(): string;
+
+        getTrackByIdx(idx: number): object;
 
         getTrackIdxForId(trackId: string): number;
 
-        getCurrentTrackInfo(): TextTrackInfo;
+        initialize(): void;
 
-        setModeForTrackIdx(idx: number, mode: string): void;
+        manualProcessing(time: number): void;
 
-        deleteCuesFromTrackIdx(trackIdx: number, start: number, end: number): void;
+        setCurrentTrackIdx(idx: number): void;
 
-        deleteAllTextTracks(): void;
+        setModeForTrackIdx(idx: number, mode: string): void;
     }
 
     /**
@@ -3911,35 +4984,43 @@ declare namespace dashjs {
      **/
 
     export interface ThumbnailController {
+        getCurrentTrack(): object;
+
+        getCurrentTrackIndex(): number;
+
+        getPossibleVoRepresentations(): Representation[];
+
         getStreamId(): string;
 
         initialize(): void;
 
         provide(time: number, callback: Function): void;
 
-        setTrackByIndex(index: number): void;
-
-        getCurrentTrackIndex(): number;
+        reset(): void;
 
-        getBitrateList(): BitrateInfo;
+        setTrackById(id: number): void;
 
-        reset(): void;
+        setTrackByIndex(index: number): void;
     }
 
     export interface ThumbnailTracks {
-        getTracks(): any[];
-
         addTracks(): void;
 
-        reset(): void;
-
-        setTrackByIndex(index: number): void;
-
         getCurrentTrack(): any | null;
 
         getCurrentTrackIndex(): number;
 
+        getRepresentations(): Representation[];
+
         getThumbnailRequestForTime(time: number): Request;
+
+        getTracks(): any[];
+
+        reset(): void;
+
+        setTrackById(id: number): void;
+
+        setTrackByIndex(index: number): void;
     }
 
     /**
@@ -3950,6 +5031,14 @@ declare namespace dashjs {
         select(baseURLs: BaseURL[]): BaseURL;
     }
 
+    export interface ContentSteeringSelector {
+        setConfig(config: object): void;
+
+        selectBaseUrlIndex(data: any): number;
+
+        reset(): void;
+    }
+
     export interface DVBSelector {
         select(baseURLs: BaseURL[]): BaseURL[];
     }
@@ -3961,29 +5050,15 @@ declare namespace dashjs {
     export interface BaseURLSelector {
         chooseSelector(isDVB: boolean): void;
 
-        select(data: ArrayBuffer): void;
-
         reset(): void;
 
-        setConfig(config: object): void;
-    }
-
-    export interface LocationSelector {
-        selectBaseUrlIndex(data: any): number;
-
-        setConfig(config: object): void;
-    }
-
-    export interface LocationSelector {
-        select(mpdLocations: MpdLocation[]): MpdLocation | null;
-
-        reset(): void;
+        select(data: ArrayBuffer): void;
 
         setConfig(config: object): void;
     }
 
     export interface BoxParser {
-        parse(data: ArrayBuffer): IsoFile | null;
+        findInitRange(data: ArrayBuffer): Range;
 
         findLastTopIsoBoxCompleted(types: string[], buffer: ArrayBuffer | Uint8Array, offset: number): IsoBoxSearchInfo;
 
@@ -3991,37 +5066,43 @@ declare namespace dashjs {
 
         getSamplesInfo(ab: ArrayBuffer): object;
 
-        findInitRange(data: ArrayBuffer): Range;
+        parse(data: ArrayBuffer): IsoFile | null;
 
         parsePayload(types: string[], buffer: ArrayBuffer, offset: number): IsoBoxSearchInfo;
     }
 
     export interface Capabilities {
-        setConfig(config: object): void;
+        areKeyIdsExpired(mediaInfo: MediaInfo): boolean;
 
-        supportsMediaSource(): boolean;
+        areKeyIdsUsable(mediaInfo: MediaInfo): boolean;
 
-        supportsEncryptedMedia(): boolean;
+        codecRootCompatibleWithCodec(codec1: string, codec2: string): boolean;
 
         isCodecSupportedBasedOnTestedConfigurations(basicConfiguration: object, type: string): boolean;
 
+        isProtectionCompatible(previousStreamInfo: StreamInfo, newStreamInfo: StreamInfo): boolean;
+
         runCodecSupportCheck(basicConfiguration: object, type: string): Promise<void>;
 
+        setConfig(config: object): void;
+
         setEncryptedMediaSupported(value: boolean): void;
 
-        supportsEssentialProperty(ep: object): boolean;
+        setProtectionController(data: any): void;
 
-        codecRootCompatibleWithCodec(codec1: string, codec2: string): boolean;
-    }
+        supportsChangeType(): boolean;
 
-    export type CapabilitiesFilter = (representation: Representation) => boolean;
+        supportsEncryptedMedia(): boolean;
 
-    export interface ICapabilitiesFilter {
-        setConfig(config: object): void;
+        supportsEssentialProperty(ep: object): boolean;
 
+        supportsMediaSource(): boolean;
+    }
+
+    export interface CapabilitiesFilter {
         filterUnsupportedFeatures(manifest: object): Promise<any>;
 
-        setCustomCapabilitiesFilters(customFilters: any): any;
+        setConfig(config: object): void;
     }
 
     export interface CustomTimeRanges {
@@ -4032,31 +5113,31 @@ declare namespace dashjs {
 
         clear(): void;
 
-        remove(start: number, end: number): void;
+        end(index: number): number;
 
         mergeRanges(rangeIndex1: number, rangeIndex2: number): boolean;
 
-        start(index: number): number;
+        remove(start: number, end: number): void;
 
-        end(index: number): number;
+        start(index: number): number;
     }
 
     export interface DefaultURLUtils {
-        parseBaseUrl(url: string): string;
+        isHTTPS(url: string): boolean;
 
-        parseOrigin(url: string): string;
+        isHTTPURL(url: string): boolean;
 
-        parseScheme(url: string): string;
+        isPathAbsolute(url: string): boolean;
 
         isRelative(url: string): boolean;
 
-        isPathAbsolute(url: string): boolean;
-
         isSchemeRelative(url: string): boolean;
 
-        isHTTPURL(url: string): boolean;
+        parseBaseUrl(url: string): string;
 
-        isHTTPS(url: string): boolean;
+        parseOrigin(url: string): string;
+
+        parseScheme(url: string): string;
 
         removeHostname(url: string): string;
 
@@ -4066,33 +5147,33 @@ declare namespace dashjs {
     export interface DOMStorage {
         getSavedBitrateSettings(type: string): number;
 
-        setSavedBitrateSettings(type: string, bitrate: number): void;
-
         getSavedMediaSettings(type: string): object;
 
+        setSavedBitrateSettings(type: string, bitrate: number): void;
+
         setSavedMediaSettings(type: string, value: any): void;
     }
 
     export interface EBMLParser {
-        getPos(): number;
-
-        setPos(value: number): void;
-
         consumeTag(tag: object, test: boolean): boolean;
 
         consumeTagAndSize(tag: object, test: boolean): boolean;
 
-        parseTag(tag: object): boolean;
-
-        skipOverElement(tag: object, test: boolean): boolean;
-
         getMatroskaCodedNum(retainMSB: boolean): number;
 
         getMatroskaFloat(size: number): number;
 
         getMatroskaUint(size: number): number;
 
+        getPos(): number;
+
         moreData(): boolean;
+
+        parseTag(tag: object): boolean;
+
+        setPos(value: number): void;
+
+        skipOverElement(tag: object, test: boolean): boolean;
     }
 
     export interface ErrorHandler {
@@ -4100,10 +5181,10 @@ declare namespace dashjs {
     }
 
     export interface InitCache {
-        save(chunk: DataChunk): void;
-
         extract(streamId: string, representationId: string): any | null;
 
+        save(chunk: DataChunk): void;
+
         reset(): void;
     }
 
@@ -4112,23 +5193,41 @@ declare namespace dashjs {
 
         getBoxes(type: string): IsoBox[];
 
+        getLastBox(): IsoBox | null;
+
         setData(value: string): void;
+    }
 
-        getLastBox(): IsoBox | null;
+    export interface LocationSelector { // DOUBLED UP?
+        selectBaseUrlIndex(data: any): number;
+
+        setConfig(config: object): void;
+    }
+
+    export interface LocationSelector {
+        reset(): void;
+
+        select(mpdLocations: MpdLocation[]): MpdLocation | null;
+
+        setConfig(config: object): void;
     }
 
     export interface ObjectUtils {
         areEqual(obj1: object, obj2: object): boolean;
     }
 
-    export interface SupervisorTools {
-        checkParameterType(parameter: any, type: string): void;
-
+    export interface SupervisorTools { // BASE FILE DIFFERENT LAYOUT FROM ALL OTHERS
         checkInteger(parameter: any): void;
 
+        checkIsVideoOrAudioType(type: string): void;
+
+        checkParameterType(parameter: any, type: string): void;
+
         checkRange(parameter: any, min: number, max: number): void;
+    }
 
-        checkIsVideoOrAudioType(type: string): void;
+    export interface TimeUtils {
+        ntpToUTC(ntpTimeStamp: number): number;
     }
 
     export interface TTMLParser {
@@ -4144,30 +5243,36 @@ declare namespace dashjs {
     }
 
     export interface URLUtils {
-        registerUrlRegex(regex: RegExp, utils: object): void;
-
-        parseBaseUrl(url: string): string;
+        isHTTPS(url: string): boolean;
 
-        parseOrigin(url: string): string;
+        isHTTPURL(url: string): boolean;
 
-        parseScheme(url: string): string;
+        isPathAbsolute(url: string): boolean;
 
         isRelative(url: string): boolean;
 
-        isPathAbsolute(url: string): boolean;
-
         isSchemeRelative(url: string): boolean;
 
-        isHTTPURL(url: string): boolean;
+        parseBaseUrl(url: string): string;
 
-        isHTTPS(url: string): boolean;
+        parseOrigin(url: string): string;
+
+        parseScheme(url: string): string;
+
+        registerUrlRegex(regex: RegExp, utils: object): void;
 
         removeHostname(url: string): string;
 
         resolve(url: string, baseUrl: BaseURL): string;
     }
 
+    export interface VttCsutomRenderingParser {
+        parse(data: any): any[];
+    }
+
     export interface VTTParser {
+        getCaptionStyles(arr: Array<any>): object;
+
         parse(data: ArrayBuffer): { start: number, end: number, data: string, styles: any };
     }
 
@@ -4175,63 +5280,62 @@ declare namespace dashjs {
      * Streaming - Vo - Metrics
      **/
 
-    export interface IBufferLevel {
+    export interface BufferLevel {
         level: number;
         t: Date;
     }
 
-    export interface IBufferState {
+    export interface BufferState {
         state: string;
         target: number;
     }
 
-    export interface IDroppedFrames {
+    export interface DroppedFrames {
         droppedFrames: number;
         time: Date;
     }
 
-    export interface IDVRInfo {
+    export interface DVRInfo {
         manifestInfo: IManifestInfo;
         range: Range;
         time: number;
     }
 
     export interface HTTPRequest {
-        tcpid: string | null;
-        type?: string | null;
-        url: string | null;
-        actualurl: string | null;
-        range: any[];
-        trequest: Date | null;
-        tresponse: Date | null;
-        responsecode: number | null;
-        interval: number | null;
-        trace: any[];
-        cmsd: object;
-        _stream: MediaType;
-        _tfinish: Date | null;
+        _fileLoaderType: string;
         _mediaduration: number | null;
         _quality: number | null;
+        _resourceTimingValues: object;
         _responseHeaders: any[] | null;
         _serviceLocation: string | null;
-        _fileLoaderType: string;
-        _resourceTimingValues: object;
+        _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 ManifestUpdate {
-        mediaType: MediaType | null;
-        type: string | null;
-        requestTime: number | null;
-        fetchTime: number | null;
         availabilityStartTime: number | null;
-        presentationStartTime: number;
+        buffered: object | null;
         clientTimeOffset: number;
         currentTime: number | null;
-        buffered: object | null;
+        fetchTime: number | null;
         latency: number;
-        streamInfo: StreamInfo[];
+        mediaType: MediaType | null;
+        presentationStartTime: number;
         representationInfo: ManifestUpdateRepresentationInfo[];
-
+        requestTime: number | null;
+        streamInfo: StreamInfo[];
+        type: string | null;
     }
 
     export interface ManifestUpdateRepresentationInfo {
@@ -4243,27 +5347,34 @@ declare namespace dashjs {
     }
 
     export interface PlayList {
-        start: number | null;
         mstart: number | null;
+        start: number | null;
         starttype: string | null;
         trace: any[];
     }
 
+    export interface RepresentationSwitch {
+        lto: number | null;
+        mt: number | null;
+        t: number | null;
+        to: number | null;
+    }
+
     export interface PlayListTrace {
-        representationid: string | null;
-        subreplevel: number | null;
-        start: number | null;
-        mstart: number | null;
         duration: number | null;
+        mstart: number | null;
         playbackspeed: number | null;
+        representationid: string | null;
+        start: number | null;
         stopreason: string | null;
+        subreplevel: number | null;
     }
 
     export interface RequestSwitch {
-        t: number | null;
+        lto: string | null;
         mt: number | null;
+        t: number | null;
         to: string | null;
-        lto: string | null;
     }
 
     export class RequestsQueue {
@@ -4280,23 +5391,23 @@ declare namespace dashjs {
 
     //eg. duration initialized with null; should be NaN?
     export interface SchedulingInfo {
-        mediaType: MediaType | null;
-        t: number | null;
-        type: string | null;
-        startTime: number | null;
         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 TCPConnection {
-        tcpid: string | null;
         dest: string | null;
-        topen: number | null;
         tclose: number | null;
         tconnect: number | null
+        tcpid: string | null;
+        topen: number | null;
     }
 
     /**
@@ -4304,32 +5415,32 @@ declare namespace dashjs {
      */
 
     export class BitrateInfo {
-        mediaType: MediaType;
         bitrate: number;
-        width: number;
         height: number;
-        scanType: string;
+        mediaType: MediaType;
         qualityIndex: number;
+        scanType: string;
+        width: number;
     }
 
     interface DashJSError {
         code: number | null;
-        message: string | null;
         data: unknown | null;
+        message: string | null;
     }
 
     export interface DataChunk {
-        streamId: string | null;
-        mediaInfo: MediaInfo | null;
-        segmentType: string | null;
-        quality: number;
-        index: number;
         bytes: number[] | null;
-        start: number;
-        end: number;
         duration: number;
-        representationId: string | null;
+        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 FragmentRequest {
@@ -4349,10 +5460,10 @@ declare namespace dashjs {
         mediaType: MediaType;
         quality: number;
         representationId: string;
-        startDate: Date;
         requestEndDate: Date | null;
         responseType: string;
         serviceLocation: string;
+        startDate: Date;
         startTime: number;
         timescale: number;
         type: 'InitializationSegment' | 'MediaSegment' | null;
@@ -4366,6 +5477,23 @@ declare namespace dashjs {
         checkforExistenceOnly: boolean;
     }
 
+    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 IsoBox {
         constructor(boxData: object);
     }
@@ -4373,17 +5501,17 @@ declare namespace dashjs {
     export class IsoBoxSearchInfo {
         constructor(lastCompletedOffset: number, found: boolean, size: number);
 
-        lastCompletedOffset: number;
         found: boolean;
+        lastCompletedOffset: number;
         size: number;
     }
 
     export class MetricsList {
-        BufferLevel: IBufferLevel[];
-        BufferState: IBufferState[];
+        BufferLevel: BufferLevel[];
+        BufferState: BufferState[];
         DVBErrors: DVBErrors[];
-        DVRInfo: IDVRInfo[];
-        DroppedFrames: IDroppedFrames[];
+        DVRInfo: DVRInfo[];
+        DroppedFrames: DroppedFrames[];
         HttpList: any[];
         ManifestUpdate: ManifestUpdate[];
         PlayList: PlayList[];
@@ -4395,59 +5523,59 @@ declare namespace dashjs {
 
     export class MediaInfoSelectionInput {
         newMediaInfo: MediaInfo;
-        previouslySelectedRepresentation: Representation | null;
         newRepresentation: Representation | null
+        previouslySelectedRepresentation: Representation | null;
     }
 
     export class TextRequest extends FragmentRequest {
         constructor(url: string, type: string);
 
-        url: string | null;
-        type: 'InitializationSegment' | 'MediaSegment' | null;
         mediaType: MediaType;
         responseType: string;
+        type: 'InitializationSegment' | 'MediaSegment' | null;
+        url: string | null;
     }
 
     export class TextTrackInfo extends MediaInfo {
         captionData: CaptionData[] | null;
-        label: string | null;
         defaultTrack: boolean;
-        kind: string;
-        isFragmented: boolean;
         isEmbedded: boolean;
+        isFragmented: boolean;
         isTTML: boolean;
+        kind: string;
+        label: string | null;
     }
 
     export interface Thumbnail {
+        height: number;
         url: string;
         width: number;
-        height: number;
         x: number;
         y: number;
     }
 
     export interface ThumbnailTrackInfo {
         bitrate: number;
-        width: number;
         height: number;
-        tilesHor: number;
-        tilesVert: number;
-        widthPerTile: number;
         heightPerTile: number;
-        startNumber: number;
+        id: string;
         segmentDuration: number;
-        timescale: number;
+        startNumber: number;
         templateUrl: string;
-        id: string;
+        tilesHor: number;
+        tilesVert: number;
+        timescale: number;
+        width: number;
+        widthPerTile: number;
     }
 
     export interface URIFragmentData {
-        t: number | null;
-        xywh: any | null;
-        track: any | null;
         id: string | null;
-        s: any | null;
         r: any | null;
+        s: any | null;
+        t: number | null;
+        track: any | null;
+        xywh: any | null;
     }
 
     /**
@@ -4455,24 +5583,26 @@ declare namespace dashjs {
      **/
 
     export interface FragmentLoader {
+        abort(): void;
+
         checkForExistence(request: Request): void;
 
         load(request: Request): void;
 
-        abort(): void;
-
         reset(): void;
+
+        resetInitialSettings(): void;
     }
 
     export interface FragmentSink {
-        append(chunk: DataChunk): void;
-
-        remove(start?: number, end?: number): void;
-
         abort(): void;
 
+        append(chunk: DataChunk): void;
+
         getAllBufferRanges(): any[];
 
+        remove(start?: number, end?: number): void;
+
         reset(): void;
     }
 
@@ -4483,17 +5613,17 @@ declare namespace dashjs {
     }
 
     export interface ManifestUpdater {
-        initialize(): void;
+        getIsUpdating(): boolean;
 
-        setManifest(manifest: object): void;
+        initialize(): void;
 
         refreshManifest(ignorePatch?: boolean): void;
 
-        getIsUpdating(): boolean;
+        reset(): void;
 
         setConfig(config: object): void;
 
-        reset(): void;
+        setManifest(manifest: object): void;
     }
 
     export namespace MediaPlayer {
@@ -4508,259 +5638,169 @@ declare namespace dashjs {
     export function MediaPlayer(): MediaPlayerFactory;
 
     export interface PreBufferSink {
-        getAllBufferRanges(): TimeRanges;
+        abort(): void;
 
         append(chunk: DataChunk): void;
 
-        remove(start: number, end: number): void;
+        discharge(start?: number, end?: number): void;
+
+        getAllBufferRanges(): TimeRanges;
 
-        abort(): void; // DECLARED AND EXPORTED BUT NOT IMPLEMENTED
+        getBuffer(): PreBufferSink;
 
-        discharge(start?: number, end?: number): void;
+        remove(start: number, end: number): void;
 
         reset(): void;
 
-        updateTimestampOffset(): void; // DECLARED AND EXPORTED BUT NOT IMPLEMENTED
+        updateTimestampOffset(): void;
 
         waitForUpdateEnd(callback: Function): void;
-
-        getBuffer(): PreBufferSink;
     }
 
     export interface SourceBufferSink {
-        getType(): string;
+        abort(): Promise<any>;
+
+        append(chunk: DataChunk, request?: Request): Promise<any>;
+
+        changeType(codec: string): Promise<any>;
 
         getAllBufferRanges(): object;
 
         getBuffer(): Buffer;
 
-        append(chunk: DataChunk, request?: Request): Promise<any>;
-
-        remove(range: Range): Promise<any>;
+        getSessionType(): string;
 
-        abort(): Promise<any>;
+        getType(): string;
 
-        reset(): void;
+        getUsable(): boolean;
 
-        updateTimestampOffset(mseTimeOffset: number): void;
+        initializeForFirstUse(streamInfo: StreamInfo, mInfo: MediaInfo, selectedRepresentation: Representation): void;
 
         initializeForStreamSwitch(mInfo: MediaInfo, selectedRepresentation: Representation, oldSourceBufferSink: SourceBufferSink): Promise<any>;
 
-        initializeForFirstUse(streamInfo: StreamInfo, mInfo: MediaInfo, selectedRepresentation: Representation): void;
-
-        updateAppendWindow(sInfo: StreamInfo): void;
+        remove(range: Range): Promise<any>;
 
-        changeType(codec: string): Promise<any>;
+        reset(): void;
 
-        getSessionType(): string;
+        updateAppendWindow(sInfo: StreamInfo): void;
 
-        getUsable(): boolean;
+        updateTimestampOffset(mseTimeOffset: number): void;
     }
 
     export interface Stream {
-        initialize(streamInfo: StreamInfo, protectionController: ProtectionController): void;
-
-        getStreamId(): string;
-
         activate(mediaSource: MediaSource, previousBufferSinks: any[]): void;
 
         deactivate(keepBuffers: boolean): void;
 
-        getIsActive(): boolean;
+        getAdapter(): DashAdapter
 
         getDuration(): number;
 
-        getStartTime(): number;
+        getHasAudioTrack(): boolean;
 
-        getId(): string;
+        getHasFinishedBuffering(): boolean
 
-        getStreamInfo(): StreamInfo | null;
+        getHasVideoTrack(): boolean;
 
-        getHasAudioTrack(): boolean;
+        getId(): string;
 
-        getHasVideoTrack(): boolean;
+        getIsActive(): boolean;
 
-        startPreloading(mediaSource: MediaSource, previousBuffers: any[], representationsFromPreviousPeriod: Representation[]): void;
+        getIsEndedEventSignaled(): boolean
 
-        getThumbnailController(): object;
+        getPreloaded(): boolean
 
-        updateData(updatedStreamInfo: StreamInfo): void;
+        getStartTime(): number;
 
-        reset(): void;
+        getStreamId(): string;
+
+        getStreamInfo(): StreamInfo | null;
 
         getStreamProcessors(): any[];
 
-        setMediaSource(mediaSource: MediaSource): void;
+        getThumbnailController(): object;
+
+        initialize(streamInfo: StreamInfo, protectionController: ProtectionController): void;
 
         isMediaCodecCompatible(newStream: Stream, previousStream: Stream | null): boolean;
 
         isProtectionCompatible(newStream: Stream): boolean
 
-        getPreloaded(): boolean
+        prepareQualityChange(e: object): void
 
-        getIsEndedEventSignaled(): boolean
+        prepareTrackChange(e: object): void
+
+        reset(): void;
 
         setIsEndedEventSignaled(value: boolean): void
 
-        getAdapter(): DashAdapter
+        setMediaSource(mediaSource: MediaSource): void;
 
-        getHasFinishedBuffering(): boolean
+        startPreloading(mediaSource: MediaSource, previousBuffers: any[], representationsFromPreviousPeriod: Representation[]): void;
 
         startScheduleControllers(): void
 
-        prepareTrackChange(e: object): void
-
-        prepareQualityChange(e: object): void
+        updateData(updatedStreamInfo: StreamInfo): void;
     }
 
     export interface StreamProcessor {
-        initialize(mediaSource: MediaSource, hasVideoTrack: boolean, isFragmented: boolean): void;
+        addMediaInfo(newMediaInfo: MediaInfo): void;
 
-        getStreamId(): string;
+        clearMediaInfoArray(): void;
 
-        getType(): string;
+        createBufferSinks(previousBufferSinks: any[]): Promise<any>;
 
-        isUpdating(): boolean;
+        finalisePlayList(time: number, reason: string): void;
 
-        getBufferController(): BufferController;
+        getBuffer(): Buffer;
 
-        getFragmentModel(): FragmentModel;
+        getBufferController(): BufferController;
 
-        getScheduleController(): ScheduleController;
+        getBufferLevel(): number;
 
-        getRepresentationController(): RepresentationController;
+        getFragmentModel(): FragmentModel;
 
-        getVoRepresentation(quality: number): Representation;
+        getMediaInfo(): MediaInfo;
 
-        getBufferLevel(): number;
+        getMediaSource(): MediaSource;
 
-        isBufferingCompleted(): boolean;
+        getRepresentationController(): RepresentationController;
 
-        createBufferSinks(previousBufferSinks: any[]): Promise<any>;
+        getScheduleController(): ScheduleController;
 
-        updateStreamInfo(newStreamInfo: StreamInfo): Promise<any>;
+        getStreamId(): string;
 
         getStreamInfo(): StreamInfo;
 
-        selectMediaInfo(selectionInput: object): Promise<any>;
-
-        clearMediaInfoArray(): void;
-
-        addMediaInfo(newMediaInfo: MediaInfo): void;
+        getType(): string;
 
-        prepareTrackSwitch(previousBufferSinks: any[]): Promise<any>;
+        getVoRepresentation(quality: number): Representation;
 
-        prepareQualityChange(e: object): void;
+        initialize(mediaSource: MediaSource, hasVideoTrack: boolean, isFragmented: boolean): void;
 
-        getMediaInfo(): MediaInfo;
+        isBufferingCompleted(): boolean;
 
-        getMediaSource(): MediaSource;
+        isUpdating(): boolean;
 
-        setMediaSource(mediaSource: MediaSource): void;
+        prepareInnerPeriodPlaybackSeeking(e: object): Promise<any>;
 
-        getBuffer(): Buffer;
+        prepareOuterPeriodPlaybackSeeking(): Promise<unknown>;
 
-        setExplicitBufferingTime(value: number): void;
+        prepareQualityChange(e: object): void;
 
-        finalisePlayList(time: number, reason: string): void;
+        prepareTrackSwitch(previousBufferSinks: any[]): Promise<any>;
 
         probeNextRequest(): Request;
 
-        prepareInnerPeriodPlaybackSeeking(e: object): Promise<any>;
+        reset(errored: boolean, keepBuffers: boolean): void;
 
-        prepareOuterPeriodPlaybackSeeking(): Promise<unknown>;
+        selectMediaInfo(selectionInput: object): Promise<any>;
 
-        reset(errored: boolean, keepBuffers: boolean): void;
-    }
+        setExplicitBufferingTime(value: number): void;
 
-    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';
-        TRACK_SELECTION_MODE_HIGHEST_SELECTION_PRIORITY: 'highestSelectionPriority';
-        CMCD_MODE_QUERY: 'query';
-        CMCD_MODE_HEADER: 'header';
-        INITIALIZE: 'initialize';
-        TEXT_SHOWING: 'showing';
-        TEXT_HIDDEN: 'hidden';
-        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';
-        XML: 'XML';
-        ARRAY_BUFFER: 'ArrayBuffer';
-        DVB_REPORTING_URL: 'dvb:reportingUrl';
-        DVB_PROBABILITY: 'dvb:probability';
-        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'
-        }
+        setMediaSource(mediaSource: MediaSource): void;
 
+        updateStreamInfo(newStreamInfo: StreamInfo): Promise<any>;
     }
 
     export interface XlinkLoader {
@@ -4770,9 +5810,13 @@ declare namespace dashjs {
     }
 
     export interface CaptionData {
-        start: number;
-        end: number;
+        cueID?: string;
         data?: string;
+        embeddedImages?: { [id: string]: string };
+        end: number;
+        images?: string[];
+        isd?: object;
+        start: number;
         styles?: {
             align?: string;
             line?: string;
@@ -4780,10 +5824,6 @@ declare namespace dashjs {
             size?: string;
         };
         type?: string;
-        cueID?: string;
-        isd?: object;
-        images?: string[];
-        embeddedImages?: { [id: string]: string };
     }
 
     export type MetricType = 'ManifestUpdate' | 'RequestsQueue';
@@ -4815,13 +5855,13 @@ declare namespace dashjs {
     }
 
     export interface KeySystemInfo {
+        cdmData?: ArrayBuffer;
+        initData?: ArrayBuffer;
+        keyId?: string,
         ks: KeySystem;
+        protData?: ProtectionData
         sessionId?: string,
         sessionType?: string,
-        keyId?: string,
-        initData?: ArrayBuffer;
-        cdmData?: ArrayBuffer;
-        protData?: ProtectionData
     }
 
     export type RequestFilter = (request: LicenseRequest) => Promise<any>;
diff --git a/samples/abr/LowestBitrateRule.js b/samples/abr/LowestBitrateRule.js
index 64c51c4969..f88019aefd 100644
--- a/samples/abr/LowestBitrateRule.js
+++ b/samples/abr/LowestBitrateRule.js
@@ -37,7 +37,6 @@ function LowestBitrateRuleClass() {
     let factory = dashjs.FactoryMaker;
     let SwitchRequest = factory.getClassFactoryByName('SwitchRequest');
     let MetricsModel = factory.getSingletonFactoryByName('MetricsModel');
-    let StreamController = factory.getSingletonFactoryByName('StreamController');
     let context = this.context;
     let instance;
 
@@ -56,18 +55,18 @@ function LowestBitrateRuleClass() {
         console.log(metrics);
 
         // Get current bitrate
-        let streamController = StreamController(context).getInstance();
-        let abrController = rulesContext.getAbrController();
-        let current = abrController.getQualityFor(mediaType, streamController.getActiveStreamInfo().id);
-
+        const abrController = rulesContext.getAbrController();
+        const representation = rulesContext.getRepresentation();
         // If already in lowest bitrate, don't do anything
-        if (current === 0) {
+        if (abrController.isPlayingAtLowestQuality(representation)) {
             return SwitchRequest(context).create();
         }
 
         // Ask to switch to the lowest bitrate
+        const mediaInfo = rulesContext.getMediaInfo();
+        const newRepresentation = abrController.getOptimalRepresentationForBitrate(mediaInfo, 0, true);
         let switchRequest = SwitchRequest(context).create();
-        switchRequest.quality = 0;
+        switchRequest.representation = newRepresentation;
         switchRequest.reason = 'Always switching to the lowest bitrate';
         switchRequest.priority = SwitchRequest.PRIORITY.STRONG;
         return switchRequest;
diff --git a/samples/abr/custom-abr-rules.html b/samples/abr/custom-abr-rules.html
index 578fe23eab..cb7b6fde06 100644
--- a/samples/abr/custom-abr-rules.html
+++ b/samples/abr/custom-abr-rules.html
@@ -23,32 +23,34 @@
         function init() {
             var video,
                 player,
-                url = "https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd";
+                url = 'https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd';
 
-            video = document.querySelector("video");
+            video = document.querySelector('video');
             player = dashjs.MediaPlayer().create();
 
             /* don't use dash.js default rules */
             player.updateSettings({
-                abr: {
-                    activeRules: {
-                        throughputRule: {
-                            active: false
-                        },
-                        bolaRule: {
-                            active: false
-                        },
-                        insufficientBufferRule: {
-                            active: false
-                        },
-                        switchHistoryRule: {
-                            active: false
-                        },
-                        droppedFramesRule: {
-                            active: false
-                        },
-                        abandonRequestsRule: {
-                            active: false
+                streaming: {
+                    abr: {
+                        rules: {
+                            throughputRule: {
+                                active: false
+                            },
+                            bolaRule: {
+                                active: false
+                            },
+                            insufficientBufferRule: {
+                                active: false
+                            },
+                            switchHistoryRule: {
+                                active: false
+                            },
+                            droppedFramesRule: {
+                                active: false
+                            },
+                            abandonRequestsRule: {
+                                active: false
+                            }
                         }
                     }
                 }
diff --git a/samples/advanced/monitoring.html b/samples/advanced/monitoring.html
index 7ca8f8bc7c..d75e545e19 100644
--- a/samples/advanced/monitoring.html
+++ b/samples/advanced/monitoring.html
@@ -45,8 +45,8 @@
 
                 if (dashMetrics && streamInfo) {
                     const periodIdx = streamInfo.index;
-                    var repSwitch = dashMetrics.getCurrentRepresentationSwitch('video', true);
-                    var bufferLevel = dashMetrics.getCurrentBufferLevel('video', true);
+                    var repSwitch = dashMetrics.getCurrentRepresentationSwitch('video');
+                    var bufferLevel = dashMetrics.getCurrentBufferLevel('video');
                     var bitrate = repSwitch ? Math.round(dashAdapter.getBandwidthForRepresentation(repSwitch.to, periodIdx) / 1000) : NaN;
                     var currentRep = player.getCurrentRepresentationForType('video');
                     var frameRate = currentRep.frameRate;
diff --git a/samples/dash-if-reference-player/app/rules/DownloadRatioRule.js b/samples/dash-if-reference-player/app/rules/DownloadRatioRule.js
deleted file mode 100644
index 8f3c4b48ea..0000000000
--- a/samples/dash-if-reference-player/app/rules/DownloadRatioRule.js
+++ /dev/null
@@ -1,202 +0,0 @@
-/**
- * The copyright in this software is being made available under the BSD License,
- * included below. This software may be subject to other third party and contributor
- * rights, including patent rights, and no such rights are granted under this license.
- *
- * Copyright (c) 2013, Dash Industry Forum.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *  * Redistributions of source code must retain the above copyright notice, this
- *  list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright notice,
- *  this list of conditions and the following disclaimer in the documentation and/or
- *  other materials provided with the distribution.
- *  * Neither the name of Dash Industry Forum nor the names of its
- *  contributors may be used to endorse or promote products derived from this software
- *  without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
- *  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- *  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- *  POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*global dashjs*/
-
-let DownloadRatioRule;
-
-function DownloadRatioRuleClass() {
-
-    let factory = dashjs.FactoryMaker;
-    let SwitchRequest = factory.getClassFactoryByName('SwitchRequest');
-    let DashMetrics = factory.getSingletonFactoryByName('DashMetrics');
-    let DashManifestModel = factory.getSingletonFactoryByName('DashManifestModel');
-    let StreamController = factory.getSingletonFactoryByName('StreamController');
-    let Debug = factory.getSingletonFactoryByName('Debug');
-
-    let context = this.context;
-    let instance,
-        logger;
-
-    function setup() {
-        logger = Debug(context).getInstance().getLogger(instance);
-    }
-
-    function getBytesLength(request) {
-        return request.trace.reduce(function (a, b) {
-            return a + b.b[0];
-        }, 0);
-    }
-
-    function getSwitchRequest(rulesContext) {
-
-        let mediaType = rulesContext.getMediaInfo().type;
-
-        let dashMetrics = DashMetrics(context).getInstance();
-        let dashManifest = DashManifestModel(context).getInstance();
-        let streamController = StreamController(context).getInstance();
-        let abrController = rulesContext.getAbrController();
-        let current = abrController.getQualityFor(mediaType, streamController.getActiveStreamInfo().id);
-
-        let requests = dashMetrics.getHttpRequests(mediaType),
-            lastRequest = null,
-            currentRequest = null,
-            downloadTime,
-            totalTime,
-            calculatedBandwidth,
-            currentBandwidth,
-            latencyInBandwidth,
-            switchUpRatioSafetyFactor,
-            currentRepresentation,
-            count,
-            bandwidths = [],
-            i,
-            q = SwitchRequest.NO_CHANGE,
-            p = SwitchRequest.PRIORITY.DEFAULT,
-            totalBytesLength = 0;
-
-        latencyInBandwidth = true;
-        switchUpRatioSafetyFactor = 1.5;
-        logger.debug("[CustomRules][" + mediaType + "][DownloadRatioRule] Checking download ratio rule... (current = " + current + ")");
-
-        if (!requests) {
-            logger.debug("[CustomRules][" + mediaType + "][DownloadRatioRule] No metrics, bailing.");
-            return SwitchRequest(context).create();
-        }
-
-
-        // Get last valid request
-        i = requests.length - 1;
-        while (i >= 0 && lastRequest === null) {
-            currentRequest = requests[i];
-            if (currentRequest._tfinish && currentRequest.trequest && currentRequest.tresponse && currentRequest.trace && currentRequest.trace.length > 0) {
-                lastRequest = requests[i];
-            }
-            i--;
-        }
-
-        if (lastRequest === null) {
-            logger.debug("[CustomRules][" + mediaType + "][DownloadRatioRule] No valid requests made for this stream yet, bailing.");
-            return SwitchRequest(context).create();
-        }
-
-        if (lastRequest.type !== 'MediaSegment') {
-            logger.debug("[CustomRules][" + mediaType + "][DownloadRatioRule] Last request is not a media segment, bailing.");
-            return SwitchRequest(context).create();
-        }
-
-        totalTime = (lastRequest._tfinish.getTime() - lastRequest.trequest.getTime()) / 1000;
-        downloadTime = (lastRequest._tfinish.getTime() - lastRequest.tresponse.getTime()) / 1000;
-
-        if (totalTime <= 0) {
-            logger.debug("[CustomRules][" + mediaType + "][DownloadRatioRule] Don't know how long the download of the last fragment took, bailing.");
-            return SwitchRequest(context).create();
-        }
-
-        totalBytesLength = getBytesLength(lastRequest);
-
-        logger.debug("[CustomRules][" + mediaType + "][DownloadRatioRule] DL: " + Number(downloadTime.toFixed(3)) + "s, Total: " + Number(totalTime.toFixed(3)) + "s, Length: " + totalBytesLength);
-
-        // Take average bandwidth over 3 requests
-        count = 1;
-        while (i >= 0 && count < 3) {
-            currentRequest = requests[i];
-
-            if (currentRequest.type !== 'MediaSegment' && currentRequest._tfinish && currentRequest.trequest && currentRequest.tresponse && currentRequest.trace && currentRequest.trace.length > 0) {
-
-                let _totalTime = (currentRequest._tfinish.getTime() - currentRequest.trequest.getTime()) / 1000;
-                let _downloadTime = (currentRequest._tfinish.getTime() - currentRequest.tresponse.getTime()) / 1000;
-                logger.debug("[CustomRules][" + mediaType + "][DownloadRatioRule] DL: " + Number(_downloadTime.toFixed(3)) + "s, Total: " + Number(_totalTime.toFixed(3)) + "s, Length: " + getBytesLength(currentRequest));
-
-                totalTime += _totalTime;
-                downloadTime += _downloadTime;
-                totalBytesLength += getBytesLength(currentRequest);
-                count += 1;
-            }
-            i--;
-        }
-
-        // Set length in bits
-        totalBytesLength *= 8;
-
-        calculatedBandwidth = latencyInBandwidth ? (totalBytesLength / totalTime) : (totalBytesLength / downloadTime);
-
-        logger.debug("[CustomRules][" + mediaType + "][DownloadRatioRule] BW = " + Math.round(calculatedBandwidth / 1000) + " kb/s");
-
-        if (isNaN(calculatedBandwidth)) {
-            return SwitchRequest(context).create();
-        }
-
-        count = rulesContext.getMediaInfo().representationCount;
-        currentRepresentation = rulesContext.getVoRepresentation();
-        currentBandwidth = dashManifest.getBandwidth(currentRepresentation);
-        for (i = 0; i < count; i += 1) {
-            bandwidths.push(rulesContext.getMediaInfo().bitrateList[i].bandwidth);
-        }
-        if (calculatedBandwidth <= currentBandwidth) {
-            for (i = current - 1; i > 0; i -= 1) {
-                if (bandwidths[i] <= calculatedBandwidth) {
-                    break;
-                }
-            }
-            q = i;
-            p = SwitchRequest.PRIORITY.WEAK;
-
-            logger.debug("[CustomRules] SwitchRequest: q=" + q + "/" + (count - 1) + " (" + bandwidths[q] + ")"/* + ", p=" + p*/);
-            return SwitchRequest(context).create(q, { name: DownloadRatioRuleClass.__dashjs_factory_name }, p);
-        } else {
-            for (i = count - 1; i > current; i -= 1) {
-                if (calculatedBandwidth > (bandwidths[i] * switchUpRatioSafetyFactor)) {
-                    // logger.debug("[CustomRules][" + mediaType + "][DownloadRatioRule] bw = " + calculatedBandwidth + " results[i] * switchUpRatioSafetyFactor =" + (bandwidths[i] * switchUpRatioSafetyFactor) + " with i=" + i);
-                    break;
-                }
-            }
-
-            q = i;
-            p = SwitchRequest.PRIORITY.STRONG;
-
-            logger.debug("[CustomRules] SwitchRequest: q=" + q + "/" + (count - 1) + " (" + bandwidths[q] + ")"/* + ", p=" + p*/);
-            return SwitchRequest(context).create(q, { name: DownloadRatioRuleClass.__dashjs_factory_name }, p);
-        }
-    }
-
-    instance = {
-        getSwitchRequest
-    };
-
-    setup();
-
-    return instance;
-}
-
-DownloadRatioRuleClass.__dashjs_factory_name = 'DownloadRatioRule';
-DownloadRatioRule = dashjs.FactoryMaker.getClassFactory(DownloadRatioRuleClass);
-
diff --git a/samples/dash-if-reference-player/index.html b/samples/dash-if-reference-player/index.html
index 71a5bd3fad..3985892403 100644
--- a/samples/dash-if-reference-player/index.html
+++ b/samples/dash-if-reference-player/index.html
@@ -32,7 +32,6 @@
     <script src="../../contrib/akamai/controlbar/ControlBar.js"></script>
     <script src="app/src/cast.js"></script>
     <script src="app/main.js"></script>
-    <script src="app/rules/DownloadRatioRule.js"></script>
     <script src="app/rules/ThroughputRule.js"></script>
 
     <!-- Google Cast -->
diff --git a/src/dash/vo/ClientDataReporting.js b/src/dash/vo/ClientDataReporting.js
index 46801fe5f2..62c5f2e0e7 100644
--- a/src/dash/vo/ClientDataReporting.js
+++ b/src/dash/vo/ClientDataReporting.js
@@ -34,11 +34,11 @@
  */
 class ClientDataReporting {
     constructor() {
+        this.adaptationSets = null;
+        this.adaptationSetsArray = [];
         this.cmcdParameters = null;
         this.serviceLocations = null;
         this.serviceLocationsArray = [];
-        this.adaptationSets = null;
-        this.adaptationSetsArray = [];
     }
 }
 
diff --git a/src/dash/vo/Mpd.js b/src/dash/vo/Mpd.js
index 6633c2ff93..c8b0c1e704 100644
--- a/src/dash/vo/Mpd.js
+++ b/src/dash/vo/Mpd.js
@@ -34,15 +34,15 @@
  */
 class Mpd {
     constructor() {
-        this.manifest = null;
-        this.suggestedPresentationDelay = 0;
-        this.availabilityStartTime = null;
         this.availabilityEndTime = Number.POSITIVE_INFINITY;
-        this.timeShiftBufferDepth = Number.POSITIVE_INFINITY;
+        this.availabilityStartTime = null;
+        this.manifest = null;
         this.maxSegmentDuration = Number.POSITIVE_INFINITY;
-        this.publishTime = null;
-        this.minimumUpdatePeriod = NaN;
         this.mediaPresentationDuration = NaN;
+        this.minimumUpdatePeriod = NaN;
+        this.publishTime = null;
+        this.suggestedPresentationDelay = 0;
+        this.timeShiftBufferDepth = Number.POSITIVE_INFINITY;
     }
 }
 
diff --git a/src/dash/vo/Segment.js b/src/dash/vo/Segment.js
index 8129ec978b..f08c24ee41 100644
--- a/src/dash/vo/Segment.js
+++ b/src/dash/vo/Segment.js
@@ -34,29 +34,28 @@
  */
 class Segment {
     constructor() {
-        this.indexRange = null;
+        // Ignore and  discard this segment after
+        this.availabilityEndTime = NaN;
+        // Do not schedule this segment until
+        this.availabilityStartTime = NaN;
+        this.duration = NaN;
         // The index of the segment in the list of segments. We start at 0
         this.index = null;
-        this.mediaRange = null;
+        this.indexRange = null;
         this.media = null;
-        this.duration = NaN;
-        // this is the time that should be inserted into the media url
-        this.replacementTime = null;
-        // this is the number that should be inserted into the media url
-        this.replacementNumber = NaN;
+        this.mediaRange = null;
         // This is supposed to match the time encoded in the media Segment
         this.mediaStartTime = NaN;
         // When the source buffer timeOffset is set to mseTimeOffset this is the
         // time that will match the seekTarget and video.currentTime
         this.presentationStartTime = NaN;
-        // Do not schedule this segment until
-        this.availabilityStartTime = NaN;
-        // Ignore and  discard this segment after
-        this.availabilityEndTime = NaN;
+        // this is the number that should be inserted into the media url
+        this.replacementNumber = NaN;
+        // this is the time that should be inserted into the media url
+        this.replacementTime = null;
+        this.representation = null;
         // For dynamic mpd's, this is the wall clock time that the video
-        // element currentTime should be presentationStartTime
         this.wallStartTime = NaN;
-        this.representation = null;
     }
 }
 
diff --git a/src/streaming/MediaPlayer.js b/src/streaming/MediaPlayer.js
index 35f498f665..98a474ab74 100644
--- a/src/streaming/MediaPlayer.js
+++ b/src/streaming/MediaPlayer.js
@@ -1578,7 +1578,7 @@ function MediaPlayer() {
      * Do NOT use representation.absoluteIndex here as this index was assigned prior to applying any filter function. If you want to select a specific representation then use setRepresentationForTypeById() instead.
      *
      * @param {MediaType} type - 'video', 'audio' or 'image'
-     * @param {number} value - the quality index, 0 corresponding to the lowest possible index
+     * @param {number} index - the quality index, 0 corresponding to the lowest possible index
      * @param {boolean} forceReplace - true if segments have to be replaced by segments of the new quality
      * @memberof module:MediaPlayer
      * @throws {@link module:MediaPlayer~STREAMING_NOT_INITIALIZED_ERROR STREAMING_NOT_INITIALIZED_ERROR} if called before initializePlayback function
@@ -2044,7 +2044,7 @@ function MediaPlayer() {
     /**
      * Sets the source to a new manifest URL or object without reloading
      * Useful for updating CDN tokens
-     * @param urlOrManifest
+     * @param {string | object} urlOrManifest
      */
     function updateSource(urlOrManifest) {
         source = urlOrManifest
diff --git a/src/streaming/controllers/MediaController.js b/src/streaming/controllers/MediaController.js
index b8446657e6..4c8cdbe9c4 100644
--- a/src/streaming/controllers/MediaController.js
+++ b/src/streaming/controllers/MediaController.js
@@ -891,6 +891,7 @@ function MediaController() {
         getCurrentTrackFor,
         getInitialSettings,
         getTracksFor,
+        getTracksWithHighestSelectionPriority,
         getTracksWithHighestBitrate,
         getTracksWithHighestEfficiency,
         getTracksWithWidestRange,
diff --git a/src/streaming/models/CustomParametersModel.js b/src/streaming/models/CustomParametersModel.js
index 6115ab818c..6c3526f0cb 100644
--- a/src/streaming/models/CustomParametersModel.js
+++ b/src/streaming/models/CustomParametersModel.js
@@ -398,37 +398,37 @@ function CustomParametersModel() {
     }
 
     instance = {
+        addAbrCustomRule,
+        addRequestInterceptor,
+        addResponseInterceptor,
+        addUTCTimingSource,
+        clearDefaultUTCTimingSources,
+        getAbrCustomRules,
+        getCustomCapabilitiesFilters,
         getCustomInitialTrackSelectionFunction,
-        setCustomInitialTrackSelectionFunction,
-        resetCustomInitialTrackSelectionFunction,
-        getLicenseResponseFilters,
         getLicenseRequestFilters,
-        getCustomCapabilitiesFilters,
+        getLicenseResponseFilters,
+        getRequestInterceptors,
+        getResponseInterceptors,
+        getUTCTimingSources,
+        getXHRWithCredentialsForType,
         registerCustomCapabilitiesFilter,
-        registerLicenseResponseFilter,
         registerLicenseRequestFilter,
-        unregisterCustomCapabilitiesFilter,
-        unregisterLicenseResponseFilter,
-        unregisterLicenseRequestFilter,
-        addAbrCustomRule,
-        removeAllAbrCustomRule,
+        registerLicenseResponseFilter,
         removeAbrCustomRule,
-        getAbrCustomRules,
-        addRequestInterceptor,
-        addResponseInterceptor,
+        removeAllAbrCustomRule,
         removeRequestInterceptor,
         removeResponseInterceptor,
-        getRequestInterceptors,
-        getResponseInterceptors,
-        addUTCTimingSource,
         removeUTCTimingSource,
-        getUTCTimingSources,
-        clearDefaultUTCTimingSources,
+        reset,
+        resetCustomInitialTrackSelectionFunction,
         restoreDefaultUTCTimingSources,
-        setXHRWithCredentialsForType,
-        getXHRWithCredentialsForType,
         setConfig,
-        reset
+        setCustomInitialTrackSelectionFunction,
+        setXHRWithCredentialsForType,
+        unregisterCustomCapabilitiesFilter,
+        unregisterLicenseRequestFilter,
+        unregisterLicenseResponseFilter,
     };
 
     setup();
diff --git a/src/streaming/models/MetricsModel.js b/src/streaming/models/MetricsModel.js
index 59ea2989d2..004d990140 100644
--- a/src/streaming/models/MetricsModel.js
+++ b/src/streaming/models/MetricsModel.js
@@ -373,23 +373,23 @@ function MetricsModel(config) {
     }
 
     instance = {
-        clearCurrentMetricsForType,
-        clearAllCurrentMetrics,
-        getMetricsFor,
-        addHttpRequest,
-        addRepresentationSwitch,
         addBufferLevel,
         addBufferState,
+        addDVBErrors,
         addDVRInfo,
         addDroppedFrames,
-        addSchedulingInfo,
-        addRequestsQueue,
+        addHttpRequest,
         addManifestUpdate,
-        updateManifestUpdateInfo,
-        addManifestUpdateStreamInfo,
         addManifestUpdateRepresentationInfo,
+        addManifestUpdateStreamInfo,
         addPlayList,
-        addDVBErrors
+        addRepresentationSwitch,
+        addRequestsQueue,
+        addSchedulingInfo,
+        clearAllCurrentMetrics,
+        clearCurrentMetricsForType,
+        getMetricsFor,
+        updateManifestUpdateInfo,
     };
 
     setup();
diff --git a/test/unit/mocks/AbrControllerMock.js b/test/unit/mocks/AbrControllerMock.js
index 3b8122d622..580e739cf9 100644
--- a/test/unit/mocks/AbrControllerMock.js
+++ b/test/unit/mocks/AbrControllerMock.js
@@ -57,21 +57,6 @@ function AbrControllerMock () {
 
     this.isPlayingAtTopQuality = function () {};
 
-    this.getQualityFor = function (type) {
-        var quality;
-
-        if (!this.currentStreamId || !this.qualityDict.hasOwnProperty(this.currentStreamId)) {
-            return QUALITY_DEFAULT;
-        }
-
-        if (!this.qualityDict[this.currentStreamId].hasOwnProperty(type)) {
-            return QUALITY_DEFAULT;
-        }
-
-        quality = this.qualityDict[this.currentStreamId][type];
-        return quality;
-    };
-
     this.setQualityFor = function (type, id, value) {
         this.currentStreamId = id;
         this.qualityDict[id] = this.qualityDict[id] || {};
diff --git a/test/unit/test/streaming/streaming.MediaPlayer.js b/test/unit/test/streaming/streaming.MediaPlayer.js
index 3b8a09493b..2c50b6648a 100644
--- a/test/unit/test/streaming/streaming.MediaPlayer.js
+++ b/test/unit/test/streaming/streaming.MediaPlayer.js
@@ -588,7 +588,7 @@ describe('MediaPlayer', function () {
         });
 
         describe('When it is not initialized', function () {
-            it('Method getQualityFor should throw an exception', function () {
+            it('Method getCurrentRepresentationForType should throw an exception', function () {
                 expect(player.getCurrentRepresentationForType).to.throw(STREAMING_NOT_INITIALIZED_ERROR);
             });
 
@@ -985,7 +985,7 @@ describe('MediaPlayer', function () {
 
     describe('Stream and Track Management Functions', function () {
         describe('When it is not initialized', function () {
-            it('Method getBitrateInfoListFor should throw an exception', function () {
+            it('Method getCurrentRepresentationForType should throw an exception', function () {
                 expect(player.getCurrentRepresentationForType).to.throw('You must first call initialize() and set a source before calling this method');
             });