@wscsports/blaze-web-sdk 0.20.0 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wscsports/blaze-web-sdk",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "main": "publish/index",
   "types": "publish/index",
   "files": [
@@ -15,14 +15,27 @@
     "publish:latest": "npm run build:prod && npm publish --access public --tag latest",
     "publish:beta": "npm run build:prod && npm publish --access public --tag beta",
     "version-download": "node ./version-downloader.js",
-    "test": "npx playwright test",
-    "test:debug": "npx playwright test --debug"
+
+    "test": "node ./node_modules/@playwright/test/cli.js test --project='Desktop Chrome'",
+    "test:desktop": "node ./node_modules/@playwright/test/cli.js test --project='Desktop Chrome' --project='Desktop Firefox' --project='Desktop Safari'",
+    "test:desktop:stories": "node ./node_modules/@playwright/test/cli.js test --project='Desktop Chrome' --project='Desktop Safari' e2e-tests/tests/stories",
+    "test:desktop:moments": "node ./node_modules/@playwright/test/cli.js test --project='Desktop Chrome' --project='Desktop Safari' e2e-tests/tests/moments",
+    "test:desktop:long-form": "node ./node_modules/@playwright/test/cli.js test --project='Desktop Chrome' --project='Desktop Safari' e2e-tests/tests/video-longform",
+
+    "test:mobile": "node ./node_modules/@playwright/test/cli.js test --project='iOS Safari 13' --project='Android Chrome'",
+    "test:mobile:stories": "node ./node_modules/@playwright/test/cli.js test --project='iOS Safari 13' --project='Android Chrome' e2e-tests/tests/stories",
+    "test:mobile:moments": "node ./node_modules/@playwright/test/cli.js test --project='iOS Safari 13' e2e-tests/tests/moments",
+    "test:mobile:long-form": "node ./node_modules/@playwright/test/cli.js test --project='iOS Safari 13' e2e-tests/tests/video-longform",
+
+    "test:android:stories": "export USE_PHYSICAL_DEVICE=true && export $(cat .env.physical-device 2>/dev/null | xargs) && node ./node_modules/@playwright/test/cli.js test --config=playwright.config.physical-device.ts --project='Android Mobile Chrome' e2e-tests/tests/stories",
+    "test:android:moments": "export USE_PHYSICAL_DEVICE=true && export $(cat .env.physical-device 2>/dev/null | xargs) && node ./node_modules/@playwright/test/cli.js test --config=playwright.config.physical-device.ts --project='Android Mobile Chrome' e2e-tests/tests/moments"
   },
   "devDependencies": {
-    "@playwright/test": "^1.44.1",
+    "@playwright/test": "^1.56.0",
     "@types/animejs": "^3.1.7",
     "@types/google_interactive_media_ads_types": "^1.20241219.0",
     "@types/hammerjs": "^2.0.45",
+    "@types/node": "^24.7.0",
     "@types/ua-parser-js": "^0.7.36",
     "@types/uuid": "^10.0.0",
     "@types/videojs-vtt.js": "^0.15.3",
@@ -34,6 +47,8 @@
     "javascript-obfuscator": "^4.0.2",
     "media-captions": "^0.0.18",
     "npm-registry-fetch": "^16.0.0",
+    "playwright-chromium": "^1.56.0",
+    "playwright-webkit": "^1.56.0",
     "style-loader": "^3.3.3",
     "ts-loader": "^9.4.4",
     "typescript": "^5.4.2",

package/publish/index.d.ts

@@ -1,9 +1,3 @@
-type PlayContentOptions = {
-    dataSource: BlazeDataSourceType;
-    actionHandlers?: ActionHandler[];
-    style?: StoryPlayerStyle | VideoPlayerStyle | MomentPlayerStyle;
-    shouldOrderContentByReadStatus?: boolean;
-};
 export declare function setDoNotTrack(value: boolean): void;
 export declare function setGeoLocation(value: string): void;
 export declare function setExternalUserId(value: string): Promise<void>;
@@ -1271,6 +1265,8 @@ export declare const Z_INDEX: {
     readonly player: "1";
     readonly interaction: "2";
     readonly onTopOfPlayer: "3";
+    readonly menuBackdrop: "99";
+    readonly menu: "100";
 };
 
 export declare const ONE_SECOND = 1000;
@@ -1590,6 +1586,7 @@ export interface IRendition {
     aspectRatio: ContentAspectRatio;
     bitRate: number;
     fileSize: number;
+    fileType?: 'Mp4' | 'Hls';
 }
 
 export interface IStory extends IContent {
@@ -2861,8 +2858,10 @@ declare abstract class VideoCacheServiceClass extends VideoCacheServiceClass_bas
     private downloadControllers;
     private cacheList;
     private cacheInitialized;
+    private cacheSupported;
     private sizeLimit;
     constructor();
+    private isCacheSupported;
     init(): Promise<void>;
     private retryCacheInitialization;
     checkCacheSize(): Promise<void>;
@@ -3870,6 +3869,7 @@ export * from './story-direction.type';
 export * from './thumbnail.type';
 export * from './trigger.type';
 export * from './user.type';
+export * from './video-format.type';
 export * from './widget.type';
 export * from './chip-status.type';
 export * from './prefetch.type';
@@ -3883,6 +3883,7 @@ export * from './action-handler.type';
 export * from './cc-language.type';
 export * from './widget-view-options.type';
 export * from './content-item.type';
+export * from './play-content-options.type';
 export * from './recommendations.type';
 
 export type EntitiesType = 'playerId' | 'teamId' | 'gameId' | 'roundId';
@@ -3914,6 +3915,13 @@ export type BlazePersonalized = BlazePersonalizedIds | BlazePersonalizedLabels;
 
 export type Platform = 'mobile' | 'tablet' | 'desktop';
 
+export type PlayContentOptions = {
+    dataSource: BlazeDataSourceType;
+    actionHandlers?: ActionHandler[];
+    style?: StoryPlayerStyle | VideoPlayerStyle | MomentPlayerStyle;
+    shouldOrderContentByReadStatus?: boolean;
+};
+
 export declare const PlayTypeArray: readonly ["Widget", "Share", "SingleContent", "AutoAdvance"];
 export type PlayType = (typeof PlayTypeArray)[number];
 
@@ -3985,6 +3993,8 @@ export type TokenData = {
     userId: string;
 };
 
+export type VideoFormat = 'mp4' | 'hls' | '';
+
 export type IWidgetViewOptions = IWidgetViewOptionsWithLabels | IWidgetViewOptionsWithStoryIds | IWidgetViewOptionsWithDataSource | ICustomWidgetOptionsWithDataSource;
 
 export type WidgetType = 'Row' | 'Grid';
@@ -4077,6 +4087,8 @@ export declare function findParentOfType<T>(target: EventTarget | null, type: {
 }, stopAt: Element): T | null;
 export declare function validateContainer(containerId: string, widgetElementName?: string): HTMLElement;
 
+export declare function fetchPosterWithHighPriority(posterUrl: string, timeout?: number): Promise<void>;
+
 export * from './accessibility-label.utils';
 export * from './ad-info.utils';
 export * from './cc-language.utils';
@@ -4086,6 +4098,7 @@ export * from './content-mapper.utils';
 export * from './country-location.utils';
 export * from './guard.utils';
 export * from './helper';
+export * from './image.utils';
 export * from './personalized.utils';
 export * from './position.utils';
 export * from './regex.utils';
@@ -4215,7 +4228,11 @@ export * from './core/video';
 export * from './core/video-modal';
 export * from './core/video-player';
 export * from './factory/playback-strategy.factory';
-export * from './strategy/hls.strategy';
+export * from './strategy/base-playback.strategy';
+export * from './strategy/long-form-hls.strategy';
+export * from './strategy/base-hls.strategy';
+export * from './strategy/short-form-hls.strategy';
+export * from './strategy/native-video.strategy';
 export * from './interface/playback-strategy.interface';
 export * from './video-events';
 
@@ -4779,9 +4796,19 @@ export declare class BlazeVideoElement extends BlazeWidgetVideoBase {
 }
 
 export declare class PlaybackStrategyFactory {
-    static createStrategy(video: HTMLVideoElement, strategyType: string): PlaybackStrategy;
+    static createStrategy(video: HTMLVideoElement, strategyType: string, widget?: BlazeWidgetVideo): PlaybackStrategy;
+}
+
+export interface LoaderDelegate {
+    show(): void;
+    hide(): void;
+    isVisible?(): boolean;
 }
 
+export interface PlaybackStrategyOptions {
+    overlay?: BlazeLongFormControlsOverlay;
+    loaderDelegate?: LoaderDelegate;
+}
 export interface PlayResult {
     status: PlayStatus;
     error?: unknown;
@@ -4793,7 +4820,11 @@ export declare enum PlayStatus {
 export interface PlaybackStrategy {
     play(): Promise<PlayResult>;
     pause(): void;
-    initialize(videoOverlay: BlazeLongFormControlsOverlay): void;
+    isPaused(): boolean;
+    isEnded(): boolean;
+    getCurrentTime(): number;
+    reset(): void;
+    initialize(options?: PlaybackStrategyOptions): void;
     toggleMute(): void;
     setMuted(muted: boolean): void;
     isMuted(): boolean;
@@ -4803,39 +4834,95 @@ export interface PlaybackStrategy {
     loadSource(src: string, bitRate: number, startingTime: number): Promise<void>;
     unload(): void;
     destroy(): void;
+    reloadWithNewSource?(src: string, bitRate?: number, startingTime?: number): Promise<void>;
+    setContentMetadata?(metadata: {
+        contentId?: string;
+        contentTitle?: string;
+        contentType?: string;
+        sessionId?: string;
+    }): void;
 }
 
-export declare class HLSStrategy implements PlaybackStrategy {
-    private hls?;
-    private videoOverlay?;
-    private video;
-    private initialBitrateBps;
-    private retryCount;
-    private maxRetries;
-    private lastTime;
-    private beforeContentPlayService;
-    private playbackWatchdogTimeout?;
-    private loaderTimeout?;
-    private recoveryTimeout?;
-    private seekRecoveryListener?;
-    private boundOnManifestParsed;
-    private boundOnBufferAppended;
-    private boundOnFragParsed;
-    private boundOnLoadedMetadata;
-    private boundOnPlaying;
-    private boundOnCanPlay;
-    private boundOnError;
-    private boundOnNativeError;
+declare const Hls: any;
+export interface HLSConfig {
+    maxBufferLength: number;
+    maxMaxBufferLength: number;
+    maxBufferSize: number;
+    maxBufferHole: number;
+    fragLoadingMaxRetry: number;
+    fragLoadingRetryDelay: number;
+    abrEwmaFastLive: number;
+    abrEwmaSlowLive: number;
+    abrEwmaFastVoD: number;
+    abrEwmaSlowVoD: number;
+    abrBandWidthFactor: number;
+    abrBandWidthUpFactor: number;
+}
+export declare const HLS_CONFIGS: {
+    readonly LONG_FORM: {
+        readonly maxBufferLength: 30;
+        readonly maxMaxBufferLength: 30;
+        readonly maxBufferSize: number;
+        readonly maxBufferHole: 4;
+        readonly fragLoadingMaxRetry: 5;
+        readonly fragLoadingRetryDelay: 1000;
+        readonly abrEwmaFastLive: 3;
+        readonly abrEwmaSlowLive: 9;
+        readonly abrEwmaFastVoD: 3;
+        readonly abrEwmaSlowVoD: 9;
+        readonly abrBandWidthFactor: 0.95;
+        readonly abrBandWidthUpFactor: 0.7;
+    };
+    readonly SHORT_FORM: {
+        readonly maxBufferLength: 3;
+        readonly maxMaxBufferLength: 5;
+        readonly maxBufferSize: number;
+        readonly maxBufferHole: 0.5;
+        readonly fragLoadingMaxRetry: 2;
+        readonly fragLoadingRetryDelay: 200;
+        readonly abrEwmaFastLive: 1;
+        readonly abrEwmaSlowLive: 2;
+        readonly abrEwmaFastVoD: 1;
+        readonly abrEwmaSlowVoD: 2;
+        readonly abrBandWidthFactor: 0.9;
+        readonly abrBandWidthUpFactor: 0.8;
+    };
+};
+export declare abstract class BaseHLSStrategy extends BasePlaybackStrategy {
+    protected hls?: typeof Hls;
+    protected initialBitrateBps: number;
+    protected retryCount: number;
+    protected maxRetries: number;
+    protected lastTime: number;
+    protected playbackWatchdogTimeout?: ReturnType<typeof setTimeout>;
+    protected loaderTimeout?: ReturnType<typeof setTimeout>;
+    protected recoveryTimeout?: ReturnType<typeof setTimeout>;
+    protected seekRecoveryListener?: () => void;
+    protected boundOnManifestParsed: () => void;
+    protected boundOnBufferAppended: () => void;
+    protected boundOnFragParsed: () => void;
+    protected boundOnLoadedMetadata: () => void;
+    protected boundOnPlaying: () => void;
+    protected boundOnCanPlay: () => void;
+    protected boundOnError: (event: any, data: any) => void;
+    protected boundOnNativeError: (e: Event) => void;
     constructor(video: HTMLVideoElement);
-    initialize(videoOverlay: BlazeLongFormControlsOverlay): void;
+    abstract initialize(options?: any): void;
+    protected abstract onLoadingState(): void;
+    protected abstract onBufferUpdate(progress: number): void;
+    protected abstract onError(event: any, data: any): void;
+    protected setupEventListeners(): void;
     loadSource(src: string, initialBitrate: number, startingTime?: number): Promise<void>;
+    protected setupHLSInstance(src: string, startingTime: number, config?: HLSConfig): void;
+    protected setupNativeHLS(src: string, startingTime: number): void;
     unload(): void;
     destroy(): void;
-    private waitForVideoCondition;
     play(): Promise<PlayResult>;
-    private startPlaybackWatchdog;
-    private handlePlaybackTimeout;
     pause(): void;
+    isPaused(): boolean;
+    isEnded(): boolean;
+    getCurrentTime(): number;
+    reset(): void;
     getDuration(): number;
     isMuted(): boolean;
     seek(clampedSeek: number): void;
@@ -4844,23 +4931,162 @@ export declare class HLSStrategy implements PlaybackStrategy {
     mute(): void;
     unmute(): void;
     toggleFullscreen(): void;
-    private updateBuffer;
-    private handleManifestParsed;
-    private handleBufferAppended;
-    private handleFragParsed;
-    private handleError;
-    private isSlowConnection;
-    private nudgePlayback;
-    private handleNetworkError;
-    private handleOnlineNetworkRecovery;
-    private recoverNativeHls;
-    private handleMediaError;
-    private reloadStream;
-    private showLoader;
-    private hideLoader;
+    protected waitForVideoCondition<T extends keyof HTMLMediaElementEventMap>(predicate: () => boolean, eventType: T, timeoutMs?: number): Promise<HTMLMediaElementEventMap[T] | void>;
+    protected startPlaybackWatchdog(): void;
+    protected handlePlaybackTimeout(): void;
+    protected handleSeekRecovery(seekTime: number): void;
+    protected isSlowConnection(): boolean;
+    protected handleManifestParsed(): void;
+    protected handleBufferAppended(): void;
+    protected handleFragParsed(): void;
+    protected handleError(event: any, data: any): void;
+    protected handlePlaying(): void;
+    protected handleNativeError(e: Event): void;
+    protected handleLoadedMetadata(): void;
+    protected getBufferProgress(): number;
+    protected showLoader(): void;
+    protected hideLoader(): void;
+    protected nudgePlayback(): void;
+    protected handleNetworkError(): void;
+    protected handleOnlineNetworkRecovery: () => void;
+    protected handleMediaError(): void;
+    protected recoverNativeHls(): void;
+    protected reloadStream(): void;
+    reloadWithNewSource(newSrc: string, initialBitrate?: number, startingTime?: number): Promise<void>;
+}
+
+export declare abstract class BasePlaybackStrategy implements PlaybackStrategy {
+    protected video: HTMLVideoElement;
+    protected contentId?: string;
+    protected contentTitle?: string;
+    protected contentType?: string;
+    protected sessionId?: string;
+    protected playAttemptStartTime: number;
+    abstract play(): Promise<PlayResult>;
+    abstract pause(): void;
+    abstract isPaused(): boolean;
+    abstract isEnded(): boolean;
+    abstract getCurrentTime(): number;
+    abstract reset(): void;
+    abstract initialize(options?: any): void;
+    abstract toggleMute(): void;
+    abstract setMuted(muted: boolean): void;
+    abstract isMuted(): boolean;
+    abstract toggleFullscreen(): void;
+    abstract seek(time: number): void;
+    abstract getDuration(): number;
+    abstract loadSource(src: string, bitRate: number, startingTime: number): Promise<void>;
+    abstract unload(): void;
+    abstract destroy(): void;
+    setContentMetadata(metadata: {
+        contentId?: string;
+        contentTitle?: string;
+        contentType?: string;
+        sessionId?: string;
+    }): void;
+    protected dispatchPlaybackEvent(eventStatus: 'success' | 'failed' | 'ready' | 'changed' | 'buffering' | 'recovered', context: {
+        result?: PlayResult;
+        timeToPlay?: number;
+        timeToFail?: number;
+        error?: any;
+        previousState?: any;
+        newState?: any;
+    }): void;
+}
+
+export declare class LongFormHlsStrategy extends BaseHLSStrategy {
+    private videoOverlay?;
+    initialize(options?: PlaybackStrategyOptions): void;
+    private configureVideoElement;
+    protected onLoadingState(): void;
+    protected onBufferUpdate(progress: number): void;
+    protected onError(event: any, data: any): void;
+    toggleFullscreen(): void;
+}
+
+export declare class NativeVideoStrategy extends BasePlaybackStrategy {
+    protected video: HTMLVideoElement;
+    private videoComponent;
+    private lastErrorExecutionTime;
+    private loaderDelegate?;
+    private playbackTimeout?;
+    private readonly PLAYBACK_TIMEOUT_MS;
+    private boundOnError;
+    private boundOnPlaying;
+    private boundOnPause;
+    private boundOnCanPlayThrough;
+    private progressCheckInterval?;
+    private lastProgressTime;
+    private lastCurrentTime;
+    private boundOnTimeUpdate;
+    constructor(video: HTMLVideoElement, videoComponent: BlazeWidgetVideo);
+    private setupErrorHandling;
     private handlePlaying;
-    private handleNativeError;
-    private handleLoadedMetadata;
+    private handlePause;
+    private handleTimeUpdate;
+    private handleCanPlayThrough;
+    private startPlaybackTimeout;
+    private clearPlaybackTimeout;
+    private handlePlaybackTimeout;
+    private handleNativeVideoError;
+    play(): Promise<PlayResult>;
+    private playWithRetry;
+    private reloadAndRetry;
+    pause(): void;
+    getCurrentTime(): number;
+    getDuration(): number;
+    isPaused(): boolean;
+    isEnded(): boolean;
+    isMuted(): boolean;
+    setMuted(muted: boolean): void;
+    mute(): void;
+    unmute(): void;
+    seek(seekPercentage: number): void;
+    toggleMute(): void;
+    toggleFullscreen(): void;
+    loadSource(src: string): Promise<void>;
+    initialize(options?: PlaybackStrategyOptions): void;
+    private configureVideoElement;
+    unload(): void;
+    destroy(): void;
+    reset(): void;
+    private startProgressBasedLoaderCleanup;
+    private stopProgressBasedLoaderCleanup;
+    private checkVideoProgressAndCleanupLoader;
+}
+
+export declare class ShortFormHLSStrategy extends BaseHLSStrategy {
+    private loaderDelegate?;
+    private isPrefetchMode;
+    private fragmentsLoaded;
+    private readonly maxPrefetchFragments;
+    private isBufferLoaderActive;
+    private progressCheckInterval?;
+    private lastProgressTime;
+    private lastCurrentTime;
+    private boundOnTimeUpdate;
+    initialize(options?: PlaybackStrategyOptions): void;
+    protected setupEventListeners(): void;
+    protected setupHLSInstance(src: string, startingTime: number): void;
+    private handleManifestParsedForPrefetch;
+    private startPrefetchLoading;
+    enablePrefetchMode(): void;
+    disablePrefetchMode(): void;
+    protected onLoadingState(): void;
+    protected onBufferUpdate(progress: number): void;
+    protected handlePlaying(): void;
+    protected handlePause(): void;
+    protected onError(event: any, data: any): void;
+    protected handleError(event: any, data: any): void;
+    protected handleSeekRecovery(seekTime: number): void;
+    seek(clampedSeek: number): void;
+    play(): Promise<any>;
+    pause(): void;
+    unload(): void;
+    private handleTimeUpdate;
+    private startProgressBasedLoaderCleanup;
+    private stopProgressBasedLoaderCleanup;
+    private checkVideoProgressAndCleanupLoader;
 }
 
 export * from './widget-video-base';
@@ -4912,7 +5138,7 @@ export declare abstract class WidgetBaseLayout extends BlazeWidgetScrollable imp
     abstract render(): void;
     widgetType(): WidgetType;
     get thumbnailShape(): ThumbnailShape;
-    protected get theme(): IWidgetTheme<StoryPlayerStyle | VideoPlayerStyle | MomentPlayerStyle>;
+    protected get theme(): IWidgetTheme<MomentPlayerStyle | StoryPlayerStyle | VideoPlayerStyle>;
     protected updateActiveLayoutThemesPerItemWithEntity(key: EntitiesType, value: string, theme: IWidgetTheme): void;
     protected setReloadData(options?: ISetWidgetOptions): void;
     set contentIds(value: string);
@@ -5415,7 +5641,6 @@ export declare class BlazeWidgetModal extends BaseWidget {
     constructor(type: ContentType);
     connectedCallback(): void;
     disconnectedCallback(): void;
-    private isRealResizeEvent;
     onResize(): void;
     handleOnContentChange(mode: ContentDirection): void;
     handleOnExitButtonClick(): void;
@@ -5615,7 +5840,6 @@ export declare class BlazeWidgetVideoBase extends HTMLElement {
     disconnectedCallback(): void;
     render(): void;
     startEnter(): void;
-    startExit(): void;
     endEnter(): void;
     endExit(): void;
 }
@@ -5634,10 +5858,14 @@ export declare class BlazeWidgetVideo extends BlazeWidgetVideoBase {
     loaderTimeoutRefAppending: NodeJS.Timeout | undefined;
     lastErrorExecutionTime: number;
     private beforeContentPlayService;
+    private playbackStrategy?;
+    private playerCommands?;
+    private videoFormat;
     isVideoStartPlaying: boolean;
     isError: boolean;
     isLoaded: boolean;
     isVideoRunning: boolean;
+    private isUnloading;
     maxRetryTimes: number;
     shouldShowImaAd: boolean;
     isCurrentlyTryingToRunImaAd: boolean;
@@ -5658,15 +5886,19 @@ export declare class BlazeWidgetVideo extends BlazeWidgetVideoBase {
     private isEnableInteractions;
     loadClosedCaptions(): Promise<void>;
     getVideoDuration(existingVideo?: HTMLVideoElement): Promise<number>;
+    private determinePosterUrl;
     loadPoster(): void;
     display(): void;
     hide(): void;
     load(loadingType?: LoadingType): Promise<void>;
     private setVideoSource;
+    reloadHLSWithNewUrl(newVideoUrl: string): Promise<void>;
+    private initializeHLSStrategy;
+    private fallbackToNativeVideo;
+    private cleanupHLSStrategy;
     unload(): Promise<void>;
     resetVideoState(): void;
     removeLoader(): void;
-    startPlayVideo(video: HTMLVideoElement, maxRetryTimes: number): Promise<void>;
     tryReloadVideo(retryTime: number): void;
     tryToAddLoader(): void;
     play(): Promise<void>;
@@ -5678,18 +5910,18 @@ export declare class BlazeWidgetVideo extends BlazeWidgetVideoBase {
     requestFrameCallback(callback: () => void): void;
     mainElement(): CanvasImageSource;
     get paused(): boolean;
+    get ended(): boolean;
     get muted(): boolean;
     set muted(value: boolean);
     get isAd(): boolean;
     render(): void;
-    restartVideo(): void;
     handleAdStarted(): void;
     handleAdEnded(): void;
     loadInteraction(): void;
     onLanguageChange(event: Event): Promise<void>;
     handleInteractionEvent(event: CustomEvent<InteractionAnalyticCustomEvent>): void;
     private tryToPlayAd;
-    private updateVideoUrlWithBeforeContentPlay;
+    private isBeingUnloaded;
 }
 
 export declare class BlazeWidgetAd extends BlazeWidgetVideoBase {
@@ -5822,7 +6054,7 @@ export declare class BlazeWidgetMomentModal extends BlazeWidgetModal {
     setModalContent(data: IMoment[], indexOfContentInWidget: number, defaultAdsInfo?: IAdInfo): void;
     onKeyDown(ev: KeyboardEvent): void;
     close(): void;
-    open(): void;
+    open(): Promise<void>;
     play(): void;
     setExitButtonDisplay(): void;
     render(): void;
@@ -5910,6 +6142,8 @@ export declare class BlazeWidgetMomentSeekBar extends HTMLElement {
     private progressBarFill;
     private progressBarKnob;
     private isMouseIn;
+    private seekingTimeout?;
+    private readonly SEEKING_DEBOUNCE_MS;
     constructor(video: BlazeWidgetVideo | BlazeWidgetAd, seekBarStyle: BlazeMomentsPlayerSeekBarStyle);
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, oldValue: string, _newValue: string): void;
@@ -5938,6 +6172,9 @@ export declare class BlazeWidgetMomentSeekBar extends HTMLElement {
     private createPlaybackPart;
     private updateProgressBarStyles;
     render(): void;
+    private setupVideoEventListeners;
+    private startSeekingLoader;
+    private stopSeekingLoader;
 }
 
 interface ButtonElementOptions {
@@ -6181,6 +6418,7 @@ export declare class BlazeWidgetStory extends BlazeWidgetContent {
     isStoryLoadCompletedTriggered: boolean;
     isStoryActive: boolean;
     isResumeOnFocusExecuted: boolean;
+    isUnloading: boolean;
     refWidget: BlazeWidgetStory[] | undefined;
     ctaModal: BlazeWidgetCtaModal;
     isCtaWasClickedOrSwiped: boolean;
@@ -6219,6 +6457,7 @@ export declare class BlazeWidgetStory extends BlazeWidgetContent {
     totalPlayStopwatch: Stopwatch;
     shadowTopElement: HTMLDivElement;
     navigationTimeout: NodeJS.Timeout | null;
+    prefetchTimeout: NodeJS.Timeout | null;
     lastPageIndexToResume: number;
     elementsToHideOnWebAds: (HTMLElement | undefined)[];
     elementsToHideOnImaAds: (HTMLElement | undefined)[];
@@ -6280,7 +6519,7 @@ export declare class BlazeWidgetStory extends BlazeWidgetContent {
     playPage(pageIndexToPlayNext: number): void;
     updatePublishedDate(index?: number): void;
     switchToPage(newPageIndex: number): void;
-    startPage(indexToPlay: number): void;
+    startPage(indexToPlay: number): Promise<void>;
     private shouldGetNewBannerAd;
     unload(): void;
     displayCurrentStoryPageAndHideTheRest(): void;