@mediakind/mkplayer 1.0.0

package/types/enums/MKStreamType.d.ts

@@ -0,0 +1,8 @@
+export declare enum MKStreamType {
+    Hls = "hls",
+    Dash = "dash",
+    Progressive = "progressive",
+    Smooth = "smooth",
+    Whep = "whep",
+    Unknown = "unknown"
+}

package/types/enums/MKTimeMode.d.ts

@@ -0,0 +1,4 @@
+export declare enum MKTimeMode {
+    AbsoluteTime = "absolutetime",
+    RelativeTime = "relativetime"
+}

package/types/enums/MKViewMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum MKViewMode {
+    Fullscreen = "fullscreen",
+    Inline = "inline",
+    PictureInPicture = "pictureinpicture"
+}

package/types/enums/index.d.ts

@@ -0,0 +1,26 @@
+//@ts-nocheck
+export { MKAdaptationLogicType } from "./MKAdaptationLogicType";
+export { MKAdQuartile } from "./MKAdQuartile";
+export { MKAdType } from "./MKAdType";
+export { MKBufferType } from "./MKBufferType";
+export { MKDrmType } from "./MKDrmType";
+export { MKErrorCode } from "./MKErrorCode";
+export { MKHttpRequestType } from "./MKHttpRequestType";
+export { MKHttpResponseType } from "./MKHttpResponseType";
+export { MKLatencyMode } from "./MKLatencyMode";
+export { MKLiveSynchronizationMethod } from "./MKLiveSynchronizationMethod";
+export { MKLocalStorageKeys } from "./MKLocalStorageKeys";
+export { MKLogLevel } from "./MKLogLevel";
+export { MKMediaType } from "./MKMediaType";
+export { MKMetadataType } from "./MKMetadataType";
+export { MKPlatformType } from "./MKPlatformType";
+export { MKPlayerEvent } from "./MKPlayerEvent";
+export { MKPlayerType } from "./MKPlayerType";
+export { MKProgramRestrictionType } from "./MKProgramRestrictionType";
+export { MKRightsMode } from "./MKRightsMode";
+export { MKRttEstimationMethod } from "./MKRttEstimationMethod";
+export { MKAssetType } from "./MKAssetType";
+export { MKStartOffsetTimelineReference } from "./MKStartOffsetTimelineReference";
+export { MKStreamType } from "./MKStreamType";
+export { MKTimeMode } from "./MKTimeMode";
+export { MKViewMode } from "./MKViewMode";

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./alias";
+export * from "./classes";
+export * from "./constants";
+export * from "./enums";
+export * from "./interfaces";

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

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

package/types/interfaces/MKAdaptationData.d.ts

@@ -0,0 +1,7 @@
+export interface MKAdaptationData {
+    representations: {
+        bandwidth: number;
+        id: string;
+    }[];
+    suggested: string;
+}

package/types/interfaces/MKAdaptationPlatformConfig.d.ts

@@ -0,0 +1,6 @@
+import { MKPlatformType } from "../enums";
+import { MKAdaptationConfig } from "./MKAdaptationConfig";
+export interface MKAdaptationPlatformConfig {
+    [MKPlatformType.Desktop]?: MKAdaptationConfig;
+    [MKPlatformType.Mobile]?: MKAdaptationConfig;
+}

package/types/interfaces/MKAdobePrimetimeConfig.d.ts

@@ -0,0 +1,11 @@
+export interface MKAdobePrimetimeConfig {
+    applicationId: string;
+    requesterId: string;
+    resourceId: string;
+    userId: string;
+    upstreamUserId: string;
+    slmt: string;
+    mvpd: string;
+    endpointUrl?: string;
+    isStaging?: boolean;
+}

package/types/interfaces/MKAnalyticsConfig.d.ts

