@inappstory/slide-api 0.0.30 → 0.1.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { Player as VODPlayer } from "@inappstory/video-player";
+import { Player as VideoPlayer } from "@inappstory/video-player";
 declare const enum CARD_TYPE {
     STORY = 1,
     UGC_STORY = 2,
@@ -593,7 +595,8 @@ declare class WidgetQuest extends WidgetBase<WidgetQuestOptions> {
     protected variants: Array<HTMLElement>;
     private readonly isWidget;
     private readonly slideCount;
-    private readonly nonFinalSlide;
+    private readonly nonFinalSlide?;
+    private readonly navigationNextSlide?;
     private readonly slideDisabledNavigation;
     private readonly finalSlide;
     constructor(element: HTMLElement, options: Partial<WidgetQuestOptions>);
@@ -615,6 +618,8 @@ declare class WidgetQuest extends WidgetBase<WidgetQuestOptions> {
     private _addNewRouteHistory;
     private _routeMvPtrBack;
     private getLastSlideIndexFromRouteHistory;
+    // переделать в handleRouteTrigger
+    // не завязываться на click, сделать через коллбэк - default action
     private handleRouteClick;
     static api: {
         widgetClassName: string;
@@ -630,8 +635,9 @@ declare class WidgetQuest extends WidgetBase<WidgetQuestOptions> {
             direction: "backward" | "forward";
             slideIndex: number;
             slideCount: number;
-            click: () => void;
-        }) => void;
+        }) => {
+            continueDefaultNavigation: boolean;
+        };
     };
 }
 type WidgetQuizOptions = WidgetOptionsBase;
@@ -832,6 +838,70 @@ declare class WidgetTest extends WidgetBase<WidgetTestOptions> {
         slideTestWithTimer: (element: HTMLElement) => boolean;
     };
 }
