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

package/publish/index.d.ts

@@ -363,7 +363,7 @@ export declare abstract class BaseWidget extends HTMLElement {
     removeElement(): void;
 }
 
-type BlazeSourceType = 'labels' | 'ids' | 'recommendations';
+type BlazeSourceType = 'labels' | 'ids';
 export type AdvancedOrdering = 'LiveFirst';
 export interface BlazeDataSourceType {
     sourceType: BlazeSourceType;
@@ -374,7 +374,6 @@ export interface BlazeDataSourceType {
     maxItems?: number;
     advancedOrdering?: AdvancedOrdering;
     personalized?: BlazePersonalized;
-    recommendations?: BlazeRecommendations;
 }
 export declare const BlazeInternalError: {
     LabelExpressionMustNotBeEmpty: string;
@@ -382,15 +381,10 @@ 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 {
@@ -399,7 +393,7 @@ export declare class BlazeDataSourceValidations {
         labels?: string | string[] | BlazeWidgetLabel;
         storyIds?: string[];
         contentIds?: string[];
-    }, dataSource?: BlazeDataSourceType, contentType?: ContentType): void;
+    }, dataSource?: BlazeDataSourceType): void;
 }
 
 export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): {
@@ -956,7 +950,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(): ".8rem" | "1rem" | ".5rem";
+    get fontSize(): "1rem" | ".8rem" | ".5rem";
 }
 
 export type ButtonAttribute = (typeof BUTTON_ATTRIBUTES)[keyof typeof BUTTON_ATTRIBUTES];
@@ -977,7 +971,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-visible" | "blaze-btn-hidden" | "button-desktop-animation")[];
+    static get observedAttributes(): ("height" | "order" | "width" | "icon-color" | "disabled" | "blaze-btn-hidden" | "blaze-btn-visible" | "button-desktop-animation")[];
     private onMouseEnter;
     private onMouseLeave;
     private onClick;
@@ -1078,7 +1072,7 @@ export declare class BlazeShareButton extends BaseWidget {
     get size(): SizeType;
     set size(value: SizeType);
     set type(value: ShareButtonType);
-    get fontSize(): ".8rem" | "1rem" | ".5rem";
+    get fontSize(): "1rem" | ".8rem" | ".5rem";
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(name: AttributeType, oldValue: string, newValue: string): void;
@@ -1342,7 +1336,6 @@ export interface AppConfiguration {
         configRefetchIntervalInMinutes?: number;
         enableClientPlaybackModification?: 'true' | 'false' | string;
     };
-    recommendationsConfigurations?: IRecommendationsConfigurations;
     sdkLoggerConfigurations?: ILoggerConfiguration;
 }
 
@@ -1589,6 +1582,7 @@ export interface IRendition {
     aspectRatio: ContentAspectRatio;
     bitRate: number;
     fileSize: number;
+    fileType?: 'Mp4' | 'Hls';
 }
 
 export interface IStory extends IContent {
@@ -2008,11 +2002,9 @@ 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' | 'recommendations'>;
-export type IdsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'labels' | 'recommendations' | 'labelsPriority' | 'maxItems'>;
-export type RecommendationsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'ids' | 'labels'>;
+export type LabelsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'ids'>;
+export type IdsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'labels' | 'labelsPriority' | 'maxItems'>;
 
 export interface IDatabase {
     init: () => Promise<void>;
@@ -2129,7 +2121,6 @@ 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 {
@@ -2230,13 +2221,6 @@ 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;
@@ -2382,9 +2366,6 @@ type GetByLabelsOptions = GetOptions & {
 type GetByIdsOptions = GetOptions & {
     ids: string[];
 };
-type GetByRecommendationsOptions = GetOptions & {
-    recommendations: BlazeRecommendations;
-};
 export interface ApiResponse<T> {
     assetsExpiryTime: string;
     totalItems: number;
@@ -2427,7 +2408,6 @@ 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;
@@ -2460,7 +2440,6 @@ declare abstract class ApiServiceClass extends ApiServiceClass_base implements I
     private getContentDefaultParams;
     private getContentParamsByLabels;
     private getContentParamsByIds;
-    private getContentParamsByRecommendations;
 }
 export declare const ApiService: ApiServiceClass;
 
@@ -3882,7 +3861,6 @@ 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<{
@@ -3934,18 +3912,6 @@ 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;
@@ -4215,6 +4181,9 @@ 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';
 
@@ -4778,9 +4747,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;
@@ -4792,7 +4771,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;
@@ -4802,39 +4785,115 @@ 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 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;
     constructor(video: HTMLVideoElement);
-    initialize(videoOverlay: BlazeLongFormControlsOverlay): void;
+    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;
     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;
+    protected dispatchPlaybackEvent(eventStatus: 'success' | 'failed' | 'ready' | 'changed' | 'buffering' | 'recovered', context: {
+        result?: PlayResult;
+        timeToPlay?: number;
+        timeToFail?: number;
+        error?: any;
+        previousState?: any;
+        newState?: any;
+    }): void;
     pause(): void;
+    isPaused(): boolean;
+    isEnded(): boolean;
+    getCurrentTime(): number;
+    reset(): void;
     getDuration(): number;
     isMuted(): boolean;
     seek(clampedSeek: number): void;
@@ -4843,23 +4902,113 @@ 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 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 handlePlaying;
-    private handleNativeError;
-    private handleLoadedMetadata;
+    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;
 }
 
 export * from './widget-video-base';
@@ -4937,7 +5086,6 @@ 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;
@@ -5382,6 +5530,7 @@ 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;
@@ -5633,6 +5782,9 @@ 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;
@@ -5657,15 +5809,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>;
@@ -5677,18 +5833,17 @@ 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 {
@@ -5818,7 +5973,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;
@@ -6215,6 +6370,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)[];
@@ -6269,10 +6425,10 @@ export declare class BlazeWidgetStory extends BlazeWidgetContent {
     loadStoryPostersByDistance(distance: number): void;
     revertNextPageButtonToPreviousAction(): void;
     displayRestartStoryButton(): void;
-    playPage(pageIndexToPlayNext: number): void;
+    playPage(pageIndexToPlayNext: number): Promise<void>;
     updatePublishedDate(index?: number): void;
     switchToPage(newPageIndex: number): void;
-    startPage(indexToPlay: number): void;
+    startPage(indexToPlay: number): Promise<void>;
     unload(): void;
     displayCurrentStoryPageAndHideTheRest(): void;
     load(loadingType?: LoadingType): void;
@@ -6348,109 +6504,3 @@ 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;
-    };
-};
-
-
-
-