@mediakind/mkplayer 1.7.0 → 1.9.0

package/package.json

@@ -1,11 +1,9 @@
 {
     "name": "@mediakind/mkplayer",
-    "version": "1.7.0",
+    "version": "1.9.0",
     "description": "MediaKind HTML5 player SDK for HLS and DASH streams.",
-    "author": {
-        "name": "MediaKind"
-    },
-    "license": "©2023 Copyright Mediakind Ltd. All Rights Reserved. Including All Downloadable Materials.",
+    "author": "MediaKind",
+    "license": "©2024 Copyright Mediakind Ltd. All Rights Reserved. Including All Downloadable Materials.",
     "homepage": "https://mediakind.com",
     "repository": {
         "type": "git",
@@ -20,10 +18,10 @@
         "hls player",
         "dash player"
     ],
-    "main": "./mkplayer.js",
-    "types": "./types",
+    "main": "mkplayer.js",
+    "types": "types/index.d.ts",
     "dependencies": {
-        "bitmovin-player": "8.138.0",
+        "bitmovin-player": "8.159.0",
         "bitmovin-player-ui": "^3.52.0"
     }
 }

package/types/alias/index.d.ts

@@ -7,5 +7,11 @@ export type MKRequestBody = {
 };
 export type MKHttpMethod = "GET" | "PUT" | "POST" | "DELETE";
 export type MKRequestQueryParams = {
-    [key: string]: string | number | boolean | null | undefined;
+    [key: string]: string | number | boolean | null;
+};
+export type MKWishAbrConfig = {
+    TARGET_BITRATE_FACTOR: number;
+    TARGET_BUFFER_FACTOR: number;
+    BITRATE_MODIFIER_FUNCTION_TYPE: 'log' | 'linear';
+    USE_RATE_BASED_SELECTION_ON_SEEKING: boolean;
 };

package/types/classes/player/MKPlayer.d.ts

@@ -1,57 +1,64 @@
 import { MKEventBase } from "../common";
