@mediakind/mkplayer 1.1.1 → 1.2.0

package/interfaces/MKPeriodContentInformation.d.ts

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

package/interfaces/MKPeriodInformation.d.ts

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

package/interfaces/MKPeriodSwitchObject.d.ts

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

package/interfaces/MKPlayReadyDrmConfig.d.ts

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

package/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/interfaces/MKPlayerAPI.d.ts

@@ -0,0 +1,96 @@
+import { MKAudioQuality } from "./MKAudioQuality";
+import { MKAudioTrack } from "./MKAudioTrack";
+import { MKBufferLevel } from "./MKBufferLevel";
+import { MKDownloadedAudioData } from "./MKDownloadedAudioData";
+import { MKDownloadedVideoData } from "./MKDownloadedVideoData";
+import { MKLowLatencySyncConfig } from "./MKLowLatencySyncConfig";
+import { MKPlayerEventCallback } from "./MKPlayerEventCallback";
+import { MKSourceConfig } from "./MKSourceConfig";
+import { MKSubtitleTrack } from "./MKSubtitleTrack";
+import { MKThumbnail } from "./MKThumbnail";
+import { MKTimeRange } from "./MKTimeRange";
+import { MKVideoQuality } from "./MKVideoQuality";
+import { MKViewModeOptions } from "./MKViewModeOptions";
+import { MKPlayerEvent, MKTimeMode, MKLogLevel, MKViewMode, MKBufferType, MKMediaType } from "../enums";
+export interface MKPlayerAPI {
+    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[];
+    getVersion(): string;
+    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 | 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;
+    on(eventType: MKPlayerEvent, callback: MKPlayerEventCallback): void;
+    off(eventType: MKPlayerEvent, callback: MKPlayerEventCallback): 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;
+}

package/interfaces/MKPlayerConfig.d.ts

@@ -0,0 +1,21 @@
+import { MKLogConfig } from "./MKLogConfig";
+import { MKCastConfig } from "./MKCastConfig";
+import { MKLiveConfig } from "./MKLiveConfig";
+import { MKBufferConfig } from "./MKBufferConfig";
+import { MKPlaybackConfig } from "./MKPlaybackConfig";
+import { MKAdaptationPlatformConfig } from "./MKAdaptationPlatformConfig";
+import { MKPlayerEventConfig } from "./MKPlayerEventConfig";
+export interface MKPlayerConfig {
+    key?: string;
+    ui?: boolean;
+    log?: MKLogConfig;
+    live?: MKLiveConfig;
+    cast?: MKCastConfig;
+    buffer?: MKBufferConfig;
+    playback?: MKPlaybackConfig;
+    events?: MKPlayerEventConfig;
+    adaptation?: MKAdaptationPlatformConfig;
+    enableHlsImageMediaPlaylistSupport?: boolean;
+    enableAdTrackingBeacons?: boolean;
+    enableSubtitleOverlay?: boolean;
+}

package/interfaces/MKPlayerEngine.d.ts

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

package/interfaces/MKPlayerEventCallback.d.ts

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

package/interfaces/MKPlayerEventConfig.d.ts

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

package/interfaces/MKPlayerTechnology.d.ts

@@ -0,0 +1,5 @@
+import { MKPlayerType, MKStreamType } from "../enums";
+export interface MKPlayerTechnology {
+    player: MKPlayerType;
+    streaming: MKStreamType;
+}

package/interfaces/MKPreferredTechnology.d.ts

@@ -0,0 +1,4 @@
+import { MKPlayerTechnology } from "./MKPlayerTechnology";
+export interface MKPreferredTechnology extends MKPlayerTechnology {
+    exclude?: boolean;
+}

package/interfaces/MKProgramInfo.d.ts

@@ -0,0 +1,6 @@
+import { MKProgramRestrictions } from "./MKProgramRestrictions";
+import { MKTimeRange } from "./MKTimeRange";
+export interface MKProgramInfo {
+    timeRange?: MKTimeRange;
+    programRestrictions: MKProgramRestrictions;
+}

package/interfaces/MKProgramRestrictions.d.ts

@@ -0,0 +1,5 @@
+import { MKError } from "./MKError";
+export interface MKProgramRestrictions {
+    controlBlocking: MKError[];
+    playbackBlocking: MKError[];
+}

package/interfaces/MKProgressiveSource.d.ts

@@ -0,0 +1,7 @@
+export interface MKProgressiveSource {
+    url: string;
+    type?: string;
+    bitrate?: number;
+    preferred?: boolean;
+    label?: string;
+}

package/interfaces/MKQuality.d.ts

@@ -0,0 +1,7 @@
+export interface MKQuality {
+    bitrate: number;
+    codec?: string;
+    id: string;
+    label?: string;
+    uid?: string;
+}

package/interfaces/MKQualityMetadata.d.ts

