@mediakind/mkplayer 1.1.1 → 1.1.2

package/package.json

@@ -1,15 +1,25 @@
 {
     "name": "@mediakind/mkplayer",
-    "version": "1.1.1",
+    "version": "1.1.2",
     "description": "MediaKind HTML5 player SDK for HLS and DASH streams.",
-    "author": "MediaKind",
+    "author": {
+        "name": "MediaKind"
+    },
     "license": "©2023 Copyright Mediakind Ltd. All Rights Reserved. Including All Downloadable Materials.",
+    "homepage": "https://mediakind.com",
     "repository": {
         "type": "git",
-        "url": "https://dev.azure.com/mediakind/MediaFirst/_git/MKPlayerSDK-Web"
+        "url": ""
     },
-    "main": "bin/mkplayer.js",
-    "directories": {
-        "bin": "bin"
-    }
+    "keywords": [
+        "mkplayer",
+        "mkplayer web",
+        "html5 video player",
+        "html5 video",
+        "html5 web player",
+        "hls player",
+        "dash player"
+    ],
+    "main": "./mkplayer.js",
+    "types": "./src/index.d.ts"
 }

package/src/alias/index.d.ts

@@ -0,0 +1,10 @@
+export type MKBitrate = string | number;
+export type MKRequestHeaders = {
+    [key: string]: string;
+};
+export type MKRequestBodyParams = {
+    [key: string]: any;
+};
+export type MKRequestQueryParams = {
+    [key: string]: string | number | boolean | null | undefined;
+};

package/src/classes/common/MKAzukiResponseUtils.d.ts

@@ -0,0 +1,8 @@
+import { MKDrmType, MKStreamType } from "../../enums";
+import { MKProgramInfo, MKProgramRestrictions } from "../../interfaces";
+export declare abstract class MKAzukiResponseUtils {
+    static getStreamType(response: any): MKStreamType;
+    static getDrmType(response: any): MKDrmType;
+    static getProgramRestrictions(response: any): MKProgramRestrictions;
+    static getProgramInfo(response: any): MKProgramInfo;
+}

package/src/classes/common/MKEventBase.d.ts

@@ -0,0 +1,9 @@
+import { MKPlayerEvent } from "../../enums";
+import { MKPlayerEventBase, MKPlayerEventCallback } from "../../interfaces";
+export declare class MKEventBase {
+    private readonly eventEmitter;
+    constructor();
+    on(eventType: MKPlayerEvent, callback: MKPlayerEventCallback): void;
+    off(eventType: MKPlayerEvent, callback: MKPlayerEventCallback): void;
+    emit(eventType: MKPlayerEvent, eventData?: MKPlayerEventBase): void;
+}

package/src/classes/common/MKLocalStorage.d.ts

@@ -0,0 +1,28 @@
+import { MKLocalStorageKeys } from "../../enums";
+declare abstract class LocalStorage<T extends string> {
+    private secret;
+    private readonly localStorgage;
+    constructor();
+    protected get(key: T): string | null;
+    protected set(key: T, value: string): void;
+    protected clearItem(key: T): void;
+    protected clearItems(keys: T[]): void;
+    private encrypt;
+    private decrypt;
+}
+export declare class MKLocalStorage extends LocalStorage<MKLocalStorageKeys> {
+    private static instance?;
+    private constructor();
+    static getInstance(): MKLocalStorage;
+    setRegistered(authToken: string): void;
+    getRegistered(): string | null;
+    clearRegistered(): void;
+    setDeviceId(deviceId: string): void;
+    getDeviceId(): string | null;
+    setDeviceProfile(deviceProfile: string): void;
+    getDeviceProfile(): string | null;
+    setBeaconData(beaconData: any): void;
+    getBeaconData(): any;
+    clearBeaconData(): void;
+}
+export {};

package/src/classes/common/MKLog.d.ts

