@wscsports/blaze-web-sdk 0.14.3 → 0.16.0

package/publish/index.d.ts

@@ -7,6 +7,7 @@ type PlayContentOptions = {
 export declare function setDoNotTrack(value: boolean): void;
 export declare function setGeoLocation(value: string): void;
 export declare function setExternalUserId(value: string): Promise<void>;
+export declare function setOnItemClick(callback: ItemClickCallback | undefined): void;
 export declare function Initialize(apiKey: string, userOptions?: Partial<IBlazeSDKOptions>): Promise<void>;
 export declare function WidgetRowView(containerId: string, options: IWidgetViewOptions): IWidgetView;
 export declare function WidgetGridView(containerId: string, options: IWidgetViewOptions): IWidgetView;
@@ -41,6 +42,7 @@ declare const _default: {
     addDelegateListener: typeof addDelegateListener;
     setDoNotTrack: typeof setDoNotTrack;
     setGeoLocation: typeof setGeoLocation;
+    setOnItemClick: typeof setOnItemClick;
     LabelBuilder: typeof LabelBuilder;
     DataSourceBuilder: typeof DataSourceBuilder;
     Delegations: typeof Delegation;
@@ -427,6 +429,7 @@ declare class DeviceDetector {
     static getInstance(): DeviceDetector;
     private detectOS;
     private detectBrowser;
+    get getPlatform(): Platform;
     get isDesktop(): boolean;
     get isMobile(): boolean;
     get isTablet(): boolean;
@@ -435,6 +438,8 @@ declare class DeviceDetector {
     private handleResize;
     isIOSMobileTabletSafari(): boolean;
     get isFullscreenSupported(): boolean;
+    getDeviceInfo(): UAParser.IDevice;
+    getOSInfo(): UAParser.IOS;
 }
 export declare const deviceDetector: DeviceDetector;
 
@@ -468,17 +473,22 @@ export declare class FullscreenManager {
 
 export * from './analytics.class';
 export * from './base-element.class';
+export * from './data-source.class';
 export * from './debounce';
 export * from './device-detector.class';
 export * from './events-listener';
+export * from './fullscreen-manager.class';
 export * from './label-builder.class';
+export * from './logger/logger-manager.class';
+export * from './logger/logger-storage.class';
+export * from './logger/logger-transport.class';
+export * from './logger/logger-throttle.class';
 export * from './long-press.handler';
 export * from './singleton.class';
 export * from './throttle';
 export * from './url';
-export * from './data-source.class';
-export * from './fullscreen-manager.class';
 export * from './visiblity-manager.class';
+export * from './accessibility';
 
 export interface IBlazeWidgetLabel {
     readonly _type: 'BlazeWidgetLabel';
@@ -577,6 +587,217 @@ export declare class VisibilityManager {
     detach(): void;
 }
 
+export declare const DEFAULT_ACCESSIBILITY_CONFIG: AccessibilityConfig;
+export declare const DEFAULT_CONTENT_ACCESSIBILITY_CONFIG: ContentAccessibilityConfig;
+
+export interface ModalLabelConfig {
+    contentType: ContentType;
+    position: number;
+    total: number;
+    title?: string;
+    currentContent?: any;
+    includeNavigationContext?: boolean;
+}
+export declare function generateModalAriaLabel(config: ModalLabelConfig): string;
+
+declare class AccessibilityManager implements IAccessibilityManager {
+    private announcementService;
+    private contentButtons;
+    private modalFocusReturnTarget;
+    constructor(config?: AccessibilityConfig);
+    setupLiveRegions(container: HTMLElement): void;
+    announce(announcement: AccessibilityAnnouncement): void;
+    private getContentTypeLabel;
+    manageFocus(element: HTMLElement): void;
+    storeModalFocusReturnTarget(element: HTMLElement): void;
+    private returnFocusFromModal;
+    setupModalAccessibility(modal: HTMLElement, contentType: ContentType): void;
+    announceModalStatus(action: string, contentType: ContentType, context?: any): void;
+    closeModal(contentType: ContentType): void;
+    private clearModalFocusReturnTarget;
+    cleanup(): void;
+    clearAnnouncementQueue(): void;
+}
+export { AccessibilityManager };
+export declare const accessibilityManager: AccessibilityManager;
+
+export declare class ButtonLabelManager {
+    static setButtonLabel(button: BlazeButton | BlazeCtaButton, label: string): void;
+    static buildPlayPauseLabel(isPlaying: boolean, contentType: ContentType): string;
+    static buildMuteLabel(isMuted: boolean, contentType: ContentType): string;
+    static buildLikeLabel(isLiked: boolean): string;
+    static buildCtaLabel(ctaText?: string): string;
+    static buildNavigationLabel(direction: 'next' | 'prev', contentType: ContentType, target?: 'page' | 'content'): string;
+    static setBatchLabels(buttonLabelPairs: Array<[BlazeButton | BlazeCtaButton | undefined, string]>): void;
+}
+
+declare class ContentAccessibilityManager implements IContentAccessibilityManager {
+    private config;
+    private contentStrategies;
+    private registeredWidgets;
+    private lastUserActionTime;
+    private readonly userActionThrottleMs;
+    constructor(config?: ContentAccessibilityConfig);
+    private initializeStrategies;
+    registerContentWidget(contentId: string, elements: IContentWidgetElements, contentType: ContentType): void;
+    updateButtonLabels(contentId: string, dynamicState: Partial<IContentWidgetData>): void;
+    private getContentTypeLabel;
+    unregisterContentWidget(contentId: string): void;
+    announceUserAction(contentType: ContentType, action: string, context: UserActionContext): void;
+    announceModalOpening(contentType: ContentType, context: ModalContext): void;
+    announceNavigation(position: number, total: number, type: string, title?: string, context?: AccessibilityContext): void;
+    private generateMeaningfulAnnouncement;
+    private buildPageNavigationAnnouncement;
+    private buildStoryNavigationAnnouncement;
+    private buildMomentNavigationAnnouncement;
+    private buildGenericNavigationAnnouncement;
+    private formatAnnouncementMessage;
+    cleanup(): void;
+}
+export { ContentAccessibilityManager };
+export declare const contentAccessibilityManager: ContentAccessibilityManager;
+
+declare abstract class BaseContentAccessibilityStrategy implements IContentAccessibilityStrategy {
+    protected contentType: ContentType;
+    protected buttonLabels: BaseButtonLabelConfig;
+    protected registeredWidgets: Map<string, IContentWidgetElements>;
+    constructor(contentType: ContentType, buttonLabels: BaseButtonLabelConfig);
+    setupAccessibility(contentId: string, elements: IContentWidgetElements): void;
+    updateLabels(contentId: string, data: IContentWidgetData): void;
+    cleanup(contentId: string): void;
+}
+export declare class StoryAccessibilityStrategy extends BaseContentAccessibilityStrategy {
+    private storyButtonLabels;
+    constructor(buttonLabels: StoryButtonLabelConfig);
+    updateLabels(contentId: string, data: IContentWidgetData): void;
+}
+export declare class MomentAccessibilityStrategy extends BaseContentAccessibilityStrategy {
+    private momentButtonLabels;
+    constructor(buttonLabels: MomentButtonLabelConfig);
+    updateLabels(contentId: string, data: IContentWidgetData): void;
+}
+
+export * from './accessibility.class';
+export * from './accessibility-configs';
+export * from './content-accessibility-manager.class';
+export * from './content-accessibility-strategies';
+export * from './accessibility-utils';
+export * from './button-label-manager';
+
+export * from './logger-manager.class';
+export * from './logger-storage.class';
+export * from './logger-transport.class';
+export * from './logger-throttle.class';
+export * from './logger-database-adapter';
+
+export declare class LoggerDatabaseAdapter implements ILoggerDatabase {
+    storeLog(entry: LogEntryDB): Promise<void>;
+    getLogBatch(maxSize: number): Promise<LogEntryDB[]>;
+    removeLogs(ids: string[]): Promise<void>;
+    clearLogs(): Promise<void>;
+    getLogCount(): Promise<number>;
+}
+
+export declare class LoggerManager implements ILogger {
+    private static readonly LOG_IDENTIFIER_PREFIX;
+    private readonly storage;
+    private readonly transport;
+    private readonly throttle;
+    private configuration;
+    private pendingConfigUpdate;
+    private isInitialized;
+    private isDestroyed;
+    private isSending;
+    private immediateLogs;
+    private offlineQueue;
+    private immediateTimer;
+    private configUpdateTimer;
+    private isOnline;
+    private onlineStatusListener;
+    constructor(database: ILoggerDatabase);
+    init(configuration?: ILoggerConfiguration): Promise<void>;
+    destroy(): Promise<void>;
+    updateConfiguration(configuration: ILoggerConfiguration): void;
+    log(level: LogLevel, customLogIdentifier: string, message: string, metadata: ILogMetadata): Promise<void>;
+    private shouldLog;
+    private shouldSendImmediately;
+    private addToImmediateBatch;
+    private flushImmediateLogs;
+    private removeEntriesFromStorage;
+    private sendEntriesAndCleanup;
+    private processBatch;
+    private setupNetworkMonitoring;
+    private syncOfflineQueue;
+    private addToOfflineQueue;
+    private scheduleConfigurationUpdate;
+    private applyPendingConfiguration;
+    private resetLoggerState;
+    private handleNetworkReconnection;
+    private setDefaultLoggerConfiguration;
+}
+
+export interface ILoggerDatabase {
+    storeLog(entry: LogEntryDB): Promise<void>;
+    getLogBatch(maxSize: number): Promise<LogEntryDB[]>;
+    removeLogs(ids: string[]): Promise<void>;
+    clearLogs(): Promise<void>;
+    getLogCount(): Promise<number>;
+}
+export declare class LoggerStorage {
+    private database;
+    constructor(database: ILoggerDatabase);
+    store(entry: LogEntryDB): Promise<void>;
+    getBatch(maxSize: number): Promise<LogEntryDB[]>;
+    remove(ids: string[]): Promise<void>;
+    clear(): Promise<void>;
+    getLogCount(): Promise<number>;
+}
+
+export declare class LoggerThrottle {
+    private batchIntervalMs;
+    private logCount;
+    private batchInterval;
+    private batchCallback;
+    private _maxBatchSize;
+    private _minBatchSize;
+    get minBatchSize(): number;
+    get maxBatchSize(): number;
+    updateConfiguration(config: {
+        batchIntervalMs: number;
+        maxBatchSize: number;
+        minBatchSize: number;
+    }): void;
+    onBatchReady(callback: () => Promise<void>): void;
+    destroy(): void;
+    private setupBatchInterval;
+    incrementLogCount(): void;
+    shouldTriggerBatch(): boolean;
+}
+
+export declare class BatchRejectedError extends Error {
+    constructor(message?: string);
+}
+export interface ILogApiRequest {
+    message: string;
+    level: string;
+    api_key: string;
+    api_scheme_version: string;
+    metadata: ILogMetadata;
+}
+export declare class LoggerTransport {
+    private readonly MAX_RETRY_ATTEMPTS;
+    private readonly BASE_RETRY_DELAY;
+    private readonly MAX_RETRY_DELAY;
+    private readonly REQUEST_TIMEOUT;
+    send(entries: LogEntryDB[]): Promise<void>;
+    private sendWithRetry;
+    private attemptSend;
+    private preparePayload;
+    private sendToEndpoint;
+    private calculateRetryDelay;
+    private delay;
+}
+
 export declare class BlazeAlert extends BaseWidget {
     titleContainer: HTMLDivElement;
     textContainer: HTMLDivElement;
@@ -631,10 +852,9 @@ export declare class BlazeDrawer extends BaseWidget {
 export declare class BlazeImage extends BaseWidget {
     thumbnailElement: HTMLImageElement;
     constructor();
+    private onError;
     load(src: string): void;
     setHeight(value: string): void;
-    setRatio(ratio: string): void;
-    setBorderRadius(radius: string): void;
     setAccessibility(text: string): void;
 }
 
@@ -748,6 +968,7 @@ export declare class BlazeButton extends BaseWidget {
     isAnimationOnDesktopInitialized: boolean;
     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")[];
     private onMouseEnter;
     private onMouseLeave;
@@ -759,6 +980,7 @@ export declare class BlazeButton extends BaseWidget {
     get width(): string | number | boolean;
     setIconUrl(value: string): void;
     setIconUrlAnimation(value: string): void;
+    setAriaLabel(label: string): void;
     private applyIconStyles;
     private setIsHidden;
     private setIsVisible;
@@ -829,6 +1051,7 @@ export declare class BlazeCtaButton extends BaseWidget {
     setAnchorButtonStyles(styles: Partial<CSSStyleDeclaration>): void;
     setCtaTextStyle(styles: Partial<CSSStyleDeclaration>): void;
     setCtaIconStyles(styles: Partial<CSSStyleDeclaration>): void;
+    setAriaLabel(label: string): void;
     clearAllAnimations(): void;
 }
 
@@ -855,6 +1078,19 @@ export declare class BlazeShareButton extends BaseWidget {
     createButton(text: string, svgIcon: string): void;
 }
 
+export declare const ACCESSIBILITY_TIMING: {
+    readonly FOCUS_DELAY: 500;
+    readonly LABEL_CLEAR_DELAY: 1000;
+    readonly CONFIG_SCHEDULE_DELAY: 1000;
+};
+export declare const ACCESSIBILITY_ATTRIBUTES: {
+    readonly ACTIVE_TABINDEX: "0";
+    readonly INACTIVE_TABINDEX: "-1";
+    readonly REGION_ROLE: "region";
+    readonly ARIA_HIDDEN_FALSE: "false";
+    readonly ARIA_HIDDEN_TRUE: "true";
+};
+
 export declare const IMA_RATIOS: {
     readonly general: "1x1";
     readonly horizontal: "640x480";
@@ -982,6 +1218,7 @@ export declare const ASPECT_RATIO_16_9_STRING = "16 / 9";
 export declare const ASPECT_RATIO_9_16_STRING = "9 / 16";
 export declare const ASPECT_RATIO_4_3_STRING = "4 / 3";
 
+export * from './accessibility.constants';
 export * from './ads.constants';
 export * from './analytics.constants';
 export * from './device.constants';
@@ -1039,6 +1276,7 @@ export declare const DB_NAMES: {
     readonly USER: "user";
     readonly STORIES: "stories";
     readonly VIDEOS: "videos";
+    readonly LOGS: "logs";
 };
 export declare class Database implements IDatabase {
     private readonly options;
@@ -1052,7 +1290,9 @@ export declare class Database implements IDatabase {
     private deleteDatabase;
     createTransaction(tableName: string, mode: 'readonly' | 'readwrite'): IDBObjectStore | null;
     get<T>(tableName: string, key: string): Promise<IResponse<T>>;
+    getAll<T>(tableName: string): Promise<T[]>;
     update<T>(tableName: string, value: any): Promise<IResponse<T>>;
+    delete(tableName: string, key: string): Promise<IResponse<void>>;
     private throttledReinit;
 }
 
@@ -1090,7 +1330,9 @@ export type IAdInfo = IWebAdInfo | IImaAdInfo;
 export interface AppConfiguration {
     configurations: {
         analyticsAddEntitiesInfo?: string;
+        configRefetchIntervalInMinutes?: number;
     };
+    sdkLoggerConfigurations?: ILoggerConfiguration;
 }
 
 export type ContentExtraInfo = {
@@ -1153,6 +1395,7 @@ export * from './cta.interface';
 export * from './interaction.interface';
 export * from './layer-content.interface';
 export * from './layer.interface';
+export * from './log-entry.interface';
 export * from './moment.interface';
 export * from './page.interface';
 export * from './rendition.interface';
@@ -1257,6 +1500,16 @@ export interface ILayer {
     content: ILayerContent;
 }
 
+export interface LogEntryDB {
+    id: string;
+    message: string;
+    level: LogLevel;
+    timestamp: string;
+    logIdentifier: string;
+    metadata: string;
+    priority: number;
+}
+
 type MomentType = 'Content' | 'Ad';
 export interface IMoment extends IContent {
     momentIndexInPlaylist: number;
@@ -1447,6 +1700,15 @@ export * from './event.enum';
 export * from './http-status.enum';
 export * from './button.enum';
 export * from './action-handler-id.enum';
+export * from './log-level.enum';
+
+export declare enum LogLevel {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR",
+    CRITICAL = "CRITICAL"
+}
 
 export interface WidgetsTagNameMap {
     'blaze-sdk': BlazeWidgetSDK;
@@ -1594,6 +1856,72 @@ export declare const shareVideosIconSvg = "data:image/svg+xml;base64,PHN2ZyB4bWx
 export declare const linkIconSvg = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMjRweCIgdmlld0JveD0iMCAtOTYwIDk2MCA5NjAiIHdpZHRoPSIyNHB4IiBmaWxsPSIjNWY2MzY4Ij48cGF0aCBkPSJNNDQwLTI4MEgyODBxLTgzIDAtMTQxLjUtNTguNVQ4MC00ODBxMC04MyA1OC41LTE0MS41VDI4MC02ODBoMTYwdjgwSDI4MHEtNTAgMC04NSAzNXQtMzUgODVxMCA1MCAzNSA4NXQ4NSAzNWgxNjB2ODBaTTMyMC00NDB2LTgwaDMyMHY4MEgzMjBabTIwMCAxNjB2LTgwaDE2MHE1MCAwIDg1LTM1dDM1LTg1cTAtNTAtMzUtODV0LTg1LTM1SDUyMHYtODBoMTYwcTgzIDAgMTQxLjUgNTguNVQ4ODAtNDgwcTAgODMtNTguNSAxNDEuNVQ2ODAtMjgwSDUyMFoiLz48L3N2Zz4=";
 export declare const checkMarkSvg = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPG1hc2sgaWQ9Im1hc2swXzUxMl8xMDY4IiBzdHlsZT0ibWFzay10eXBlOmFscGhhIiBtYXNrVW5pdHM9InVzZXJTcGFjZU9uVXNlIiB4PSIwIiB5PSIwIiB3aWR0aD0iMjQiIGhlaWdodD0iMjQiPgo8cmVjdCB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIGZpbGw9IiNEOUQ5RDkiLz4KPC9tYXNrPgo8ZyBtYXNrPSJ1cmwoI21hc2swXzUxMl8xMDY4KSI+CjxwYXRoIGQ9Ik05LjU1MDEgMThMMy44NTAxIDEyLjNMNS4yNzUxIDEwLjg3NUw5LjU1MDEgMTUuMTVMMTguNzI1MSA1Ljk3NDk4TDIwLjE1MDEgNy4zOTk5OEw5LjU1MDEgMThaIiBmaWxsPSIjRjBGMEYwIi8+CjwvZz4KPC9zdmc+Cg==";
 
+export interface AccessibilityContext {
+    navigationType?: string;
+export interface ModalContext extends AccessibilityContext {
+    total: number;
+    isPlaying?: boolean;
+    hasClosedCaptions?: boolean;
+    totalPages?: number;
+}
+export interface UserActionContext extends AccessibilityContext {
+    setupAccessibility(contentId: string, elements: IContentWidgetElements): void;
+    updateLabels(contentId: string, data: IContentWidgetData): void;
+    cleanup(contentId: string): void;
+}
+export interface AccessibilityAnnouncement {
+    message: string;
+    priority: AnnouncementPriority;
+    delay?: number;
+    category?: AnnouncementCategory;
+}
+export interface IContentWidgetButtons {
+    play?: HTMLElement;
+    mute?: HTMLElement;
+    like?: HTMLElement;
+    share?: HTMLElement;
+    close?: HTMLElement;
+    cta?: HTMLElement;
+    captions?: HTMLElement;
+    custom1?: HTMLElement;
+    custom2?: HTMLElement;
+    nextStoryPage?: HTMLElement;
+    prevStoryPage?: HTMLElement;
+    nextStory?: HTMLElement;
+    prevStory?: HTMLElement;
+    nextMoment?: HTMLElement;
+    prevMoment?: HTMLElement;
+}
+export interface IContentWidgetData {
+    id: string;
+    title?: string;
+    isPlaying?: boolean;
+    isMuted?: boolean;
+    isLiked?: boolean;
+    hasClosedCaptions?: boolean;
+    ctaText?: string;
+}
+export interface IContentWidgetElements {
+    widget: HTMLElement;
+    buttons: IContentWidgetButtons;
+    data: IContentWidgetData;
+}
+export interface IContentAccessibilityManager {
+    registerContentWidget(contentId: string, elements: IContentWidgetElements, contentType: ContentType): void;
+    updateButtonLabels(contentId: string, dynamicState: Partial<IContentWidgetData>): void;
+    announceUserAction(contentType: ContentType, action: string, context: UserActionContext): void;
+    announceModalOpening(contentType: ContentType, context: ModalContext): void;
+    announceNavigation(position: number, total: number, type: string, title?: string, context?: AccessibilityContext): void;
+    unregisterContentWidget(contentId: string): void;
+    cleanup(): void;
+}
+export interface IAccessibilityManager {
+    setupLiveRegions(container?: HTMLElement): void;
+    announce(announcement: AccessibilityAnnouncement): void;
+    manageFocus(element: HTMLElement): void;
+    cleanup(): void;
+}
+
 type CustomNativeTargeting = Record<string, string | string[]>;
 type CustomNativeArgs = {
     path: string;
@@ -1661,7 +1989,9 @@ export type IdsDataSourceParams = Omit<BlazeDataSourceType, 'sourceType' | 'labe
 export interface IDatabase {
     init: () => Promise<void>;
     get: <T>(tableName: string, key: string) => Promise<IResponse<T>>;
+    getAll: <T>(tableName: string) => Promise<T[]>;
     update: <T>(tableName: string, value: any) => Promise<IResponse<T>>;
+    delete: (tableName: string, key: string) => Promise<IResponse<void>>;
 }
 export interface IDatabaseInitOptions {
     onOpen: (db: IDBDatabase) => Promise<void>;
@@ -1751,6 +2081,7 @@ export type BlazeVideoIconsStyle = BaseBlazeIcons & {
     };
 };
 
+export * from './accessibility-manager.interface';
 export * from './ad-handler.interface';
 export * from './behaviors.interface';
 export * from './blaze-sdk.interface';
@@ -1761,14 +2092,27 @@ export * from './device.interface';
 export * from './drawable.interface';
 export * from './http-response.interface';
 export * from './icons.interface';
+export * from './logger.interface';
 export * from './player.interface';
 export * from './response.interface';
 export * from './service.interface';
 export * from './widget-label-builder.interface';
 export * from './widget-options.interface';
 export * from './widget-view.interface';
+export * from './item-click-callback.interface';
 export { default as Observable } from './observable';
 
+export interface ItemClickContext {
+    containerId: string;
+    item: IContent;
+    itemIndexInContainer: number;
+    contentType: ContentType;
+}
+export interface ItemClickCallbackResult {
+    shouldPreventOpen: boolean;
+}
+export type ItemClickCallback = (context: ItemClickContext) => ItemClickCallbackResult;
+
 export interface ILayoutDataSourceOptions {
     dataSource?: BlazeDataSourceType;
     labels?: string | string[] | BlazeWidgetLabel;
@@ -1781,6 +2125,74 @@ export interface ILayoutDataSourceOptions {
     shouldOrderWidgetByReadStatus?: boolean;
 }
 
+export interface ILoggerConfiguration {
+    isEnabled: boolean;
+    loggerBatchIntervalInSeconds: number;
+    loggerMaxAllowedBatchSize: number;
+    loggerMinAllowedBatchSize: number;
+    logLevel: LogLevel;
+    immediateLogLevel: LogLevel;
+    ignoredLogs: IIgnoredLog[];
+}
+export interface IIgnoredLog {
+    logIdentifier: string;
+    sdkType: 'Web';
+    applyFromVersion?: string;
+    applyBelowVersion?: string;
+    applySpecificVersions?: string[];
+}
+export interface ILogEntry {
+    id: string;
+    message: string;
+    level: LogLevel;
+    timestamp: string;
+    logIdentifier: string;
+    metadata: ILogMetadata;
+}
+export interface ILogMetadata {
+    session_id: string;
+    id: string;
+    log_identifier: string;
+    sdk_type: string;
+    sdk_version: string;
+    api_key: string;
+    device_type: string;
+    device_brand: string;
+    device_model: string;
+    operating_system: string;
+    operating_system_version: string;
+    screen_resolution: string;
+    connection_type: string;
+    app_id: string;
+    app_version: string;
+    reporting_timestamp: string;
+    [key: string]: any;
+}
+export declare const METADATA_FIELDS: {
+    readonly SESSION_ID: "session_id";
+    readonly ID: "id";
+    readonly SDK_TYPE: "sdk_type";
+    readonly SDK_VERSION: "sdk_version";
+    readonly API_KEY: "api_key";
+    readonly DEVICE_TYPE: "device_type";
+    readonly DEVICE_BRAND: "device_brand";
+    readonly DEVICE_MODEL: "device_model";
+    readonly OPERATING_SYSTEM: "operating_system";
+    readonly OPERATING_SYSTEM_VERSION: "operating_system_version";
+    readonly SCREEN_RESOLUTION: "screen_resolution";
+    readonly CONNECTION_TYPE: "connection_type";
+    readonly APP_ID: "app_id";
+    readonly APP_VERSION: "app_version";
+    readonly REPORTING_TIMESTAMP: "reporting_timestamp";
+    readonly LOG_IDENTIFIER: "log_identifier";
+};
+export interface ILogger {
+    init(configuration?: ILoggerConfiguration): Promise<void>;
+    log(level: LogLevel, logIdentifier: string, message: string, metadata?: Record<string, any>): void;
+    updateConfiguration(configuration: ILoggerConfiguration): void;
+    destroy(): Promise<void>;
+}
+
 export default interface IntersectionObservable {
     intersectionObserver: IntersectionObserver;
     handleIntersection(entries: IntersectionObserverEntry[]): void;
@@ -1904,6 +2316,24 @@ declare abstract class AnalyticsServiceClass extends AnalyticsServiceClass_base
 }
 export declare const AnalyticsService: AnalyticsServiceClass;
 
+export declare class AnnouncementService implements IAnnouncementService {
+    private config;
+    private containerRegions;
+    private announcementQueue;
+    private isProcessingAnnouncement;
+    private lastAnnouncementTime;
+    private liveRegionsSetup;
+    constructor(config: AnnouncementConfig);
+    setupLiveRegions(container: HTMLElement): void;
+    announce(message: string, priority?: AnnouncementPriority, category?: AnnouncementCategory): void;
+    queueAnnouncement(announcement: AccessibilityAnnouncement): void;
+    clearQueue(): void;
+    isProcessing(): boolean;
+    private processAnnouncementQueue;
+    private performAnnouncement;
+    cleanup(): void;
+}
+
 type GetOptions = {
     orderType?: OrderType;
 };
@@ -1977,6 +2407,7 @@ declare abstract class ApiServiceClass extends ApiServiceClass_base implements I
         setLiked: boolean;
     }): Promise<void>;
     sendAnaltyicsEvents(body: Partial<AnalyticsEvent>[]): Promise<import("../interfaces").IHttpResponse<unknown>>;
+    sendLoggerLogs(compressedBody: ArrayBuffer): Promise<import("../interfaces").IHttpResponse<unknown>>;
     sendInteractionResponse(options: {
         interactionId: Interaction['id'];
         responseId: string;
@@ -1998,9 +2429,13 @@ declare const AppConfigurationServiceClass_base: {
 };
 declare abstract class AppConfigurationServiceClass extends AppConfigurationServiceClass_base implements IService {
     private _appConfigurations?;
+    private _refetchInterval;
     constructor();
     get appConfigurations(): AppConfiguration | undefined;
     init(options: IBlazeSDKOptions): Promise<void>;
+    private setupRefetchInterval;
+    private clearRefetchInterval;
+    destroy(): void;
 }
 export declare const AppConfigurationService: AppConfigurationServiceClass;
 
@@ -2040,11 +2475,13 @@ declare abstract class ConfigServiceClass extends ConfigServiceClass_base implem
     private _shouldAllowClosedCaptions;
     private _appContext;
     private _disableAutoLoadingContent;
+    private _onItemClick;
     protected constructor();
     init(options: IBlazeSDKOptions): Promise<void>;
     private readonly _russiaRegionCDN;
     private readonly _urls;
     private readonly _analyticsUrls;
+    private _loggerUrls;
     private readonly _globalStorageCDN;
     private readonly _russiaStorageCDN;
     private readonly _sdkStorageCDNs;
@@ -2056,7 +2493,8 @@ declare abstract class ConfigServiceClass extends ConfigServiceClass_base implem
     private set environment(value);
     get sendAnalytics(): boolean;
     get shouldCreateUser(): boolean;
-    get analyticsApiUrl(): string | undefined;
+    get analyticsApiUrl(): string;
+    get loggerApiUrl(): string;
     get externalUserId(): string | null;
     set externalUserId(value: string | null);
     get doNotTrack(): boolean;
@@ -2097,6 +2535,8 @@ declare abstract class ConfigServiceClass extends ConfigServiceClass_base implem
     set appContext(value: Record<string, any>);
     get disableAutoLoadingContent(): boolean;
     set disableAutoLoadingContent(value: boolean);
+    get onItemClick(): ItemClickCallback | undefined;
+    set onItemClick(value: ItemClickCallback | undefined);
 }
 export declare const ConfigService: ConfigServiceClass;
 
@@ -2132,6 +2572,11 @@ declare abstract class DatabaseServiceClass extends DatabaseServiceClass_base im
     updateVideoData(videoId: string, data: Partial<VideoDBData>): Promise<void>;
     getVideoLike(videoId: string): Promise<IResponse<VideoDBData> | null>;
     getVideoPosterById(videoId: string): Promise<string | undefined>;
+    addLog(log: LogEntryDB): Promise<void>;
+    getLogs(maxCount: number): Promise<LogEntryDB[]>;
+    removeLogs(logIds: string[]): Promise<void>;
+    clearLogs(): Promise<void>;
+    getLogCount(): Promise<number>;
 }
 export declare const DatabaseService: DatabaseServiceClass;
 
@@ -2203,7 +2648,9 @@ export * from './event.service';
 export * from './interaction.service';
 export * from './like.service';
 export * from './logger.service';
+export * from './moment.service';
 export * from './startup.service';
+export * from './story.service';
 export * from './user.service';
 export * from './video-cache.service';
 export * from './video-player.service';
@@ -2212,6 +2659,7 @@ export * from './widgets.service';
 export * from './moment.service';
 export * from './story.service';
 export * from './user-country.service';
+export * from './announcement.service';
 
 declare const InteractionServiceClass_base: {
     new (): {};
@@ -2241,33 +2689,18 @@ declare abstract class LikeServiceClass extends LikeServiceClass_base implements
 }
 export declare const LikeService: LikeServiceClass;
 
-interface LoggerParams {
-    message: string;
-    level?: LogLevel;
-    metadata?: Record<string, any>;
-}
-declare enum LogLevel {
-    INFO = "info",
-    WARN = "warn",
-    ERROR = "error"
-}
 declare const LoggerServiceClass_base: {
     new (): {};
     _instance: LoggerServiceClass;
     getInstance(): LoggerServiceClass;
 };
-declare class LoggerServiceClass extends LoggerServiceClass_base implements IService {
-    private isEnabled;
-    private logStack;
-    private constructor();
+declare abstract class LoggerServiceClass extends LoggerServiceClass_base implements IService, ILogger {
+    private loggerManager;
+    constructor();
     init(): Promise<void>;
-    private getCurrentTime;
-    private logToConsole;
-    log({ message, level, metadata }: LoggerParams): void;
-    info(message: string, metadata?: Record<string, any>): void;
-    warn(message: string, metadata?: Record<string, any>): void;
-    error(message: string, metadata?: Record<string, any>): void;
-    printLogsToScreen(): void;
+    destroy(): Promise<void>;
+    updateConfiguration(configuration: ILoggerConfiguration): void;
+    log(level: LogLevel, logIdentifier: string, message: string, metadata?: ILogMetadata): Promise<void>;
 }
 export declare const LoggerService: LoggerServiceClass;
 
@@ -2913,6 +3346,30 @@ export type EnhancementsType = {
     hasSwipeUp: boolean;
 } | null;
 
+export type AnnouncementPriority = 'polite' | 'assertive';
+export type AnnouncementCategory = 'navigation' | 'status' | 'error' | 'success';
+export declare const ANNOUNCEMENT_CONSTANTS: {
+    readonly LIVE_REGIONS: {
+        readonly POLITE_ID: "blaze-aria-live-polite";
+        readonly ASSERTIVE_ID: "blaze-aria-live-assertive";
+        readonly STYLES: {
+            readonly POSITION: "absolute";
+            readonly LEFT: "-10000px";
+            readonly WIDTH: "1px";
+            readonly HEIGHT: "1px";
+            readonly OVERFLOW: "hidden";
+        };
+    };
+    readonly ATTRIBUTES: {
+        readonly ARIA_LIVE: "aria-live";
+        readonly ARIA_ATOMIC: "aria-atomic";
+        readonly ATOMIC_VALUE: "true";
+    };
+    readonly TIMING: {
+        readonly REGION_SETUP_DELAY: 10;
+    };
+};
+
 export interface IAttributeParser {
     getIntAttribute(key: string, defaultValue?: number): number | undefined;
     getFloatAttribute(key: string, defaultValue?: number): number | undefined;
@@ -3332,6 +3789,7 @@ export type StoryGestureType = 'Swipe Up' | 'CTA Click';
 export type MomentGestureType = 'CTA Click';
 
 export * from './animation.type';
+export * from './announcement.type';
 export * from './attribute-parser';
 export * from './button.type';
 export * from './chip-status.type';
@@ -3467,6 +3925,24 @@ export type IWidgetViewOptions = IWidgetViewOptionsWithLabels | IWidgetViewOptio
 
 export type WidgetType = 'Row' | 'Grid';
 
+export declare function buildContentTypeLabel(contentType: ContentType, title: string, elementType?: 'button' | 'item' | 'player'): string;
+export declare function getContentTypeAction(contentType: ContentType): string;
+export declare function buildStatusInfo(content: IStory | IMoment | IVideo, badgeStyle?: IndicatorStyle): string;
+export declare function buildContentAriaLabel(options: {
+    contentType: ContentType;
+    title: string;
+    content: IStory | IMoment | IVideo;
+    position?: number;
+    total?: number;
+    badgeStyle?: IndicatorStyle;
+    elementType?: 'button' | 'item' | 'player';
+}): string;
+export declare function buildCarouselLabel(contentType: ContentType, count: number, includeInstructions?: boolean): {
+    label: string;
+    announcement: string;
+};
+export declare function generateThumbnailAltText(contentType: ContentType, title: string, content: IStory | IMoment | IVideo): string;
+
 export declare function isImaAdInfo(ad: IAdInfo): ad is IImaAdInfo;
 export declare function addContextToCustomTargeting(adInfo: IBaseAdInfo, customTargeting: Record<string, string | string[]>): void;
 
@@ -3537,6 +4013,7 @@ export declare function findParentOfType<T>(target: EventTarget | null, type: {
 }, stopAt: Element): T | null;
 export declare function validateContainer(containerId: string, widgetElementName?: string): HTMLElement;
 
+export * from './accessibility-label.utils';
 export * from './ad-info.utils';
 export * from './cc-language.utils';
 export * from './chip.utils';
@@ -3549,6 +4026,7 @@ export * from './personalized.utils';
 export * from './position.utils';
 export * from './regex.utils';
 export * from './shared-event-target.utils';
+export * from './tab-index-utils';
 export * from './stopwatch';
 
 export declare function getPersonalizedParamsForRequest(personalized?: BlazePersonalized): {
@@ -3595,8 +4073,74 @@ export declare class Stopwatch {
     reset(): void;
 }
 
+export declare class AccessibilityUtils {
+    static setElementsAccessible(elements: Element[]): void;
+    static setElementsInaccessible(elements: Element[]): void;
+    static setElementAccessibilityHidden(element: Element): void;
+    static setElementsAccessibilityHidden(elements: Element[]): void;
+}
+
 export declare function getVideoDuration(existingVideo?: HTMLVideoElement, videoUrl?: string): Promise<number>;
 
+export { LOG_LEVEL_VALUES, isLogLevelAllowed, calculateLogPriority } from './logger-level-utils';
+export { buildLogMetadata, MetadataKeys } from './logger-metadata-utils';
+export { compressPayload } from './logger-compression-utils';
+export { estimateEntrySize, calculateTotalMemoryUsage } from './logger-memory-utils';
+export { validateLoggerConfigurationDetailed, shouldIgnoreLog, sanitizeBatchSizeConfiguration } from './logger-validation-utils';
+export { extractEntryIds } from './logger-storage-utils';
+export { pruneOfflineQueue, addToOfflineQueueWithPruning } from './logger-offline-utils';
+
+export declare function compressPayload(payload: object | string): Promise<ArrayBuffer>;
+
+export declare const LOG_LEVEL_VALUES: {
+    readonly DEBUG: 1;
+    readonly INFO: 2;
+    readonly WARN: 3;
+    readonly ERROR: 4;
+    readonly CRITICAL: 5;
+};
+export declare function isLogLevelAllowed(logLevel: LogLevel, configuredLevel: LogLevel): boolean;
+export declare function calculateLogPriority(level: LogLevel): number;
+
+export declare function estimateEntrySize(entry: LogEntryDB): number;
+export declare function calculateTotalMemoryUsage(entries: LogEntryDB[]): number;
+
+export declare const MetadataKeys: {
+    readonly SESSION_ID: "session_id";
+    readonly ID: "id";
+    readonly SDK_TYPE: "sdk_type";
+    readonly SDK_VERSION: "sdk_version";
+    readonly API_KEY: "api_key";
+    readonly DEVICE_TYPE: "device_type";
+    readonly DEVICE_BRAND: "device_brand";
+    readonly DEVICE_MODEL: "device_model";
+    readonly OPERATING_SYSTEM: "operating_system";
+    readonly OPERATING_SYSTEM_VERSION: "operating_system_version";
+    readonly SCREEN_RESOLUTION: "screen_resolution";
+    readonly CONNECTION_TYPE: "connection_type";
+    readonly REPORTING_TIMESTAMP: "reporting_timestamp";
+    readonly LOG_IDENTIFIER: "log_identifier";
+};
+export declare function buildLogMetadata(sessionId: string, logId: string, logIdentifier?: string, customMetadata?: Record<string, any>): Record<string, any>;
+
+export declare function pruneOfflineQueue(queue: LogEntryDB[], maxSize: number): {
+    prunedQueue: LogEntryDB[];
+    removedCount: number;
+};
+export declare function addToOfflineQueueWithPruning(queue: LogEntryDB[], entry: LogEntryDB, maxSize: number): {
+    updatedQueue: LogEntryDB[];
+    removedCount: number;
+};
+
+export declare function extractEntryIds(entries: LogEntryDB[]): string[];
+
+export declare function validateLoggerConfigurationDetailed(config: ILoggerConfiguration): {
+    isValid: boolean;
+    errors: string[];
+};
+export declare function sanitizeBatchSizeConfiguration(config: ILoggerConfiguration): ILoggerConfiguration;
+export declare function shouldIgnoreLog(logIdentifier: string, ignoredLogs: IIgnoredLog[]): boolean;
+
 export * from './commands/player-buttons.command';
 export * from './commands/video-commands';
 export * from './components/timer';
@@ -4335,7 +4879,7 @@ export declare abstract class WidgetBaseLayout extends BlazeWidgetScrollable imp
     protected abstract updateWidgetDisplay(): void;
     protected sortContent(): void;
     protected reorderWidgets(): void;
-    private getContentType;
+    protected getContentType(): ContentType;
     static get observedAttributes(): string[];
     protected createModal(type: ContentType): void;
     protected beforeStoryModalCreation(): void;
@@ -4621,20 +5165,25 @@ export declare class BlazeWidgetItem extends BaseWidget implements Observable {
     contentType: ContentType | undefined;
     chipType: ChipStatusType;
     intersectionObserver: IntersectionObserver;
-    get parentRef(): BlazeWidgetLayout;
-    statusIndicatorSettings: IndicatorStyle;
-    paddingItem: PositionOffset;
+    private position;
+    private total;
     content: IStory | IMoment | IVideo;
     onClick: (() => void) | undefined;
     private boundOnWidgetClick;
+    private boundOnFocus;
+    get parentRef(): BlazeWidgetLayout;
+    statusIndicatorSettings: IndicatorStyle;
+    paddingItem: PositionOffset;
     constructor(options: BlazeWidgetItemOptions);
     private initializeWidget;
     connectedCallback(): void;
+    private updateAriaLabel;
     updateWidget(): void;
     updateWidgetItemPadding(): void;
     updateWidgetItemStyle(layoutStyle: LayoutStyle): void;
     private setupDOMElements;
     private setupEventListeners;
+    private onFocus;
     private handleWidgetClick;
     disconnectedCallback(): void;
     debouncedIntersectionAction: {
@@ -4645,6 +5194,7 @@ export declare class BlazeWidgetItem extends BaseWidget implements Observable {
     };
     handleIntersection(): void;
     private setData;
+    private setupChildElementsAccessibility;
     isFullyVisibleInParent(): boolean;
     loadNewThumbnail(): void;
     getThumbnailUrl(): string;
@@ -4665,12 +5215,19 @@ export declare class BlazeWidgetItem extends BaseWidget implements Observable {
     getPaddingOnContainer(): PositionOffset;
     setPaddingOnContainer(padding: PositionOffset): void;
     setChipStyle(): void;
+    private getItemIndex;
     event(action: WidgetAction, data: Partial<WidgetEvent>, label?: string | undefined): void;
     render(): void;
+    updateAccessibilityInfo(info: {
+        position: number;
+        total: number;
+        contentType?: ContentType;
+    }): void;
 }
 
 /// <reference types="node" />
 export declare class BlazeWidgetLayout extends WidgetBaseLayout {
+    containerId: string | undefined;
     skeletonContainer: BlazeDiv | undefined;
     widgetHeight: number;
     parentHeight: number | undefined;
@@ -4683,6 +5240,8 @@ export declare class BlazeWidgetLayout extends WidgetBaseLayout {
     onMouseLeaveEvent: (e: MouseEvent) => void;
     currentlyAnimatedItem: BlazeWidgetItem | undefined;
     firstVisibleItem: BlazeWidgetItem | undefined;
+    private focusedItemIndex;
+    private lastFocusedIndex;
     get refElement(): ShadowRoot | BlazeWidgetLayout;
     constructor();
     connectedCallback(): void;
@@ -4691,13 +5250,12 @@ export declare class BlazeWidgetLayout extends WidgetBaseLayout {
     onResize(): void;
     handleHeightChangeMutation(mutationsList: MutationRecord[]): void;
     handleIntersection(entries: IntersectionObserverEntry[]): void;
-    onKeyDown(e: KeyboardEvent): void;
     onContentChange(mode: ContentDirection): void;
     onPlayerClose(): void;
     onPlayerOpen(): void;
     setFirstVisibleItem(): void;
     getParentHeightWithoutPadding(): number | null;
-    setId(id: string): void;
+    setId(containerId: string): void;
     set storyIds(value: string);
     set contentIds(value: string);
     updateWidgetUI(): void;
@@ -4759,10 +5317,24 @@ 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;
+    private navigateToNextItem;
+    private navigateToPreviousItem;
+    private navigateToItem;
+    private activateCurrentItem;
+    private announceCurrentItem;
+    updateFocusedItemIndex(index: number): void;
+    private setFocusState;
+    private removeTabIndexFromWidgetItems;
+    private restoreTabIndexOnWidgetItems;
 }
 
 export declare class BlazeWidgetModal extends BaseWidget {
     player: BlazeWidgetStoryPlayer | BlazeWidgetMomentPlayer | BlazeWidgetVideoPlayer;
+    private contentType;
     isOpen: boolean;
     exitButtonElement: BlazeButton;
     exitButtonWrapperElement: BlazeDiv;
@@ -4771,6 +5343,7 @@ export declare class BlazeWidgetModal extends BaseWidget {
     isMultiTouch: boolean;
     boundOnResizeEvent: (this: Window, ev: UIEvent) => void;
     boundOnPopStateEvent: (ev: PopStateEvent) => void;
+    boundOnExitButtonClick: (ev: MouseEvent) => void;
     onContentChange?: (mode: ContentDirection) => void;
     onClose: ((options?: ISmoothOpenCloseModal) => void) | undefined;
     onOpen: (() => void) | undefined;
@@ -4780,6 +5353,7 @@ export declare class BlazeWidgetModal extends BaseWidget {
     private isRealResizeEvent;
     onResize(): void;
     handleOnContentChange(mode: ContentDirection): void;
+    handleOnExitButtonClick(): void;
     handlePopState(): void;
     seek(id: string): void;
     setupHammer(): void;
@@ -4796,6 +5370,7 @@ export declare class BlazeWidgetModal extends BaseWidget {
         customButtonVisibility?: boolean;
     }): boolean;
     render(): void;
+    private transferFocusToModal;
 }
 
 export type BlazeWidgetContent = BlazeWidgetStory | BlazeWidgetMoment | BlazeVideoElement;
@@ -5191,6 +5766,8 @@ export declare class BlazeWidgetMomentPlayer extends WidgetAbstractPlayer {
     boundHandleMuteClicked: () => void;
     private fetchedPosterUrls;
     private preloadTimer;
+    private accessibilityConfigTimeout;
+    private focusTimeout;
     constructor();
     get currentMoment(): BlazeWidgetMoment;
     connectedCallback(): void;
@@ -5210,6 +5787,7 @@ export declare class BlazeWidgetMomentPlayer extends WidgetAbstractPlayer {
     updateItemData(itemToReplaceWith: BlazeWidgetMoment & BlazeWidgetStory & BlazeVideoElement, nextItemToInsert: BlazeWidgetMoment | BlazeWidgetStory | BlazeVideoElement): void;
     createAnimation(content: BlazeWidgetMoment, direction: ContentDirection, targetIndex: number): AnimeTimelineInstance;
     handleAnimationStart(content: BlazeWidgetMoment, direction: ContentDirection): void;
+    private calculateTruePosition;
     handleAnimationCompletion(content: BlazeWidgetMoment, mode: ContentDirection): Promise<void>;
     loadAndPlayContent(): Promise<void>;
     setContent(content: BlazeWidgetMoment[]): void;
@@ -5228,6 +5806,13 @@ export declare class BlazeWidgetMomentPlayer extends WidgetAbstractPlayer {
     loadContentBatch(): void;
     resetStyles(): void;
     render(): void;
+    configurePlayerContentAccessibility(): void;
+    private setCurrentMomentAccessibility;
+    private setInactiveMomentAccessibility;
+    private scheduleAccessibilityConfig;
+    private cancelAccessibilityConfig;
+    private scheduleFocus;
+    private cancelFocus;
 }
 
 export declare class BlazeWidgetMomentSeekBar extends HTMLElement {
@@ -5317,6 +5902,7 @@ export declare class BlazeWidgetMoment extends BlazeWidgetContent {
     onClose: () => void;
     boundOnCtaClicked: (event: Event) => void;
     boundPlayPauseButtonClick: (event: MouseEvent) => void;
+    boundOnKeyDown: (event: KeyboardEvent) => void;
     topContainer: BlazeDiv;
     bottomContainer: BlazeDiv;
     bottomContentContainer: BlazeDiv;
@@ -5425,6 +6011,18 @@ export declare class BlazeWidgetMoment extends BlazeWidgetContent {
     restartVideo(): void;
     adjustContentView(): void;
     event(action: MomentAction, momentData: Partial<MomentEvent>, label?: string | undefined): Promise<void>;
+    private registerMomentAccessibility;
+    updateAccessibilityLabels(): void;
+    private buildMomentAccessibilityState;
+    updateContentAccessibilityAfterDataChange(): void;
+    protected updateButtonAccessibilityLabels(): void;
+    enableAllButtons(): void;
+    disableAllButtons(): void;
+    protected setButtonsAccessibilityState(buttons: Element[], accessible: boolean): void;
+    private enableAnchorElements;
+    private disableAnchorElements;
+    getAllFocusableButtons(): Element[];
+    private getMomentButtonsForAccessibility;
     render(): void;
 }
 
@@ -5457,6 +6055,8 @@ export declare class BlazeWidgetStoryPlayer extends WidgetAbstractPlayer {
     boundOnKeyDown: (event: KeyboardEvent) => Promise<void>;
     backgroundAnimation?: Animation;
     dispatchExitStoryEvents: (() => void) | undefined;
+    private accessibilityConfigTimeout;
+    private focusTimeout;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
@@ -5487,6 +6087,15 @@ export declare class BlazeWidgetStoryPlayer extends WidgetAbstractPlayer {
     render(): void;
     loadContentBatch(): void;
     playToggleCurrentStory(): void;
+    manageElementsAccessible(activeContentId: string): void;
+    calculateTruePosition(currentContent: BlazeWidgetStory): number;
+    private configurePlayerContentAccessibility;
+    private setCurrentStoryAccessibility;
+    private setInactiveStoryAccessibility;
+    private scheduleAccessibilityConfig;
+    private cancelAccessibilityConfig;
+    private scheduleFocus;
+    private cancelFocus;
 }
 
 export declare class BlazeWidgetStory extends BlazeWidgetContent {
@@ -5659,6 +6268,18 @@ export declare class BlazeWidgetStory extends BlazeWidgetContent {
     private onNextPageEvent;
     private onPrevPageEvent;
     private getPagesContentExtraInfo;
+    getAllFocusableButtons(): Element[];
+    enableAllButtons(): void;
+    disableAllButtons(): void;
+    protected setButtonsAccessibilityState(buttons: Element[], accessible: boolean): void;
+    private registerStoryAccessibility;
+    private buildStoryRegistrationData;
+    private getStoryButtonsForAccessibility;
+    private getStoryDataForAccessibility;
+    private updateStoryAccessibilityLabels;
+    private getCurrentAccessibilityState;
+    updateAccessibilityLabels(): void;
+    private buildStoryAccessibilityState;
 }
 
 export declare const ElementId: {