@vkontakte/videoplayer-interactive 1.0.60-dev.04f0bb5f.0 → 1.0.60-dev.bdbbdd48.0

package/index.d.ts

@@ -0,0 +1,11 @@
+export type { HistoryApi } from './modules/Interactives';
+export { EVENT_NAMES, Interactives, utils, graphEventTypes, interactivesEventTypes, isLastChapter, hasEndTemplate, isOneTextCtrlContainer } from './modules/Interactives';
+export type { IInteractiveOptions, InteractiveRange, InteractiveProjectInfo, PlayerChangedData, VideoInfo } from './modules/Interactives';
+export { ManifestController } from './modules/ManifestController';
+export * from './manifest';
+export { compareVersions } from './utils/compareVersions';
+export { CustomError } from './utils/Error';
+export * from './utils/chapterHelpers';
+export declare const SDKInfo: {
+    version: string;
+};

package/{types/manifest → manifest}/utils.d.ts

@@ -1,4 +1,5 @@
-import { EventActionTypes, type AnyManifest, type AnyControl } from '../manifest';
+import type { EventActionTypes } from '#/manifest';
+import { type AnyManifest, type AnyControl } from '#/manifest';
 /**
  * checks manifest object validity
  * @param manifest - manifest to check

package/{types/modules → modules}/Graph/Graph.d.ts

@@ -1,7 +1,8 @@
-import { type InterfaceLanguage, Nullable } from '@vkontakte/videoplayer-shared';
-import type { VideoInfo } from '../../modules/Interactives';
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import { type InterfaceLanguage } from '@vkontakte/videoplayer-shared';
+import type { VideoInfo } from '#/modules/Interactives';
 import type { GraphEditor } from '@interactiveplatform/movika-graph-editor';
-import type { Chapter, Manifest } from '../../manifest';
+import type { Chapter, Manifest } from '#/manifest';
 interface GraphOptions {
     lang: InterfaceLanguage | string;
     root: HTMLElement;

package/{types/modules → modules}/Interactives/Interactives.d.ts

@@ -1,10 +1,13 @@
-import { Observable, ValueSubject, Nullable } from '@vkontakte/videoplayer-shared';
-import type { Chapter, Manifest, AnyManifest } from '../../manifest';
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import { Observable, ValueSubject } from '@vkontakte/videoplayer-shared';
+import { InteractiveInterfaceClick } from '@vkontakte/videoplayer-statistics';
+import type { Chapter, Manifest, AnyManifest, ManifestVideo, GraphEditChapter, GraphViewChapter } from '#/manifest';
 import { type GlobalEvents } from './utils/events';
 import { type InteractiveRange } from './utils/getInteractiveRanges';
+import { type HistoryControllerState } from './utils/HistoryController';
 import type { IInteractiveOptions, IOptionalInteractiveOptions, VideoInfo } from './types';
 import type { IPlayer } from '@vkontakte/videoplayer-core';
-import type { InstanceStatistics } from '../../modules/SeamlessController/InstanceManager';
+import type { InstanceStatistics } from '#/modules/SeamlessController/InstanceManager';
 declare enum INTERACTIVE_APP_STATES {
     created = 0,
     initiated = 1,
@@ -84,8 +87,8 @@ export declare class Interactives {
         playPrev?: boolean;
     }): Promise<void>;
     getStatEvents(): {
-        click$: Observable<unknown>;
-        nextMovie$: Observable<unknown>;
+        click$: Observable<InteractiveInterfaceClick>;
+        nextMovie$: Observable<number>;
     };
     toggleGraphView(show?: boolean): Promise<void>;
     setVisitedChapters(chapterIds: string[]): void;
@@ -114,22 +117,22 @@ export declare class Interactives {
         videoId: string | null;
         chapterId: string;
     };
-    getHistoryState(): import("./utils/HistoryController").HistoryControllerState;
+    getHistoryState(): HistoryControllerState;
     /**
      * @deprecated Используйте this.state.isSeekable$
      */
     getIsSeekable(): ValueSubject<boolean>;
-    getInteractiveRanges(): import("./utils/getInteractiveRanges").InteractiveRanges;
+    getInteractiveRanges(): InteractiveRange[];
     getNextInteractiveStartTime(offsetMs?: number): number | null;