@@ -0,0 +1,10 @@
+import { MKLogLevel } from "../../enums";
+export declare abstract class MKLog {
+    private static logLevel;
+    private static logTag;
+    static setLogLevel(logLevel: MKLogLevel): void;
+    static log(message?: any, ...options: any[]): void;
+    static debug(message?: any, ...options: any[]): void;
+    static warn(message?: any, ...options: any[]): void;
+    static error(message?: any, ...options: any[]): void;
+}

package/src/classes/common/MKPlatform.d.ts

@@ -0,0 +1,29 @@
+export declare abstract class MKPlatform {
+    static getDeviceProfile(): string;
+    private static getDeviceId;
+    private static getDrmPlatform;
+    private static getOSVendorName;
+    private static isIE;
+    private static isEdge;
+    private static isMac;
+    private static isWindows;
+    private static isXbox;
+    private static isPlayStation5;
+    private static isPlayStation4;
+    private static isSafari;
+    private static isIOSDevice;
+    private static isIOSWebView;
+    private static isChrome;
+    private static isFirefox;
+    private static isOpera;
+    private static isComcastX1;
+    private static isOperaTV;
+    private static isChromebook;
+    private static isDesktopChromeBrowser;
+    private static isWebOS;
+    private static isTizenTV;
+    private static isLinux;
+    private static isIOSFamily;
+    private static isChromeCast;
+    private static isAndroid;
+}

package/src/classes/common/MKProgramManager.d.ts

@@ -0,0 +1,13 @@
+import { MKAzukiRequest } from "../request";
+import { MKError, MKProgramInfo } from "../../interfaces";
+export declare class MKProgramManager {
+    private azukiRequest?;
+    private programInfoList;
+    private currentProgramInfo?;
+    constructor(azukiRequest?: MKAzukiRequest);
+    reset(): void;
+    updateProgramInfoList(currentProgramInfo: MKProgramInfo): void;
+    validateProgramRestrictions(programInfo: MKProgramInfo): MKError[];
+    checkProgramBoundary(currentTime: number): MKProgramInfo | null;
+    private getProgramInfo;
+}

package/src/classes/common/MKSubtitleOverlay.d.ts

@@ -0,0 +1,25 @@
+import { MKSubtitleCue } from "../../interfaces";
+export declare class MKSubtitleOverlay {
+    private static readonly CEA608_NUM_ROWS;
+    private static readonly CEA608_NUM_COLUMNS;
+    private static readonly DEFAULT_REGION_STYLE;
+    private static readonly DEFAULT_CELL_RESOLUTION;
+    private videoContainer;
+    private videoElement;
+    private subtitleContainer;
+    private subtitleRegion;
+    private enabled;
+    constructor(videoElement: HTMLVideoElement);
+    private reset;
+    private getSubtitleContainer;
+    private getSubtitleRegion;
+    private rgbaCheck;
+    private styleTextToObject;
+    private updateRegion;
+    enable(): void;
+    disable(): void;
+    show(cue: MKSubtitleCue): void;
+    hide(): void;
+    updateFontSize(): void;
+    destroy(): void;
+}

package/src/classes/common/MKThumbnailManager.d.ts

@@ -0,0 +1,22 @@
+import { MKThumbnail } from "../../interfaces";
+export declare class MKThumbnailManager {
+    private httpRequest;
+    private manifestUrl;
+    private imageMediaPlaylists;
+    private thumbnails;
+    private isEnabled;
+    private currentPlaylistData;
+    private targetDuration;
+    private reloadPlaylistTimer?;
+    private retryCount;
+    private static readonly PLAYLIST_MAX_RETRY_COUNT;
+    constructor();
+    getThumbnail(time: number): MKThumbnail | null;
+    enable(manifestUrl: string): void;
+    disable(): void;
+    private fetchAndProcessImageMediaPlaylist;
+    private reloadImageMediaPlaylist;
+    private refetchAndProcessImageMediaPlaylistOnError;
+    private fetchImageMediaPlaylists;
+    private fetchManifest;
+}

package/src/classes/common/MKUtils.d.ts

