@vkontakte/videoplayer-interactive 1.0.28 → 1.0.29-dev.6887ae27.0

package/types/modules/Interactives/containers/ChoiceContainer.d.ts

@@ -1,13 +1,13 @@
 import { Container } from './Container';
-import { LatestContainer } from "../../../movika.core/manifest";
+import { ChapterContainer } from "../../../manifest";
 import { ControlEventCallback } from "../../../modules/Interactives/controls";
-export declare const createChoiceContainer: (container: LatestContainer, rootElement: HTMLElement) => ChoiceContainer | undefined;
+export declare const createChoiceContainer: (container: ChapterContainer, rootElement: HTMLElement) => ChoiceContainer | undefined;
 export declare class ChoiceContainer extends Container {
     private rootElement;
     private layout;
     isRemoved: boolean;
     isDisabled: boolean;
-    constructor(container: LatestContainer, rootElement: HTMLElement);
+    constructor(container: ChapterContainer, rootElement: HTMLElement);
     createView(eventCallback: ControlEventCallback): HTMLElement;
     hide(): void;
     show(): void;

package/types/modules/Interactives/containers/Container.d.ts

@@ -1,11 +1,11 @@
-import Control from '../../../modules/Interactives/controls/Control.js';
-import { LatestContainer } from "../../../movika.core/manifest";
+import Control from '../../../modules/Interactives/controls/Control';
+import { ChapterContainer } from "../../../manifest";
 import { ControlCreator } from "../../../modules/Interactives/controls";
 export declare class Container {
-    container: LatestContainer;
+    container: ChapterContainer;
     private factories;
     controls: Control[];
-    constructor(container: LatestContainer);
+    constructor(container: ChapterContainer);
     addControlFactory(type: string, factory: ControlCreator): void;
     removeControlFactory(type: string): void;
     private setControls;

package/types/modules/Interactives/controls/Control.d.ts

@@ -1,15 +1,14 @@
-import { LatestControl } from '../../../movika.core/manifest';
-import { ControlEventCallback, CreateViewParams, Dimensions, LayoutCallback } from './types';
+import type { ControlEventCallback, CreateViewParams, Dimensions, LayoutCallback, TControl } from './types';
 type ControlContainer = {
     element: HTMLElement;
     dimensions: Dimensions;
 };
 export default abstract class Control {
-    control: LatestControl;
+    control: TControl;
     protected container: Nullable<ControlContainer>;
     protected controlElement: Nullable<HTMLElement>;
     private clickListener;
-    protected constructor(control: LatestControl);
+    protected constructor(control: TControl);
     abstract createView(params: CreateViewParams): void;
     abstract getElement(): Nullable<HTMLElement>;
     abstract disable(): void;

package/types/modules/Interactives/controls/types.d.ts

@@ -1,6 +1,6 @@
-import { ControlEvent, ControlLayoutParams } from '../../../movika.core/manifest/manifest_3_3/control';
-import { LatestControl } from '../../../movika.core/manifest';
+import type { Control as TControl, ControlEvent, ControlLayoutParams } from '../../../manifest';
 import Control from '../../../modules/Interactives/controls/Control';
+export { TControl };
 export declare enum CONTROLLER_IDS {
     AREA = "int_area",
     TEXT = "int_text",
@@ -18,8 +18,7 @@ export type CreateViewParams = {
 type ControlEventCallbackParams = {
     action: ControlEvent['action'];
     controlId: string;
-    controlType: LatestControl['type'];
+    controlType: TControl['type'];
 };
 export type ControlEventCallback = (params: ControlEventCallbackParams) => void;
-export type ControlCreator = (control: LatestControl) => Control | undefined;
-export {};
+export type ControlCreator = (control: TControl) => Control | undefined;

package/types/modules/Interactives/index.d.ts

@@ -1,12 +1,12 @@
 import { Container } from './containers/index';
 export { Interactives } from './Interactives';
 export { EVENT_NAMES, graphEventTypes, interactivesEventTypes } from './utils/events';
-export type { VideoInfo, InteractiveProjectInfo, PlayerChangedData } from './types';
+export type { InteractiveProjectInfo, PlayerChangedData, VideoInfo } from './types';
 export { isLastChapter, hasEndTemplate, isOneTextCtrlContainer } from './utils/gameUtils';
 export type { InteractiveRange } from './utils/getInteractiveRanges';
 export declare const utils: {
     Container: typeof Container;
-    createChoiceContainer: (container: import("../../movika.core/manifest").LatestContainer, rootElement: HTMLElement) => import("./containers/ChoiceContainer").ChoiceContainer | undefined;
+    createChoiceContainer: (container: import("@interactiveplatform/movika-manifest").ChapterContainer, rootElement: HTMLElement) => import("./containers/ChoiceContainer").ChoiceContainer | undefined;
     createAreaControl: import("./controls").ControlCreator;
     createButtonControl: import("./controls").ControlCreator;
     getRootEl: () => Element | null;

package/types/modules/Interactives/types.d.ts

@@ -3,7 +3,7 @@ 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 { LatestChapter, LatestManifestVideo } from '../../movika.core/manifest';
+import type { Chapter, ManifestVideo } from '../../manifest';
 export type VideoInfo = {
     id: string;
     cover: string;
@@ -45,8 +45,8 @@ export interface IInteractiveOptions {
     disableControlsOnPause?: boolean;
 }
 export type ChapterChangedData = {
-    chapter: LatestChapter;
-    manifestVideo: LatestManifestVideo;
+    chapter: Chapter;
+    manifestVideo: ManifestVideo;
 };
 export type PlayerChangedData<T = any> = {
     player: IPlayer;

package/types/modules/Interactives/utils/GameController.d.ts

@@ -1,15 +1,28 @@
 import { type ISubscription, type IValueSubject } from '@vkontakte/videoplayer-shared';
 import { type IPlayer } from '@vkontakte/videoplayer-core';
 import type { InteractiveEventsType } from './InteractiveEvents';
-import type { LatestChapterBranch } from '../../../movika.core/manifest';
+import type { ChapterBranch } from '../../../manifest';
 import type { EventEmitter } from '../../../utils/EventEmitter';
 import type { ChoiceContainer } from "../../../modules/Interactives/containers";
 import { SelectBranches } from './SelectBranches';
 import { type GlobalEvents } from './events';
 import { GameStates } from './gameUtils';
+type ConstructorArg = {
+    player: IPlayer;
+    container: ChoiceContainer;
+    branches: ChapterBranch[];
+    selectBranches: ReturnType<typeof SelectBranches>;
+    interactiveEvents: InteractiveEventsType;
+    globalEventEmitter: EventEmitter;
+    globalEvents: GlobalEvents;
+    ignoreContainerEvent: () => boolean;
+    permanentTextControls: boolean;
+    disabledControls$: IValueSubject<boolean>;
+    onRemove: () => void;
+};
 export declare class GameController {
     container: ChoiceContainer;
-    branches: LatestChapterBranch[];
+    branches: ChapterBranch[];
     selectBranches: ReturnType<typeof SelectBranches>;
     subscription: ISubscription;
     player: IPlayer;
@@ -23,19 +36,8 @@ export declare class GameController {
     isSelectedControlEvent: boolean;
     isSelectedContainerEvent: boolean;
     globalEvents: GlobalEvents;
-    constructor({ player, container, branches, selectBranches, interactiveEvents, globalEvents, globalEventEmitter, ignoreContainerEvent, permanentTextControls, disabledControls$, onRemove, }: {
-        player: any;
-        container: any;
-        branches: any;
-        selectBranches: any;
-        interactiveEvents: any;
-        globalEvents: any;
-        globalEventEmitter: any;
-        ignoreContainerEvent: any;
-        permanentTextControls: any;
-        disabledControls$: any;
-        onRemove: any;
-    });
+    constructor({ player, container, branches, selectBranches, interactiveEvents, globalEvents, globalEventEmitter, ignoreContainerEvent, permanentTextControls, disabledControls$, onRemove, }: ConstructorArg);
+    private emitContainerVisibilityEvent;
     registerEvents(): void;
     hide: () => void;
     show: () => void;
@@ -49,3 +51,4 @@ export declare class GameController {
     removeView(): void;
     destroy(): void;
 }
+export {};

package/types/modules/Interactives/utils/GroupsStack.d.ts

@@ -1,7 +1,7 @@
-import { type EventActionTypes } from '../../../movika.core/manifest';
+import type { EventActionKeys } from '../../../manifest';
 export type TPriority = 'chapter' | 'container' | 'control';
 export type TPayload = {
-    actionType: EventActionTypes;
+    actionType: EventActionKeys;
     action: AnyFn;
 };
 export type TMapInitiator = {
@@ -13,17 +13,17 @@ type TMapPriority = {
 type TMap = {
     [timestamp: number]: TMapPriority;
 };
-export type TMapMapFlattened = {
+export type TMapFlattened = {
     timestamp: number;
     priority: TPriority;
     initiator: string;
 } & TPayload;
-type GetAndRemoveArgType = Partial<Omit<TMapMapFlattened, keyof TPayload>> & Pick<TMapMapFlattened, 'timestamp'>;
+type GetAndRemoveArgType = Partial<Omit<TMapFlattened, keyof TPayload>> & Pick<TMapFlattened, 'timestamp'>;
 export type TGroupsStack = ReturnType<typeof GroupsStack>;
 export declare function GroupsStack(): {
     map: TMap;
     remove: ({ timestamp, priority, initiator }: GetAndRemoveArgType) => boolean;
-    add: ({ timestamp, priority, initiator, ...rest }: TMapMapFlattened) => void;
+    add: ({ timestamp, priority, initiator, ...rest }: TMapFlattened) => void;
     removeAll: () => void;
     get: ({ timestamp, priority, initiator }: GetAndRemoveArgType) => TMapInitiator | TPayload[] | TMapPriority | null;
     getLte: (timestamp: number) => TMap;

package/types/modules/Interactives/utils/HistoryController.d.ts

@@ -1,8 +1,9 @@
 import { Nullable, Subject } from '@vkontakte/videoplayer-shared';
 import type { IValueSubject } from '@vkontakte/videoplayer-shared';
 import { EventEmitter } from '../../../utils/EventEmitter';
-import type { VideoId } from '../../../movika.core/manifest';
-import type { Interactives, VideoInfo } from '../../../modules/Interactives';
+import type { 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[]>;

package/types/modules/Interactives/utils/InteractiveEvents.d.ts

@@ -1,4 +1,4 @@
-import { type LatestContainer } from '../../../movika.core/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>;
@@ -21,7 +21,7 @@ export declare function InteractiveEvents(player: IPlayer): {
             timestamp: any;
             id: any;
         }) => void;
-        setData: (containers?: LatestContainer[]) => void;
+        setData: (containers?: Container[]) => void;
         resetCalled: (timestamp: number) => void;
         isReady: (timestamp: number) => boolean;
         release: () => void;

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

@@ -1,17 +1,19 @@
-import type { LatestChapter } from '../../../movika.core/manifest';
-import type { SelectBranchesArg, OnControlEventArg, ContinuePlaybackArg, ExpectEventHandlerArg, OnChapterEventArg, OnContainerEventArg, OnExpectEventArg, SetManifestContainerEventsArg, ActionMap, AnyAction } from './SelectBranches.types';
+import type { Chapter } from '../../../manifest';
+import type { SelectBranchesArg, OnControlEventArg, ContinuePlaybackArg, ExpectEventHandlerArg, OnChapterEventArg, OnContainerEventArg, OnExpectEventArg, SetManifestContainerEventsArg, 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 declare const SelectBranches: ({ globalEventEmitter, player, interactiveEvents, removeControllers, }: SelectBranchesArg) => {
+export type ExtendArgsReturnType = ReturnType<typeof extendArgs>;
+export declare const SelectBranches: ({ globalEventEmitter, globalEvents, player, interactiveEvents, removeControllers, }: SelectBranchesArg) => {
     onControlEvent: ({ action, controlType, controlId, containerId, branches, onEvent, isEOV, isDisabled, }: OnControlEventArg) => void;
     onContainerEvent: ({ action, container: { id: containerId, endTime }, branches, isEOV, autoSelected, }: OnContainerEventArg) => void;
     onChapterEvent: ({ chapterId, action, branches }: OnChapterEventArg) => (() => ContinuePlaybackArg<"chapter">) | undefined;
     onExpectEvent: <T extends keyof ActionMap>({ subjectId, subjectName }: OnExpectEventArg<T>) => void;
     expectEventHandler: <T extends keyof ActionMap>({ subjectId, subjectName }: ExpectEventHandlerArg<T>) => void;
-    setManifestChapterEvents: (chapter: LatestChapter) => void;
+    setManifestChapterEvents: (chapter: Chapter) => void;
     setManifestContainerEvents: ({ container, branches, isEOV }: SetManifestContainerEventsArg) => void;
     stopExpect: () => void;
     state: {

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

@@ -1,39 +1,43 @@
-import type { LatestContainer, ControlEvent, LatestControl, LatestChapterBranch, ContainerEvent, ChapterEvent } from '../../../movika.core/manifest';
+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';
 export type SubjectName = 'chapter' | 'container' | 'control';
+export type AfterExpectActionType = 'after-expect';
+export type Behaviour = 'change-chapter' | 'change-manifest';
 export type SelectBranchesArg = {
     globalEventEmitter: EventEmitter;
+    globalEvents: GlobalEvents;
     player: IPlayer;
     interactiveEvents: InteractiveEventsType;
     removeControllers?: AnyFn;
 };
 export type OnControlEventArg = {
     action: ControlEvent['action'];
-    controlType: LatestControl['type'];
-    controlId: LatestControl['id'];
-    containerId: LatestContainer['id'];
+    controlType: Control['type'];
+    controlId: Control['id'];
+    containerId: ChapterContainer['id'];
     onEvent: AnyFn;
-    branches?: LatestChapterBranch[];
+    branches?: ChapterBranch[];
     isEOV?: () => boolean;
     isDisabled?: () => boolean;
 };
 export type OnContainerEventArg = {
     action: ContainerEvent['action'];
-    container: LatestContainer;
+    container: ChapterContainer;
     autoSelected?: boolean;
-    branches?: LatestChapterBranch[];
+    branches?: ChapterBranch[];
     isEOV?: boolean;
 };
 export type OnChapterEventArg = {
     action: ChapterEvent['action'];
     chapterId: string;
-    branches?: LatestChapterBranch[];
+    branches?: ChapterBranch[];
 };
 export type SetManifestContainerEventsArg = {
-    container: LatestContainer;
-    branches: LatestChapterBranch[];
+    container: ChapterContainer;
+    branches: ChapterBranch[];
     isEOV?: boolean;
 };
 export type AnyAction = ControlEvent['action'] | ContainerEvent['action'] | ChapterEvent['action'];
@@ -42,7 +46,7 @@ export type ActionMap = {
     container: ContainerEvent['action'];
     chapter: ChapterEvent['action'];
 };
-export type SubjectType<T extends keyof ActionMap> = T extends 'control' ? LatestControl['type'] : undefined;
+export type SubjectType<T extends keyof ActionMap> = T extends 'control' ? Control['type'] : undefined;
 export type EventActionCommon<T extends keyof ActionMap> = {
     subjectId: string;
     subjectName: T;
@@ -53,19 +57,19 @@ export type EventActionCommonWithAction<T extends keyof ActionMap> = EventAction
 };
 export type OpenURIArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
     payload: {
-        URI?: string;
+        URI?: Nullable<string>;
     };
 };
 export type ChangeManifestArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
     payload: {
-        behaviour?: string;
+        behaviour?: Behaviour;
     };
 };
 export type ChangeChapterArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
     payload: {
         chapterId: string;
         autoSelect: boolean;
-        behaviour?: string;
+        behaviour?: Behaviour;
     };
 };
 export type ContinuePlaybackArg<T extends keyof ActionMap> = EventActionCommonWithAction<T>;

package/types/modules/Interactives/utils/events.d.ts

@@ -1,7 +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 { LatestManifest } from '../../../movika.core/manifest';
+import type { Manifest } from '../../../manifest';
+import { TInteractiveRangeEndedEvent, TInteractivesActionChoiceEvent, TInteractivesActionExecutionEvent, TInteractivesContainerRemoved, SubjectName, TInteractivesVisibility } from './events.types';
 export interface GlobalEvents {
     noInteraction$: Subject<void>;
     graphVisibilityChanged$: Subject<boolean>;
@@ -10,14 +11,22 @@ export interface GlobalEvents {
     playerChanged$: Subject<PlayerChangedData>;
     error$: Subject<CustomError>;
     eachTick$: Subject<EachTickData>;
-    manifestChanged$: Subject<LatestManifest>;
+    manifestChanged$: Subject<Manifest>;
+    interactiveRangeEnded$: Subject<TInteractiveRangeEndedEvent>;
+    interactiveContainerRemoved$: Subject<TInteractivesContainerRemoved>;
+    interactiveActionExecution$: Subject<TInteractivesActionExecutionEvent<SubjectName>>;
+    interactiveActionChoice$: Subject<TInteractivesActionChoiceEvent<SubjectName>>;
+    interactiveVisibilityChanged$: Subject<TInteractivesVisibility<'container'>>;
 }
 export declare const EVENT_NAMES: {
     /**
-    * @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$
-    * & interactivesInstance.events.watchAgainIsClicked$
-    */
+     * @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$
+     * & interactivesInstance.events.watchAgainIsClicked$
+     */
     readonly graph: "graph";
+    /**
+     * @deprecated Используйте interactivesInstance.events
+     */
     readonly interactives: "interactives";
     /**
      * @deprecated Используйте interactivesInstance.events.chapterChanged$
@@ -31,19 +40,25 @@ export declare const EVENT_NAMES: {
      * @deprecated Используйте interactivesInstance.events.manifestChanged$
      */
     readonly manifestChanged: "manifest-changed";
+    /**
+     * @deprecated Используйте interactivesInstance.events.error$
+     */
     readonly errors: "errors";
     readonly eachTick: "eachTick";
     readonly historyInited: "history-inited";
     readonly historyDestroyed: "history-destroyed";
 };
 /**
-* @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$ &
-* interactivesInstance.events.watchAgainIsClicked$
-*/
+ * @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$ &
+ * interactivesInstance.events.watchAgainIsClicked$
+ */
 export declare const graphEventTypes: {
     readonly visibility: "visibility";
     readonly watchAgainClicked: "watchAgainClicked";
 };
+/**
+ * @deprecated use InteractivesEventTypes enum instead
+ */
 export declare const interactivesEventTypes: {
     readonly actionChoiceCanceled: "action-choice-canceled";
     readonly actionChoice: "action-choice";
@@ -52,3 +67,11 @@ export declare const interactivesEventTypes: {
     readonly containerRemoved: "container-removed";
     readonly rangeEnded: "range-ended";
 };
+export declare enum InteractivesEventTypes {
+    ACTION_CHOICE_CANCELED = "action-choice-canceled",
+    ACTION_CHOICE = "action-choice",
+    ACTION_EXECUTION = "action-execution",
+    VISIBILITY = "visibility",
+    CONTAINER_REMOVED = "container-removed",
+    RANGE_ENDED = "range-ended"
+}

package/types/modules/Interactives/utils/events.types.d.ts

@@ -0,0 +1,47 @@
+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 { InteractiveRange } from './getInteractiveRanges';
+export type { SubjectName };
+type InteractivesEventTypesValues = `${InteractivesEventTypes}`;
+type InteractivesEventTypesValuesChapter = InteractivesEventTypes.ACTION_CHOICE | InteractivesEventTypes.ACTION_CHOICE_CANCELED | InteractivesEventTypes.ACTION_EXECUTION;
+type InteractivesEventTypesValuesContainer = InteractivesEventTypesValues;
+type InteractivesEventTypesValuesControl = InteractivesEventTypesValuesChapter | InteractivesEventTypes.VISIBILITY;
+type InteractiveEventType<T extends SubjectName> = T extends 'container' ? InteractivesEventTypesValuesContainer : InteractivesEventTypesValuesControl;
+type TInteractiveCommon<T extends SubjectName, U extends InteractiveEventType<T>> = {
+    subjectId: string;
+    subjectName: T;
+    type: U;
+};
+export type TInteractivesVisibility<T extends Exclude<SubjectName, 'chapter'>> = TInteractiveCommon<T, InteractivesEventTypes.VISIBILITY> & {
+    visibility: boolean;
+    isFirst?: boolean;
+};
+type EventActionTypesValues = `${EventActionTypes}`;
+export type TInteractiveRangeEndedEvent = {
+    type: InteractivesEventTypes.RANGE_ENDED;
+    payload: InteractiveRange;
+};
+type NonChapterChangeEvents = EventActionTypes.openURI | EventActionTypes.continuePlayback | EventActionTypes.expect;
+type TInteractivesActionExecEventPayload<T extends EventActionTypesValues> = T extends Exclude<EventActionTypesValues, NonChapterChangeEvents> ? Partial<{
+    chapterId: string;
+    autoSelect: boolean;
+    behaviour: Behaviour;
+    manifestURL: string;
+}> : undefined;
+export type TInteractivesActionExecutionEvent<T extends SubjectName> = TInteractiveCommon<T, InteractivesEventTypes.ACTION_EXECUTION> & {
+    actionType: ActionMap[T]['type'] | AfterExpectActionType;
+    subjectType?: SubjectType<T>;
+    payload?: TInteractivesActionExecEventPayload<ActionMap[T]['type']>;
+};
+type TInteractivesActionChoiceEventPayload<T extends SubjectName> = T extends 'chapter' ? ChapterEvent['action']['args'] : T extends 'container' ? ContainerEvent['action']['args'] : ControlEvent['action']['args'] & {
+    containerId: string;
+};
+type TSubjectTypeValues<T extends SubjectName> = T extends 'chapter' ? undefined : T extends 'container' ? ChapterContainer['type'] : Control['type'];
+export type TInteractivesActionChoiceEvent<T extends SubjectName> = TInteractiveCommon<T, InteractivesEventTypes.ACTION_CHOICE | InteractivesEventTypes.ACTION_CHOICE_CANCELED> & {
+    subjectType?: TSubjectTypeValues<T>;
+    actionType: EventActionTypesValues;
+    payload: TInteractivesActionChoiceEventPayload<T>;
+};
+export type TInteractivesContainerRemoved = TInteractiveCommon<'container', InteractivesEventTypes.CONTAINER_REMOVED>;

package/types/modules/Interactives/utils/fallbackStrategies.d.ts

@@ -1,4 +1,4 @@
-import { type LatestChapterBranch } from '../../../movika.core/manifest';
+import { type ChapterBranch } from '../../../manifest';
 /**
  * Returns a random number in the range [0, limit) or [limit, 0) if the 'limit'
  * value is negative
@@ -7,17 +7,17 @@ export declare const getRandomNumber: (limit: number) => number;
 /**
  *  Finds the value with minimal weight number
  */
-export declare const minFallbackStrategy: (branches: LatestChapterBranch[]) => Nullable<import("../../../movika.core/manifest/manifest_3_3/chapter").ChapterBranch>;
+export declare const minFallbackStrategy: (branches: ChapterBranch[]) => Nullable<ChapterBranch>;
 /**
  *  Finds the value with maximal weight number
  */
-export declare const maxFallbackStrategy: (branches: LatestChapterBranch[]) => Nullable<import("../../../movika.core/manifest/manifest_3_3/chapter").ChapterBranch>;
+export declare const maxFallbackStrategy: (branches: ChapterBranch[]) => Nullable<ChapterBranch>;
 /**
  *  Finds first branch with `isDefault === true` value
  */
-export declare const defaultFallbackStrategy: (branches: LatestChapterBranch[]) => import("../../../movika.core/manifest/manifest_3_3/chapter").ChapterBranch | undefined;
+export declare const defaultFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch | undefined;
 /**
  *  Returns the random branch
  */
-export declare const weightlessRandomFallbackStrategy: (branches: LatestChapterBranch[]) => import("../../../movika.core/manifest/manifest_3_3/chapter").ChapterBranch;
-export declare const weightyRandomFallbackStrategy: (branches: LatestChapterBranch[]) => import("../../../movika.core/manifest/manifest_3_3/chapter").ChapterBranch;
+export declare const weightlessRandomFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch;
+export declare const weightyRandomFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch;

package/types/modules/Interactives/utils/gameUtils.d.ts

@@ -1,4 +1,4 @@
-import { type LatestControl, type LatestChapter, type LatestContainer } from '../../../movika.core/manifest';
+import { type Control, type Chapter, type ChapterContainer } from '../../../manifest';
 import type { GameController } from './GameController';
 export declare enum GameStates {
     nothing = 0,
@@ -9,20 +9,20 @@ export declare enum GameStates {
     removed = 5,
     destroyed = 6
 }
-export declare const isControlsExist: (controls: LatestControl[]) => boolean;
-export declare const isLastChapter: (chapter: LatestChapter) => boolean;
-export declare const hasEndTemplate: (chapter: LatestChapter) => boolean;
-export declare const isBeforeStartTime: (currentTime: number, container: LatestContainer) => boolean;
-export declare const isInteractiveTime: (currentTime: number, container: LatestContainer) => boolean;
-export declare const isAfterInteractiveTime: (currentTime: number, container: LatestContainer) => boolean;
-type AnyEvent = LatestContainer['events'] | LatestChapter['events'] | LatestControl['events'];
+export declare const isControlsExist: (controls: Control[]) => boolean;
+export declare const isLastChapter: (chapter: Chapter) => boolean;
+export declare const hasEndTemplate: (chapter: Chapter) => boolean;
+export declare const isBeforeStartTime: (currentTime: number, container: ChapterContainer) => boolean;
+export declare const isInteractiveTime: (currentTime: number, container: ChapterContainer) => boolean;
+export declare const isAfterInteractiveTime: (currentTime: number, container: ChapterContainer) => boolean;
+type AnyEvent = (ChapterContainer | Chapter | Control)['events'];
 export declare const isExpectEvent: (events?: AnyEvent) => boolean;
-export declare const getExpectEvent: (events?: AnyEvent) => import("../../../movika.core/manifest").ControlEvent | import("../../../movika.core/manifest").ChapterEvent | import("../../../movika.core/manifest").ContainerEvent | undefined;
-export declare const isOneCtrlOneContainer: (controls: LatestControl[]) => boolean;
-export declare const isOneTextCtrlContainer: (controls: LatestControl[]) => boolean;
-export declare function excludeTextControl(containers?: LatestContainer[]): import("../../../movika.core/manifest/manifest_3_3/chapter").ChapterContainer[];
-export declare const isEOVEndTime: (target: HTMLVideoElement, endTime: LatestContainer["endTime"]) => boolean;
+export declare const getExpectEvent: (events?: AnyEvent) => import("../../../manifest").ControlEvent | import("../../../manifest").ChapterEvent | import("../../../manifest").ContainerEvent | undefined;
+export declare const isOneCtrlOneContainer: (controls: Control[]) => boolean;
+export declare const isOneTextCtrlContainer: (controls: Control[]) => boolean;
+export declare function excludeTextControl(containers?: ChapterContainer[]): ChapterContainer[];
+export declare const isEOVEndTime: (target: HTMLVideoElement, endTime: ChapterContainer["endTime"]) => boolean;
 export declare function partial<T extends unknown[], U extends unknown[], R>(fn: (...args: [...T, ...U]) => R, ...presetArgs: T): (...laterArgs: U) => R;
 export declare function partial<T extends Record<string, unknown>, P extends Partial<T>>(fn: (args: T) => unknown, presetArgs: P): (laterArgs: Omit<T, keyof P>) => ReturnType<typeof fn>;
-export declare const shouldIgnoreContainerEvent: (container: LatestContainer, gameControllers: GameController[]) => boolean;
+export declare const shouldIgnoreContainerEvent: (container: ChapterContainer, gameControllers: GameController[]) => boolean;
 export {};

package/types/modules/Interactives/utils/getInteractiveRanges.d.ts

@@ -1,4 +1,4 @@
-import { type Container } from '../../../movika.core/manifest';
+import { type Container } from '../../../manifest';
 export type InteractiveRange = {
     subjects: string[];
     range: [number, number];

package/types/modules/Interactives/utils/renderingUtils.d.ts

@@ -1,4 +1,4 @@
-import { type LatestControl } from '../../../movika.core/manifest';
+import { type Control } from '../../../manifest';
 import { type Dimensions } from '../../../modules/Interactives/controls';
 export declare const classnamesPrefix = "interactive";
 export declare const rootElClassName = "interactive-controls-container";
@@ -33,27 +33,29 @@ export declare enum TEXT_ALIGN {
     end = "right",
     center = "center"
 }
-type SetTextPositionStylesProps = {
+export type SetTextPositionStylesProps = {
     target: HTMLElement;
-    props: LatestControl['props'];
+    props: Control['props']['text'] & {
+        alignment: Control['layoutParams']['alignment'];
+    };
 };
 export declare const setTextPositionStyles: ({ target, props }: SetTextPositionStylesProps) => void;
 type SetTextStylesProps = {
     target: HTMLElement;
-    props: LatestControl['props'];
+    props: Control['props'];
     fallback: ControlStylesFallbacks;
     dependsOn: Dimensions;
 };
 export declare const setTextStyles: ({ target, props, fallback, dependsOn }: SetTextStylesProps) => void;
 type SetBackgroundStylesProps = {
     target: HTMLElement;
-    props: LatestControl['props'];
+    props: Control['props'];
     fallback: ControlStylesFallbacks;
 };
 export declare const setBackgroundStyles: ({ target, props, fallback }: SetBackgroundStylesProps) => void;
 type SetBorderStylesProps = {
     target: HTMLElement;
-    props: LatestControl['props'];
+    props: Control['props'];
     fallback: ControlStylesFallbacks;
     dependsOn: Dimensions;
 };
@@ -61,7 +63,7 @@ export declare const setBorderStyles: ({ target, props, fallback, dependsOn }: S
 type SetAngleProps = {
     target: HTMLElement;
     fallback: ControlStylesFallbacks;
-    layoutParams: LatestControl['layoutParams'];
+    layoutParams: Control['layoutParams'];
 };
 export declare const setAngle: ({ target, layoutParams, fallback }: SetAngleProps) => void;
 export {};

package/types/modules/Loaders/vkVideoLoader/types.d.ts

@@ -1,5 +1,5 @@
-import type { ManifestVideo, ManifestVideoVariant } from '../../../movika.core/manifest';
-export type { Extensions, Standard } from '../../../movika.core/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/Loaders/vkVideoLoader/utils.d.ts

@@ -1,5 +1,3 @@
-import type { ManifestVideoVariant } from '../../../movika.core/manifest';
 import type { FullRequestParams, VideoVideoImage } from './types';
 export declare function createRequestURL({ baseURL, requestParams }: FullRequestParams): string;
 export declare function findMaxResolutionFrame(frames?: VideoVideoImage[]): VideoVideoImage | undefined;
-export declare function isVKVariantItem(variantItem: ManifestVideoVariant): boolean;