-    getChapterBranches(chapterId?: string): {
+    getChapterBranches(chapterId?: string): Array<{
         chapter: Chapter;
-        graph: import("../../manifest").GraphEditChapter | import("../../manifest").GraphViewChapter | undefined;
-        media: import("../../manifest").ManifestVideo;
-    }[];
+        graph: GraphEditChapter | GraphViewChapter | undefined;
+        media: ManifestVideo;
+    }>;
     getCurrentChapter(): {
         chapter: Nullable<Chapter>;
-        media: Nullable<import("../../manifest").ManifestVideo>;
-        graph: Nullable<import("@interactiveplatform/movika-manifest").GraphDesign>;
+        media: Nullable<ManifestVideo>;
+        graph: Nullable<Manifest['graph']>;
     };
     getCurrentManifest(): Nullable<Manifest>;
     on(eventName: string, fn: AnyFn): this;

package/{types/modules → modules}/Interactives/Layout.d.ts

@@ -1,5 +1,5 @@
-import { ChapterContainer, ControlLayoutParams } from '../../manifest';
-import { CssVarsManager } from '../../utils/CssVarsManager';
+import type { ChapterContainer, ControlLayoutParams } from '#/manifest';
+import type { CssVarsManager } from '#/utils/CssVarsManager';
 declare abstract class Layout {
     layout: ChapterContainer['layout'];
     cssVarsManager: CssVarsManager;

package/{types/modules → modules}/Interactives/containers/ChoiceContainer.d.ts

@@ -1,8 +1,8 @@
 import { Container } from './Container';
-import { ChapterContainer } from '../../../manifest';
+import type { ChapterContainer } from '#/manifest';
 import type { ChoiceContainerOptions, ContainerCreateViewParams } from './types';
-import { Nullable } from '@vkontakte/videoplayer-shared';
-import { CssVarsManager } from '../../../utils/CssVarsManager';
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import type { CssVarsManager } from '#/utils/CssVarsManager';
 export declare const createChoiceContainer: (container: ChapterContainer, rootElement: HTMLElement, cssVarsManager: CssVarsManager, options?: ChoiceContainerOptions) => ChoiceContainer | undefined;
 export declare class ChoiceContainer extends Container {
     private rootElement;

package/{types/modules → modules}/Interactives/containers/Container.d.ts

@@ -1,9 +1,9 @@
 import { Subject } from '@vkontakte/videoplayer-shared';
-import { CustomError } from '../../../utils/Error';
-import type { ChapterContainer } from '../../../manifest';
-import { type Control, type ControlCreator, type Options } from '../../../modules/Interactives/controls';
+import type { CustomError } from '#/utils/Error';
+import type { ChapterContainer } from '#/manifest';
+import { type Control, type ControlCreator, type Options } from '#/modules/Interactives/controls';
 import { type ChoiceContainerOptions } from './types';
-import { CssVarsManager } from '../../../utils/CssVarsManager';
+import type { CssVarsManager } from '#/utils/CssVarsManager';
 export declare class Container {
     container: ChapterContainer;
     options?: Options;
@@ -12,7 +12,7 @@ export declare class Container {
     error$: Subject<CustomError>;
     readonly cssVarsManager: CssVarsManager;
     constructor(container: ChapterContainer, cssVarsManager: CssVarsManager, options?: Options);
-    featureIsEnabled(name: keyof ChoiceContainerOptions['features']): unknown;
+    featureIsEnabled(name: keyof ChoiceContainerOptions['features']): boolean;
     onError(message: string | undefined, error: unknown): void;
     addControlFactory(type: string, factory: ControlCreator<any>): void;
     removeControlFactory(type: string): void;

package/{types/modules → modules}/Interactives/containers/types.d.ts

@@ -1,5 +1,5 @@
-import { Options, ControlEventCallback } from '../controls';
-import { AnimationsFeatureToggles } from '../types';
+import type { Options, ControlEventCallback } from '../controls';
+import type { AnimationsFeatureToggles } from '../types';
 export type ChoiceContainerOptions = {
     isTouch: boolean;
     features: Pick<AnimationsFeatureToggles, 'controlsExpectTimeBlinkAnimation' | 'controlsTapPlace' | 'controlsFillAnimation'>;

package/{types/modules → modules}/Interactives/controls/AreaControl.d.ts

@@ -1,3 +1,4 @@
+import { type Nullable } from '@vkontakte/videoplayer-shared';
 import { Control } from './Control';
 import { type ControlCreator, type ControlCreateViewParams, type TControl, type ControlOptions } from './types';
 export declare const createAreaControl: ControlCreator<ControlOptions, AreaControl>;
@@ -7,7 +8,7 @@ declare class AreaControl extends Control {
     registerBlinkAnimationEvents(): void;
     disable(): void;
     enable(): void;
-    getElement(): import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
+    getElement(): Nullable<HTMLElement>;
     updateShadowStyles(isDark?: boolean): void;
     toggleBlinkAnimation(enable?: boolean): void;
     syncBlinkAnimation(refAnim: HTMLElement): void;

package/{types/modules → modules}/Interactives/controls/ButtonControl.d.ts

@@ -1,3 +1,4 @@
+import { type Nullable } from '@vkontakte/videoplayer-shared';
 import { Control } from './Control';
 import { type ControlCreator, type ControlCreateViewParams, type TControl, type ControlOptions } from './types';
 import { ControlFillAnimation } from '../utils/ControlFillAnimation';
@@ -11,7 +12,7 @@ declare class ButtonControl extends Control {
     registerBlinkAnimationEvents(): void;
     disable(): void;
     enable(): void;
-    getElement(): import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
+    getElement(): Nullable<HTMLElement>;
     toggleBlinkAnimation(enable?: boolean): void;
     syncBlinkAnimation(refAnim: HTMLElement): void;
     onBlinkHovering(): void;

package/{types/modules → modules}/Interactives/controls/Control.d.ts

@@ -1,8 +1,9 @@
-import { Subject, Subscription, Nullable } from '@vkontakte/videoplayer-shared';
-import { CustomError } from '../../../utils/Error';
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import { Subject, Subscription } from '@vkontakte/videoplayer-shared';
+import type { CustomError } from '#/utils/Error';
 import { ControlTap } from '../utils/ControlTap';
 import type { ControlEventCallback, ControlCreateViewParams, Dimensions, Callbacks, Options, TControl, ControlOptions } from './types';
-import { CssVarsManager } from '../../../utils/CssVarsManager';
+import type { CssVarsManager } from '#/utils/CssVarsManager';
 type ControlContainer = {
     element: HTMLElement;
     dimensions: Dimensions;
@@ -11,7 +12,7 @@ type ControlContainer = {
 type ClickListener = (event: MouseEvent) => void;
 export declare abstract class Control {
     control: TControl;
-    options?: Options | undefined;
+    options: Options | undefined;
     container: Nullable<ControlContainer>;
     controlElement: Nullable<HTMLElement>;
     subscriptions: Subscription;
@@ -39,8 +40,8 @@ export declare abstract class Control {
     addControlTap(controlElement: HTMLElement): void;
     createContainerElement(callbacks: Callbacks): void;
     createClickListener(callback: AnyFn): ClickListener;
-    featureIsEnabled(name: keyof ControlOptions['features']): boolean | undefined;
-    isTouch(): boolean | undefined;
+    featureIsEnabled(name: keyof ControlOptions['features']): boolean;
+    isTouch(): boolean;
     setEvents(callback: ControlEventCallback): void;
     removeListeners(): void;
 }

package/{types/modules → modules}/Interactives/controls/TextControl.d.ts

@@ -1,10 +1,11 @@
+import type { Nullable } from '@vkontakte/videoplayer-shared';
 import { Control } from './Control';
 import { type ControlCreator, type ControlCreateViewParams, type TControl, type ControlOptions } from './types';
 export declare const createTextControl: ControlCreator<ControlOptions, TextControl>;
 declare class TextControl extends Control {
     constructor(control: TControl, options?: ControlOptions);
     createView({ parentElement, callbacks }: ControlCreateViewParams): void;
-    getElement(): import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
+    getElement(): Nullable<HTMLElement>;
     disable(): void;
     enable(): void;
     onProgress(): void;

package/{types/modules → modules}/Interactives/controls/types.d.ts

@@ -1,7 +1,7 @@
-import type { Control as TControl, ControlEvent, ControlLayoutParams } from '../../../manifest';
-import type { Control } from '../../../modules/Interactives/controls/Control';
-import { AnimationsFeatureToggles } from '../../../modules/Interactives/types';
-export { TControl };
+import type { Control as TControl, ControlEvent, ControlLayoutParams } from '#/manifest';
+import type { Control } from '#/modules/Interactives/controls/Control';
+import type { AnimationsFeatureToggles } from '#/modules/Interactives/types';
+export type { TControl };
 export declare const CONTROLLER_PREFIX = "int";
 export declare enum CONTROLLER_IDS {
     AREA = "int_area",

package/modules/Interactives/index.d.ts

@@ -0,0 +1,16 @@
+import { Container, createChoiceContainer } from './containers/index';
+import { createAreaControl, createButtonControl } from './controls';
+import { classnamesPrefix } from './utils/renderingUtils';
+export { Interactives } from './Interactives';
+export { EVENT_NAMES, graphEventTypes, interactivesEventTypes } from './utils/events';
+export type { InteractiveProjectInfo, PlayerChangedData, VideoInfo, IInteractiveOptions } from './types';
+export type { HistoryApi } from './utils/HistoryController';
+export { isLastChapter, hasEndTemplate, isOneTextCtrlContainer } from './utils/gameUtils';
+export type { InteractiveRange } from './utils/getInteractiveRanges';
+export declare const utils: {
+    Container: typeof Container;
+    createChoiceContainer: typeof createChoiceContainer;
+    createAreaControl: typeof createAreaControl;
+    createButtonControl: typeof createButtonControl;
+    classnamesPrefix: typeof classnamesPrefix;
+};

package/{types/modules → modules}/Interactives/types.d.ts

@@ -1,9 +1,9 @@
 import type { InterfaceLanguage } from '@vkontakte/videoplayer-shared';
 import type { IOptionalTuningConfig, IPlayer } from '@vkontakte/videoplayer-core';
 import type { IOneStat } from '@vkontakte/videoplayer-statistics';
-import type { Loaders } from '../../modules/ManifestController/Loadable';
-import type { HistoryApi, HistorySettings } from '../../modules/Interactives/utils/HistoryController';
-import type { Chapter, ManifestVideo } from '../../manifest';
+import type { Loaders } from '#/modules/ManifestController/Loadable';
+import type { HistoryApi, HistorySettings } from '#/modules/Interactives/utils/HistoryController';
+import type { Chapter, ManifestVideo } from '#/manifest';
 export type { VideoInfo } from '@interactiveplatform/movika-graph-editor';
 export type InteractiveProjectInfo = {
     videoId: string;

package/{types/modules → modules}/Interactives/utils/GameController.d.ts

@@ -1,12 +1,12 @@
 import { type ISubscription, type IValueSubject } from '@vkontakte/videoplayer-shared';
 import { type IPlayer } from '@vkontakte/videoplayer-core';
 import type { InteractiveEventsType } from './InteractiveEvents';
-import type { ChapterBranch } from '../../../manifest';
-import type { EventEmitter } from '../../../utils/EventEmitter';
-import { CustomError } from '../../../utils/Error';
+import type { ChapterBranch } from '#/manifest';
+import type { EventEmitter } from '#/utils/EventEmitter';
+import type { CustomError } from '#/utils/Error';
 import type { SelectBranchesType } from './SelectBranches';
-import type { IgnoreExpectState, AnimationsFeatureToggles, IInteractiveOptions } from '../../../modules/Interactives/types';
-import type { ChoiceContainer } from '../../../modules/Interactives/containers';
+import type { IgnoreExpectState, AnimationsFeatureToggles, IInteractiveOptions } from '#/modules/Interactives/types';
+import type { ChoiceContainer } from '#/modules/Interactives/containers';
 import { type GlobalEvents } from './events';
 import { GameStates } from './gameUtils';
 type Features = Pick<AnimationsFeatureToggles, 'controlsHideAnimation'> & Pick<IInteractiveOptions, 'enableAvPlayerSupport'>;

package/{types/modules → modules}/Interactives/utils/GroupsStack.d.ts

@@ -1,4 +1,4 @@
-import type { EventActionKeys } from '../../../manifest';
+import type { EventActionKeys } from '#/manifest';
 export type TPriority = 'chapter' | 'container' | 'control';
 export type TPayload = {
     actionType: EventActionKeys;
@@ -22,10 +22,10 @@ type GetAndRemoveArgType = Partial<Omit<TMapFlattened, keyof TPayload>> & Pick<T
 export type TGroupsStack = ReturnType<typeof GroupsStack>;
 export declare function GroupsStack(): {
     map: TMap;
-    remove: ({ timestamp, priority, initiator }: GetAndRemoveArgType) => boolean;
-    add: ({ timestamp, priority, initiator, ...rest }: TMapFlattened) => void;
+    remove: (args: GetAndRemoveArgType) => boolean;
+    add: (args: TMapFlattened) => void;
     removeAll: () => void;
-    get: ({ timestamp, priority, initiator }: GetAndRemoveArgType) => TMapInitiator | TPayload[] | TMapPriority | null;
+    get: (args: GetAndRemoveArgType) => TMapPriority | TMapInitiator | TPayload[] | null;
     getLte: (timestamp: number) => TMap;
     getGte: (timestamp: number) => TMap;
 };

package/{types/modules → modules}/Interactives/utils/HistoryController.d.ts

@@ -1,10 +1,10 @@
-import { Nullable, Subject } from '@vkontakte/videoplayer-shared';
-import type { IValueSubject } from '@vkontakte/videoplayer-shared';
-import { EventEmitter } from '../../../utils/EventEmitter';
-import type { VideoId } from '../../../manifest';
-import type { VideoInfo } from '../../../modules/Interactives';
-import type { Interactives } from '../../../modules/Interactives';
-import { CustomError } from '../../../utils/Error';
+import { Subject } from '@vkontakte/videoplayer-shared';
+import type { IValueSubject, Nullable } from '@vkontakte/videoplayer-shared';
+import type { EventEmitter } from '#/utils/EventEmitter';
+import type { Manifest, VideoId } from '#/manifest';
+import type { VideoInfo } from '#/modules/Interactives';
+import type { Interactives } from '#/modules/Interactives';
+import { CustomError } from '#/utils/Error';
 export interface HistoryApi {
     get: (rawId: string) => Promise<number[]>;
     save: (rawId: string, videoIds: number[]) => Promise<void>;
@@ -40,10 +40,10 @@ export default class HistoryController {
         error$: Subject<CustomError>;
     };
     constructor({ globalEventEmitter, videoId, interactiveController, historyApi, settings }: HistoryControllerParams);
-    setManifest(manifest: any): Promise<void>;
+    setManifest(manifest: Manifest): Promise<void>;
     get inited(): boolean;
     updateHistory(chapterIds: string[], shouldSave?: boolean): Promise<void>;
-    goBack(): Promise<boolean | undefined>;
+    goBack(): Promise<void>;
     getProjectHistory(): Promise<void>;
     getInitialChapterId(): string;
     getInitialVideoId(): VideoId | null;

package/{types/modules → modules}/Interactives/utils/InteractiveEvents.d.ts

@@ -1,13 +1,19 @@
-import { type Container } from '../../../manifest';
+import { type Container } from '#/manifest';
 import { type TPayload, type TGroupsStack } from './GroupsStack';
 import type { IPlayer } from '@vkontakte/videoplayer-core';
-export type InteractiveEventsType = ReturnType<typeof InteractiveEvents>;
 type AddMethodParamType = Parameters<TGroupsStack['add']>[0];
 type RemoveMethodParamType = Parameters<TGroupsStack['remove']>[0];
-/**
- * Executes an events at different times of the current chapter
- */
-export declare function InteractiveEvents(player: IPlayer, interactiveTimeOpenUri: boolean): {
+export interface ContainersEventsCallStateType {
+    setCalled: (args: {
+        timestamp: number;
+        id: string;
+    }) => void;
+    setData: (containers?: Container[]) => void;
+    resetCalled: (timestamp: number) => void;
+    isReady: (timestamp: number) => boolean;
+    release: () => void;
+}
+export interface InteractiveEventsType {
     setPlayer: (player: IPlayer) => void;
     add: (args: AddMethodParamType) => void;
     remove: (args: RemoveMethodParamType) => void;
@@ -16,16 +22,11 @@ export declare function InteractiveEvents(player: IPlayer, interactiveTimeOpenUr
     listen: () => void;
     unlisten: () => void;
     release: () => void;
-    containersEventsCallState: {
-        setCalled: ({ timestamp, id }: {
-            timestamp: number;
-            id: string;
-        }) => void;
-        setData: (containers?: Container[]) => void;
-        resetCalled: (timestamp: number) => void;
-        isReady: (timestamp: number) => boolean;
-        release: () => void;
-    };
+    containersEventsCallState: ContainersEventsCallStateType;
     getPreparedToExecActions: (timestamp?: number) => TPayload[];
-};
+}
+/**
+ * Executes an events at different times of the current chapter
+ */
+export declare function InteractiveEvents(player: IPlayer, interactiveTimeOpenUri: boolean): InteractiveEventsType;
 export {};

package/{types/modules → modules}/Interactives/utils/ResizeManager.d.ts

@@ -1,6 +1,6 @@
 import type { IPlayer } from '@vkontakte/videoplayer-core';
-import { Nullable } from '@vkontakte/videoplayer-shared';
-import { CssVarsManager } from '../../../utils/CssVarsManager';
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import type { CssVarsManager } from '#/utils/CssVarsManager';
 type ResizeManagerArg = () => {
     parentElement: HTMLElement;
     cssVarsManager: CssVarsManager;

package/modules/Interactives/utils/SelectBranches.d.ts

@@ -0,0 +1,23 @@
+import type { Chapter } from '#/manifest';
+import type { SelectBranchesArg, OnControlEventArg, ChangeChapterArg, ContinuePlaybackArg, ExpectEventHandlerArg, OnChapterEventArg, OnContainerEventArg, OnExpectEventArg, SetManifestContainerEventsArg, OpenURIArg, ActionMap, AnyAction, AfterExpectActionType } from './SelectBranches.types';
+export declare const defaultArgs: {
+    readonly shouldOpenNow: true;
+    readonly isDetachContainer: true;
+};
+export declare const AFTER_EXPECT_ACTION: AfterExpectActionType;
+export declare const extendArgs: <T extends AnyAction>(action: T, rewrite?: boolean) => T;
+export type ExtendArgsReturnType = ReturnType<typeof extendArgs>;
+export declare const SelectBranches: ({ globalEventEmitter, globalEvents, player, interactiveEvents }: SelectBranchesArg) => {
+    onControlEvent: (arg: OnControlEventArg) => void;
+    onContainerEvent: (arg: OnContainerEventArg) => void;
+    onChapterEvent: (arg: OnChapterEventArg) => (() => ChangeChapterArg<"chapter">) | (() => ContinuePlaybackArg<"chapter">) | (() => OpenURIArg<"chapter">) | undefined;
+    onExpectEvent: <T extends keyof ActionMap>(arg: OnExpectEventArg<T>) => void;
+    expectEventHandler: <T extends keyof ActionMap>(arg: ExpectEventHandlerArg<T>) => void;
+    setManifestChapterEvents: (chapter: Chapter) => void;
+    setManifestContainerEvents: (arg: SetManifestContainerEventsArg) => void;
+    stopExpect: () => void;
+    state: {
+        isExpect: boolean;
+    };
+};
+export type SelectBranchesType = typeof SelectBranches;

package/{types/modules → modules}/Interactives/utils/SelectBranches.types.d.ts

@@ -1,9 +1,9 @@
-import type { ChapterContainer, Control, ChapterBranch, ControlEvent, ContainerEvent, ChapterEvent } from '../../../manifest';
-import type { EventEmitter } from '../../../utils/EventEmitter';
+import type { ChapterContainer, Control, ChapterBranch, ControlEvent, ContainerEvent, ChapterEvent } from '#/manifest';
+import type { EventEmitter } from '#/utils/EventEmitter';
 import type { IPlayer } from '@vkontakte/videoplayer-core';
 import type { InteractiveEventsType } from './InteractiveEvents';
 import type { GlobalEvents } from './events';
-import { Nullable } from '@vkontakte/videoplayer-shared';
+import type { Nullable } from '@vkontakte/videoplayer-shared';
 export type SubjectName = 'chapter' | 'container' | 'control';
 export type AfterExpectActionType = 'after-expect';
 export type Behaviour = 'change-chapter' | 'change-manifest';

package/{types/modules → modules}/Interactives/utils/angleUtils.d.ts

@@ -1,7 +1,7 @@
 /**
  * use normalizeRadians before use
  */
-export declare function isPositiveXAxis(angle: number): angle is 0;
+export declare function isPositiveXAxis(angle: number): boolean;
 /**
  * use normalizeRadians before use
  */

package/{types/modules → modules}/Interactives/utils/createControlText.d.ts

@@ -1,4 +1,4 @@
-import type { AnyControl } from '../../../manifest';
+import type { AnyControl } from '#/manifest';
 type Type = Lowercase<AnyControl['type']> | AnyControl['type'];
 export declare const createControlText: (type: Type) => HTMLElement;
 export {};

package/{types/modules → modules}/Interactives/utils/emitOnError.d.ts

@@ -1,6 +1,6 @@
-import { ErrorCategoryEnum, ErrorSeverityEnum } from '../../../types';
-import { CustomError } from '../../../utils/Error';
-import { Subject } from '@vkontakte/videoplayer-shared';
+import { ErrorCategoryEnum, ErrorSeverityEnum } from '#/types';
+import { CustomError } from '#/utils/Error';
+import type { Subject } from '@vkontakte/videoplayer-shared';
 type EmitOnErrorArg = {
     emitter$: Subject<CustomError>;
     error?: unknown;

package/{types/modules → modules}/Interactives/utils/events.d.ts

@@ -1,8 +1,8 @@
 import type { Subject } from '@vkontakte/videoplayer-shared';
-import type { ChapterChangedData, EachTickData, PlayerChangedData } from '../../../modules/Interactives/types';
-import type { CustomError } from '../../../utils/Error';
-import type { Manifest } from '../../../manifest';
-import { TInteractiveRangeEndedEvent, TInteractivesActionChoiceEvent, TInteractivesActionExecutionEvent, TInteractivesContainerRemoved, TInteractivesContainerFakeRemoved, SubjectName, TInteractivesVisibility } from './events.types';
+import type { ChapterChangedData, EachTickData, PlayerChangedData } from '#/modules/Interactives/types';
+import type { CustomError } from '#/utils/Error';
+import type { Manifest } from '#/manifest';
+import type { TInteractiveRangeEndedEvent, TInteractivesActionChoiceEvent, TInteractivesActionExecutionEvent, TInteractivesContainerRemoved, TInteractivesContainerFakeRemoved, SubjectName, TInteractivesVisibility } from './events.types';
 export interface GlobalEvents {
     noInteraction$: Subject<void>;
     graphVisibilityChanged$: Subject<boolean>;

package/{types/modules → modules}/Interactives/utils/events.types.d.ts

@@ -1,7 +1,7 @@
 import type { SubjectName, ActionMap, SubjectType, AfterExpectActionType, Behaviour } from './SelectBranches.types';
-import { InteractivesEventTypes } from './events';
-import { EventActionTypes } from '../../../manifest';
-import type { ControlEvent, ContainerEvent, ChapterEvent, ChapterContainer, Control } from '../../../manifest';
+import type { InteractivesEventTypes } from './events';
+import type { EventActionTypes } from '#/manifest';
+import type { ControlEvent, ContainerEvent, ChapterEvent, ChapterContainer, Control } from '#/manifest';
 import type { InteractiveRange } from './getInteractiveRanges';
 export type { SubjectName };
 type InteractivesEventTypesValues = `${InteractivesEventTypes}`;

package/{types/modules → modules}/Interactives/utils/fallbackStrategies.d.ts

@@ -1,4 +1,5 @@
-import { type ChapterBranch } from '../../../manifest';
+import { type ChapterBranch } from '#/manifest';
+import type { Nullable } from '@vkontakte/videoplayer-shared';
 /**
  * Returns a random number in the range [0, limit) or [limit, 0) if the 'limit'
  * value is negative
@@ -7,11 +8,11 @@ export declare const getRandomNumber: (limit: number) => number;
 /**
  *  Finds the value with minimal weight number
  */
-export declare const minFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch | null;
+export declare const minFallbackStrategy: (branches: ChapterBranch[]) => Nullable<ChapterBranch>;
 /**
  *  Finds the value with maximal weight number
  */
-export declare const maxFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch | null;
+export declare const maxFallbackStrategy: (branches: ChapterBranch[]) => Nullable<ChapterBranch>;
 /**
  *  Finds first branch with `isDefault === true` value
  */

package/{types/modules → modules}/Interactives/utils/gameUtils.d.ts

@@ -1,6 +1,6 @@
-import { type Control, type Chapter, type ChapterContainer } from '../../../manifest';
+import { type Control, type Chapter, type ChapterContainer } from '#/manifest';
 import type { GameController } from './GameController';
-import type { IgnoreExpectState } from '../../../modules/Interactives/types';
+import type { IgnoreExpectState } from '#/modules/Interactives/types';
 export declare enum GameStates {
     nothing = 0,
     beforeInteractive = 1,
@@ -17,8 +17,9 @@ export declare const isBeforeStartTime: (currentTime: number, container: Chapter
 export declare const isInteractiveTime: (currentTime: number, container: ChapterContainer) => boolean;
 export declare const isAfterInteractiveTime: (currentTime: number, container: ChapterContainer) => boolean;
 type AnyEvent = (ChapterContainer | Chapter | Control)['events'];
+type ExtractItemFromArray<T> = T extends (infer U)[] ? U : never;
 export declare const isExpectEvent: (events?: AnyEvent) => boolean;
-export declare const getExpectEvent: (events?: AnyEvent) => import("../../../manifest").ControlEvent | import("../../../manifest").ChapterEvent | import("../../../manifest").ContainerEvent | undefined;
+export declare const getExpectEvent: (events?: AnyEvent) => ExtractItemFromArray<AnyEvent> | undefined;
 export declare const isOneCtrlOneContainer: (controls: Control[]) => boolean;
 export declare const isOneTextCtrlContainer: (controls: Control[]) => boolean;
 export declare function excludeTextControl(containers?: ChapterContainer[]): ChapterContainer[];

package/{types/modules → modules}/Interactives/utils/getInteractiveRanges.d.ts

@@ -1,4 +1,4 @@
-import { type Container } from '../../../manifest';
+import { type Container } from '#/manifest';
 export type Subject = {
     id: string;
     isRemoved: boolean;

package/{types/modules → modules}/Interactives/utils/renderingUtils.d.ts

@@ -1,5 +1,5 @@
-import { type Control } from '../../../manifest';
-import { type Dimensions } from '../../../modules/Interactives/controls';
+import { type Control } from '#/manifest';
+import { type Dimensions } from '#/modules/Interactives/controls';
 export declare const classnamesPrefix = "interactive";
 export declare const controlStylesFallbacks: {
     textColor: string;
@@ -30,11 +30,6 @@ export declare enum JUSTIFY_CONTENT {
     end = "flex-end",
     center = "center"
 }
-export declare enum TEXT_ALIGN {
-    start = "left",
-    end = "right",
-    center = "center"
-}
 export type SetTextPositionStylesProps = {
     target: HTMLElement;
     props: Control['props']['text'] & {

package/{types/modules → modules}/Loaders/vkVideoLoader/types.d.ts

@@ -1,5 +1,5 @@
-import type { ManifestVideo, ManifestVideoVariant } from '../../../manifest';
-export type { Extension, Standard } from '../../../manifest';
+import type { ManifestVideo, ManifestVideoVariant } from '#/manifest';
+export type { Extension, Standard } from '#/manifest';
 export interface GetVKVideoParams {
     access_token: string;
     owner_id?: number;

package/{types/modules → modules}/ManifestController/ManifestController.d.ts

@@ -1,6 +1,6 @@
 import type { IValueSubject, Nullable } from '@vkontakte/videoplayer-shared';
-import type { ChapterBranch, ManifestVideo, Chapter, Manifest, GraphEditChapter, GraphViewChapter, AnyManifest } from '../../manifest';
-import { Loadable } from './Loadable';
+import type { ChapterBranch, ManifestVideo, Chapter, Manifest, GraphEditChapter, GraphViewChapter, AnyManifest } from '#/manifest';
+import { Loadable, type Loaders } from './Loadable';
 type BranchesData = {
     chapter: Chapter;
     graph: GraphEditChapter | GraphViewChapter | undefined;
@@ -12,21 +12,21 @@ export declare class ManifestController extends Loadable {
     media: Nullable<ManifestVideo>;
     graph: Nullable<Manifest['graph']>;
     prevChapter$: IValueSubject<Chapter | null>;
-    onError: Function;
-    constructor(loaders: any, onError: Function);
+    onError: (err: unknown) => void;
+    constructor(loaders: Partial<Loaders>, onError: (err: unknown) => void);
     release(): this;
     setManifest(source: AnyManifest | string): Promise<ManifestController>;
     setInitial(): Promise<ManifestController>;
     setNext(chapterId?: string | undefined): Promise<ManifestController>;
     errorHandler(errors: unknown): void;
-    getInitial(): BranchesData | null;
+    getInitial(): Nullable<BranchesData>;
     getByChapterId(chapterId?: string | undefined): Nullable<BranchesData>;
     getBranches(chapterId?: string | undefined): BranchesData[];
     getByBranches(branches?: ChapterBranch[]): BranchesData[];
     getCurrent(): {
         chapter: Nullable<Chapter>;
         media: Nullable<ManifestVideo>;
-        graph: Nullable<import("@interactiveplatform/movika-manifest").GraphDesign>;
+        graph: Nullable<Manifest['graph']>;
     };
     isInitialChapter(): boolean;
     isEndChapter(): boolean;