@@ -0,0 +1,19 @@
+import { MKRequestQueryParams } from "../../alias";
+export declare abstract class MKUtils {
+    static updateURLQueryParams(url: string, params?: MKRequestQueryParams): string;
+    static getURLQueryParam(url: string, key: string): string | null;
+    static base64Encode(input: string): string;
+    static base64Decode(inputString: string, decodeToUTF8?: boolean): string;
+    static getUUID(): string;
+    static getCurrentTimestamp(): number;
+    static timestampToISOString(timestamp: number, skipMilliseconds?: boolean): string;
+    static dateISOStringToTimestamp(isoString: string): number;
+    static dateISOStringByAddingSeconds(isoString: string, seconds: number): string;
+    static isString(value: any): boolean;
+    static isValidString(value: any): boolean;
+    static isObject(value: any): boolean;
+    static isValidObject(value: any): boolean;
+    static isArray(value: any): boolean;
+    static isNumber(value: any): boolean;
+    static isBoolean(value: any): boolean;
+}

package/src/classes/common/MKUtils.spec.d.ts

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

package/src/classes/common/index.d.ts

@@ -0,0 +1,9 @@
+export { MKAzukiResponseUtils } from "./MKAzukiResponseUtils";
+export { MKEventBase } from "./MKEventBase";
+export { MKLocalStorage } from "./MKLocalStorage";
+export { MKLog } from "./MKLog";
+export { MKPlatform } from "./MKPlatform";
+export { MKProgramManager } from "./MKProgramManager";
+export { MKSubtitleOverlay } from "./MKSubtitleOverlay";
+export { MKThumbnailManager } from "./MKThumbnailManager";
+export { MKUtils } from "./MKUtils";

package/src/classes/error/MKAzukiRequestError.d.ts

@@ -0,0 +1,8 @@
+import { MKError } from "../../interfaces";
+export declare class MKAzukiRequestError implements MKError {
+    code: string;
+    name: string;
+    message: string;
+    constructor(api: string, code?: number, message?: string);
+    private getErrorCode;
+}

package/src/classes/error/MKBitmovinPlayerError.d.ts

@@ -0,0 +1,5 @@
+import { MKPlayerError } from "./MKPlayerError";
+export declare class MKBitmovinPlayerError extends MKPlayerError {
+    constructor(errorObj: any);
+    private getErrorCode;
+}

package/src/classes/error/MKHttpError.d.ts

@@ -0,0 +1,10 @@
+import { MKError } from "../../interfaces";
+export declare class MKHttpError implements MKError {
+    code: string;
+    name: string;
+    message: string;
+    constructor(error: {
+        code: string;
+        message: string;
+    });
+}

package/src/classes/error/MKPlayerError.d.ts

@@ -0,0 +1,7 @@
+import { MKError } from "../../interfaces";
+export declare class MKPlayerError implements MKError {
+    code: string;
+    name: string;
+    message: string;
+    constructor();
+}

package/src/classes/error/MKProgramRestrictionError.d.ts

@@ -0,0 +1,9 @@
+import { MKError } from "../../interfaces";
+import { MKProgramRestrictionType } from "../../enums";
+export declare class MKProgramRestrictionError implements MKError {
+    code: string;
+    name: string;
+    message: string;
+    constructor(programRestriction: MKProgramRestrictionType);
+    private getRestrictionCodeAndMessage;
+}

package/src/classes/error/index.d.ts

@@ -0,0 +1,5 @@
+export { MKAzukiRequestError } from "./MKAzukiRequestError";
+export { MKBitmovinPlayerError } from "./MKBitmovinPlayerError";
+export { MKHttpError } from "./MKHttpError";
+export { MKPlayerError } from "./MKPlayerError";
+export { MKProgramRestrictionError } from "./MKProgramRestrictionError";

package/src/classes/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./common";
+export * from "./error";
+export * from "./player";
+export * from "./request";

package/src/classes/player/MKBitmovinPlayer.d.ts

