@npo/player 1.29.1 → 2.0.0-beta.1

package/dist/main.d.ts

@@ -0,0 +1,1242 @@
+import { default as default_2 } from 'shaka-player';
+
+declare class AdvertService {
+    private readonly player;
+    private readonly vastParser;
+    private adContainer?;
+    private adVideoElement?;
+    private clickElement?;
+    private isInitialized;
+    private session?;
+    private videoElement?;
+    private readonly boundClickElementHandler;
+    constructor(player: PlayerApi);
+    initialize(): Promise<void>;
+    requestAds(streamObject: IStreamObject): Promise<void>;
+    pauseAd(): void;
+    resumeAd(): void;
+    isPlayingAd(): boolean;
+    isAdPaused(): boolean;
+    skipAd(): void;
+    getAdRemainingTime(): number;
+    getCurrentTime(): number;
+    getDuration(): number;
+    getTotalAds(): number;
+    getAdPosition(): number;
+    setVolume(volume: number): void;
+    getVolume(): number;
+    mute(): void;
+    unmute(): void;
+    destroy(): void;
+    setAdClickElement(el: HTMLElement | null): void;
+    private getContentVideo;
+    private ensureSession;
+}
+
+declare type AirPlayConnectionState = {
+    available: boolean;
+    connected: boolean;
+    error?: string;
+};
+
+declare class AirPlayService implements IAirPlayService {
+    private readonly player;
+    private readonly mediaEl;
+    private readonly boundCheckConnected;
+    constructor(player: PlayerApi);
+    destroy(): void;
+    private addEventListeners;
+    private updateAirPlayState;
+    checkAvailability(): boolean;
+    private checkConnected;
+    startAirPlay(): void;
+    stopAirPlay(): void;
+}
+
+declare type CastConnectionState = {
+    available: boolean;
+    connected: boolean;
+    error?: string;
+};
+
+declare type CastingData = {
+    source: string;
+    streamObject?: IStreamObject;
+    metadata?: NpoPlayerMetaData;
+    npoTagSession?: string;
+};
+
+declare class CastService {
+    private castInitialized;
+    private readonly receiverApplicationId;
+    private readonly player;
+    private castContext;
+    private streamObject;
+    private volumeBeforeCasting;
+    private playbackRate;
+    private npoTagSession;
+    private drmConfig;
+    private source;
+    private boundMediaListeners;
+    private currentAvailability;
+    private checkCastAvailabilityIntervalId;
+    constructor(player: PlayerApi, receiverApplicationId: string);
+    destroy(): void;
+    private initializeCastCheckInterval;
+    private checkCastAvailability;
+    private isCastConnected;
+    private getCheckCastIntervalTime;
+    private loadCastSdk;
+    updateCastingData({ source, streamObject, metadata, npoTagSession }: CastingData): void;
+    initialize(): Promise<void>;
+    isCastAvailable(): boolean;
+    isCastActive(): boolean;
+    startCastSession(): void;
+    private updateMediaElementVisibility;
+    stopCastSession(): void;
+    getCastDeviceName(): string | undefined;
+    private hasValidMediaUrl;
+    private getSession;
+    private loadMedia;
+    private getImageSizeAsync;
+    private constructMediaMetadata;
+    private attachMediaListeners;
+    private updateCastState;
+    private syncCastAndPlayer;
+}
+
+declare interface Chapter {
+    from: number;
+    until: number;
+    type: string;
+    title: string;
+}
+
+declare interface ChapterSkipOptions {
+    skippableTypes?: string[];
+}
+
+declare class ChapterSkipService implements IChapterSkipService_2 {
+    private readonly player;
+    private skippableTypes;
+    private readonly chaptersMap;
+    private readonly activeChapters;
+    currentChapter: Chapter | undefined;
+    isCurrentChapterSkippable: boolean;
+    constructor(player: PlayerApi, options?: ChapterSkipOptions);
+    setSkippableTypes(types: string[]): void;
+    registerChapters(chapters: Chapter[]): void;
+    skipCurrentChapter(): void;
+    private getChapterId;
+    private convertChaptersToActions;
+    private isChapterSkippable;
+    private setupEventListeners;
+    private readonly handleActionTriggered;
+    private readonly handleActionExited;
+    private updateCurrentChapter;
+    private clearCurrentChapter;
+    private hasAnyNonSkippableChapter;
+    private hideSkipButton;
+    private findLongestSkippableChapter;
+    private setCurrentChapter;
+    private hasChapterChanged;
+    private emitChapterExitEvent;
+    private clearChapters;
+    destroy(): void;
+    reset(): void;
+}
+
+declare enum DisplayModes {
+    INLINE = "inline",
+    FULLSCREEN = "fullscreen",
+    PIP = "pip"
+}
+
+export declare const DRM_FAIRPLAY = "fairplay";
+
+export declare const DRM_PLAYREADY = "playready";
+
+export declare const DRM_WIDEVINE = "widevine";
+
+export declare type DRMType = typeof DRM_WIDEVINE | typeof DRM_PLAYREADY | typeof DRM_FAIRPLAY;
+
+declare type EmitParams<T, K extends keyof T> = {
+    eventName: K;
+    value?: T[K];
+};
+
+declare type ErrorListener = (error: IPlayerError) => void;
+
+declare class ErrorManager implements IErrorManager {
+    private static globalHandlersAttached;
+    private static _lastInstance;
+    private readonly errorListeners;
+    private readonly resetListeners;
+    private readonly warningListeners;
+    private npoPlayerRef;
+    private debounceCleanup?;
+    private isDestroyed;
+    constructor(npoPlayer: NpoPlayer);
+    destroy(): void;
+    private attachGlobalErrorHandlers;
+    setNpoPlayerRef(npoPlayer: NpoPlayer): void;
+    onError(listener: ErrorListener): void;
+    onReset(listener: ResetListener): void;
+    onWarning(listener: WarningListener): void;
+    static handleSilentError(playerError: IPlayerError): void;
+    handleError(config: HandleErrorConfig): IPlayerError;
+    private _logNpoTagError;
+    handleErrorState(config: IErrorStateHandlerConfig): void;
+    setupErrorDebounce(config: IErrorDebounceConfig): void;
+    /**
+     * Simulate an error for testing purposes
+     * This triggers the error handling flow including QoS metrics logging
+     *
+     * @param errorCode - The error code to simulate (default: 1012)
+     */
+    simulateError(errorCode?: number): IPlayerError;
+}
+
+declare type HandleErrorConfig = IBaseErrorConfig;
+
+export declare interface IActionContext {
+    currentTime: number;
+    duration: number;
+    action: ITimeBoundAction;
+    player: IPlayerApi;
+}
+
+declare interface IAdUiState {
+    isPlayingAd: boolean;
+    isAdPaused: boolean;
+    duration: number;
+    remainingTime: number;
+    currentTime: number;
+    adPosition: number;
+    totalAds: number;
+}
+
+declare interface IAdUiState_2 {
+    isPlayingAd: boolean;
+    isAdPaused: boolean;
+    duration: number;
+    remainingTime: number;
+    currentTime: number;
+    adPosition: number;
+    totalAds: number;
+}
+
+declare interface IAirPlayService {
+    checkAvailability(): boolean;
+    startAirPlay(): void;
+    stopAirPlay(): void;
+}
+
+declare interface IBaseErrorConfig {
+    errorEvent: IPlayerError;
+    customErrorMessageOverlayConfig?: Record<number, string>;
+    emitError?: (payload: IPlayerError) => void;
+    setErrorState?: (payload: IPlayerError) => void;
+    resetFn?: () => void;
+}
+
+declare interface IChapterSkipService {
+    skipCurrentChapter(): void;
+}
+
+declare interface IChapterSkipService_2 {
+    currentChapter: Chapter | undefined;
+    isCurrentChapterSkippable: boolean;
+    registerChapters(chapters: Chapter[]): void;
+    skipCurrentChapter(): void;
+    setSkippableTypes(types: string[]): void;
+    destroy(): void;
+    reset(): void;
+}
+
+export declare interface ICustomDRMConfig {
+    drmType: DRMType;
+    profileName: ProfileName;
+    secure?: boolean;
+    headers?: Record<string, string>;
+}
+
+declare interface IErrorDebounceConfig {
+    player: any;
+    mediaElement: HTMLMediaElement;
+    setErrorStateFn: (errorEvent: Event) => void;
+    resetFn: () => void;
+    debounceTimeInMs?: number;
+}
+
+export declare interface IErrorManager {
+    handleError(config: HandleErrorConfig): IPlayerError;
+    handleErrorState(config: IErrorStateHandlerConfig): void;
+    setupErrorDebounce(config: IErrorDebounceConfig): void;
+    onError(listener: (error: IPlayerError) => void): void;
+    onReset(listener: () => void): void;
+    onWarning(listener: (warning: IPlayerError) => void): void;
+}
+
+declare interface IErrorStateHandlerConfig extends IBaseErrorConfig {
+    mediaElement: HTMLMediaElement;
+    retryCallback?: (lastTimestamp: number) => Promise<any>;
+}
+
+declare interface IInputHandler {
+    addKeyMapping(combo: KeyCombo, handler: (event: KeyboardEvent) => void): void;
+    removeKeyMapping(combo: KeyCombo): void;
+    defaultKeyCombos: Record<string, KeyCombo>;
+    playbackRateOptions: number[] | undefined;
+}
+
+declare interface IInputHandler_2 {
+    addKeyMapping(combo: KeyCombo_2, handler: (event: KeyboardEvent) => void): void;
+    removeKeyMapping(combo: KeyCombo_2): void;
+    defaultKeyCombos: Record<string, KeyCombo_2>;
+    playbackRateOptions: number[] | undefined;
+}
+
+export declare interface INpoAudioPlayerUIFactory extends INpoPlayerUIFactory {
+    init(config: NpoPlayerUIFactoryConfig): void;
+}
+
+declare interface INpoPlayerUIFactory {
+    mediaElement: HTMLMediaElement | null;
+    updateModeClass(): void;
+    setMetadata(metadata: IStreamObjectMetadata, infoPanelHTML?: string): void;
+    setBackButtonCallback?(callback?: () => void): void;
+    setLoadingState(): void;
+    removeLoadingState(): void;
+    resetUI(): void;
+    destroy(): void;
+}
+
+export declare interface INpoVideoPlayerUIFactory extends INpoPlayerUIFactory {
+    init(config: NpoPlayerUIFactoryConfig): void;
+}
+
+declare class InputHandler implements IInputHandler_2 {
+    private keyMappings;
+    private readonly player;
+    private readonly container;
+    private readonly focusManager;
+    private isAttached;
+    playbackRateOptions: number[];
+    constructor(player: PlayerApi, container: HTMLElement);
+    readonly defaultKeyCombos: Record<string, KeyCombo_2>;
+    private setupKeyMappings;
+    private readonly keydownHandler;
+    private matchesKeyCombo;
+    private shouldHandleKeyEvent;
+    private volumeUp;
+    private volumeDown;
+    private increasePlaybackRate;
+    private decreasePlaybackRate;
+    attach(): void;
+    detach(): void;
+    addKeyMapping(combo: KeyCombo_2, handler: (event: KeyboardEvent) => void): void;
+    removeKeyMapping(combo: KeyCombo_2): void;
+    resetInteractionState(): void;
+    hasUserInteractedOutsideContainer(): boolean;
+    isInputHandlerAttached(): boolean;
+    destroy(): void;
+}
+
+export declare interface IPlayerApi {
+    playerId: string;
+    player: unknown;
+    playerEvents: IPlayerEventEmitter<IPlayerEventsMap>;
+    uiEvents: any;
+    play(): Promise<void>;
+    pause(): void;
+    togglePlayPause(): Promise<void>;
+    replay(): void;
+    isLive(): boolean;
+    getMode(): Modes;
+    getSeekRange(): {
+        start: number;
+        end: number;
+    };
+    forward(seconds?: number): void;
+    backward(seconds?: number): void;
+    getMediaElement(): HTMLMediaElement | null;
+    getPlayerContainer(): HTMLElement | null;
+    reemit(eventName: string, data?: any): void;
+    on(eventName: string, handler: (evt: any) => void): void;
+    off(eventName: string, handler: (evt: any) => void): void;
+    once(eventName: string, handler: (evt: any) => void): void;
+    isBuffering(): boolean;
+    getPlaybackRate(): number;
+    setPlaybackRate(rate: number): void;
+    getVolume(): number;
+    setVolume(volume: number): void;
+    mute(): void;
+    unMute(): void;
+    isMuted(): boolean;
+    isPlaying(): boolean;
+    getDuration(): number;
+    getCurrentTime(): number;
+    seek(time: number): void;
+    seekToLiveEdge(): void;
+    getNetworkingEngine(): unknown;
+    removeAllTextTracks(): void;
+    setTextTrackVisibility(options: {
+        language: string;
+        persist?: boolean;
+    }): void;
+    getTextTracks(): TextTrackList;
+    getVariantTracks?(): Array<unknown>;
+    configure?(config: unknown): void;
+    isPlayingAd?(): boolean;
+    getAdUiState?(): IAdUiState;
+    onAdEvent?(eventName: string, handler: (evt: any) => void): void;
+    offAdEvent?(eventName: string, handler: (evt: any) => void): void;
+    setAdClickElement(button: HTMLButtonElement): void;
+    enterFullscreen(): void;
+    exitFullscreen(): void;
+    isFullscreenPossible(): boolean;
+    isDisplayModeChangeAllowed(): boolean;
+    isPipSupported(): boolean;
+    enterPip(): Promise<void>;
+    exitPip(): Promise<void>;
+    castService: {
+        isCastAvailable(): boolean;
+        isCastActive(): boolean;
+        startCastSession(): void;
+        stopCastSession(): void;
+        getCastDeviceName(): string;
+    };
+    state: IPlayerState;
+    airPlayService: IAirPlayService;
+    thumbnailService?: IThumbnailTrackService;
+    chapterSkipService?: IChapterSkipService;
+    streamTrackService?: IStreamTrackService;
+    mediaStateListeners?: () => void;
+}
+
+declare interface IPlayerContext {
+    source: string;
+    streamObject: IStreamObject;
+    playerConfig: NpoPlayerConfig;
+    streamOptions?: StreamOptions;
+}
+
+export declare interface IPlayerError {
+    code: number;
+    message: string;
+    original?: any;
+    silent?: boolean;
+}
+
+declare interface IPlayerEventEmitter<T extends Record<string, any>> {
+    emit<K extends keyof T>(params: {
+        eventName: K;
+        value?: T[K];
+    }): void;
+    on<K extends keyof T>(params: {
+        eventName: K;
+        listener: (event: CustomEvent<T[K]>) => void;
+    }): void;
+    off<K extends keyof T>(params: {
+        eventName: K;
+        listener: (event: CustomEvent<T[K]>) => void;
+    }): void;
+}
+
+declare interface IPlayerEventsMap {
+    [PlayerEventNames.MediaStateChanged]: MediaStates;
+    [PlayerEventNames.DisplayModeChanged]: DisplayModes;
+    [PlayerEventNames.CastStateChanged]: Event;
+    [PlayerEventNames.AirPlayStateChanged]: AirPlayConnectionState;
+    [PlayerEventNames.AirPlayConnectionChanged]: Event;
+    [PlayerEventNames.AdComplete]: Event;
+    [PlayerEventNames.AdError]: {
+        error: unknown;
+    };
+    [PlayerEventNames.AdPaused]: Event;
+    [PlayerEventNames.AdResumed]: Event;
+    [PlayerEventNames.AdSkipped]: Event;
+    [PlayerEventNames.AdStarted]: Event;
+    [PlayerEventNames.AdUiUpdate]: Event;
+    [PlayerEventNames.AllAdsCompleted]: Event;
+    [PlayerEventNames.CanPlay]: Event;
+    [PlayerEventNames.CanPlayThrough]: Event;
+    [PlayerEventNames.DurationChange]: Event;
+    [PlayerEventNames.Ended]: Event;
+    [PlayerEventNames.Error]: Event | Record<string, unknown>;
+    [PlayerEventNames.LoadedData]: Event;
+    [PlayerEventNames.LoadedMetadata]: Event;
+    [PlayerEventNames.Pause]: Event;
+    [PlayerEventNames.Play]: Event;
+    [PlayerEventNames.Playing]: Event;
+    [PlayerEventNames.Progress]: Event;
+    [PlayerEventNames.RateChange]: Event;
+    [PlayerEventNames.Buffering]: Event;
+    [PlayerEventNames.Seeked]: Event;
+    [PlayerEventNames.Seeking]: Event;
+    [PlayerEventNames.Stalled]: Event;
+    [PlayerEventNames.TimeUpdate]: Event;
+    [PlayerEventNames.VolumeChange]: Event;
+    [PlayerEventNames.Waiting]: Event;
+    [PlayerEventNames.TimeBoundActionTriggered]: {
+        action: ITimeBoundAction;
+        context: IActionContext;
+    };
+    [PlayerEventNames.TimeBoundActionExited]: {
+        action: ITimeBoundAction;
+        context: IActionContext;
+    };
+    [PlayerEventNames.ChapterEntered]: {
+        chapter: Chapter;
+        isSkippable: boolean;
+    };
+    [PlayerEventNames.ChapterExited]: {
+        action: ITimeBoundAction;
+    };
+    [PlayerEventNames.StreamTrackChanged]: Event;
+}
+
+declare interface IPlayerLoad {
+    normalizedAvType?: MediaType;
+    avType?: string;
+    hasDvrWindow?: boolean;
+    isLiveStream?: boolean;
+    streamProfile?: string;
+    sourceProfile?: string;
+}
+
+declare interface IPlayerState {
+    adActive: boolean;
+    adPaused: boolean;
+    airPlay: AirPlayConnectionState;
+    audioLanguage: string;
+    audioPlaybackQuality: number;
+    cast: CastConnectionState;
+    displayMode: DisplayModes;
+    forceUIVisible: boolean;
+    fullscreen: boolean;
+    language: string;
+    mediaState: MediaStates;
+    muted: boolean;
+    playbackRate: number;
+    subtitleLanguage: string;
+    useAudioDescription: boolean;
+    videoPlaybackQuality: number;
+    volume: number;
+}
+
+declare interface ISegment {
+    inpoint: number;
+    outpoint: number;
+    duration: number;
+}
+
+export declare interface ISterData {
+    identifier: string;
+    deviceType?: number;
+    os?: string;
+    osVersion?: string;
+    player?: string;
+}
+
+declare interface IStreamDrmConfig {
+    token?: string;
+    certificateUrl?: string;
+    licenseUrl: string;
+    type: string;
+    expirationInSeconds?: number;
+    httpHeaders?: Record<string, string>;
+}
+
+export declare interface IStreamObject {
+    stream: IStreamObjectStream;
+    metadata: IStreamObjectMetadata;
+    assets?: IStreamObjectAssets;
+    user: {
+        type: 'plus' | 'anonymous';
+    };
+    segment?: ISegment;
+}
+
+declare interface IStreamObjectAssets {
+    scrubbingThumbnail?: string;
+    subtitles?: ISubtitle[];
+    preroll?: string;
+    prerollDebug?: string;
+}
+
+export declare interface IStreamObjectMetadata {
+    ageRating?: string;
+    avType?: string;
+    broadcaster?: string;
+    channel?: string;
+    chapters?: Chapter[];
+    description: string;
+    duration?: string;
+    genres?: string[];
+    hasPreroll?: string;
+    nicam?: string[];
+    omroep?: string;
+    poster?: string;
+    posterIsDefault?: boolean;
+    prid?: string;
+    title: string;
+}
+
+declare interface IStreamObjectStream {
+    avType: string;
+    drmToken?: string;
+    drmType: string;
+    drm?: IStreamDrmConfig;
+    streamProfile: string;
+    sourceProfile: string;
+    streamURL: string;
+    isLiveStream?: boolean;
+    hasDvrWindow?: boolean;
+}
+
+declare interface IStreamTrackService {
+    currentTrack: StreamTrack | undefined;
+    getAvailableVideoTracks(): StreamTrack[];
+    getAudioTracksByVideoQuality(qualityValue: number): StreamTrack[];
+    getAudioOnlyTracks(): StreamTrack[];
+    setTrack(track: StreamTrack, forced: boolean): void;
+}
+
+declare interface ISubtitle {
+    iso: string;
+    location: string;
+    name: string;
+}
+
+declare interface IThumbnailTrackService {
+    isAvailable(): boolean;
+    renderThumbnailToCanvas(time: number, canvas: HTMLCanvasElement): Promise<void>;
+}
+
+export declare interface ITimeBoundAction {
+    id: string;
+    type: TimeBoundActionType;
+    markerType?: MarkerTypes;
+    startTime: number;
+    endTime?: number;
+    callback?: (context: IActionContext) => void;
+    label?: string;
+    fireOnce?: boolean;
+}
+
+declare interface ITimeBoundActionsService {
+    initialize(): void;
+    destroy(): void;
+    registerAction(action: ITimeBoundAction): void;
+    registerActions(actions: ITimeBoundAction[]): void;
+    unregisterAction(actionId: string): void;
+    clearActions(): void;
+}
+
+declare type KeyCombo = {
+    key: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+};
+
+declare type KeyCombo_2 = {
+    key: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+};
+
+declare type Listener<T> = (event: CustomEvent<T>) => void;
+
+declare type Listener_2 = (...args: any[]) => void;
+
+declare class LogEmitter {
+    private readonly listeners;
+    emit(event: LogEventType, ...args: any[]): boolean;
+    on(event: LogEventType, listener: Listener_2): this;
+    once(event: LogEventType, listener: Listener_2): this;
+    off(event: LogEventType, listener: Listener_2): this;
+}
+
+export declare enum LogEventType {
+    ERROR = "logError",
+    EVENT = "logEvent"
+}
+
+export declare enum MarkerTypes {
+    ACTION = "action",
+    SEGMENT = "segment",
+    HIDDEN = "hidden"
+}
+
+export declare enum MediaStates {
+    PLAY = "play",
+    PAUSE = "pause",
+    BUFFERING = "buffering",
+    READY = "ready",
+    ERROR = "error",
+    ENDED = "ended"
+}
+
+export declare enum MediaType {
+    VIDEO = "video",
+    AUDIO = "audio"
+}
+
+export declare enum Modes {
+    VOD = "vod",
+    LIVE = "live",
+    LIVE_NO_DVR = "live-no-dvr",
+    NONE = "none"
+}
+
+export declare class NpoAudioPlayer extends NpoPlayerCore {
+    constructor(container: HTMLElement, playerConfig: NpoAudioPlayerConfig & {
+        uiFactory?: INpoAudioPlayerUIFactory;
+    });
+}
+
+export declare type NpoAudioPlayerConfig = NpoPlayerConfig & {
+    options?: NpoPlayerOptions;
+    uiFactory?: INpoAudioPlayerUIFactory;
+};
+
+declare type NpoPlayer = NpoAudioPlayer | NpoVideoPlayer;
+
+declare type NpoPlayerConfig = {
+    autoplay?: boolean;
+    options?: NpoPlayerOptions;
+    npoTag?: any;
+    chromecastReceiverId?: string;
+    uiFactory?: INpoPlayerUIFactory;
+    mediaType?: MediaType;
+    settingsStore?: any;
+    playbackRateOptions?: number[];
+};
+
+declare abstract class NpoPlayerCore {
+    player: PlayerApi;
+    uiFactory?: INpoAudioPlayerUIFactory | INpoVideoPlayerUIFactory;
+    errorManager: ErrorManager;
+    readonly version: string;
+    readonly container: HTMLElement;
+    readonly npoTagProps?: NpoTagProperties;
+    readonly logEmitter?: LogEmitter;
+    readonly playerConfig: NpoPlayerConfig;
+    readonly settingsStore: SettingsStore;
+    protected inputHandler: InputHandler;
+    protected playerContext?: IPlayerContext;
+    streamOptions: StreamOptions;
+    private readonly ready;
+    private readonly loadStreamService;
+    readonly cast: {
+        isAvailable: () => boolean;
+        isActive: () => boolean;
+        startSession: () => void;
+        stopSession: () => void;
+    };
+    constructor(container: HTMLElement, playerConfig: NpoAudioPlayerConfig | NpoVideoPlayerConfig);
+    private doError;
+    load(newSource: string, streamOptions?: StreamOptions): Promise<void>;
+    play(): Promise<void>;
+    pause(): void;
+    unload(): Promise<void>;
+    destroy(): Promise<void>;
+    seek(timestamp: number): void;
+    getCurrentTime(): number;
+    mute(): void;
+    unmute(): void;
+    isMuted(): boolean;
+    isPlaying(): boolean;
+    setVolume(volume: number): void;
+    getVolume(): number;
+    getDuration(): number;
+    isLive(): boolean;
+    isBuffering(): boolean;
+    getPlaybackRate(): number;
+    setPlaybackRate(rate: number): void;
+    getSeekRange(): {
+        start: number;
+        end: number;
+    };
+    seekToLiveEdge(): void;
+    getAvailableVideoQualities(): Array<StreamTrack>;
+    setVideoQuality(qualityValue: number): void;
+    on(eventName: string, handler: EventHandler): void;
+    off(eventName: string, handler: EventHandler): void;
+    once(eventName: string, handler: EventHandler): void;
+    /**
+     * Enable keyboard controls for the player
+     * Spacebar: Play/Pause, Left/Right arrows: Seek, Up/Down arrows: Volume, Escape: Exit fullscreen
+     */
+    enableKeyboardControls(): void;
+    /**
+     * Disable keyboard controls for the player
+     */
+    disableKeyboardControls(): void;
+    /**
+     * Check if keyboard controls are currently enabled
+     */
+    isKeyboardControlsEnabled(): boolean;
+    /**
+     * Add a custom keyboard shortcut
+     * @param combo - Key combination (e.g., { key: 'k', ctrl: true })
+     * @param callback - Function to execute when key combination is pressed
+     */
+    addKeyboardShortcut(combo: {
+        key: string;
+        ctrl?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+        meta?: boolean;
+    }, callback: (event: KeyboardEvent) => void): void;
+    retry(lastTimestamp: number): Promise<void>;
+    logClick(params: Omit<NpoTagClickEvent, 'click_chapter_1'>): void;
+}
+
+export declare type NpoPlayerMetaData = {
+    title?: string;
+    description?: string;
+    poster?: string;
+    broadcaster?: string;
+    posterIsDefault?: boolean;
+};
+
+export declare type NpoPlayerOptions = {
+    autoplay?: boolean;
+    customFallbackPoster?: string;
+    enableKeyboardControls?: boolean;
+    enableSubtitles?: string | boolean;
+    hidePoster?: boolean;
+    playbackRateOptions?: number[];
+    preload?: boolean;
+    skippableChapters?: string[];
+    ster?: ISterData;
+    uiLanguage?: string;
+};
+
+declare type NpoPlayerUIFactoryConfig = {
+    container: HTMLElement;
+    player: IPlayerApi;
+    options: NpoPlayerOptions;
+    errorManager: IErrorManager;
+    retryCallback?: (lastTimestamp: number) => Promise<void>;
+    inputHandler?: IInputHandler;
+    logClick?: (params: Omit<NpoTagClickEvent, 'click_chapter_1'>) => void;
+};
+
+declare type NpoTagClickEvent = {
+    click_name: string;
+    click_type: 'navigation' | 'action' | 'exit' | 'download' | (string & {});
+    click_chapter_1?: string;
+    click_chapter_2?: string;
+    click_chapter_3?: string;
+};
+
+declare type NpoTagProperties = {
+    initprops: any;
+    streamTracker: any;
+    pageTracker: any;
+    npoTag: any;
+    qosMetrics: any;
+    debugMode?: boolean;
+    cleanup?: () => void;
+};
+
+declare class NpoVideoPlayer extends NpoPlayerCore {
+    constructor(playerConfig: NpoVideoPlayerConfig & {
+        uiFactory?: INpoVideoPlayerUIFactory;
+    }, container: HTMLElement);
+}
+export { NpoVideoPlayer }
+export default NpoVideoPlayer;
+
+export declare type NpoVideoPlayerConfig = NpoPlayerConfig & {
+    options?: NpoPlayerOptions;
+    uiFactory?: INpoVideoPlayerUIFactory;
+};
+
+/**
+ * The playerApi class is a wrapper around the Shaka Player API,
+ * providing a simplified interface for interacting with the player.
+ * Besides the Shaka Player API, the playerApi class also provides additional functionality
+ * for controlling the player and interacting with the mediaElement.
+ */
+declare class PlayerApi implements IPlayerApi {
+    airPlayService: AirPlayService;
+    castService: CastService;
+    advertService: AdvertService;
+    readonly playerId: string;
+    readonly playerEvents: PlayerEventEmitter<IPlayerEventsMap>;
+    state: IPlayerState;
+    uiEvents: any;
+    readonly mediaStateListeners: () => void;
+    thumbnailService: ThumbnailTrackService;
+    timeBoundActionsService: TimeBoundActionsService;
+    chapterSkipService: ChapterSkipService;
+    subtitlesService: SubtitlesService;
+    readonly streamTrackService: StreamTrackService;
+    readonly playerConfig: NpoPlayerConfig;
+    readonly container: HTMLElement;
+    readonly settingsStore: SettingsStore;
+    private displayModeHandler;
+    private isInitialized;
+    private _player;
+    private currentStreamMode;
+    private streamLoadingData?;
+    private readonly mediaEventListeners;
+    get player(): default_2.Player;
+    constructor(container: HTMLElement, playerConfig: NpoPlayerConfig);
+    destroy(): void;
+    initialize(): Promise<void>;
+    getPlayerContainer(): HTMLElement;
+    load(source: string, streamLoadingData?: IPlayerLoad): Promise<void>;
+    unload(): Promise<void>;
+    play(): Promise<void>;
+    pause(): void;
+    togglePlayPause(): Promise<void>;
+    replay(): void;
+    seek(time: number): void;
+    forward(seconds?: number): void;
+    backward(seconds?: number): void;
+    getCurrentTime(): number;
+    getPlaybackRate(): number;
+    setPlaybackRate(rate: number): void;
+    getVolume(): number;
+    setVolume(volume: number): void;
+    mute(): void;
+    isMuted(): boolean;
+    unMute(): void;
+    toggleMute(): void;
+    isPlaying(): boolean;
+    isLive(): boolean;
+    isBuffering(): boolean;
+    getDuration(): number;
+    seekToLiveEdge(): void;
+    getNetworkingEngine(): default_2.extern.getNetworkingEngine;
+    getSeekRange(): {
+        start: number;
+        end: number;
+    };
+    getMediaElement(): HTMLMediaElement;
+    addTextTracks(subtitles: ISubtitle[]): void;
+    addTextTrack(subtitle: ISubtitle): void;
+    setTextTrackVisibility({ language, persist }: {
+        language: string;
+        persist?: boolean;
+    }): void;
+    getSelectedTextTrack(): TextTrack | undefined;
+    removeAllTextTracks(): void;
+    getTextTracks(): TextTrackList;
+    isFullscreenPossible(): boolean;
+    enterFullscreen(): void;
+    exitFullscreen(): void;
+    isDisplayModeChangeAllowed(): boolean;
+    isPipSupported(): boolean;
+    enterPip(): Promise<void>;
+    exitPip(): Promise<void>;
+    configure(config: default_2.extern.PlayerConfiguration): void;
+    private applyPersistedSettings;
+    private setupPlaybackRateHandler;
+    private initAirPlayService;
+    private forwardAllMediaEvents;
+    private createMediaEventForwardingHandler;
+    private readonly onLoadedMetadata;
+    private toPlayerEventName;
+    on(eventName: string, handler: EventHandler): void;
+    off(eventName: string, handler: EventHandler): void;
+    once(eventName: string, handler: EventHandler): void;
+    reemit(eventName: string, data?: any): void;
+    getConfiguration(): default_2.extern.PlayerConfiguration;
+    onAdEvent(eventName: string, handler: EventHandler): void;
+    offAdEvent(eventName: string, handler: EventHandler): void;
+    isPlayingAd(): boolean;
+    setAdClickElement(adClickElement: HTMLElement): void;
+    getAdUiState(): IAdUiState_2 | undefined;
+    getMode(): Modes;
+    private determineStreamMode;
+}
+
+declare class PlayerEventEmitter<T extends Record<string, any>> implements EventTarget {
+    readonly playerId?: string;
+    private readonly eventTarget;
+    private _allListeners;
+    constructor(playerId?: string);
+    emit<K extends keyof T>(params: EmitParams<T, K>): void;
+    on<K extends keyof T>(params: {
+        eventName: K;
+        listener: Listener<T[K]>;
+    }): void;
+    off<K extends keyof T>(params: {
+        eventName: K;
+        listener: Listener<T[K]>;
+    }): void;
+    once<K extends keyof T>(params: {
+        eventName: K;
+        listener: Listener<T[K]>;
+    }): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null): void;
+    dispatchEvent(event: Event): boolean;
+    removeAllListeners(): void;
+}
+
+export declare enum PlayerEventNames {
+    MediaStateChanged = "mediaStateChanged",
+    DisplayModeChanged = "displayModeChanged",
+    CastStateChanged = "castStateChanged",
+    AirPlayStateChanged = "airPlayStateChanged",
+    AirPlayConnectionChanged = "webkitcurrentplaybacktargetiswirelesschanged",
+    AdComplete = "ad-complete",
+    AdError = "ad-error",
+    AdPaused = "ad-paused",
+    AdResumed = "ad-resumed",
+    AdSkipped = "ad-skipped",
+    AdStarted = "ad-started",
+    AdUiUpdate = "ad-ui-update",
+    AllAdsCompleted = "all-ads-completed",
+    CanPlay = "canplay",
+    CanPlayThrough = "canplaythrough",
+    DurationChange = "durationchange",
+    Ended = "ended",
+    Error = "error",
+    LoadedData = "loadeddata",
+    LoadedMetadata = "loadedmetadata",
+    Pause = "pause",
+    Play = "play",
+    Playing = "playing",
+    Progress = "progress",
+    RateChange = "ratechange",
+    Buffering = "buffering",
+    Seeked = "seeked",
+    Seeking = "seeking",
+    Stalled = "stalled",
+    TimeUpdate = "timeupdate",
+    VolumeChange = "volumechange",
+    Waiting = "waiting",
+    TimeBoundActionTriggered = "time-bound-action-triggered",
+    TimeBoundActionExited = "time-bound-action-exited",
+    ChapterEntered = "chapter-entered",
+    ChapterExited = "chapter-exited",
+    StreamTrackChanged = "stream-track-changed"
+}
+
+export declare type PlayNext = {
+    showPlayNext?: boolean;
+    duration?: number;
+    offset?: number;
+    proceedCallback?: () => void;
+    cancelCallback?: () => void;
+};
+
+export declare const PROFILE_DASH = "dash";
+
+export declare const PROFILE_HLS = "hls";
+
+export declare type ProfileName = typeof PROFILE_DASH | typeof PROFILE_HLS;
+
+declare type ResetListener = () => void;
+
+declare class SettingsStore {
+    private cache;
+    private readonly storageKey;
+    private readonly useLocalStorage;
+    constructor(storageKey: string, defaults?: Record<string, unknown>);
+    set(key: string, value: unknown): void;
+    get(key: string, fallback?: unknown): unknown;
+    private persist;
+}
+
+export declare type StreamOptions = {
+    autoplay?: boolean;
+    endpoint?: string;
+    liveOffset?: boolean;
+    liveProgramTime?: number;
+    metadata?: {
+        ageRating?: string;
+        broadcaster?: string;
+        description?: string;
+        nicam?: string[];
+        poster?: string;
+        prid?: string;
+        ster?: ISterData;
+        title?: string;
+    };
+    npotag?: {
+        pageTracker?: any;
+    };
+    playNext?: PlayNext;
+    retryCallback?: () => void;
+    startOffset?: number;
+    infoPanelHTML?: string;
+    customDRMConfig?: ICustomDRMConfig;
+    timeBoundActions?: ITimeBoundAction[];
+    skippableChapters?: string[];
+    backButtonCallback?: () => void;
+};
+
+declare type StreamTrack = {
+    id: number;
+    streamTrackId: number;
+    label: string;
+    value: number;
+    width?: number;
+    height?: number;
+    bandwidth?: number;
+    originalTrack?: any;
+    language?: string;
+    isAudioOnly: boolean;
+    isAudioDescription: boolean;
+    playlistUrl?: string;
+};
+
+declare class StreamTrackService implements IStreamTrackService {
+    private readonly player;
+    private readonly hlsManifestParser;
+    private manifestTracks;
+    private currentManifestUri;
+    private _currentTrack;
+    get currentTrack(): StreamTrack | undefined;
+    readonly idAutoTrack = -1;
+    constructor(player: PlayerApi);
+    isManifestTrackAvailable(): boolean;
+    reset(): void;
+    private getShakaPlayer;
+    getVariantTracks(): Array<default_2.extern.VariantTrack>;
+    getAudioTracks(): Array<default_2.extern.AudioTrack>;
+    getVideoTracks(): Array<default_2.extern.VideoTrack>;
+    isAudioOnly(): boolean;
+    getAvailableVideoTracks(): Array<StreamTrack>;
+    getAudioTracksByVideoQuality(qualityValue: number): StreamTrack[];
+    getAudioOnlyTracks(): StreamTrack[];
+    init(): void;
+    setTrack(track: StreamTrack, forced: boolean): void;
+    setVideoTrackByQuality(qualityValue: number): void;
+    getAlternateStreamURLForSafari(): string | undefined;
+    parseManifestForTracks(manifestUri: string): Promise<void>;
+    private mapVariantTracksToStreamTracks;
+    private addAutoRow;
+    private loadQualityDirect;
+    private loadAndResume;
+    private updatePlayerState;
+    private getVideoTracksFromManifest;
+    private setStreamTrack;
+    private setPlayerQualityState;
+    private getActiveTrack;
+    private hasChoiceOfTrack;
+}
+
+declare class SubtitlesService {
+    private readonly player;
+    private _isAudioOnly?;
+    constructor(player: PlayerApi);
+    isAudioOnly(): boolean;
+    reset(): void;
+    handleSubtitles(streamObject: IStreamObject): void;
+}
+
+declare interface ThumbnailCue {
+    startTime: number;
+    endTime: number;
+    url: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+declare interface ThumbnailData {
+    imageUrl: string;
+    spriteX: number;
+    spriteY: number;
+    spriteWidth: number;
+    spriteHeight: number;
+}
+
+declare class ThumbnailTrackService implements IThumbnailTrackService {
+    private readonly vttParser;
+    private readonly spriteImageCache;
+    private isInitialized;
+    constructor();
+    initialize(vttUrl: string | undefined): Promise<void>;
+    private preloadInitialImages;
+    private loadSpriteImage;
+    getThumbnailAtTime(time: number): ThumbnailData | undefined;
+    renderThumbnailToCanvas(time: number, canvas: HTMLCanvasElement): Promise<void>;
+    isAvailable(): boolean;
+    reset(): void;
+    getParser(): ThumbnailTrackVttParser;
+}
+
+declare class ThumbnailTrackVttParser {
+    private static readonly TIMESTAMP_REGEX;
+    private static readonly SPRITE_COORDINATES_REGEX;
+    private cues;
+    private vttFileUrl;
+    parse(vttUrl: string): Promise<void>;
+    private parseVttText;
+    private parseTimestamp;
+    private parseCueLine;
+    private resolveUrl;
+    getCueAtTime(time: number): ThumbnailCue | undefined;
+    getAllCues(): ThumbnailCue[];
+    hasLoadedCues(): boolean;
+    clear(): void;
+}
+
+declare class TimeBoundActionsService implements ITimeBoundActionsService {
+    private static readonly CHECK_INTERVAL_MS;
+    private static readonly TIME_TOLERANCE_SECONDS;
+    private static readonly EPOCH_THRESHOLD;
+    private readonly player;
+    private readonly actions;
+    private readonly triggeredOnceActions;
+    private readonly currentActiveActions;
+    private intervalId;
+    private lastCheckTime;
+    private isInitialized;
+    private streamStartEpoch;
+    constructor(player: PlayerApi);
+    initialize(): void;
+    destroy(): void;
+    registerAction(action: ITimeBoundAction): void;
+    registerActions(actions: ITimeBoundAction[]): void;
+    unregisterAction(actionId: string): void;
+    private resetFiredActions;
+    clearActions(): void;
+    private readonly onSeeked;
+    private startIntervalCheck;
+    private stopIntervalCheck;
+    private onTimeUpdate;
+    private isEvaluatingActions;
+    private pendingEvaluateActions;
+    private evaluateActions;
+    private getNowActiveActions;
+    private processNewActions;
+    private processExitedActions;
+    private handlePendingEvaluation;
+    private detectAndSetStreamStartEpoch;
+    private convertToPlayerTime;
+    private isPointInTimeAction;
+    private isWithinTolerance;
+    private isTimeInRange;
+    private handleActionEntered;
+    private handleActionExited;
+    reset(): void;
+}
+
+export declare enum TimeBoundActionType {
+    CHAPTER = "chapter",
+    MARKER = "marker",
+    CALLBACK = "callback",
+    PLAY_NEXT = "play-next"
+}
+
+declare type WarningListener = (warning: IPlayerError) => void;
+
+export { }