@@ -0,0 +1,41 @@
+export interface MKAnalyticsConfig {
+    key?: string;
+    title?: string;
+    userId?: string;
+    videoId?: string;
+    experimentName?: string;
+    isLive?: boolean;
+    player?: string;
+    playerKey?: string;
+    cdnProvider?: string;
+    customData1?: string;
+    customData2?: string;
+    customData3?: string;
+    customData4?: string;
+    customData5?: string;
+    customData6?: string;
+    customData7?: string;
+    customData8?: string;
+    customData9?: string;
+    customData10?: string;
+    customData11?: string;
+    customData12?: string;
+    customData13?: string;
+    customData14?: string;
+    customData15?: string;
+    customData16?: string;
+    customData17?: string;
+    customData18?: string;
+    customData19?: string;
+    customData20?: string;
+    customData21?: string;
+    customData22?: string;
+    customData23?: string;
+    customData24?: string;
+    customData25?: string;
+    customData26?: string;
+    customData27?: string;
+    customData28?: string;
+    customData29?: string;
+    customData30?: string;
+}

package/types/interfaces/MKAudioAdaptationData.d.ts

@@ -0,0 +1,3 @@
+import { MKAdaptationData } from "./MKAdaptationData";
+export interface MKAudioAdaptationData extends MKAdaptationData {
+}

package/types/interfaces/MKAudioQuality.d.ts

@@ -0,0 +1,3 @@
+import { MKQuality } from "./MKQuality";
+export interface MKAudioQuality extends MKQuality {
+}

package/types/interfaces/MKAudioTrack.d.ts

@@ -0,0 +1,6 @@
+import { MKMediaTrack } from "./MKMediaTrack";
+import { MKAudioQuality } from "./MKAudioQuality";
+export interface MKAudioTrack extends MKMediaTrack {
+    lang: string;
+    getQualities(): MKAudioQuality[];
+}

package/types/interfaces/MKBitrateLimitationConfig.d.ts