@@ -0,0 +1,106 @@
+import { MKEventBase } from "../common";
+import { MKBufferType, MKLogLevel, MKMediaType, MKTimeMode, MKViewMode } from "../../enums";
+import { MKPlayerConfig, MKSourceConfig, MKLowLatencySyncConfig, MKBufferLevel, MKPlayerEngine, MKViewModeOptions, MKTimeRange, MKVideoQuality, MKAudioQuality, MKDownloadedVideoData, MKDownloadedAudioData, MKAudioTrack, MKSubtitleTrack, MKThumbnail } from "../../interfaces";
+export declare class MKBitmovinPlayer extends MKEventBase implements MKPlayerEngine {
+    private player;
+    private playerUI?;
+    private playerConfig;
+    private videoContainer;
+    private subtitleOverlay?;
+    private sourceConfig?;
+    private playStart?;
+    private firstTimeChangedUpdate;
+    private hasPreroll;
+    private enableAdTrackingBeacons;
+    private enableSubtitleOverlay;
+    private adBreakStartedEventData?;
+    private adStartedEventData?;
+    private adQuartileOffsets;
+    private adTrackingList;
+    private static readonly DEFAULT_BUFFER_CONFIG;
+    private static readonly DEFAULT_PLAYBACK_CONFIG;
+    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;
+    getAvailableAudio(): MKAudioTrack[];
+    getAvailableAudioQualities(): MKAudioQuality[];
+    getAvailableSubtitles(): MKSubtitleTrack[];
+    getAvailableVideoQualities(): MKVideoQuality[];
+    getBufferLevel(type: MKBufferType, media: MKMediaType): MKBufferLevel | null;
+    getBufferedRanges(): MKTimeRange[];
+    getVideoContainer(): HTMLElement;
+    getCurrentTime(mode?: MKTimeMode): number;
+    getDownloadedAudioData(): MKDownloadedAudioData | null;
+    getDownloadedVideoData(): MKDownloadedVideoData | null;
+    getDroppedVideoFrames(): number;
+    getDuration(): number;
+    getMaxTimeShift(): number;
+    getPlaybackAudioData(): MKAudioQuality | null;
+    getPlaybackSpeed(): number;
+    getPlaybackVideoData(): MKVideoQuality | null;
+    getSeekableRange(mode?: MKTimeMode): MKTimeRange;
+    getThumbnail(time: number): MKThumbnail | null;
+    getTimeShift(): number;
+    getTotalStalledTime(): number;
+    getVideoElement(): HTMLVideoElement;
+    getVideoQuality(): MKVideoQuality | null;
+    getViewMode(): MKViewMode | null;
+    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;
+    pause(issuer?: string): void;
+    play(issuer?: string): Promise<void>;
+    preload(): void;
+    removeSubtitle(subtitleID: string): void;
+    seek(time: number, issuer?: string): boolean;
+    seekToLiveEdge(issuer?: string): void;
+    setAspectRatio(aspectratio: string | number): void;
+    setAudio(trackID: string): void;
+    setAudioQuality(audioQualityID: string): void;
+    setAuthorizationToken(_authorizationToken: string): void;
+    setInhomeStatus(_inhomeStatus: boolean): void;
+    setLocationDetail(_locationDetail: string): 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;
+    setVolume(volume: number, issuer?: string): void;
+    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;
+    private getAdQuartileOffsets;
+    private emitAdEvents;
+    private updateAdTrackingList;
+    private notifyAdTracking;
+    private companionXMLToJson;
+    private processCompanionAds;
+}

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