@@ -0,0 +1,9 @@
+export interface MKQualityMetadata {
+    id: string;
+    mimeType: string;
+    bitrate: number;
+    width: number;
+    height: number;
+    qualityRanking?: number;
+    frameRate?: number;
+}

package/interfaces/MKRegisteredSource.d.ts

@@ -0,0 +1,7 @@
+import { MKAzukiConfig } from "./MKAzukiConfig";
+export interface MKRegisteredSource {
+    mediaId: string;
+    azukiConfig: MKAzukiConfig;
+    applicationToken?: string;
+    catchupStartTime?: string;
+}

package/interfaces/MKRollInfo.d.ts

@@ -0,0 +1,16 @@
+import { MKDrmConfig } from "./MKDrmConfig";
+import { MKProgramInfo } from "./MKProgramInfo";
+import { MKDrmType, MKStreamType } from "../enums";
+export interface MKRollInfo {
+    mediaId: string;
+    isLive: boolean;
+    isLiveEvent: boolean;
+    beaconInterval: number;
+    drmType: MKDrmType;
+    drmConfig?: MKDrmConfig;
+    streamType: MKStreamType;
+    sourceUrl: string;
+    failoverSourceUrl?: string;
+    programInfo: MKProgramInfo;
+    asidInitToken?: string;
+}

package/interfaces/MKSourceConfig.d.ts

@@ -0,0 +1,32 @@
+import { MKAssetType } from "../enums";
+import { MKDrmConfig } from "./MKDrmConfig";
+import { MKUllSource } from "./MKUllSource";
+import { MKCdnOptions } from "./MKCdnOptions";
+import { MKSourceOptions } from "./MKSourceOptions";
+import { MKSubtitleTrack } from "./MKSubtitleTrack";
+import { MKThumbnailTrack } from "./MKThumbnailTrack";
+import { MKAnalyticsConfig } from "./MKAnalyticsConfig";
+import { MKRegisteredSource } from "./MKRegisteredSource";
+import { MKProgressiveSource } from "./MKProgressiveSource";
+import { MKSourceLabelingStreamTypeConfig } from "./MKSourceLabelingStreamTypeConfig";
+export interface MKSourceConfig {
+    title?: string;
+    description?: string;
+    poster?: string;
+    sessionId?: string;
+    assetType?: MKAssetType;
+    hls?: string;
+    dash?: string;
+    smooth?: string;
+    progressive?: string | MKProgressiveSource[];
+    whep?: string;
+    ull?: MKUllSource;
+    registered?: MKRegisteredSource;
+    drmConfig?: MKDrmConfig;
+    cdnOptions?: MKCdnOptions;
+    sourceOptions?: MKSourceOptions;
+    labeling?: MKSourceLabelingStreamTypeConfig;
+    analyticsConfig?: MKAnalyticsConfig;
+    subtitleTracks?: MKSubtitleTrack[];
+    thumbnailTrack?: MKThumbnailTrack;
+}

package/interfaces/MKSourceLabelingConfig.d.ts

@@ -0,0 +1,8 @@
+import { MKQualityMetadata } from "./MKQualityMetadata";
+import { MKSubtitleTrack } from "./MKSubtitleTrack";
+import { MKTrackMetadata } from "./MKTrackMetadata";
+export interface MKSourceLabelingConfig {
+    tracks?: (track: MKTrackMetadata) => string;
+    qualities?: (quality: MKQualityMetadata) => string;
+    subtitles?: (subtitle: MKSubtitleTrack) => string;
+}

package/interfaces/MKSourceLabelingStreamTypeConfig.d.ts

@@ -0,0 +1,5 @@
+import { MKSourceLabelingConfig } from "./MKSourceLabelingConfig";
+export interface MKSourceLabelingStreamTypeConfig {
+    dash?: MKSourceLabelingConfig;
+    hls?: MKSourceLabelingConfig;
+}

package/interfaces/MKSourceOptions.d.ts

@@ -0,0 +1,18 @@
+import { MKRequestHeaders } from "../alias";
+import { MKStartOffsetTimelineReference } from "../enums";
+import { MKPeriodInformation } from "./MKPeriodInformation";
+export interface MKSourceOptions {
+    audioCodecPriority?: string[];
+    dashManifestWithCredentials?: boolean;
+    dashWithCredentials?: boolean;
+    headers?: MKRequestHeaders;
+    hlsManifestWithCredentials?: boolean;
+    hlsWithCredentials?: boolean;
+    manifestWithCredentials?: boolean;
+    persistentPoster?: boolean;
+    shouldRecreateSourceBuffersOnPeriodSwitch?: ((sourcePeriodInfo: MKPeriodInformation, targetPeriodInfo: MKPeriodInformation, suggestion: boolean) => boolean);
+    startOffset?: number;
+    startOffsetTimelineReference?: MKStartOffsetTimelineReference;
+    videoCodecPriority?: string[];
+    withCredentials?: boolean;
+}

