@wscsports/blaze-web-sdk 0.19.3-beta.1 → 0.20.0

package/publish/index.d.ts

@@ -363,7 +363,7 @@ export declare abstract class BaseWidget extends HTMLElement {
     removeElement(): void;
 }
 
-type BlazeSourceType = 'labels' | 'ids';
+type BlazeSourceType = 'labels' | 'ids' | 'recommendations';
 export type AdvancedOrdering = 'LiveFirst';
 export interface BlazeDataSourceType {
     sourceType: BlazeSourceType;
@@ -374,6 +374,7 @@ export interface BlazeDataSourceType {
     maxItems?: number;
     advancedOrdering?: AdvancedOrdering;
     personalized?: BlazePersonalized;
+    recommendations?: BlazeRecommendations;
 }
 export declare const BlazeInternalError: {
     LabelExpressionMustNotBeEmpty: string;
@@ -381,10 +382,15 @@ export declare const BlazeInternalError: {
     IdsMustNotBeEmpty: string;
     MissingLabelsProperty: string;
     IdsMustNotHaveSpaces: string;
+    ForYouNotSupported: string;
+    TrendingNotSupported: string;
+    ForYouContentPreparationNotSupported: string;
+    TrendingContentPreparationNotSupported: string;
 };
 export declare class BlazeDataSourceFactory {
     static createLabelsDataSource(params: LabelsDataSourceParams): BlazeDataSourceType;
     static createIdsDataSource(params: IdsDataSourceParams): BlazeDataSourceType;
+    static createRecommendationsDataSource(params: RecommendationsDataSourceParams): BlazeDataSourceType;
     static setLabelsPriority(labelsPriority: string | string[] | BlazeWidgetLabel[] | undefined): string;
 }
 export declare class BlazeDataSourceValidations {
@@ -393,7 +399,7 @@ export declare class BlazeDataSourceValidations {
         labels?: string | string[] | BlazeWidgetLabel;
         storyIds?: string[];
         contentIds?: string[];
-    }, dataSource?: BlazeDataSourceType): void;
+    }, dataSource?: BlazeDataSourceType, contentType?: ContentType): void;
 }
 
 export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): {
@@ -950,7 +956,7 @@ export declare class BlazeTypography extends BaseWidget {
     attributeChangedCallback(name: AttributeType, oldValue: string, newValue: string): void;
     onSizeChange(size: SizeType): void;
     onTextChange(text: string): void;
-    get fontSize(): "1rem" | ".8rem" | ".5rem";
+    get fontSize(): ".8rem" | "1rem" | ".5rem";
 }
 
 export type ButtonAttribute = (typeof BUTTON_ATTRIBUTES)[keyof typeof BUTTON_ATTRIBUTES];
@@ -971,7 +977,7 @@ export declare class BlazeButton extends BaseWidget {
     get refElement(): ShadowRoot | this;
     constructor();
     private setupFocusDelegation;
-    static get observedAttributes(): ("height" | "order" | "width" | "icon-color" | "disabled" | "blaze-btn-hidden" | "blaze-btn-visible" | "button-desktop-animation")[];
+    static get observedAttributes(): ("height" | "order" | "width" | "icon-color" | "disabled" | "blaze-btn-visible" | "blaze-btn-hidden" | "button-desktop-animation")[];
     private onMouseEnter;
     private onMouseLeave;
     private onClick;
@@ -1072,7 +1078,7 @@ export declare class BlazeShareButton extends BaseWidget {
     get size(): SizeType;
     set size(value: SizeType);
     set type(value: ShareButtonType);
-    get fontSize(): "1rem" | ".8rem" | ".5rem";
+    get fontSize(): ".8rem" | "1rem" | ".5rem";
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(name: AttributeType, oldValue: string, newValue: string): void;
@@ -1336,6 +1342,7 @@ export interface AppConfiguration {
         configRefetchIntervalInMinutes?: number;
         enableClientPlaybackModification?: 'true' | 'false' | string;
     };
+    recommendationsConfigurations?: IRecommendationsConfigurations;
     sdkLoggerConfigurations?: ILoggerConfiguration;
 }
 
@@ -1557,6 +1564,7 @@ export interface IContentPage extends IBasePage {
     cta: ICta;
     parentStoryId?: string;
     shouldShowImaAd?: boolean;
+    shouldShowBannerAd?: boolean;
     adInfo?: IAdInfo;
     interaction?: Interaction;
     poster?: IThumbnail;
@@ -1582,7 +1590,6 @@ export interface IRendition {
     aspectRatio: ContentAspectRatio;
     bitRate: number;
     fileSize: number;
-    fileType?: 'Mp4' | 'Hls';
 }
 
 export interface IStory extends IContent {
@@ -2002,9 +2009,11 @@ export interface IButtonPlayerConfig {
 export interface IDataSourceBuilder {
     labels: (params: LabelsDataSourceParams) => BlazeDataSourceType;
     ids: (params: IdsDataSourceParams) => BlazeDataSourceType;
+    recommendations: (params: RecommendationsDataSourceParams) => BlazeDataSourceType;
 }
-export type LabelsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'ids'>;
-export type IdsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'labels' | 'labelsPriority' | 'maxItems'>;
+export type LabelsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'ids' | 'recommendations'>;
+export type IdsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'labels' | 'recommendations' | 'labelsPriority' | 'maxItems'>;
+export type RecommendationsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'ids' | 'labels'>;
 
 export interface IDatabase {
     init: () => Promise<void>;
@@ -2121,6 +2130,7 @@ export * from './widget-label-builder.interface';
 export * from './widget-options.interface';
 export * from './widget-view.interface';
 export * from './item-click-callback.interface';
+export * from './recommendations.interface';
 export { default as Observable } from './observable';
 
 export interface ItemClickContext {
@@ -2221,6 +2231,13 @@ export default interface IntersectionObservable {
 
 export type ScreenMode = 'Full Screen' | 'Embedded';
 
+export interface IRecommendationsConfigurations {
+    enableForYouContentPreparation: boolean;
+    enableTrendingContentPreparation: boolean;
+    supportForYou: boolean;
+    supportTrending: boolean;
+}
+
 export interface IResponse<T = any> {
     data?: T;
     error?: Error;
@@ -2366,6 +2383,9 @@ type GetByLabelsOptions = GetOptions & {
 type GetByIdsOptions = GetOptions & {
     ids: string[];
 };
+type GetByRecommendationsOptions = GetOptions & {
+    recommendations: BlazeRecommendations;
+};
 export interface ApiResponse<T> {
     assetsExpiryTime: string;
     totalItems: number;
@@ -2408,6 +2428,7 @@ declare abstract class ApiServiceClass extends ApiServiceClass_base implements I
         error?: Error | undefined;
     }>;
     getMomentsByLabels(options: GetByLabelsOptions): Promise<import("../interfaces").IHttpResponse<MomentsResponse>>;
+    getMomentsByRecommendations(options: GetByRecommendationsOptions): Promise<import("../interfaces").IHttpResponse<MomentsResponse>>;
     updateMomentLikeStatus(options: {
         momentId: string;
         setLiked: boolean;
@@ -2440,6 +2461,7 @@ declare abstract class ApiServiceClass extends ApiServiceClass_base implements I
     private getContentDefaultParams;
     private getContentParamsByLabels;
     private getContentParamsByIds;
+    private getContentParamsByRecommendations;
 }
 export declare const ApiService: ApiServiceClass;
 
@@ -3861,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 './recommendations.type';
 
 export type EntitiesType = 'playerId' | 'teamId' | 'gameId' | 'roundId';
 export type PerItemStyleOverrides = Partial<Record<EntitiesType, Array<{
@@ -3912,6 +3935,18 @@ export type PrefetchingPolicyType = 'low' | 'default';
 
 export type ContentAspectRatio = 'Vertical' | 'Horizontal';
 
+type RecommendationsType = {
+    anyLabelFilter?: string[];
+};
+export type BlazeRecommendationsForYou = RecommendationsType & {
+    promotedLabels?: string[];
+};
+export type BlazeRecommendationsTrending = RecommendationsType;
+export type BlazeRecommendations = {
+    forYou?: BlazeRecommendationsForYou;
+    trending?: BlazeRecommendationsTrending;
+};
+
 export type ScreenState = 'default_view' | 'full_screen';
 export type ScreenChangeState = {
     current_state: ScreenState;
@@ -4181,9 +4216,6 @@ 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-hls.strategy';
-export * from './strategy/simple-hls.strategy';
-export * from './strategy/native-video.strategy';
 export * from './interface/playback-strategy.interface';
 export * from './video-events';
 
@@ -4747,19 +4779,9 @@ export declare class BlazeVideoElement extends BlazeWidgetVideoBase {
 }
 
 export declare class PlaybackStrategyFactory {
-    static createStrategy(video: HTMLVideoElement, strategyType: string, widget?: BlazeWidgetVideo): PlaybackStrategy;
-}
-
-export interface LoaderDelegate {
-    show(): void;
-    hide(): void;
-    isVisible?(): boolean;
+    static createStrategy(video: HTMLVideoElement, strategyType: string): PlaybackStrategy;
 }
 
-export interface PlaybackStrategyOptions {
-    overlay?: BlazeLongFormControlsOverlay;
-    loaderDelegate?: LoaderDelegate;
-}
 export interface PlayResult {
     status: PlayStatus;
     error?: unknown;
@@ -4771,11 +4793,7 @@ export declare enum PlayStatus {
 export interface PlaybackStrategy {
     play(): Promise<PlayResult>;
     pause(): void;
-    isPaused(): boolean;
-    isEnded(): boolean;
-    getCurrentTime(): number;
-    reset(): void;
-    initialize(options?: PlaybackStrategyOptions): void;
+    initialize(videoOverlay: BlazeLongFormControlsOverlay): void;
     toggleMute(): void;
     setMuted(muted: boolean): void;
     isMuted(): boolean;
@@ -4785,115 +4803,39 @@ 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;
 }
 
-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 implements PlaybackStrategy {
-    protected hls?: typeof Hls;
-    protected video: HTMLVideoElement;
-    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 contentId?: string;
-    protected contentTitle?: string;
-    protected contentType?: string;
-    protected sessionId?: string;
-    protected playAttemptStartTime: number;
-    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;
+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;
     constructor(video: HTMLVideoElement);
-    setContentMetadata(metadata: {
-        contentId?: string;
-        contentTitle?: string;
-        contentType?: string;
-        sessionId?: string;
-    }): 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;
+    initialize(videoOverlay: BlazeLongFormControlsOverlay): 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>;
-    protected dispatchPlaybackEvent(eventStatus: 'success' | 'failed' | 'ready' | 'changed' | 'buffering' | 'recovered', context: {
-        result?: PlayResult;
-        timeToPlay?: number;
-        timeToFail?: number;
-        error?: any;
-        previousState?: any;
-        newState?: any;
-    }): void;
+    private startPlaybackWatchdog;
+    private handlePlaybackTimeout;
     pause(): void;
-    isPaused(): boolean;
-    isEnded(): boolean;
-    getCurrentTime(): number;
-    reset(): void;
     getDuration(): number;
     isMuted(): boolean;
     seek(clampedSeek: number): void;
@@ -4902,113 +4844,23 @@ export declare abstract class BaseHLSStrategy implements PlaybackStrategy {
     mute(): void;
     unmute(): void;
     toggleFullscreen(): void;
-    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 class HLSStrategy extends BaseHLSStrategy {
-    private videoOverlay?;
-    initialize(options?: PlaybackStrategyOptions): void;
-    protected onLoadingState(): void;
-    protected onBufferUpdate(progress: number): void;
-    protected onError(event: any, data: any): void;
-    toggleFullscreen(): void;
-}
-
-export declare class NativeVideoStrategy implements PlaybackStrategy {
-    private video;
-    private videoComponent;
-    private lastErrorExecutionTime;
-    private loaderDelegate?;
-    private playbackTimeout?;
-    private readonly PLAYBACK_TIMEOUT_MS;
-    private boundOnError;
-    private boundOnPlaying;
-    private boundOnPause;
-    private boundOnCanPlayThrough;
-    private contentId?;
-    private contentTitle?;
-    private contentType?;
-    private sessionId?;
-    private playAttemptStartTime;
-    constructor(video: HTMLVideoElement, videoComponent: BlazeWidgetVideo);
-    private setupErrorHandling;
+    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;
     private handlePlaying;
-    private handlePause;
-    private handleCanPlayThrough;
-    private startPlaybackTimeout;
-    private clearPlaybackTimeout;
-    private handlePlaybackTimeout;
-    private handleNativeVideoError;
-    play(): Promise<PlayResult>;
-    private waitForVideoToStartLoading;
-    setContentMetadata(metadata: {
-        contentId?: string;
-        contentTitle?: string;
-        contentType?: string;
-        sessionId?: string;
-    }): void;
-    private dispatchPlaybackEvent;
-    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;
-}
-
-export declare class SimpleHLSStrategy extends BaseHLSStrategy {
-    private loaderDelegate?;
-    private isPrefetchMode;
-    private fragmentsLoaded;
-    private readonly maxPrefetchFragments;
-    initialize(options?: PlaybackStrategyOptions): 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 handleSeekRecovery(seekTime: number): void;
-    seek(clampedSeek: number): void;
+    private handleNativeError;
+    private handleLoadedMetadata;
 }
 
 export * from './widget-video-base';
@@ -5086,6 +4938,7 @@ export declare abstract class WidgetBaseLayout extends BlazeWidgetScrollable imp
     setContentIds(ids: string[], options?: ISetWidgetOptions): void;
     setMaxItemsSize(maxItemsSize?: number, options?: ISetWidgetOptions): void;
     setActionHandlers(actionHandlers: ActionHandler[]): void;
+    setRecommendations(recommendations?: BlazeRecommendations, options?: ISetWidgetOptions): void;
     protected appendModalToBlazeSDK(modal: BlazeWidgetMomentModal | BlazeWidgetStoryModal | BlazeWidgetVideoModal): void;
     updateWidgetsData(): void;
     protected abstract reorderWidgetItems(): void;
@@ -5530,7 +5383,6 @@ export declare class BlazeWidgetLayout extends WidgetBaseLayout {
     connectWidgets(): void;
     get thumbnailShape(): ThumbnailShape;
     widgetType(): WidgetType;
-    setPersonalized(personalized?: BlazePersonalized): void;
     private setupAccessibility;
     private updateAccessibilityLabel;
     onKeyDown(e: KeyboardEvent): void;
@@ -5782,9 +5634,6 @@ export declare class BlazeWidgetVideo extends BlazeWidgetVideoBase {
     loaderTimeoutRefAppending: NodeJS.Timeout | undefined;
     lastErrorExecutionTime: number;
     private beforeContentPlayService;
-    private playbackStrategy?;
-    private playerCommands?;
-    private isHLSVideo;
     isVideoStartPlaying: boolean;
     isError: boolean;
     isLoaded: boolean;
@@ -5809,19 +5658,15 @@ 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>;
@@ -5833,17 +5678,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;
 }
 
 export declare class BlazeWidgetAd extends BlazeWidgetVideoBase {
@@ -5892,6 +5738,7 @@ export declare class BlazeWidgetAd extends BlazeWidgetVideoBase {
 
 export declare class BlazeWidgetBannerAd extends HTMLElement {
     parentContnet: BlazeWidgetContent;
+    isHidden(): boolean;
     constructor(parentContent: BlazeWidgetContent);
     private adContainer;
     private bannerAdInfo;
@@ -5899,7 +5746,9 @@ export declare class BlazeWidgetBannerAd extends HTMLElement {
     private get googletag();
     connectedCallback(): void;
     disconnectedCallback(): void;
-    show(bannerAdInfo?: IBannerAdInfo): void;
+    show(bannerAdInfo?: IBannerAdInfo, sendBannerViewEvent?: boolean): void;
+    hide(): void;
+    unhide(): void;
     private setInitialStyles;
     private setAdContainer;
     private raiseAnalyticsEventToParent;
@@ -5973,7 +5822,7 @@ export declare class BlazeWidgetMomentModal extends BlazeWidgetModal {
     setModalContent(data: IMoment[], indexOfContentInWidget: number, defaultAdsInfo?: IAdInfo): void;
     onKeyDown(ev: KeyboardEvent): void;
     close(): void;
-    open(): Promise<void>;
+    open(): void;
     play(): void;
     setExitButtonDisplay(): void;
     render(): void;
@@ -6370,7 +6219,6 @@ 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)[];
@@ -6402,6 +6250,7 @@ export declare class BlazeWidgetStory extends BlazeWidgetContent {
     private disableStoriesNavigationButtons;
     private disablePageNavigationButtons;
     private setButtonNavigationAsDisabled;
+    private shouldShowBannerAd;
     adjustContentView(): void;
     private setPlayerButtonPosition;
     updatePlayerButtonIcons(): void;
@@ -6418,6 +6267,9 @@ export declare class BlazeWidgetStory extends BlazeWidgetContent {
     private createProgressElements;
     private createProgressPart;
     setData(story: IStory): void;
+    get currentContentPage(): IContentPage;
+    get nextContentPage(): IContentPage | null;
+    get prevContentPage(): IContentPage | null;
     get currentPage(): BlazeWidgetVideoBase;
     get nextPage(): BlazeWidgetVideoBase;
     get prevPage(): BlazeWidgetVideoBase;
@@ -6425,10 +6277,11 @@ export declare class BlazeWidgetStory extends BlazeWidgetContent {
     loadStoryPostersByDistance(distance: number): void;
     revertNextPageButtonToPreviousAction(): void;
     displayRestartStoryButton(): void;
-    playPage(pageIndexToPlayNext: number): Promise<void>;
+    playPage(pageIndexToPlayNext: number): void;
     updatePublishedDate(index?: number): void;
     switchToPage(newPageIndex: number): void;
-    startPage(indexToPlay: number): Promise<void>;
+    startPage(indexToPlay: number): void;
+    private shouldGetNewBannerAd;
     unload(): void;
     displayCurrentStoryPageAndHideTheRest(): void;
     load(loadingType?: LoadingType): void;
@@ -6504,3 +6357,109 @@ export declare class BlazeWidgetStory extends BlazeWidgetContent {
     private buildStoryAccessibilityState;
 }
 
+export declare const ElementId: {
+    BlazeWidgetItem: string;
+    CtaButton: string;
+    BlazeWidgetStoryVideo: string;
+    BlazeWidgetStoryNextPageButton: string;
+    BlazeWidgetStoryPrevPageButton: string;
+    BlazeWidgetStoryNextStoryButton: string;
+    BlazeWidgetStoryPrevStoryButton: string;
+    BlazeWidgetStoryPlayButton: string;
+    BlazeWidgetStoryExitButton: string;
+    BlazeWidgetStoryMuteButton: string;
+    BlazeWidgetStoryShareButton: string;
+    BlazeEmbeddedStoryNextPageButton: string;
+    BlazeEmbeddedStoryPrevPageButton: string;
+};
+
+export declare class ElementUtils {
+    static getFirstVisibleElement(page: Page, testId: string): Promise<import("playwright-core").Locator>;
+}
+
+export declare const SingleStoryDefaultData: {
+    id: string;
+    title: string;
+    description: string;
+    isLive: boolean;
+    createTime: string;
+    updateTime: string;
+    thumbnails: {
+        rendition: {
+            url: string;
+            bitRate: null;
+            fileSize: null;
+            aspectRatio: string;
+        };
+        renditions: {
+            url: string;
+            bitRate: null;
+            fileSize: null;
+            aspectRatio: string;
+        }[];
+        type: string;
+    }[];
+    pages: {
+        id: string;
+        type: string;
+        index: number;
+        duration: number;
+        isSkippable: boolean;
+        thumbnail: {
+            rendition: {
+                url: string;
+                bitRate: null;
+                fileSize: null;
+                aspectRatio: string;
+            };
+            renditions: {
+                url: string;
+                bitRate: null;
+                fileSize: null;
+                aspectRatio: string;
+            }[];
+            type: string;
+        };
+        cta: {
+            type: string;
+            text: string;
+            url: string;
+            backgroundColor: string;
+            textColor: string;
+        };
+        createTime: string;
+        updateTime: string;
+        baseLayer: {
+            type: string;
+            content: {
+                renditions: {
+                    url: string;
+                    bitRate: number;
+                    fileSize: number;
+                    aspectRatio: string;
+                }[];
+            };
+        };
+        interaction: null;
+        ignoreReadStatusForStory: boolean;
+        closedCaptions: {
+            url: string;
+            bitRate: null;
+            fileSize: null;
+            aspectRatio: string;
+        }[];
+    }[];
+    adInfo: null;
+    bannerAdInfo: null;
+    geoRestriction: null;
+    entities: {
+        gameId: string;
+        teamId: null;
+        playerId: null;
+        roundId: null;
+    };
+};
+
+
+
+