@wscsports/blaze-web-sdk 0.13.5 → 0.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wscsports/blaze-web-sdk",
-  "version": "0.13.5",
+  "version": "0.14.1",
   "main": "publish/index",
   "types": "publish/index",
   "files": [

package/publish/index.d.ts

@@ -11,6 +11,7 @@ export declare function Initialize(apiKey: string, userOptions?: Partial<IBlazeS
 export declare function WidgetRowView(containerId: string, options: IWidgetViewOptions): IWidgetView;
 export declare function WidgetGridView(containerId: string, options: IWidgetViewOptions): IWidgetView;
 export declare function WidgetEmbeddedStory(containerId: string, options: IWidgetViewOptions): IWidgetView;
+export declare function WidgetCustomView(containerId: string, options: ICustomWidgetOptionsWithDataSource): ICustomWidgetView;
 export declare function Theme(theme: ThemeType, contentType: 'moment'): IWidgetTheme<MomentPlayerStyle>;
 export declare function Theme(theme: ThemeType, contentType: 'story'): IWidgetTheme<StoryPlayerStyle>;
 export declare function Theme(theme: ThemeType, contentType: 'video'): IWidgetTheme<VideoPlayerStyle>;
@@ -35,6 +36,7 @@ declare const _default: {
     WidgetGridView: typeof WidgetGridView;
     WidgetRowView: typeof WidgetRowView;
     WidgetEmbeddedStory: typeof WidgetEmbeddedStory;
+    WidgetCustomView: typeof WidgetCustomView;
     Theme: typeof Theme;
     addDelegateListener: typeof addDelegateListener;
     setDoNotTrack: typeof setDoNotTrack;
@@ -360,7 +362,7 @@ export declare abstract class BaseWidget extends HTMLElement {
 type BlazeSourceType = 'labels' | 'ids';
 export type AdvancedOrdering = 'LiveFirst';
 export interface BlazeDataSourceType {
-    type: BlazeSourceType;
+    sourceType: BlazeSourceType;
     labels?: string | string[] | BlazeWidgetLabel;
     labelsPriority?: string | string[] | BlazeWidgetLabel[];
     ids?: string[];
@@ -383,6 +385,11 @@ export declare class BlazeDataSourceFactory {
 }
 export declare class BlazeDataSourceValidations {
     static validateFormat(dataSource: BlazeDataSourceType): void;
+    static validateDataSource(containerId: string, legacyProps: {
+        labels?: string | string[] | BlazeWidgetLabel;
+        storyIds?: string[];
+        contentIds?: string[];
+    }, dataSource?: BlazeDataSourceType): void;
 }
 
 export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): {
@@ -1109,9 +1116,20 @@ export interface IContent {
     isAd: boolean;
     entities?: ContentEntities;
     bannerAdInfo?: IBannerAdInfo;
+    description?: string;
     closedCaptions?: IClosedCaption[];
     extraInfo: ExtraInfo;
 }
+export interface IBlazeContent {
+    id: string;
+    title: string;
+    updateTime: string;
+    createTime: string;
+    thumbnails: IThumbnail[];
+    hasViewed: boolean;
+    type?: string;
+    entities?: ContentEntities;
+}
 
 export interface ICta {
     type: 'Deeplink' | 'Web' | null;
@@ -1254,13 +1272,16 @@ export interface IMoment extends IContent {
     cta: ICta;
     adInfo?: IAdInfo;
     subtitle?: string;
-    description?: string;
 }
 export type MomentDB = {
     id: string;
     liked: boolean;
     viewed: boolean;
 };
+export interface IBlazeMoment extends IBlazeContent {
+    duration: string;
+    likes: number;
+}
 
 interface IBasePage {
     id: string;
@@ -1288,6 +1309,15 @@ export interface IAdPage extends IBasePage {
     type: 'Ad';
     adInfo?: IWebAdInfo;
 }
+export interface IBlazePage {
+    id: string;
+    duration: number;
+    hasViewed: boolean;
+    createTime: string;
+    index?: number;
+    thumbnail?: IThumbnail;
+    poster?: IThumbnail;
+}
 export type IPage = IAdPage | IContentPage;
 
 export interface IRendition {
@@ -1298,12 +1328,15 @@ export interface IRendition {
 }
 
 export interface IStory extends IContent {
-    description: string;
     isLive: boolean;
     pages: IPage[];
     adInfo?: IAdInfo;
     compositionType?: string;
 }
+export interface IBlazeStory extends IBlazeContent {
+    pages: IBlazePage[];
+    isLive: boolean;
+}
 
 export interface IThumbnail {
     type: ThumbnailApiType;
@@ -1312,7 +1345,6 @@ export interface IThumbnail {
 }
 
 export interface IVideo extends IContent {
-    description: string;
     isLive: boolean;
     pages: IPage[];
     adInfo?: IAdInfo;
@@ -1329,6 +1361,11 @@ export interface VideoDBData {
     currentTime: number;
     posterCurrentTime: string;
 }
+export interface IBlazeVideo extends IBlazeContent {
+    duration: string;
+    likes: number;
+    isLive: boolean;
+}
 
 export declare enum ActionHandlerId {
     AddCustomActionButton = "addCustomActionButton"
@@ -1419,6 +1456,7 @@ export interface WidgetsTagNameMap {
     'blaze-widget-modal': BlazeWidgetModal;
     'blaze-widget-item': BlazeWidgetItem;
     'blaze-widget-layout': BlazeWidgetLayout;
+    'blaze-widget-custom-layout': BlazeWidgetCustomLayout;
     'blaze-widget-story': BlazeWidgetStory;
     'blaze-widget-story-player': BlazeWidgetStoryPlayer;
     'blaze-widget-story-modal': BlazeWidgetStoryModal;
@@ -1461,6 +1499,7 @@ interface WidgetsTagNameOptionsMap {
     'blaze-widget-modal': {};
     'blaze-widget-item': {};
     'blaze-widget-layout': {};
+    'blaze-widget-custom-layout': {};
     'blaze-widget-story': {};
     'blaze-widget-story-player': {};
     'blaze-widget-story-modal': {};
@@ -1505,12 +1544,17 @@ export declare abstract class WidgetsFactory {
 
 export * from './elements.factory';
 
+export declare function isStory(item: ContentItem): item is IStory;
+export declare function isVideo(item: ContentItem): item is IVideo;
+export declare function isMoment(item: ContentItem): item is IMoment;
+
 export declare function isValidIds(ids: unknown): ids is string[];
 export declare function hasValidIds(...sources: Array<string[] | undefined>): boolean;
 
 export * from './widget-theme.guard';
 export * from './labels.guard';
 export * from './ids.guard';
+export * from './contents.guard';
 
 export declare function isValidLabels(labels: unknown): labels is string | string[] | IBlazeWidgetLabel;
 export declare function hasValidLabels(...sources: Array<string | string[] | IBlazeWidgetLabel | undefined>): boolean;
@@ -1611,8 +1655,8 @@ export interface IDataSourceBuilder {
     labels: (params: LabelsDataSourceParams) => BlazeDataSourceType;
     ids: (params: IdsDataSourceParams) => BlazeDataSourceType;
 }
-export type LabelsDataSourceParams = Omit<BlazeDataSourceType, 'type' | 'ids'>;
-export type IdsDataSourceParams = Omit<BlazeDataSourceType, 'type' | 'labels' | 'labelsPriority' | 'maxItems'>;
+export type LabelsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'ids'>;
+export type IdsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'labels' | 'labelsPriority' | 'maxItems'>;
 
 export interface IDatabase {
     init: () => Promise<void>;
@@ -1725,6 +1769,18 @@ export * from './widget-options.interface';
 export * from './widget-view.interface';
 export { default as Observable } from './observable';
 
+export interface ILayoutDataSourceOptions {
+    dataSource?: BlazeDataSourceType;
+    labels?: string | string[] | BlazeWidgetLabel;
+    storyIds?: string[];
+    contentIds?: string[];
+    maxItemsCount?: number;
+    maxDisplayItemsCount?: number;
+    orderType?: string;
+    labelsPriority?: string | string[] | BlazeWidgetLabel[];
+    shouldOrderWidgetByReadStatus?: boolean;
+}
+
 export default interface IntersectionObservable {
     intersectionObserver: IntersectionObserver;
     handleIntersection(entries: IntersectionObserverEntry[]): void;
@@ -1776,7 +1832,13 @@ export interface IWidgetViewOptionsWithDataSource extends IWidgetViewOptionsBase
     storyIds?: never;
     labels?: never;
 }
-export type IWidgetViewOptions = IWidgetViewOptionsWithLabels | IWidgetViewOptionsWithStoryIds | IWidgetViewOptionsWithDataSource;
+export interface IBlazeCustomRenderer {
+    render(contents: BlazeContentItem[], container: HTMLElement, playContent: (contentId: string) => void): void;
+    destroy?(): void;
+}
+export interface ICustomWidgetOptionsWithDataSource extends IWidgetViewOptionsWithDataSource {
+    customRenderer: IBlazeCustomRenderer;
+}
 
 export interface IWidgetView extends HTMLElement {
     setTheme: (theme: IWidgetTheme | ThemeType) => void;
@@ -1797,6 +1859,10 @@ export interface IWidgetView extends HTMLElement {
 export interface ISetWidgetOptions {
     shouldReloadData?: boolean;
 }
+export interface ICustomWidgetView extends IWidgetView {
+    getContainer: () => HTMLElement;
+    getContents: () => IBlazeContent[];
+}
 
 declare const AdServiceClass_base: {
     new (): {};
@@ -3236,6 +3302,9 @@ export type IClosedCaption = {
 };
 export type ClosedCaptionsState = CcLanguageCode | 'Off' | 'Unknown' | 'Unavailable';
 
+export type ContentItem = IStory | IVideo | IMoment | IContent;
+export type BlazeContentItem = IBlazeStory | IBlazeVideo | IBlazeMoment | IBlazeContent;
+
 export type FontWeightType = 'normal' | 'bold' | 'bolder' | 'lighter' | 'inherit' | 'initial' | 'unset' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
 export type TextTransformType = 'capitalize' | 'uppercase' | 'lowercase' | 'none';
 
@@ -3303,6 +3372,8 @@ export * from './animation.type';
 export * from './screen.type';
 export * from './action-handler.type';
 export * from './cc-language.type';
+export * from './widget-view-options.type';
+export * from './content-item.type';
 
 export type EntitiesType = 'playerId' | 'teamId' | 'gameId' | 'roundId';
 export type PerItemStyleOverrides = Partial<Record<EntitiesType, Array<{
@@ -3392,6 +3463,8 @@ export type TokenData = {
     userId: string;
 };
 
+export type IWidgetViewOptions = IWidgetViewOptionsWithLabels | IWidgetViewOptionsWithStoryIds | IWidgetViewOptionsWithDataSource | ICustomWidgetOptionsWithDataSource;
+
 export type WidgetType = 'Row' | 'Grid';
 
 export declare function isImaAdInfo(ad: IAdInfo): ad is IImaAdInfo;
@@ -3414,6 +3487,13 @@ export declare function calculateChipSize(type: 'chip' | 'badge', statusIndicato
 
 export declare function delay(ms: number): Promise<void>;
 
+export declare function transformContent(item: IContent): IBlazeContent;
+export declare function transformStory(item: IStory): IBlazeStory;
+export declare function transformVideo(item: IVideo): IBlazeVideo;
+export declare function transformMoment(item: IMoment): IBlazeMoment;
+export declare function transformContentItem(item: ContentItem): BlazeContentItem;
+export declare function transformContentsArray(items: ContentItem[]): BlazeContentItem[];
+
 type CountryCode = typeof CountryCodes[number];
 export declare function isValidCountryCode(countryCode: string): countryCode is CountryCode;
 
@@ -3454,11 +3534,13 @@ export declare function isElementInsideTarget(target: EventTarget | null, select
 export declare function findParentOfType<T>(target: EventTarget | null, type: {
     new (...args: any[]): T;
 }, stopAt: Element): T | null;
+export declare function validateContainer(containerId: string, widgetElementName?: string): HTMLElement;
 
 export * from './ad-info.utils';
 export * from './cc-language.utils';
 export * from './chip.utils';
 export * from './common.utils';
+export * from './content-mapper.utils';
 export * from './country-location.utils';
 export * from './guard.utils';
 export * from './helper';
@@ -3861,7 +3943,7 @@ export declare class BlazeVideoNavigationOverlay extends HTMLElement {
     loader: BlazeLoader;
     private _platform;
     constructor();
-    static get observedAttributes(): ("layout" | "hidden" | "has-next" | "has-prev")[];
+    static get observedAttributes(): ("hidden" | "layout" | "has-next" | "has-prev")[];
     attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
     private applyAttribute;
     connectedCallback(): void;
@@ -4173,6 +4255,7 @@ export declare class HLSStrategy implements PlaybackStrategy {
 
 export * from './widget-video-base';
 export * from './widget-player';
+export * from './widget-custom-layout';
 export * from './ad/widget-ad';
 export * from './ad/widget-banner-ad';
 export * from './ad/widget-vast-ad';
@@ -4197,6 +4280,83 @@ export * from './widget-captions';
 export * from '../video/core/video';
 export * from './widget-cc-modal';
 
+export declare abstract class WidgetBaseLayout extends BlazeWidgetScrollable implements Observable, IWidgetView {
+    isWidgetVisible: boolean;
+    widgetItems: BlazeWidgetItem[];
+    analyticsStack: Record<WidgetAction, boolean>;
+    shouldReloadData: boolean;
+    shouldReloadWhenPlayerIsClosed: boolean;
+    personalized?: BlazePersonalized;
+    preset: IWidgetTheme | undefined;
+    contents: IStory[] | IMoment[] | IVideo[];
+    actionHandlers: ActionHandler[];
+    defaultAdsInfo: IAdInfo | undefined;
+    thumbnailWidth: number | undefined;
+    thumbnailHeight: number | undefined;
+    storysModal: BlazeWidgetStoryModal | undefined;
+    momentsModal: BlazeWidgetMomentModal | undefined;
+    videosModal: BlazeWidgetVideoModal | undefined;
+    perItemStyleOverrides: PerItemStyleOverrides;
+    activeOverridesLayoutThemes: PerItemStyleOverrides;
+    constructor();
+    abstract render(): void;
+    widgetType(): WidgetType;
+    get thumbnailShape(): ThumbnailShape;
+    protected get theme(): IWidgetTheme<StoryPlayerStyle | VideoPlayerStyle | MomentPlayerStyle>;
+    protected updateActiveLayoutThemesPerItemWithEntity(key: EntitiesType, value: string, theme: IWidgetTheme): void;
+    protected setReloadData(options?: ISetWidgetOptions): void;
+    set contentIds(value: string);
+    set storyIds(value: string);
+    addDelegateListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    event(action: WidgetAction, data: Partial<WidgetEvent>, label?: string | undefined): void;
+    intersectionObserver: IntersectionObserver;
+    abstract handleIntersection(entries: IntersectionObserverEntry[]): void;
+    getTheme(): IWidgetTheme;
+    setTheme(theme: IWidgetTheme | ThemeType): void;
+    reload(): void;
+    abstract updateWidgetUI(): void;
+    setMaxItemsDisplaySize(size: number): void;
+    setDelegations(delegates: Record<Delegation, EventListenerOrEventListenerObject>): void;
+    abstract updateOverrideStyles(perItemStyleOverrides: PerItemStyleOverrides): void;
+    abstract setId(id: string): void;
+    protected setOrderType(orderType?: string): void;
+    updateDataSource(dataSource: BlazeDataSourceType): void;
+    setPersonalized(personalized?: BlazePersonalized): void;
+    setAdvancedOrdering(advancedOrdering?: AdvancedOrdering): void;
+    setLabels(labels: string | string[] | BlazeWidgetLabel, options?: ISetWidgetOptions): void;
+    setLabelsPriority(labelsPriority: string | string[] | BlazeWidgetLabel[], options?: ISetWidgetOptions): void;
+    setContentIds(ids: string[], options?: ISetWidgetOptions): void;
+    setMaxItemsSize(maxItemsSize?: number, options?: ISetWidgetOptions): void;
+    setActionHandlers(actionHandlers: ActionHandler[]): void;
+    protected appendModalToBlazeSDK(modal: BlazeWidgetMomentModal | BlazeWidgetStoryModal | BlazeWidgetVideoModal): void;
+    updateWidgetsData(): void;
+    protected abstract reorderWidgetItems(): void;
+    protected abstract updateWidgetDisplay(): void;
+    protected sortContent(): void;
+    protected reorderWidgets(): void;
+    private getContentType;
+    static get observedAttributes(): string[];
+    protected createModal(type: ContentType): void;
+    protected beforeStoryModalCreation(): void;
+    protected abstract setupVideoModalCallbacks(): void;
+    protected abstract setupMomentModalCallbacks(): void;
+    protected abstract setupStoryModalCallbacks(): void;
+    loadContent(): Promise<void>;
+    protected handleContentLoadError(e: any): Promise<void>;
+    protected handleStoryContent(): void;
+    protected handleVideoContent(): void;
+    protected handleMomentContent(): void;
+    attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
+    protected playVideo(contentId: string): void;
+    protected playMoment(contentId: string): void;
+    protected playStory(contentId: string): void;
+    protected handleAssetsExpiry(data: {
+        assetsExpiryTime: string;
+    }): void;
+    protected removeSkeletonContainer?(): Promise<void>;
+    protected abstract handlePostContentLoad(isStoryContentType: boolean, isMomentContentType: boolean, isVideoContentType: boolean): Promise<void>;
+}
+
 type Position = {
     top?: string;
     left?: string;
@@ -4329,6 +4489,32 @@ export declare class BlazeWidgetCtaModal extends BaseWidget {
     render(): void;
 }
 
+export declare class BlazeWidgetCustomLayout extends WidgetBaseLayout implements ICustomWidgetView {
+    private customContainer;
+    private customRenderer;
+    constructor(customRenderer: IBlazeCustomRenderer);
+    getContainer(): HTMLElement;
+    getContents(): IBlazeContent[];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    handleIntersection(entries: IntersectionObserverEntry[]): void;
+    reload(): void;
+    updateWidgetUI(): void;
+    setMaxItemsDisplaySize(size: number): void;
+    setDelegations(delegates: Record<Delegation, EventListenerOrEventListenerObject>): void;
+    updateOverrideStyles(): void;
+    setId(id: string): void;
+    protected handlePostContentLoad(isStoryContentType: boolean, isMomentContentType: boolean, isVideoContentType: boolean): Promise<void>;
+    protected reorderWidgetItems(): void;
+    protected updateWidgetDisplay(): void;
+    private setupModalContent;
+    private playContentById;
+    render(): void;
+    protected setupVideoModalCallbacks(): void;
+    protected setupMomentModalCallbacks(): void;
+    protected setupStoryModalCallbacks(): void;
+}
+
 export declare class BlazeWidgetEmbeddedStory extends BaseWidget implements IWidgetView, Observable {
     preset?: IWidgetTheme;
     contents: BlazeWidgetStory[];
@@ -4484,47 +4670,27 @@ export declare class BlazeWidgetItem extends BaseWidget implements Observable {
 }
 
 /// <reference types="node" />
-export declare class BlazeWidgetLayout extends BlazeWidgetScrollable implements Observable, IWidgetView {
-    storysModal: BlazeWidgetStoryModal | undefined;
-    momentsModal: BlazeWidgetMomentModal | undefined;
-    videosModal: BlazeWidgetVideoModal | undefined;
-    defaultAdsInfo: IAdInfo | undefined;
-    content: IStory[] | IMoment[] | IVideo[];
+export declare class BlazeWidgetLayout extends WidgetBaseLayout {
     skeletonContainer: BlazeDiv | undefined;
-    widgetItems: BlazeWidgetItem[];
-    preset: IWidgetTheme | undefined;
-    perItemStyleOverrides: PerItemStyleOverrides;
-    activeOverridesLayoutThemes: PerItemStyleOverrides;
-    isWidgetVisible: boolean;
-    thumbnailWidth: number | undefined;
-    thumbnailHeight: number | undefined;
     widgetHeight: number;
     parentHeight: number | undefined;
-    intersectionObserver: IntersectionObserver;
     heightObserver: MutationObserver;
     reloadTimeout: NodeJS.Timeout | undefined;
-    analyticsStack: Record<WidgetAction, boolean>;
-    actionHandlers: ActionHandler[];
     onResizeEvent: (this: Window, ev: UIEvent) => void;
     onMouseMoveEvent: ((e: MouseEvent) => void) & {
         cancel: () => void;
     };
     onMouseLeaveEvent: (e: MouseEvent) => void;
-    shouldReloadWhenPlayerIsClosed: boolean;
-    shouldReloadData: boolean;
-    private personalized?;
     currentlyAnimatedItem: BlazeWidgetItem | undefined;
     firstVisibleItem: BlazeWidgetItem | undefined;
     get refElement(): ShadowRoot | BlazeWidgetLayout;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
-    private getContentType;
     onResizeEventDelay(): void;
     onResize(): void;
     handleHeightChangeMutation(mutationsList: MutationRecord[]): void;
     handleIntersection(entries: IntersectionObserverEntry[]): void;
-    attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
     onKeyDown(e: KeyboardEvent): void;
     onContentChange(mode: ContentDirection): void;
     onPlayerClose(): void;
@@ -4532,39 +4698,24 @@ export declare class BlazeWidgetLayout extends BlazeWidgetScrollable implements
     setFirstVisibleItem(): void;
     getParentHeightWithoutPadding(): number | null;
     setId(id: string): void;
-    private setReloadData;
-    addDelegateListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
     set storyIds(value: string);
     set contentIds(value: string);
-    setContentIds(ids: string[], options?: ISetWidgetOptions): void;
-    setLabelsPriority(labelsPriority: string | string[] | BlazeWidgetLabel[], options?: ISetWidgetOptions): void;
-    setActionHandlers(actionHandlers: ActionHandler[]): void;
-    setLabels(labels: string | string[] | BlazeWidgetLabel, options?: ISetWidgetOptions): void;
-    getTheme(): IWidgetTheme;
-    setTheme(theme: IWidgetTheme | ThemeType): void;
-    private get theme();
-    updateOverrideStyles(perItemStyleOverrides: PerItemStyleOverrides): void;
-    reload(): void;
-    private updateActiveLayoutThemesPerItemWithEntity;
     updateWidgetUI(): void;
+    updateOverrideStyles(perItemStyleOverrides: PerItemStyleOverrides): void;
+    private updatePlayerStyle;
     setMaxPaddingOnWidgetItems(): void;
-    updateDataSource(dataSource: BlazeDataSourceType): void;
-    setDelegations(delegates: Record<Delegation, EventListenerOrEventListenerObject>): void;
-    private setOrderType;
     setMaxItemsDisplaySize(maxSize: number): void;
     setMaxItemsSize(maxItemsSize?: number, options?: ISetWidgetOptions): void;
-    private updatePlayerStyle;
-    private createModal;
-    private appendModalToBlazeSDK;
-    static get observedAttributes(): string[];
-    private onItemClick;
-    private loadContent;
-    private handleStoryContent;
-    private handleVideoContent;
-    private handleMomentContent;
-    handleAssetsExpiry(data: {
+    protected setupVideoModalCallbacks(): void;
+    protected setupMomentModalCallbacks(): void;
+    protected setupStoryModalCallbacks(): void;
+    protected beforeStoryModalCreation(): void;
+    protected removeSkeletonContainer(): Promise<void>;
+    protected handlePostContentLoad(isStoryContentType: boolean, isMomentContentType: boolean, isVideoContentType: boolean): Promise<void>;
+    protected handleAssetsExpiry(data: {
         assetsExpiryTime: string;
     }): void;
+    private onItemClick;
     handleWidgetContent(): void;
     calculateChipSizes(theme: IWidgetTheme): {
         badge: {
@@ -4602,16 +4753,12 @@ export declare class BlazeWidgetLayout extends BlazeWidgetScrollable implements
         labelAdditionalWidth: number;
         labelAdditionalHeight: number;
     };
-    event(action: WidgetAction, data: Partial<WidgetEvent>, label?: string | undefined): void;
-    private sortContent;
-    private reorderWidgets;
-    updateWidgetsData(): void;
-    private updateWidgetDisplay;
+    protected reorderWidgetItems(): void;
+    protected updateWidgetDisplay(): void;
     private maxSize;
     connectWidgets(): void;
     get thumbnailShape(): ThumbnailShape;
     widgetType(): WidgetType;
-    setPersonalized(personalized?: BlazePersonalized): void;
 }
 
 export declare class BlazeWidgetModal extends BaseWidget {
@@ -4984,6 +5131,7 @@ export declare class BlazeWidgetVastAd extends HTMLElement {
     constructor(contentType: ContentType, getReferringObject?: (() => ReferringEventInfo) | undefined);
     private initializeGoogleIma;
     private buildImaUrl;
+    private cleanupAdSession;
     startAd(videoElement: HTMLVideoElement, adInfo: IImaAdInfo, contentExtraInfo?: ContentExtraInfo, addCustomParams?: (url: URL) => void, addExtraAnalyticsParams?: AddExtraAnalyticsParams): Promise<Boolean>;
     private onAdsManagerLoaded;
     private loadAds;