package/interfaces/MKSubtitleCue.d.ts

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

package/interfaces/MKSubtitleCuePosition.d.ts

@@ -0,0 +1,4 @@
+export interface MKSubtitleCuePosition {
+    column: number;
+    row: number;
+}

package/interfaces/MKSubtitleTrack.d.ts

@@ -0,0 +1,5 @@
+import { MKTextTrack } from "./MKTextTrack";
+export interface MKSubtitleTrack extends MKTextTrack {
+    enabled?: boolean;
+    forced?: boolean;
+}

package/interfaces/MKSynchronizationConfigEntry.d.ts

@@ -0,0 +1,5 @@
+import { MKLiveSynchronizationMethod } from "../enums";
+export interface MKSynchronizationConfigEntry {
+    method: MKLiveSynchronizationMethod;
+    serverUrl: string;
+}

package/interfaces/MKTextTrack.d.ts

@@ -0,0 +1,7 @@
+import { MKMediaTrack } from "./MKMediaTrack";
+export interface MKTextTrack extends MKMediaTrack {
+    isFragmented?: boolean;
+    kind: string;
+    lang: string;
+    url?: string;
+}

package/interfaces/MKThumbnail.d.ts

@@ -0,0 +1,10 @@
+export interface MKThumbnail {
+    end: number;
+    height: number;
+    start: number;
+    text: string;
+    url: string;
+    width: number;
+    x: number;
+    y: number;
+}

package/interfaces/MKThumbnailTrack.d.ts

@@ -0,0 +1,3 @@
+export interface MKThumbnailTrack {
+    url: string;
+}

package/interfaces/MKTimeRange.d.ts

@@ -0,0 +1,4 @@
+export interface MKTimeRange {
+    start: number;
+    end: number;
+}

package/interfaces/MKTrackMetadata.d.ts

@@ -0,0 +1,5 @@
+export interface MKTrackMetadata {
+    id?: string;
+    mimeType?: string;
+    lang: string;
+}

package/interfaces/MKUllSource.d.ts

@@ -0,0 +1,4 @@
+export interface MKUllSource {
+    channelId: string;
+    controllerServiceUrl: string;
+}

package/interfaces/MKVTTProperties.d.ts

@@ -0,0 +1,13 @@
+import { MKVTTRegionProperties } from "./MKVTTRegionProperties";
+export interface MKVTTProperties {
+    align: "left" | "start" | "center" | "middle" | "end" | "right";
+    id?: string;
+    line: number | string;
+    lineAlign: "start" | "center" | "auto";
+    position: number | "auto";
+    positionAlign: "line-left" | "center" | "line-right" | "auto";
+    region?: MKVTTRegionProperties;
+    size: number;
+    snapToLines: boolean;
+    vertical: "rl" | "lr" | "";
+}

package/interfaces/MKVTTRegionProperties.d.ts

@@ -0,0 +1,10 @@
+export interface MKVTTRegionProperties {
+    id: string;
+    lines: number;
+    regionAnchorX: number;
+    regionAnchorY: number;
+    scroll: "up" | "";
+    viewportAnchorX: number;
+    viewportAnchorY: number;
+    width: number;
+}

package/interfaces/MKVideoAdaptationData.d.ts

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

package/interfaces/MKVideoQuality.d.ts

@@ -0,0 +1,6 @@
+import { MKQuality } from "./MKQuality";
+export interface MKVideoQuality extends MKQuality {
+    frameRate?: number;
+    height: number;
+    width: number;
+}

package/interfaces/MKVideoSizeLimitationConfig.d.ts

@@ -0,0 +1,6 @@
+export interface MKVideoSizeLimitationConfig {
+    maxSelectableVideoHeight?: number;
+    maxSelectableVideoWidth?: number;
+    minSelectableVideoHeight?: number;
+    minSelectableVideoWidth?: number;
+}

package/interfaces/MKVideoTrack.d.ts

@@ -0,0 +1,5 @@
+import { MKMediaTrack } from "./MKMediaTrack";
+import { MKVideoQuality } from "./MKVideoQuality";
+export interface MKVideoTrack extends MKMediaTrack {
+    getQualities(): MKVideoQuality[];
+}

package/interfaces/MKViewModeOptions.d.ts

@@ -0,0 +1,3 @@
+export interface MKViewModeOptions {
+    fullscreenElement?: HTMLElement;
+}

package/interfaces/MKWidevineModularDrmConfig.d.ts