+interface ILayoutApi {
+    get widgetCopyApi(): typeof WidgetCopy.api | undefined;
+    get widgetBarcodeApi(): typeof WidgetBarcode.api | undefined;
+    get widgetDataInputApi(): typeof WidgetDataInput.api | undefined;
+    get widgetDateCountdownApi(): typeof WidgetDateCountdown.api | undefined;
+    get widgetMultiSlideApi(): typeof WidgetMultiSlide.api | undefined;
+    get widgetPollApi(): typeof WidgetPoll.api | undefined;
+    get widgetPollLayersApi(): typeof WidgetPollLayers.api | undefined;
+    get widgetQuestApi(): typeof WidgetQuest.api | undefined;
+    get widgetQuizApi(): typeof WidgetQuiz.api | undefined;
+    get widgetQuizGroupedApi(): typeof WidgetQuizGrouped.api | undefined;
+    get widgetRangeSliderApi(): typeof WidgetRangeSlider.api | undefined;
+    get widgetRateApi(): typeof WidgetRate.api | undefined;
+    get widgetShareApi(): typeof WidgetShare.api | undefined;
+    get widgetTestApi(): typeof WidgetTest.api | undefined;
+    get widgetVoteApi(): typeof WidgetVote.api | undefined;
+    get widgetProductsApi(): typeof WidgetProducts.api | undefined;
+    get VideoPlayer(): typeof VODPlayer | undefined;
+}
+declare class LayoutService {
+    private _env;
+    private _sdkApi;
+    private _layoutApi;
+    constructor(_env: Window, _sdkApi: SDKApi, _layoutApi: ILayoutApi);
+    get env(): Window;
+    get sdkApi(): SDKApi;
+    get layoutApi(): ILayoutApi;
+}
+declare class SlideTimeline {
+    private readonly slideIndex;
+    private readonly slideDuration;
+    private readonly slideDisabledTimer;
+    private readonly slideReady;
+    private readonly _afterResumeQueuePush;
+    constructor(slideIndex: number, slideDuration: number, slideDisabledTimer: boolean, slideReady: Promise<void>, _afterResumeQueuePush: (cb: () => void) => void);
+    private resumedAt;
+    private timeSpent;
+    private timelineDisabledState;
+    private currentState;
+    static get layoutService(): LayoutService;
+    private get layoutService();
+    get isSDKSupportUpdateTimeline(): boolean | undefined;
+    get index(): number;
+    private updateTimeline;
+    /**
+     * Start timeline after slide started
+     * Nothing do if old sdk
+     */
+    slideStarted(): void;
+    slideRestarted(): void;
+    /**
+     *
+     */
+    slidePaused(videoCurrentTime: number | null): void;
+    slideResumed(videoCurrentTime: number | null): void;
+    slideStopped(): void;
+    /**
+     * Update timer state (duration from 0 to actual value) and start timeline
+     * used by widgets
+     */
+    startDisabledTimeline(fallback: () => void): void;
+    onSlideDataWaiting(videoCurrentTime: number | null): void;
+    onSlideError(videoCurrentTime: number | null): void;
+}
 type APIResponse<DTO> = {
     status: number;
     data: DTO;
@@ -848,6 +918,7 @@ type FontDTO = {
 };
 interface SDKApi {
     getCardServerData(cardId: number): Record<string, any> | null;
+    updateCardServerDataLocally(cardId: number, data: Record<string, any>): void;
     getSlideDuration(cardId: number, slideIndex: number): number | null;
     showNextSlide(duration: number): void;
     sendStatisticEvent(name: string, data: Record<string, string | number | Array<string | number>>, devPayload?: Record<string, string | number | Array<string | number>>, forceEnableStatisticV2?: boolean): void;
@@ -865,7 +936,14 @@ interface SDKApi {
     setCardLocalData(keyValue: Record<string, any>, sendToServer: boolean): void;
     getWidgetsSharedData<WidgetType extends keyof WidgetsSharedDataMap>(cardId: number, widget: Widgets): WidgetsSharedDataMap[WidgetType] | null;
     vibrate(pattern: number): void;
-    openUrl(target: string): void;
+    openUrl(data: {
+        type: "link" | "swipeUpLink" | "swipeUpItems";
+        link: {
+            type: "url" | "json";
+            target: string;
+        };
+        elementId?: string;
+    }): void;
     sendApiRequest<ResponseDTO>(url: string, method: string, params: Record<string, any> | null, headers: Record<string, any> | null, data: Record<string, any> | null, profilingKey: string): Promise<APIResponse<ResponseDTO>>;
     sendApiRequestSupported(): boolean;
     showToast(text: string): void;
@@ -899,6 +977,9 @@ interface SDKApi {
     enableVerticalSwipeGesture(): void;
     disableBackpress(): void;
     enableBackpress(): void;
+    closeCard(reason: string): void;
+    openStory(id: number, index: number): void;
+    openGame(gameInstanceId: string): void;
 }
 declare class WidgetsService {
     private _env;
@@ -997,6 +1078,7 @@ interface SDKInterface {
      *         }
      */
     getCardServerData(cardId: number): Record<string, any> | null;
+    updateCardServerDataLocally(data: Record<string, any>): void;
     /**
      * Return slide duration or null
      *
@@ -1065,7 +1147,14 @@ interface SDKInterface {
      *         window._showNarrativeLink(target);
      *     }
      */
-    openUrl(target: string): void;
+    openUrl(data: {
+        type: "link" | "swipeUpLink" | "swipeUpItems";
+        link: {
+            type: "url" | "json";
+            target: string;
+        };
+        elementId?: string;
+    }): void;
     /**
      * Possible implementation
      *
@@ -1110,7 +1199,7 @@ interface SDKInterface {
      */
     setCardSessionValue(key: string, value: string): void;
     getCardSessionValue(key: string): string | undefined;
-    updateTimeline?(slideIndex: number, action: TIMELINE_ACTION, currentTime: number, duration: number, showLoader: boolean, showError: boolean): void;
+    updateTimeline(slideIndex: number, action: TIMELINE_ACTION, currentTime: number, duration: number, showLoader: boolean, showError: boolean): void;
     /**
      * Get fonts from session.cache
      */
@@ -1128,42 +1217,518 @@ interface SDKInterface {
      * Continue to react on any vertical swipe gesture
      */
     enableVerticalSwipeGesture(): void;
+    /**
+     * Intent with action - close card (story | IAM)
+     */
+    closeCard(reason: string): void;
+    /**
+     * Intent with action - open story (with id and slide index)
+     */
+    openStory(id: number, index: number): void;
+    /**
+     * Intent with action - open game
+     */
+    openGame(gameInstanceId: string): void;
 }
-type WidgetCopyApi = typeof WidgetCopy.api;
-type WidgetDataInputApi = typeof WidgetDataInput.api;
-type WidgetDateCountdownApi = typeof WidgetDateCountdown.api;
-type WidgetMultiSlideApi = typeof WidgetMultiSlide.api;
-type WidgetPollApi = typeof WidgetPoll.api;
-type WidgetPollLayersApi = typeof WidgetPollLayers.api;
-type WidgetQuestApi = typeof WidgetQuest.api;
-type WidgetQuizApi = typeof WidgetQuiz.api;
-type WidgetQuizGroupedApi = typeof WidgetQuizGrouped.api;
-type WidgetRangeSliderApi = typeof WidgetRangeSlider.api;
-type WidgetRateApi = typeof WidgetRate.api;
-type WidgetShareApi = typeof WidgetShare.api;
-type WidgetTestApi = typeof WidgetTest.api;
-type WidgetVoteApi = typeof WidgetVote.api;
-type WidgetBarcodeApi = typeof WidgetBarcode.api;
-type WidgetProductsApi = typeof WidgetProducts.api;
-type SlideApi = {
-    Animation: IAnimation;
-    WidgetCopy: WidgetCopyApi;
-    WidgetDataInput: WidgetDataInputApi;
-    WidgetDateCountdown: WidgetDateCountdownApi;
-    WidgetMultiSlide: WidgetMultiSlideApi;
-    WidgetPoll: WidgetPollApi;
-    WidgetPollLayers: WidgetPollLayersApi;
-    WidgetQuest: WidgetQuestApi;
-    WidgetQuiz: WidgetQuizApi;
-    WidgetQuizGrouped: WidgetQuizGroupedApi;
-    WidgetRangeSlider: WidgetRangeSliderApi;
-    WidgetRate: WidgetRateApi;
-    WidgetShare: WidgetShareApi;
-    WidgetTest: WidgetTestApi;
-    WidgetVote: WidgetVoteApi;
-    WidgetBarcode: WidgetBarcodeApi;
-    WidgetProducts: WidgetProductsApi;
-};
-declare const getSlideApi: (_sdkInterface: SDKInterface) => SlideApi;
-export { getSlideApi, Widgets };
-export type { SDKInterface, SlideApi, WidgetCopyApi, WidgetDataInputApi, WidgetDateCountdownApi, WidgetMultiSlideApi, WidgetPollApi, WidgetPollLayersApi, WidgetQuestApi, WidgetQuizApi, WidgetQuizGroupedApi, WidgetRangeSliderApi, WidgetRateApi, WidgetShareApi, WidgetTestApi, WidgetVoteApi, WidgetBarcodeApi, WidgetProductsApi, IAnimation, WidgetsSharedDataMap, WidgetRangeSliderSharedData, WidgetPollSharedData, WidgetVoteSharedData, FontDTO };
+type LocalData = Record<string, any>;
+declare global {
+    interface Window {
+        slideTimeline: SlideTimeline;
+    }
+}
+interface IElement {
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStop(): void;
+    onStart(): void;
+    handleClick(): boolean;
+    // is Layer on pause (by opened WidgetProducts for instance)
+    isLayerForcePaused: boolean;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+}
+declare class DataInput implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _widgetApi: typeof WidgetDataInput.api);
+    static isTypeOf(element: IElement): element is DataInput;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    setUserData(id: string, text: string): void;
+    get isLayerForcePaused(): boolean;
+}
+declare class Poll implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _widgetApi: typeof WidgetPoll.api);
+    static isTypeOf(element: IElement): element is Poll;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    setUserData(id: string, text: string): void;
+    get isLayerForcePaused(): boolean;
+}
+declare class PollLayers implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _layersNodesRefs;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _layersNodesRefs: Array<HTMLElement>, _widgetApi: typeof WidgetPollLayers.api);
+    static isTypeOf(element: IElement): element is PollLayers;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    get isLayerForcePaused(): boolean;
+}
+declare class Products implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _widgetApi: typeof WidgetProducts.api);
+    static isTypeOf(element: IElement): element is Products;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    handleBackpress(): void;
+    get elementNodeRef(): HTMLElement;
+    get isClickCapturedByWidget(): boolean;
+    get isLayerForcePaused(): boolean;
+}
+declare class Quest implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _widgetApi: typeof WidgetQuest.api);
+    static isTypeOf(element: IElement): element is Quest;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    handleRouteClick(options: {
+        direction: "backward" | "forward";
+        slideIndex: number;
+        slideCount: number;
+    }): {
+        continueDefaultNavigation: boolean;
+    };
+    get isLayerForcePaused(): boolean;
+}
+declare class Quiz implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    // widgetApi in ctor
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _widgetApi: typeof WidgetQuiz.api);
+    static isTypeOf(element: IElement): element is Quiz;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    get slideQuizIsDone(): boolean;
+    get isLayerForcePaused(): boolean;
+}
+declare class QuizGrouped implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _widgetApi: typeof WidgetQuizGrouped.api);
+    static isTypeOf(element: IElement): element is QuizGrouped;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    get slideQuizGroupedIsDone(): boolean;
+    get isLayerForcePaused(): boolean;
+}
+declare class RangeSlider implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _widgetApi: typeof WidgetRangeSlider.api);
+    static isTypeOf(element: IElement): element is RangeSlider;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    get isClickCapturedBySlider(): boolean;
+    handleClick(): boolean;
+    get isLayerForcePaused(): boolean;
+}
+declare class Rate implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _widgetApi: typeof WidgetRate.api);
+    static isTypeOf(element: IElement): element is Rate;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    setUserData(id: string, text: string): void;
+    get isLayerForcePaused(): boolean;
+}
+declare class Share implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _layersNodesRefs;
+    private readonly _widgetApi;
+    private static readonly _className;
+    private static readonly _widgetApiName;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _layersNodesRefs: Array<HTMLElement>, _widgetApi: typeof WidgetShare.api);
+    static isTypeOf(element: IElement): element is Share;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    complete(id: string, isSuccess: boolean): void;
+    get isLayerForcePaused(): boolean;
+}
+declare class SwipeUp implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer);
+    static isTypeOf(element: IElement): element is SwipeUp;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    get elementNodeRef(): HTMLElement;
+    get isLayerForcePaused(): boolean;
+}
+declare class SwipeUpItems implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer);
+    static isTypeOf(element: IElement): element is SwipeUpItems;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    get elementNodeRef(): HTMLElement;
+    get isLayerForcePaused(): boolean;
+}
+declare class Test implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _widgetApi;
+    private static readonly _className;
+    static className(): string;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _widgetApi: typeof WidgetTest.api);
+    static isTypeOf(element: IElement): element is Test;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    handleClick(): boolean;
+    get slideTestIsDone(): boolean;
+    get slideTestWithTimer(): boolean;
+    get isLayerForcePaused(): boolean;
+}
+declare class Video implements IElement {
+    private readonly _elementNodeRef;
+    private readonly _layer;
+    private readonly _VideoPlayer;
+    private readonly _sdkApi;
+    private static readonly _className;
+    static className(): string;
+    private readonly _video;
+    private readonly _isVOD;
+    private readonly _vodData;
+    private _vodPlayerInstance;
+    private _videoStateAdapter;
+    constructor(_elementNodeRef: HTMLElement, _layer: Layer, _VideoPlayer: typeof VideoPlayer | undefined, _sdkApi: SDKApi);
+    static isTypeOf(element: IElement): element is Video;
+    mediaElementsLoadingPromises: Array<Promise<HTMLImageElement | HTMLVideoElement>>;
+    init(localData: LocalData): Promise<boolean>;
+    private _isScreenOnPause;
+    onPause(): void;
+    onResume(): void;
+    onStart(): void;
+    onStop(): void;
+    private _initVOD;
+    private _convertMpdUrls;
+    handleClick(): boolean;
+    get isLayerForcePaused(): boolean;
+    private _videoStartedPromise;
+    get videoStartedPromise(): Promise<{
+        currentTime: number;
+    }> | null;
+    start(muted?: boolean): Promise<{
+        currentTime: number;
+    }>;
+    pause(resetVideoTime?: boolean): number | null;
+    resume(): Promise<{
+        currentTime: number;
+    }>;
+    stop(): Promise<void>;
+    enableAudio(): void;
+    disableAudio(): void;
+}
+declare class Slide {
+    private readonly _slidesNodesRefs;
+    private readonly _slideReadyPromise;
+    private readonly _afterResumeQueuePush;
+    private readonly _layers;
+    private _start;
+    constructor(_slidesNodesRefs: Array<HTMLElement>, _slideReadyPromise: Promise<void>, _afterResumeQueuePush: (cb: () => void) => void);
+    private _activeLayer;
+    get activeLayer(): Layer;
+    get layers(): Array<Layer>;
+    get layersNodesRefs(): Array<HTMLElement>;
+    private _initMultiSlide;
+    init(localData: LocalData): Promise<boolean>;
+    refreshActiveLayer(): void;
+    showLayer(showIndex: number, muted?: boolean): void;
+    get layoutService(): LayoutService;
+    get slideIndex(): number;
+    get cardId(): number;
+    get cardType(): CARD_TYPE;
+    get slideCount(): number;
+    get disabledNavigation(): boolean;
+}
+declare class Layer {
+    private readonly _nodeRef;
+    private readonly _slide;
+    private readonly _slideReadyPromise;
+    private readonly _afterResumeQueuePush;
+    private readonly _slideIndex;
+    private readonly _cardId;
+    private readonly _cardType;
+    private readonly _slideCount;
+    private readonly _duration;
+    private readonly _disabledTimer;
+    private readonly _disabledNavigation;
+    private _elements;
+    private readonly _timeline;
+    constructor(_nodeRef: HTMLElement, _slide: Slide, _slideReadyPromise: Promise<void>, _afterResumeQueuePush: (cb: () => void) => void);
+    init(localData: LocalData): Array<Promise<boolean>>;
+    get nodeRef(): HTMLElement;
+    get elements(): Array<IElement>;
+    get slide(): Slide;
+    get timeline(): SlideTimeline;
+    get layoutService(): LayoutService;
+    get sdkApi(): SDKApi;
+    getLocalData(): Promise<LocalData>;
+    get isQuest(): boolean;
+    private _initTextFit;
+    private _initTextElementAutoWidthCorrection;
+    get slideIndex(): number;
+    get cardId(): number;
+    get cardType(): CARD_TYPE;
+    get slideCount(): number;
+    get disabledNavigation(): boolean;
+    get videoElement(): Video | null;
+    get rangeSliderElement(): RangeSlider | null;
+    get quizElement(): Quiz | null;
+    get quizGroupedElement(): QuizGrouped | null;
+    get questElement(): Quest | null;
+    get testElement(): Test | null;
+    get dataInputElement(): DataInput | null;
+    get pollElement(): Poll | null;
+    get pollLayersElement(): PollLayers | null;
+    get rateElement(): Rate | null;
+    get shareElement(): Share | null;
+    get swipeUpElement(): SwipeUp | null;
+    get swipeUpItemsElement(): SwipeUpItems | null;
+    get productsElement(): Products | null;
+    isClickCapturedBySlider(): boolean;
+    private _animationPauseCb;
+    private _animationResumeCb;
+    start(muted?: boolean): Promise<{
+        currentTime: number;
+    }>;
+    stop(): Promise<void>;
+    stopInternal(): void;
+    pause(resetVideoTime?: boolean, stopAnimation?: boolean): Promise<{
+        currentTime: number | null;
+    }>;
+    resume(): Promise<unknown>;
+    enableAudio(): void;
+    disableAudio(): void;
+    get isLayerForcePaused(): boolean;
+}
+declare const enum STATE {
+    INIT = 0,
+    INITED = 1,
+    START = 2,
+    STARTED = 3,
+    RESUME = 4,
+    RESUMED = 5,
+    PAUSE = 6,
+    PAUSED = 7,
+    FORCE_PAUSED = 8,
+    STOP = 9,
+    STOPPED = 10
+}
+declare class SlideApi {
+    private readonly config;
+    get layoutDirection(): "ltr" | "rtl";
+    private static renderedBoxClassName;
+    private static prerenderBoxClassName;
+    private readonly _slideWrapper;
+    private readonly _viewport;
+    constructor(config: {
+        slideWrapper: HTMLElement;
+        viewport: Window;
+        userResizeHandler?: (data: {
+            viewportWidth: number;
+            viewportHeight: number;
+            fontSize: number;
+        }) => void;
+        slideRatio: number;
+        isFullscreen: boolean;
+        slideLoadedCb?: (data: {
+            slide: Slide;
+            result: boolean;
+            reason?: string;
+        }) => void;
+    });
+    destroy(): void;
+    private initListeners;
+    private destroyListeners;
+    private refreshSizes;
+    showSlide(html: string): Promise<{
+        slide: Slide;
+        result: boolean;
+        reason?: string;
+    }>;
+    handleBackpress(): void;
+    private get layoutService();
+    private getLocalData;
+    private get sdkApi();
+    private _fontsInit;
+    private _initAndLoadFonts;
+    private _slide;
+    private _slideInInit;
+    private _state;
+    private _afterStartInitQueue;
+    private _afterResumeQueue;
+    get state(): STATE;
+    private _onAllMediaLoaded;
+    private _init;
+    private _slideInRender;
+    private _slideBoxRenderComplete;
+    private _slideBoxRenderError;
+    private _startVideo;
+    private _slideConfig;
+    slideStart(configString: string): Promise<{
+        currentTime: number;
+    }>;
+    slideRestart(configString: string): Promise<{
+        currentTime: number;
+    }>;
+    private _pauseCbTimer;
+    slidePause(): Promise<void>;
+    slideResume(): Promise<void>;
+    slideStop(): Promise<void>;
+    slideTimerEnd(): void;
+    // for call from SlideApi internals (from widgets)
+    // skip state checking and sdk issues
+    slidePauseUI(): Promise<void>;
+    // for call from SlideApi internals (from widgets)
+    // skip state checking and sdk issues
+    slideResumeUI(): Promise<void>;
+    enableAudio(): void;
+    disableAudio(): void;
+    get isStopped(): boolean;
+    afterStartInitQueuePush(cb: () => void): false | undefined;
+    afterResumeQueuePush(cb: () => void): false | undefined;
+    get activeLayer(): Layer;
+    get slide(): Slide;
+    showLayer(index: number): void;
+    slideClickHandler(targetElement: HTMLElement, navigationDirection: "forward" | "backward"): {
+        canClickNext: boolean;
+    };
+    private _performLinkSpecialAndReturnTarget;
+    private _performLinkTarget;
+    // получать событие swipeUp от sdk, в том числе и от web sdk
+    slideSwipeUpHandler(target?: HTMLElement): boolean;
+}
+declare module SlideApiWrapper {
+    export { SlideApi };
+}
+import BaseSlideApi = SlideApiWrapper.SlideApi;
+declare class SlideApi$0 extends BaseSlideApi {
+    constructor(_sdkInterface: SDKInterface, config: {
+        root: HTMLElement;
+        slideRatio: number;
+        isFullscreen: boolean;
+        nonce?: string;
+        viewport: Window;
+        userResizeHandler?: (data: {
+            viewportWidth: number;
+            viewportHeight: number;
+            fontSize: number;
+        }) => void;
+        VODPlayer?: typeof VODPlayer;
+    });
+}
+export type { SDKInterface, SlideApi$0 as SlideApi, FontDTO };
+export { Widgets };