@@ -0,0 +1,104 @@
+import { MKEventBase } from "../common";
+import { MKBufferType, MKLogLevel, MKMediaType, MKTimeMode, MKViewMode } from "../../enums";
+import { MKAudioQuality, MKAudioTrack, MKBufferLevel, MKDownloadedAudioData, MKDownloadedVideoData, MKLowLatencySyncConfig, MKPlayerAPI, MKPlayerConfig, MKSourceConfig, MKSubtitleTrack, MKThumbnail, MKTimeRange, MKVideoQuality, MKViewModeOptions } from "../../interfaces";
+export declare class MKPlayer extends MKEventBase implements MKPlayerAPI {
+    private playerConfig;
+    private videoContainer;
+    private videoElement?;
+    private azukiRequest?;
+    private player?;
+    private sourceConfig?;
+    private thumbnailManager;
+    private programManager?;
+    private sessionBeaconTimer?;
+    private sourceLoaded;
+    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;
+    getAvailableAudio(): MKAudioTrack[];
+    getAvailableAudioQualities(): MKAudioQuality[];
+    getAvailableSubtitles(): MKSubtitleTrack[];
+    getAvailableVideoQualities(): MKVideoQuality[];
+    getBufferLevel(type: MKBufferType, media: MKMediaType): MKBufferLevel | null;
+    getBufferedRanges(): MKTimeRange[];
+    getVideoContainer(): HTMLElement;
+    getCurrentTime(mode?: MKTimeMode): number;
+    getDownloadedAudioData(): MKDownloadedAudioData | null;
+    getDownloadedVideoData(): MKDownloadedVideoData | null;
+    getDroppedVideoFrames(): number;
+    getDuration(): number;
+    getMaxTimeShift(): number;
+    getPlaybackAudioData(): MKAudioQuality | null;
+    getPlaybackSpeed(): number;
+    getPlaybackVideoData(): MKVideoQuality | null;
+    getSeekableRange(mode?: MKTimeMode | undefined): MKTimeRange | null;
+    getThumbnail(time: number): MKThumbnail | null;
+    getTimeShift(): number;
+    getTotalStalledTime(): number;
+    getVideoElement(): HTMLVideoElement | undefined;
+    getVideoQuality(): MKVideoQuality | null;
+    getViewMode(): MKViewMode | null;
+    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;
+    pause(issuer?: string): void;
+    play(issuer?: string): Promise<void>;
+    preload(): void;
+    removeSubtitle(subtitleID: string): void;
+    seek(time: number, issuer?: string): boolean;
+    seekToLiveEdge(issuer?: string): void;
+    setAspectRatio(aspectratio: string | number): void;
+    setAudio(trackID: string): void;
+    setAudioQuality(audioQualityID: string): void;
+    setAuthorizationToken(authorizationToken: string): void;
+    setInhomeStatus(inhomeStatus: boolean): void;
+    setLocationDetail(locationDetail: string): 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;
+    setVolume(volume: number, issuer?: string): void;
+    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;
+    private updateSourceConfigFromRollInfo;
+    private initializeBitmovinPlayerEngine;
+    private initializePlayer;
+    private addListeners;
+    private emitProgramTimeChangedEvent;
+    private unloadAndEmitErrorEvent;
+    private emitProgramRestrictionsEvent;
+    private loadSource;
+    private scheduleSessionBeaconNotifications;
+    private onBeaconNotificationError;
+    private cancelSessionBeaconNotifications;
+}

package/src/classes/player/index.d.ts

@@ -0,0 +1,2 @@
+export { MKBitmovinPlayer } from "./MKBitmovinPlayer";
+export { MKPlayer } from "./MKPlayer";

package/src/classes/request/MKAzukiRequest.d.ts

@@ -0,0 +1,27 @@
+import { MKHttpRequest } from "./MKHttpRequest";
+import { MKProgramInfo, MKSourceConfig, MKRollInfo } from "../../interfaces";
+export declare class MKAzukiRequest extends MKHttpRequest {
+    private mediaId;
+    private ownerUid;
+    private sessionId;
+    private baseUrl;
+    private headers;
+    private isLive;
+    private rightsMode;
+    private catchupStartTime?;
+    private localStorage;
+    private beaconInterval;
+    static locationDetail?: string;
+    static inhomeStatus: boolean;
+    constructor(sourceConfig: MKSourceConfig);
+    setAuthorizationToken(authorizationToken: string): void;
+    getBeaconInterval(): number;
+    registrationRequest(): Promise<void>;
+    rollRequest(): Promise<MKRollInfo>;
+    beaconRequest(isFinalBeacon?: boolean): Promise<void>;
+    programInfoRequest(startDate: string, endDate: string): Promise<MKProgramInfo[]>;
+    pendingBeaconRequest(): Promise<void>;
+    private getRequestHeaders;
+    private saveBeaconData;
+    private clearBeaconData;
+}