@@ -0,0 +1,7 @@
+import { MKBitrate } from "../alias";
+export interface MKBitrateLimitationConfig {
+    maxSelectableAudioBitrate?: MKBitrate;
+    maxSelectableVideoBitrate?: MKBitrate;
+    minSelectableAudioBitrate?: MKBitrate;
+    minSelectableVideoBitrate?: 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/MKBufferConfig.d.ts

@@ -0,0 +1,6 @@
+import { MKMediaType } from "../enums";
+import { MKBufferMediaTypeConfig } from "./MKBufferMediaTypeConfig";
+export interface MKBufferConfig {
+    [MKMediaType.Audio]?: MKBufferMediaTypeConfig;
+    [MKMediaType.Video]?: MKBufferMediaTypeConfig;
+}

package/types/interfaces/MKBufferLevel.d.ts

@@ -0,0 +1,7 @@
+import { MKBufferType, MKMediaType } from "../enums";
+export interface MKBufferLevel {
+    level: number;
+    media: MKMediaType;
+    targetLevel: number;
+    type: MKBufferType;
+}

package/types/interfaces/MKBufferMediaTypeConfig.d.ts

@@ -0,0 +1,5 @@
+import { MKBufferType } from "../enums";
+export interface MKBufferMediaTypeConfig {
+    [MKBufferType.BackwardDuration]?: number;
+    [MKBufferType.ForwardDuration]?: number;
+}

package/types/interfaces/MKCastConfig.d.ts

@@ -0,0 +1,8 @@
+export interface MKCastConfig {
+    type: 'googlecast';
+    receiverApplicationId?: string;
+    messageNamespace?: string;
+    receiverVersion?: 'v3';
+    rejoinActiveSession?: boolean;
+    prepareMediaInfo?(mediaInfo: any): Promise<any>;
+}

package/types/interfaces/MKCdn.d.ts

@@ -0,0 +1 @@
+export {};

package/types/interfaces/MKCdnOptions.d.ts

@@ -0,0 +1,5 @@
+export interface MKCdnOptions {
+    cdnTokens?: {
+        [key: string]: string | number | boolean | null;
+    };
+}

package/types/interfaces/MKClearKeyDRMConfig.d.ts

@@ -0,0 +1,14 @@
+import { MKHeaders } from "../alias";
+export interface MKClearKeyDRMConfig extends Array<MKClearKeyDRMConfigEntry> {
+}
+export interface MKClearKeyDRMConfigEntry {
+    kid?: string;
+    key: string;
+}
+export interface MKClearKeyDRMServerConfig {
+    LA_URL: string;
+    withCredentials?: boolean;
+    maxLicenseRequestRetries?: number;
+    licenseRequestRetryDelay?: number;
+    headers?: MKHeaders;
+}

package/types/interfaces/MKDownloadedAudioData.d.ts

@@ -0,0 +1,3 @@
+import { MKDownloadedData } from "./MKDownloadedData";
+export interface MKDownloadedAudioData extends MKDownloadedData {
+}

package/types/interfaces/MKDownloadedData.d.ts

@@ -0,0 +1,5 @@
+export interface MKDownloadedData {
+    bitrate: number;
+    id: string;
+    isAuto: boolean;
+}

package/types/interfaces/MKDownloadedVideoData.d.ts

@@ -0,0 +1,5 @@
+import { MKDownloadedData } from "./MKDownloadedData";
+export interface MKDownloadedVideoData extends MKDownloadedData {
+    height: number;
+    width: number;
+}

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/MKDrmConfig.d.ts

@@ -0,0 +1,14 @@
+import { MKDrmType } from "../enums";
+import { MKClearKeyDRMConfig, MKClearKeyDRMServerConfig } from "./MKClearKeyDRMConfig";
+import { MKFairplayDrmConfig } from "./MKFairplayDrmConfig";
+import { MKPlayReadyDrmConfig } from "./MKPlayReadyDrmConfig";
+import { MKWidevineModularDrmConfig } from "./MKWidevineModularDrmConfig";
+export interface MKDrmConfig {
+    [MKDrmType.ClearKey]?: MKClearKeyDRMConfig | MKClearKeyDRMServerConfig;
+    [MKDrmType.Widevine]?: MKWidevineModularDrmConfig;
+    [MKDrmType.Playready]?: MKPlayReadyDrmConfig;
+    [MKDrmType.Fairplay]?: MKFairplayDrmConfig;
+    immediateLicenseRequest?: boolean;
+    preferredKeySystems?: string[];
+    usingAzuki?: boolean;
+}

package/types/interfaces/MKDrmLicense.d.ts

@@ -0,0 +1,5 @@
+export interface MKDrmLicense {
+    id: string;
+    keyIds: string[];
+    keySystemString: string;
+}

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/MKEnvironmentConfig.d.ts

@@ -0,0 +1,6 @@
+export interface MKEnvironmentConfig {
+    serverUrl: string;
+    kssUrl?: string;
+    authToken: string;
+    ownerUid?: string;
+}

package/types/interfaces/MKError.d.ts

@@ -0,0 +1,5 @@
+export interface MKError extends Error {
+    code: string;
+    message: string;
+    name: string;
+}

package/types/interfaces/MKFairplayDrmConfig.d.ts

@@ -0,0 +1,20 @@
+import { MKHeaders } from "../alias";
+import { MKHttpResponseType } from "../enums";
+export interface MKFairplayDrmConfig {
+    LA_URL?: string;
+    certificateURL: string;
+    certificateHeaders?: MKHeaders;
+    headers?: MKHeaders;
+    licenseResponseType?: MKHttpResponseType;
+    maxCertificateRequestRetries?: number;
+    maxLicenseRequestRetries?: number;
+    serverCertificate?: ArrayBuffer;
+    useUint16InitData?: boolean;
+    withCredentials?: boolean;
+    getLicenseServerUrl?: ((skdUrl: string) => string);
+    prepareCertificate?: ((data: any) => ArrayBuffer);
+    prepareContentId?: ((url: string) => string);
+    prepareLicense?: ((data: any) => string);
+    prepareLicenseAsync?: ((data: any) => Promise<Uint8Array>);
+    prepareMessage?: ((event: any, session: any) => any);
+}

package/types/interfaces/MKHttpRequestOptions.d.ts

@@ -0,0 +1,8 @@
+import { MKRequestBody, MKHeaders, MKRequestQueryParams } from "../alias";
+export interface MKHttpRequestOptions {
+    timeout?: number;
+    headers?: MKHeaders;
+    body?: MKRequestBody;
+    queryParams?: MKRequestQueryParams;
+    withCredentials?: boolean;
+}

package/types/interfaces/MKHttpResponse.d.ts

@@ -0,0 +1,12 @@
+import { MKHeaders } from "../alias";
+export interface MKHttpResponse {
+    headers?: MKHeaders;
+    ok: boolean;
+    status: number;
+    statusText: string;
+    redirected?: boolean;
+    responseTime: number;
+    url: string;
+    json: <T>() => T;
+    text: () => Promise<string>;
+}

package/types/interfaces/MKImageMediaPlaylist.d.ts

@@ -0,0 +1 @@
+export {};

package/types/interfaces/MKLiveConfig.d.ts

@@ -0,0 +1,6 @@
+import { MKLowLatencyConfig } from "./MKLowLatencyConfig";
+import { MKSynchronizationConfigEntry } from "./MKSynchronizationConfigEntry";
+export interface MKLiveConfig {
+    lowLatency?: MKLowLatencyConfig;
+    synchronization?: MKSynchronizationConfigEntry[];
+}

package/types/interfaces/MKLogConfig.d.ts

@@ -0,0 +1,4 @@
+import { MKLogLevel } from "../enums";
+export interface MKLogConfig {
+    level: MKLogLevel;
+}

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/MKLowLatencyConfig.d.ts

@@ -0,0 +1,6 @@
+import { MKLowLatencySyncConfig } from "./MKLowLatencySyncConfig";
+export interface MKLowLatencyConfig {
+    catchup?: MKLowLatencySyncConfig;
+    fallback?: MKLowLatencySyncConfig;
+    targetLatency?: number;
+}

package/types/interfaces/MKLowLatencySyncConfig.d.ts

@@ -0,0 +1,5 @@
+export interface MKLowLatencySyncConfig {
+    playbackRate?: number;
+    playbackRateThreshold?: number;
+    seekThreshold?: number;
+}

package/types/interfaces/MKManifestAPI.d.ts

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

package/types/interfaces/MKMediaTrack.d.ts

@@ -0,0 +1,6 @@
+import { MKMediaTrackRole } from "./MKMediaTrackRole";
+export interface MKMediaTrack {
+    id: string;
+    label: string;
+    role?: MKMediaTrackRole[];
+}

package/types/interfaces/MKMediaTrackRole.d.ts

@@ -0,0 +1,6 @@
+export interface MKMediaTrackRole {
+    id?: string;
+    value?: string;
+    schemeIdUri: string;
+    [key: string]: string | undefined;
+}

package/types/interfaces/MKMetadata.d.ts

@@ -0,0 +1,7 @@
+import { MKMetadataType } from "../enums";
+export interface MKMetadata {
+    payload: any;
+    type: MKMetadataType;
+    start?: number;
+    end?: number;
+}

package/types/interfaces/MKPeriodContentInformation.d.ts

@@ -0,0 +1,5 @@
+export interface MKPeriodContentInformation {
+    codec: string;
+    isDrmProtected: boolean;
+    mimeType: string;
+}

package/types/interfaces/MKPeriodInformation.d.ts

@@ -0,0 +1,5 @@
+import { MKPeriodContentInformation } from "./MKPeriodContentInformation";
+export interface MKPeriodInformation {
+    contentInformation: MKPeriodContentInformation[];
+    periodId: string;
+}

package/types/interfaces/MKPeriodSwitchObject.d.ts

@@ -0,0 +1,3 @@
+export interface MKPeriodSwitchObject {
+    periodId: string;
+}

package/types/interfaces/MKPlayReadyDrmConfig.d.ts

@@ -0,0 +1,12 @@
+import { MKHeaders } from "../alias";
+export interface MKPlayReadyDrmConfig {
+    LA_URL?: string;
+    customData?: string;
+    forceSSL?: boolean;
+    headers?: MKHeaders;
+    licenseRequestRetryDelay?: number;
+    maxLicenseRequestRetries?: number;
+    plaintextChallenge?: boolean;
+    utf8message?: boolean;
+    withCredentials?: boolean;
+}

package/types/interfaces/MKPlayStation5Tweaks.d.ts

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

package/types/interfaces/MKPlaybackConfig.d.ts

@@ -0,0 +1,16 @@
+import { MKPreferredTechnology } from "./MKPreferredTechnology";
+import { MKSubtitleTrack } from "./MKSubtitleTrack";
+export interface MKPlaybackConfig {
+    audioCodecPriority?: string[];
+    audioLanguage?: string[];
+    autoplay?: boolean;
+    isForcedSubtitle?: (subtitle: MKSubtitleTrack) => boolean;
+    muted?: boolean;
+    playsInline?: boolean;
+    preferredTech?: MKPreferredTechnology[];
+    seeking?: boolean;
+    subtitleLanguage?: string[];
+    timeShift?: boolean;
+    videoCodecPriority?: string[];
+    volume?: number;
+}

package/types/interfaces/MKPlayerAPI.d.ts

@@ -0,0 +1,6 @@
+import { MKPlayerCoreAPI } from "./MKPlayerCoreAPI";
+export interface MKPlayerAPI extends MKPlayerCoreAPI {
+    updateAuthToken(authToken: string): void;
+    setInhomeStatus(inhomeStatus: boolean): void;
+    setLocationDetail(locationDetail: string | null): void;
+}

package/types/interfaces/MKPlayerConfig.d.ts

@@ -0,0 +1,26 @@
+import { MKLogConfig } from "./MKLogConfig";
+import { MKLiveConfig } from "./MKLiveConfig";
+import { MKBufferConfig } from "./MKBufferConfig";
+import { MKPlaybackConfig } from "./MKPlaybackConfig";
+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;
+    log?: MKLogConfig;
+    live?: MKLiveConfig;
+    buffer?: MKBufferConfig;
+    playback?: MKPlaybackConfig;
+    events?: MKPlayerEventConfig;
+    analytics?: MKAnalyticsConfig | false;
+    adaptation?: MKAdaptationPlatformConfig;
+    enableHlsImageMediaPlaylistSupport?: boolean;
+    enableAdTrackingBeacons?: boolean;
+    enableSubtitleOverlay?: boolean;
+    cast?: MKCastConfig;
+    appId?: string;
+    tweaks?: MKTweaksConfig;
+}

package/types/interfaces/MKPlayerCoreAPI.d.ts

@@ -0,0 +1,105 @@
+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";
+import { MKTimelineMarker } from "./MKTimelineMarker";
+import { MKAnalyticsConfig } from "./MKAnalyticsConfig";
+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;
+    addTimelineMarker(timelineMarker: MKTimelineMarker): void;
+    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;
+    getTimelineMarkers(): MKTimelineMarker[];
+    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>;
+    removeTimelineMarker(timelineMarker: MKTimelineMarker): boolean;
+    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;
+    setAnalyticsCustomData(customData: MKAnalyticsConfig): void;
+    showAirplayTargetPicker(): void;
+    unload(): Promise<void>;
+    unmute(issuer?: string): void;
+}

package/types/interfaces/MKPlayerEventCallback.d.ts

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