@@ -0,0 +1,13 @@
+import { MKRequestHeaders } from "../alias";
+export interface MKWidevineModularDrmConfig {
+    LA_URL?: string;
+    audioRobustness?: string;
+    headers?: MKRequestHeaders;
+    licenseRequestRetryDelay?: number;
+    maxLicenseRequestRetries?: number;
+    prepareLicense?: ((licenseObject: any) => any);
+    prepareMessage?: ((keyMessage: any) => any);
+    serverCertificate?: ArrayBuffer;
+    videoRobustness?: string;
+    withCredentials?: boolean;
+}

package/interfaces/events/MKAdBreakFinishedEvent.d.ts

@@ -0,0 +1,4 @@
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKAdBreakFinishedEvent extends MKPlayerEventBase {
+    id: string;
+}

package/interfaces/events/MKAdBreakStartedEvent.d.ts

@@ -0,0 +1,10 @@
+import { MKAdType } from "../../enums";
+import { MKTimeRange } from "../MKTimeRange";
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKAdBreakStartedEvent extends MKPlayerEventBase {
+    id: string;
+    adType: MKAdType;
+    adsCount: number;
+    duration: number;
+    offset: MKTimeRange;
+}

package/interfaces/events/MKAdClickThroughEvent.d.ts

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

package/interfaces/events/MKAdCompanionEvent.d.ts

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

package/interfaces/events/MKAdFinishedEvent.d.ts

@@ -0,0 +1,4 @@
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKAdFinishedEvent extends MKPlayerEventBase {
+    id: string;
+}

package/interfaces/events/MKAdMarkerEvent.d.ts

@@ -0,0 +1,5 @@
+import { MKTimeRange } from "../MKTimeRange";
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKAdMarkerEvent extends MKPlayerEventBase {
+    adMarker: MKTimeRange;
+}

package/interfaces/events/MKAdQuartileEvent.d.ts

@@ -0,0 +1,6 @@
+import { MKAdQuartile } from "../../enums";
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKAdQuartileEvent extends MKPlayerEventBase {
+    id: string;
+    quartile: MKAdQuartile;
+}

package/interfaces/events/MKAdStartedEvent.d.ts

@@ -0,0 +1,12 @@
+import { MKTimeRange } from "../MKTimeRange";
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKAdStartedEvent extends MKPlayerEventBase {
+    id: string;
+    adIndex: string | number;
+    duration: number;
+    offset: MKTimeRange;
+    title?: string;
+    system?: string;
+    creativeId?: string;
+    creativeAdId?: string;
+}

package/interfaces/events/MKAdaptationEvent.d.ts

@@ -0,0 +1,4 @@
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKAdaptationEvent extends MKPlayerEventBase {
+    representationID: string;
+}

package/interfaces/events/MKAirplayChangedEvent.d.ts

@@ -0,0 +1,4 @@
+import { MKPlaybackEvent } from "./MKPlaybackEvent";
+export interface MKAirplayChangedEvent extends MKPlaybackEvent {
+    airplayEnabled: boolean;
+}

package/interfaces/events/MKAspectRatioChangedEvent.d.ts

@@ -0,0 +1,5 @@
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKAspectRatioChangedEvent extends MKPlayerEventBase {
+    from: number;
+    to: number;
+}

package/interfaces/events/MKAudioAdaptationEvent.d.ts

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

package/interfaces/events/MKAudioChangedEvent.d.ts

@@ -0,0 +1,6 @@
+import { MKAudioTrack } from "../MKAudioTrack";
+import { MKPlaybackEvent } from "./MKPlaybackEvent";
+export interface MKAudioChangedEvent extends MKPlaybackEvent {
+    sourceAudio: MKAudioTrack;
+    targetAudio: MKAudioTrack;
+}

package/interfaces/events/MKAudioDownloadQualityChangeEvent.d.ts

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

package/interfaces/events/MKAudioDownloadQualityChangedEvent.d.ts

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

package/interfaces/events/MKAudioPlaybackQualityChangedEvent.d.ts

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

package/interfaces/events/MKAudioQualityChangedEvent.d.ts

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

package/interfaces/events/MKAudioQualityEvent.d.ts

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

package/interfaces/events/MKAudioTrackEvent.d.ts

@@ -0,0 +1,5 @@
+import { MKAudioTrack } from "../MKAudioTrack";
+import { MKPlaybackEvent } from "./MKPlaybackEvent";
+export interface MKAudioTrackEvent extends MKPlaybackEvent {
+    track: MKAudioTrack;
+}

package/interfaces/events/MKCastAvailableEvent.d.ts

@@ -0,0 +1,4 @@
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKCastAvailableEvent extends MKPlayerEventBase {
+    receiverAvailable: boolean;
+}

package/interfaces/events/MKCastStartedEvent.d.ts

@@ -0,0 +1,5 @@
+import { MKPlayerEventBase } from "./MKPlayerEventBase";
+export interface MKCastStartedEvent extends MKPlayerEventBase {
+    deviceName: string;
+    resuming: boolean;
+}