package/src/classes/request/MKHttpRequest.d.ts

@@ -0,0 +1,11 @@
+import { MKHttpRequestOptions } from "../../interfaces";
+export declare class MKHttpRequest {
+    private abortController;
+    constructor();
+    get(url: string, options?: MKHttpRequestOptions): Promise<Response>;
+    put(url: string, options?: MKHttpRequestOptions): Promise<Response>;
+    post(url: string, options?: MKHttpRequestOptions): Promise<Response>;
+    delete(url: string, options?: MKHttpRequestOptions): Promise<Response>;
+    cancelRequest(): void;
+    private request;
+}

package/src/classes/request/index.d.ts

@@ -0,0 +1,2 @@
+export { MKAzukiRequest } from "./MKAzukiRequest";
+export { MKHttpRequest } from "./MKHttpRequest";

package/src/constants/MKAzukiRequestEndpoint.d.ts

@@ -0,0 +1,36 @@
+export declare const MKAzukiRequestEndpoint: {
+    API_REQUEST_VERSION: string;
+    API_REQUEST_TYPE: string;
+    REGISTRATION: {
+        API: string;
+        get(baseUrl: string): string;
+    };
+    ROLL: {
+        API: string;
+        get(baseUrl: string): string;
+    };
+    BEACONS: {
+        API: string;
+        get(baseUrl: string): string;
+    };
+    QUERY: {
+        API: string;
+        get(baseUrl: string): string;
+    };
+    WV_LICENSE: {
+        API: string;
+        get(baseUrl: string): string;
+    };
+    PR_LICENSE: {
+        API: string;
+        get(baseUrl: string): string;
+    };
+    FP_LICENSE: {
+        API: string;
+        get(baseUrl: string): string;
+    };
+    FP_CERTIFICATE: {
+        API: string;
+        get(baseUrl: string): string;
+    };
+};

package/src/constants/MKConstants.d.ts

@@ -0,0 +1,16 @@
+export declare const MKConstants: {
+    HTTP_REQUEST_DEFAULT_TIMEOUT_MSECS: number;
+    AzukiIMC: string;
+    AzukiDefaultOwnerUid: string;
+    LiveEventPregameTuneDelta: number;
+    DrmPlatform: {
+        Widevine: string;
+        Fairplay: string;
+        Playready: string;
+    };
+    ErrorCodeTemplate: {
+        AzukiError: string;
+        PlayerError: string;
+        ProgramRestrictionError: string;
+    };
+};

package/src/constants/MKCustomError.d.ts

@@ -0,0 +1,14 @@
+export declare const MKCustomError: {
+    Unknown: {
+        code: string;
+        message: string;
+    };
+    Http: {
+        code: string;
+        message: string;
+    };
+    HttpAbort: {
+        code: string;
+        message: string;
+    };
+};

package/src/constants/index.d.ts

@@ -0,0 +1,3 @@
+export { MKAzukiRequestEndpoint } from "./MKAzukiRequestEndpoint";
+export { MKConstants } from "./MKConstants";
+export { MKCustomError } from "./MKCustomError";

package/src/enums/MKAdQuartile.d.ts

@@ -0,0 +1,5 @@
+export declare enum MKAdQuartile {
+    FirstQuartile = "firstquartile",
+    Midpoint = "midpoint",
+    ThirdQuartile = "thirdquartile"
+}

package/src/enums/MKAdType.d.ts

@@ -0,0 +1,6 @@
+export declare enum MKAdType {
+    Preroll = "preroll",
+    Midroll = "midroll",
+    Postroll = "postroll",
+    Unknown = "unknown"
+}

package/src/enums/MKBufferType.d.ts

@@ -0,0 +1,4 @@
+export declare enum MKBufferType {
+    BackwardDuration = "backwardduration",
+    ForwardDuration = "forwardduration"
+}

package/src/enums/MKDrmType.d.ts

@@ -0,0 +1,6 @@
+export declare enum MKDrmType {
+    Widevine = "widevine",
+    Playready = "playready",
+    Fairplay = "fairplay",
+    Unknown = "unknown"
+}