-import { MKBufferType, MKLogLevel, MKMediaType, MKTimeMode, MKViewMode } from "../../enums";
-import { MKAudioQuality, MKAudioTrack, MKBufferLevel, MKDownloadedAudioData, MKDownloadedVideoData, MKLowLatencySyncConfig, MKPlayerAPI, MKPlayerConfig, MKSourceConfig, MKSourceOptions, MKSubtitleTrack, MKThumbnail, MKTimeRange, MKVideoQuality, MKViewModeOptions } from "../../interfaces";
+import { MKLogLevel, MKPlayerType, MKStreamType, MKTimeMode, MKViewMode } from "../../enums";
+import { MKAdaptationAPI, MKAudioQuality, MKAudioTrack, MKDownloadedAudioData, MKDownloadedVideoData, MKDrmAPI, MKLowLatencyAPI, MKPlayerAPI, MKBufferAPI, MKPlayerConfig, MKManifestAPI, MKSubtitlesAPI, MKSegmentMap, MKSourceConfig, MKSourceOptions, MKThumbnail, MKTimeRange, MKVideoQuality, MKViewModeOptions } from "../../interfaces";
 import { MKHeaders } from "../../alias";
 export declare class MKPlayer extends MKEventBase implements MKPlayerAPI {
-    private playerConfig;
+    readonly adaptation: MKAdaptationAPI;
+    readonly buffer: MKBufferAPI;
+    readonly drm: MKDrmAPI;
+    readonly lowlatency: MKLowLatencyAPI;
+    readonly manifest: MKManifestAPI;
+    readonly subtitles: MKSubtitlesAPI;
+    private rollInfo?;
+    private player;
     private videoContainer;
-    private videoElement?;
-    private azukiRequest?;
-    private player?;
+    private playerConfig;
     private sourceConfig?;
+    private azukiRequest?;
+    private sourceLoaded;
+    private headers;
+    private programManager?;
+    private analyticsConfig?;
     private thumbnailManager;
     private secureUrlManager?;
-    private programManager?;
-    private sourceLoaded;
+    private usingFailoverSourceUrl;
     private sessionManager?;
     private adobeSessionConcurrencyRequest?;
-    private headers;
-    private analyticsConfig?;
+    private currentSourceInfo;
     constructor(videoContainer: HTMLElement, playerConfig: MKPlayerConfig);
     addCastMetadata(metadata: any): boolean;
-    addSubtitle(subtitleTrack: MKSubtitleTrack): void;
     castStop(): void;
     castVideo(): void;
     destroy(): Promise<void>;
-    disableSubtitle(subtitleID: string): void;
-    enableSubtitle(subtitleID: string): void;
     getAspectRatio(): number;
     getAudio(): MKAudioTrack | null;
-    getAudioQuality(): MKAudioQuality | null;
+    getAudioQuality(): MKAudioQuality;
     getAvailableAudio(): MKAudioTrack[];
     getAvailableAudioQualities(): MKAudioQuality[];
-    getAvailableSubtitles(): MKSubtitleTrack[];
+    getAvailableSegments(): MKSegmentMap;
     getAvailableVideoQualities(): MKVideoQuality[];
-    getBufferLevel(type: MKBufferType, media: MKMediaType): MKBufferLevel | null;
     getBufferedRanges(): MKTimeRange[];
-    getVersion(): string;
-    getVideoContainer(): HTMLElement;
     getCurrentTime(mode?: MKTimeMode): number;
-    getDownloadedAudioData(): MKDownloadedAudioData | null;
-    getDownloadedVideoData(): MKDownloadedVideoData | null;
+    getDownloadedAudioData(): MKDownloadedAudioData;
+    getDownloadedVideoData(): MKDownloadedVideoData;
     getDroppedVideoFrames(): number;
     getDuration(): number;
+    getLiveLatency(): number;
     getMaxTimeShift(): number;
-    getPlaybackAudioData(): MKAudioQuality | null;
+    getPlaybackAudioData(): MKAudioQuality;
     getPlaybackSpeed(): number;
-    getPlaybackVideoData(): MKVideoQuality | null;
-    getSeekableRange(mode?: MKTimeMode | undefined): MKTimeRange | null;
+    getPlaybackVideoData(): MKVideoQuality;
+    getPlayerType(): MKPlayerType;
+    getSeekableRange(mode?: MKTimeMode): MKTimeRange;
+    getStreamType(): MKStreamType;
     getThumbnail(time: number): MKThumbnail | null;
     getTimeShift(): number;
     getTotalStalledTime(): number;
+    getVersion(): string;
+    getVideoContainer(): HTMLElement;
     getVideoElement(): HTMLVideoElement | undefined;
-    getVideoQuality(): MKVideoQuality | null;
-    getViewMode(): MKViewMode | null;
+    getVideoQuality(): MKVideoQuality;
+    getViewMode(): MKViewMode;
     getVolume(): number;
     hasEnded(): boolean;
     isAirplayActive(): boolean;
@@ -65,25 +72,22 @@ export declare class MKPlayer extends MKEventBase implements MKPlayerAPI {
     isStalled(): boolean;
     isViewModeAvailable(viewMode: MKViewMode): boolean;
     load(sourceConfig: MKSourceConfig, disableSeeking?: boolean): Promise<void>;
-    reload(start?: string, sourceOptions?: MKSourceOptions): Promise<void>;
     mute(issuer?: string): void;
     pause(issuer?: string): void;
     play(issuer?: string): Promise<void>;
     preload(): void;
-    removeSubtitle(subtitleID: string): void;
+    reload(start?: string, sourceOptions?: MKSourceOptions): Promise<void>;
     seek(time: number, issuer?: string): boolean;
     seekToLiveEdge(issuer?: string): void;
     setAspectRatio(aspectratio: string | number): void;
     setAudio(trackID: string): void;
     setAudioQuality(audioQualityID: string): void;
-    updateAuthToken(authToken: string): void;
     setHttpHeaders(headers: MKHeaders | null): void;
     setInhomeStatus(inhomeStatus: boolean): void;
     setLocationDetail(locationDetail: string | null): void;
     setLogLevel(level: MKLogLevel): void;
     setPlaybackSpeed(speed: number): void;
     setPosterImage(url: string, keepPersistent: boolean): void;
-    setTargetBufferLevel(type: MKBufferType, value: number, media: MKMediaType): void;
     setVideoElement(videoElement: HTMLVideoElement): void;
     setVideoQuality(videoQualityID: string): void;
     setViewMode(viewMode: MKViewMode, options?: MKViewModeOptions): void;
@@ -91,21 +95,13 @@ export declare class MKPlayer extends MKEventBase implements MKPlayerAPI {
     showAirplayTargetPicker(): void;
     unload(): Promise<void>;
     unmute(issuer?: string): void;
-    getCatchupConfig(): MKLowLatencySyncConfig | null;
-    getFallbackConfig(): MKLowLatencySyncConfig | null;
-    getLatency(): number;
-    getTargetLatency(): number;
-    setCatchupConfig(config: MKLowLatencySyncConfig): void;
-    setFallbackConfig(config: MKLowLatencySyncConfig): void;
-    setTargetLatency(latency: number): void;
+    updateAuthToken(authToken: string): void;
     private updateHttpHeaders;
     private updateSourceConfigFromRollInfo;
-    private initializeBitmovinPlayerEngine;
-    private initializePlayer;
-    private addListeners;
+    private switchToFailoverSource;
+    private registerPlayerEventListeners;
     private emitProgramTimeChangedEvent;
     private unloadAndEmitErrorEvent;
     private emitProgramRestrictionsEvent;
-    private loadSource;
     private onSessionConcurrencyNotificationError;
 }

package/types/constants/MKVersion.d.ts

@@ -0,0 +1 @@
+export declare const version = "1.9.0";

package/types/enums/MKAdaptationLogicType.d.ts

@@ -0,0 +1,5 @@
+export declare enum MKAdaptationLogicType {
+    DOWNLOAD_PREDICTION = "v3",
+    LOW_LATENCY = "low-latency-v1",
+    WISH = "wish"
+}

package/types/enums/MKErrorCode.d.ts

@@ -32,6 +32,7 @@ export declare enum MKErrorCode {
     PLAYER_SOURCE_HLS_STREAM_ERROR = "4-71-1210",
     PLAYER_SOURCE_ENCRYPTION_METHOD_NOT_SUPPORTED = "4-71-1211",
     PLAYER_PLAYBACK_VIDEO_DECODING_ERROR = "4-72-1301",
+    NETWORK_ERROR = "4-73-1400",
     PLAYER_NETWORK_MANIFEST_DOWNLOAD_TIMEOUT = "4-73-1401",
     PLAYER_NETWORK_SEGMENT_DOWNLOAD_TIMEOUT = "4-73-1402",
     PLAYER_NETWORK_FAILED_CERTIFICATE_REQUEST = "4-73-1404",
@@ -57,5 +58,15 @@ export declare enum MKErrorCode {
     PROGRAM_RESTRICTION_DESKTOP = "4-80-109",
     PROGRAM_RESTRICTION_EXTENDED_DISPLAY = "4-80-300",
     PROGRAM_RESTRICTION_AIRPLAY = "4-80-301",
-    PROGRAM_RESTRICTION_CAST = "4-80-302"
+    PROGRAM_RESTRICTION_CAST = "4-80-302",
+    REWIND_BLOCKED = "4-80-200",
+    FASTFORWARD_BLOCKED = "4-80-201",
+    PAUSE_BLOCKED = "4-80-202",
+    RESUME_BLOCKED = "4-80-203",
+    SEEKFORWARD_BLOCKED = "4-80-204",
+    SEEKBACKWARD_BLOCKED = "4-80-205",
+    RESTART_BLOCKED = "4-80-206",
+    TIMESHIFT_BLOCKED = "4-80-207",
+    SEEKSKIP_BLOCKED = "4-80-208",
+    CATCHUP_BLOCKED = "4-80-209"
 }

package/types/enums/MKPlayerEvent.d.ts

@@ -58,7 +58,9 @@ export declare enum MKPlayerEvent {
     SegmentPlayback = "segmentplayback",
     SegmentRequestFinished = "segmentrequestfinished",
     ShowAirplayTargetPicker = "showairplaytargetpicker",
+    SourceLoad = "sourceload",
     SourceLoaded = "sourceloaded",
+    SourceUnload = "sourceunload",
     SourceUnloaded = "sourceunloaded",
     StallEnded = "stallended",
     StallStarted = "stallstarted",
@@ -79,5 +81,6 @@ export declare enum MKPlayerEvent {
     VideoQualityChanged = "videoqualitychanged",
     VideoQualityRemoved = "videoqualityremoved",
     ViewModeChanged = "viewmodechanged",
-    VolumeChanged = "volumechanged"
+    VolumeChanged = "volumechanged",
+    VSPPSessionIdAvailable = "vsppsessionidavailable"
 }

package/types/enums/MKStreamType.d.ts

@@ -4,6 +4,5 @@ export declare enum MKStreamType {
     Progressive = "progressive",
     Smooth = "smooth",
     Whep = "whep",
-    ULL = "ull",
     Unknown = "unknown"
 }

package/types/enums/index.d.ts

@@ -1,3 +1,4 @@
+export { MKAdaptationLogicType } from "./MKAdaptationLogicType";
 export { MKAdQuartile } from "./MKAdQuartile";
 export { MKAdType } from "./MKAdType";
 export { MKBufferType } from "./MKBufferType";

package/types/interfaces/MKAdaptationAPI.d.ts

@@ -0,0 +1,5 @@
+import { MKDynamicAdaptationConfig } from "./MKDynamicAdaptationConfig";
+export interface MKAdaptationAPI {
+    setConfig(adaptationConfig: MKDynamicAdaptationConfig): void;
+    getConfig(): MKDynamicAdaptationConfig;
+}

package/types/interfaces/MKAdaptationConfig.d.ts

@@ -1,19 +1,18 @@
 import { MKBitrate } from "../alias";
-import { MKRttEstimationMethod } from "../enums";
+import { MKAdaptationLogicType, MKRttEstimationMethod } from "../enums";
 import { MKAudioAdaptationData } from "./MKAudioAdaptationData";
 import { MKVideoAdaptationData } from "./MKVideoAdaptationData";
 import { MKBitrateLimitationConfig } from "./MKBitrateLimitationConfig";
-import { MKVideoSizeLimitationConfig } from "./MKVideoSizeLimitationConfig";
-export interface MKAdaptationConfig {
+import { MKDynamicAdaptationConfig } from "./MKDynamicAdaptationConfig";
+export interface MKAdaptationConfig extends MKDynamicAdaptationConfig {
     bitrates?: MKBitrateLimitationConfig;
     disableDownloadCancelling?: boolean;
     exclude?: boolean;
-    limitToPlayerSize?: boolean;
+    logic?: MKAdaptationLogicType;
     maxStartupBitrate?: MKBitrate;
     onAudioAdaptation?: (data: MKAudioAdaptationData) => string;
     onVideoAdaptation?: (data: MKVideoAdaptationData) => string;
     preload?: boolean;
-    resolution?: MKVideoSizeLimitationConfig;
     rttEstimationMethod?: MKRttEstimationMethod;
     startupBitrate?: MKBitrate;
 }

package/types/interfaces/MKBufferAPI.d.ts

@@ -0,0 +1,6 @@
+import { MKBufferType, MKMediaType } from "../enums";
+import { MKBufferLevel } from "./MKBufferLevel";
+export interface MKBufferAPI {
+    setTargetLevel(type: MKBufferType, value: number, media: MKMediaType): void;
+    getLevel(type: MKBufferType, media: MKMediaType): MKBufferLevel;
+}

package/types/interfaces/MKDrmAPI.d.ts

@@ -0,0 +1,5 @@
+export interface MKDrmAPI {
+    isDRMSupported(drmSystem: string): Promise<string>;
+    getSupportedDRM(): Promise<string[]>;
+    renewLicense(drmLicenseId: string): Promise<void>;
+}

package/types/interfaces/MKDynamicAdaptationConfig.d.ts

@@ -0,0 +1,6 @@
+import { MKVideoSizeLimitationConfig } from "./MKVideoSizeLimitationConfig";
+export interface MKDynamicAdaptationConfig {
+    qualityStabilityBalance?: number;
+    resolution?: MKVideoSizeLimitationConfig;
+    limitToPlayerSize?: boolean;
+}

package/types/interfaces/MKLowLatencyAPI.d.ts

@@ -0,0 +1,9 @@
+import { MKLowLatencySyncConfig } from "./MKLowLatencySyncConfig";
+export interface MKLowLatencyAPI {
+    setTargetLatency(latency: number): void;
+    getTargetLatency(): number;
+    setCatchupConfig(config: MKLowLatencySyncConfig): void;
+    getCatchupConfig(): MKLowLatencySyncConfig;
+    setFallbackConfig(config: MKLowLatencySyncConfig): void;
+    getFallbackConfig(): MKLowLatencySyncConfig;
+}

package/types/interfaces/MKManifestAPI.d.ts

@@ -0,0 +1,3 @@
+export interface MKManifestAPI {
+    getManifest(): string;
+}

package/types/interfaces/MKPlayStation5Tweaks.d.ts

@@ -0,0 +1,5 @@
+export interface MKPlayStation5Tweaks {
+    playmode?: '4K' | '2K';
+    pass_through?: boolean;
+    esvm?: boolean;
+}

package/types/interfaces/MKPlayerConfig.d.ts

@@ -6,6 +6,7 @@ import { MKAdaptationPlatformConfig } from "./MKAdaptationPlatformConfig";
 import { MKPlayerEventConfig } from "./MKPlayerEventConfig";
 import { MKAnalyticsConfig } from "./MKAnalyticsConfig";
 import { MKCastConfig } from "./MKCastConfig";
+import { MKTweaksConfig } from "./MKTweaksConfig";
 export interface MKPlayerConfig {
     key?: string;
     ui?: boolean;
@@ -21,5 +22,5 @@ export interface MKPlayerConfig {
     enableSubtitleOverlay?: boolean;
     cast?: MKCastConfig;
     appId?: string;
-    skipEmsgBoxes?: boolean | false;
+    tweaks?: MKTweaksConfig;
 }

package/types/interfaces/MKPlayerCoreAPI.d.ts

@@ -1 +1,99 @@
-export {};
+import { MKHeaders } from "../alias";
+import { MKThumbnail } from "./MKThumbnail";
+import { MKTimeRange } from "./MKTimeRange";
+import { MKAudioTrack } from "./MKAudioTrack";
+import { MKSourceConfig } from "./MKSourceConfig";
+import { MKAudioQuality } from "./MKAudioQuality";
+import { MKVideoQuality } from "./MKVideoQuality";
+import { MKSourceOptions } from "./MKSourceOptions";
+import { MKViewModeOptions } from "./MKViewModeOptions";
+import { MKPlayerEventCallback } from "./MKPlayerEventCallback";
+import { MKDownloadedAudioData } from "./MKDownloadedAudioData";
+import { MKDownloadedVideoData } from "./MKDownloadedVideoData";
+import { MKPlayerEvent, MKTimeMode, MKLogLevel, MKViewMode, MKPlayerType, MKStreamType } from "../enums";
+import { MKAdaptationAPI } from "./MKAdaptationAPI";
+import { MKBufferAPI } from "./MKBufferAPI";
+import { MKDrmAPI } from "./MKDrmAPI";
+import { MKSubtitlesAPI } from "./MKSubtitlesAPI";
+import { MKLowLatencyAPI } from "./MKLowLatencyAPI";
+import { MKSegmentMap } from "./MKSegmentMap";
+import { MKManifestAPI } from "./MKManifestAPI";
+import { MKPlayerEventBase } from "./events";
+export interface MKPlayerCoreAPI {
+    readonly adaptation: MKAdaptationAPI;
+    readonly buffer: MKBufferAPI;
+    readonly drm: MKDrmAPI;
+    readonly lowlatency: MKLowLatencyAPI;
+    readonly manifest: MKManifestAPI;
+    readonly subtitles: MKSubtitlesAPI;
+    addCastMetadata(metadata: any): boolean;
+    castStop(): void;
+    castVideo(): void;
+    destroy(): Promise<void>;
+    getAspectRatio(): number;
+    getAudio(): MKAudioTrack | null;
+    getAudioQuality(): MKAudioQuality;
+    getAvailableAudio(): MKAudioTrack[];
+    getAvailableAudioQualities(): MKAudioQuality[];
+    getAvailableSegments(): MKSegmentMap;
+    getAvailableVideoQualities(): MKVideoQuality[];
+    getBufferedRanges(): MKTimeRange[];
+    getCurrentTime(mode?: MKTimeMode): number;
+    getDownloadedAudioData(): MKDownloadedAudioData;
+    getDownloadedVideoData(): MKDownloadedVideoData;
+    getDroppedVideoFrames(): number;
+    getDuration(): number;
+    getLiveLatency(): number;
+    getMaxTimeShift(): number;
+    getPlaybackAudioData(): MKAudioQuality;
+    getPlaybackSpeed(): number;
+    getPlaybackVideoData(): MKVideoQuality;
+    getPlayerType(): MKPlayerType;
+    getSeekableRange(mode?: MKTimeMode): MKTimeRange;
+    getStreamType(): MKStreamType;
+    getThumbnail(time: number): MKThumbnail | null;
+    getTimeShift(): number;
+    getTotalStalledTime(): number;
+    getVersion(): string;
+    getVideoContainer(): HTMLElement;
+    getVideoElement(): HTMLVideoElement | undefined;
+    getVideoQuality(): MKVideoQuality;
+    getViewMode(): MKViewMode;
+    getVolume(): number;
+    hasEnded(): boolean;
+    isAirplayActive(): boolean;
+    isAirplayAvailable(): boolean;
+    isCastAvailable(): boolean;
+    isCasting(): boolean;
+    isLive(): boolean;
+    isMuted(): boolean;
+    isPaused(): boolean;
+    isPlaying(): boolean;
+    isStalled(): boolean;
+    isViewModeAvailable(viewMode: MKViewMode): boolean;
+    load(sourceConfig: MKSourceConfig, disableSeeking?: boolean): Promise<void>;
+    mute(issuer?: string): void;
+    off<T extends MKPlayerEventBase>(eventType: MKPlayerEvent, callback: MKPlayerEventCallback<T>): void;
+    offAll(eventType: MKPlayerEvent): void;
+    on<T extends MKPlayerEventBase>(eventType: MKPlayerEvent, callback: MKPlayerEventCallback<T>): void;
+    pause(issuer?: string): void;
+    play(issuer?: string): Promise<void>;
+    preload(): void;
+    reload(start?: string, sourceOptions?: MKSourceOptions): Promise<void>;
+    seek(time: number, issuer?: string): boolean;
+    seekToLiveEdge(issuer?: string): void;
+    setAspectRatio(aspectratio: string | number): void;
+    setAudio(trackID: string): void;
+    setAudioQuality(audioQualityID: string): void;
+    setHttpHeaders(headers: MKHeaders | null): void;
+    setLogLevel(level: MKLogLevel): void;
+    setPlaybackSpeed(speed: number): void;
+    setPosterImage(url: string, keepPersistent: boolean): void;
+    setVideoElement(videoElement: HTMLVideoElement): void;
+    setVideoQuality(videoQualityID: string): void;
+    setViewMode(viewMode: MKViewMode, options?: MKViewModeOptions): void;
+    setVolume(volume: number, issuer?: string): void;
+    showAirplayTargetPicker(): void;
+    unload(): Promise<void>;
+    unmute(issuer?: string): void;
+}

package/types/interfaces/MKPlayerEventCallback.d.ts

@@ -1,4 +1,4 @@
 import { MKPlayerEventBase } from "./events";
-export interface MKPlayerEventCallback {
-    (event: MKPlayerEventBase): void;
+export interface MKPlayerEventCallback<T extends MKPlayerEventBase> {
+    (event: T): void;
 }

package/types/interfaces/MKPlayerEventConfig.d.ts

@@ -1,4 +1,4 @@
 import { MKPlayerEventCallback } from "./MKPlayerEventCallback";
 export interface MKPlayerEventConfig {
-    [event: string]: MKPlayerEventCallback;
+    [event: string]: MKPlayerEventCallback<any>;
 }

package/types/interfaces/MKRegisteredSource.d.ts

@@ -5,6 +5,7 @@ export interface MKRegisteredSource {
     adobePrimetimeConfig?: MKAdobePrimetimeConfig;
     environmentConfig: MKEnvironmentConfig;
     applicationToken?: string;
+    offerId?: string;
     startTime?: string;
     isDvrFromRollingBuffer?: boolean;
 }

package/types/interfaces/MKSegmentInfo.d.ts

@@ -0,0 +1,5 @@
+export interface MKSegmentInfo {
+    url: string;
+    duration?: number;
+    startTime?: number;
+}

package/types/interfaces/MKSegmentMap.d.ts

@@ -0,0 +1,4 @@
+import { MKSegmentQualityMap } from "./MKSegmentQualityMap";
+export interface MKSegmentMap {
+    [mimeType: string]: MKSegmentQualityMap;
+}

package/types/interfaces/MKSegmentQualityMap.d.ts

@@ -0,0 +1,4 @@
+import { MKSegmentInfo } from "./MKSegmentInfo";
+export interface MKSegmentQualityMap {
+    [qualityID: string]: MKSegmentInfo[];
+}

package/types/interfaces/MKSourceConfig.d.ts

@@ -1,6 +1,5 @@
 import { MKAssetType } from "../enums";
 import { MKDrmConfig } from "./MKDrmConfig";
-import { MKUllSource } from "./MKUllSource";
 import { MKCdnOptions } from "./MKCdnOptions";
 import { MKSourceOptions } from "./MKSourceOptions";
 import { MKSubtitleTrack } from "./MKSubtitleTrack";
@@ -20,7 +19,6 @@ export interface MKSourceConfig {
     smooth?: string;
     progressive?: string | MKProgressiveSource[];
     whep?: string;
-    ull?: MKUllSource;
     registered?: MKRegisteredSource;
     drm?: MKDrmConfig;
     cdnOptions?: MKCdnOptions;

package/types/interfaces/MKSourceInfo.d.ts

@@ -0,0 +1,13 @@
+import { MKDrmType, MKStreamType } from "../enums";
+export interface MKSourceInfo {
+    timeTakenForSourceLoadSetup: number;
+    streamType: MKStreamType;
+    streamUrl: string;
+    drmType: MKDrmType;
+    azukiRequestTime: {
+        registration: number;
+        roll: number;
+        pendingBeacon: number;
+    };
+    secureUrlSignatureTime: number;
+}

package/types/interfaces/MKSubtitlesAPI.d.ts

@@ -0,0 +1,11 @@
+import { MKSubtitleCueEvent } from "./events";
+import { MKSubtitleTrack } from "./MKSubtitleTrack";
+export interface MKSubtitlesAPI {
+    add(subtitle: MKSubtitleTrack): void;
+    remove(subtitleID: string): void;
+    list(): MKSubtitleTrack[];
+    enable(subtitleID: string, exclusive?: boolean): void;
+    disable(subtitleID: string): void;
+    cueEnter(cue: MKSubtitleCueEvent): void;
+    cueExit(cue: MKSubtitleCueEvent): void;
+}

package/types/interfaces/MKTweaksConfig.d.ts

@@ -0,0 +1,38 @@
+import { MKWishAbrConfig } from "../alias";
+import { MKPlayStation5Tweaks } from "./MKPlayStation5Tweaks";
+export interface MKTweaksConfig {
+    [key: string]: any;
+    startup_threshold?: number;
+    restart_threshold?: number;
+    native_hls_parsing?: boolean;
+    native_hls_download_error_handling?: boolean;
+    stop_download_on_pause?: boolean;
+    hls_audio_only_threshold_bitrate?: number;
+    adaptation_set_switching_without_supplemental_property?: boolean;
+    ignore_mp4_edts_box?: boolean;
+    live_segment_list_start_index_offset?: number;
+    prevent_video_element_preloading?: boolean;
+    fairplay_ignore_duplicate_init_data_key_errors?: boolean;
+    no_quota_exceeded_adjustment?: boolean;
+    dword_base_media_decode_timestamps?: boolean;
+    force_base_media_decode_time_rewrite?: boolean;
+    preserve_gaps_for_base_media_decode_time_rewrite?: boolean;
+    min_size_for_gap_skipping?: number;
+    force_software_decryption?: boolean;
+    max_retries?: number;
+    max_cdn_retries?: number;
+    max_mpd_retries?: number;
+    mpd_retry_delay?: number;
+    mpd_update_period_tolerance?: number;
+    parse_cea_708_caption?: boolean;
+    playstation_5?: MKPlayStation5Tweaks;
+    hls_sync_segment_playback_time_via_media_sequence?: boolean;
+    hls_parse_manifest_in_worker?: boolean;
+    hls_clear_buffers_on_discontinuity_switches?: boolean;
+    chunked_cmaf_streaming?: boolean;
+    parse_emsg_boxes?: boolean;
+    wish_abr_params?: MKWishAbrConfig;
+    hls_backup_stream_penalty_duration?: number;
+    check_all_drm_licenses_for_kid?: boolean;
+    hls_parse_native_metadata?: boolean;
+}

package/types/interfaces/events/MKAdClickThroughEvent.d.ts

@@ -1,5 +1,5 @@
 import { MKPlayerEventBase } from "./MKPlayerEventBase";
-export interface MKAdClickThrough extends MKPlayerEventBase {
+export interface MKAdClickThroughEvent extends MKPlayerEventBase {
     id: string;
     adClick?: string;
     adClickTracking?: string;

package/types/interfaces/events/MKAdCompanionEvent.d.ts

@@ -1,6 +1,5 @@
 import { MKPlayerEventBase } from "./MKPlayerEventBase";
-import { MKAdCompanion } from "../MKAdCompanion";
 export interface MKAdCompanionEvent extends MKPlayerEventBase {
     id: string;
-    companionAd: MKAdCompanion;
+    data: string;
 }

package/types/interfaces/events/MKAdVerificationEvent.d.ts

@@ -1,6 +1,6 @@
 import { MKPlayerEventBase } from "./MKPlayerEventBase";
-import { MKAdVerification } from "../MKAdVerification";
 export interface MKAdVerificationEvent extends MKPlayerEventBase {
-    id: string;
-    adVerification: MKAdVerification;
+    vendorKey: string;
+    scriptUrl: string;
+    params: string;
 }

package/types/interfaces/events/MKAudioPlaybackQualityChangedEvent.d.ts

@@ -1,3 +1,4 @@
+import { MKAudioQuality } from "../MKAudioQuality";
 import { MKMediaPlaybackQualityChangeEvent } from "./MKMediaPlaybackQualityChangeEvent";
-export interface MKAudioPlaybackQualityChangedEvent extends MKMediaPlaybackQualityChangeEvent {
+export interface MKAudioPlaybackQualityChangedEvent extends MKMediaPlaybackQualityChangeEvent<MKAudioQuality> {
 }

package/types/interfaces/events/MKMediaPlaybackQualityChangeEvent.d.ts

@@ -1,6 +1,6 @@
 import { MKQuality } from "../MKQuality";
 import { MKPlayerEventBase } from "./MKPlayerEventBase";
-export interface MKMediaPlaybackQualityChangeEvent extends MKPlayerEventBase {
-    sourceQuality: MKQuality;
-    targetQuality: MKQuality;
+export interface MKMediaPlaybackQualityChangeEvent<Quality extends MKQuality> extends MKPlayerEventBase {
+    sourceQuality: Quality;
+    targetQuality: Quality;
 }

package/types/interfaces/events/MKPlayerEventBase.d.ts

@@ -2,4 +2,5 @@ import { MKPlayerEvent } from "../../enums";
 export interface MKPlayerEventBase {
     timestamp: number;
     type: MKPlayerEvent;
+    customData?: any;
 }

package/types/interfaces/events/MKSubtitleCueEvent.d.ts

@@ -0,0 +1,16 @@
+import { MKVTTProperties } from "../MKVTTProperties";
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+import { MKSubtitleCuePosition } from "../MKSubtitleCuePosition";
+export interface MKSubtitleCueEvent extends MKPlayerEventBase {
+    end: number;
+    html?: string;
+    image?: string;
+    position?: MKSubtitleCuePosition;
+    region?: string;
+    regionStyle?: string;
+    start: number;
+    subtitleId: string;
+    text: string;
+    vtt?: MKVTTProperties;
+    periodId?: string;
+}