@vkontakte/videoplayer-interactive 1.0.27-dev.60ca8010.0 → 1.0.27-dev.7d383bee.0

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

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

@@ -1,7 +1,7 @@
 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 { LatestChapterBranch } from '../../../movika.core/manifest';
 import type { EventEmitter } from '../../../utils/EventEmitter';
 import type { ChoiceContainer } from "../../../modules/Interactives/containers";
 import { SelectBranches } from './SelectBranches';
@@ -9,7 +9,7 @@ import { type GlobalEvents } from './events';
 import { GameStates } from './gameUtils';
 export declare class GameController {
     container: ChoiceContainer;
-    branches: ChapterBranch[];
+    branches: LatestChapterBranch[];
     selectBranches: ReturnType<typeof SelectBranches>;
     subscription: ISubscription;
     player: IPlayer;

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

@@ -1,7 +1,7 @@
-import type { EventActionKeys } from '../../../manifest';
+import { type EventActionTypes } from '../../../movika.core/manifest';
 export type TPriority = 'chapter' | 'container' | 'control';
 export type TPayload = {
-    actionType: EventActionKeys;
+    actionType: EventActionTypes;
     action: AnyFn;
 };
 export type TMapInitiator = {
@@ -13,17 +13,17 @@ type TMapPriority = {
 type TMap = {
     [timestamp: number]: TMapPriority;
 };
-export type TMapFlattened = {
+export type TMapMapFlattened = {
     timestamp: number;
     priority: TPriority;
     initiator: string;
 } & TPayload;
-type GetAndRemoveArgType = Partial<Omit<TMapFlattened, keyof TPayload>> & Pick<TMapFlattened, 'timestamp'>;
+type GetAndRemoveArgType = Partial<Omit<TMapMapFlattened, keyof TPayload>> & Pick<TMapMapFlattened, 'timestamp'>;
 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;
+    add: ({ timestamp, priority, initiator, ...rest }: TMapMapFlattened) => 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,9 +1,8 @@
 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 type { VideoId } from '../../../movika.core/manifest';
+import type { Interactives, VideoInfo } 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 Container } from '../../../manifest';
+import { type LatestContainer } from '../../../movika.core/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?: Container[]) => void;
+        setData: (containers?: LatestContainer[]) => void;
         resetCalled: (timestamp: number) => void;
         isReady: (timestamp: number) => boolean;
         release: () => void;

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

@@ -1,4 +1,4 @@
-import type { Chapter } from '../../../manifest';
+import type { LatestChapter } from '../../../movika.core/manifest';
 import type { SelectBranchesArg, OnControlEventArg, ContinuePlaybackArg, ExpectEventHandlerArg, OnChapterEventArg, OnContainerEventArg, OnExpectEventArg, SetManifestContainerEventsArg, ActionMap, AnyAction } from './SelectBranches.types';
 export declare const defaultArgs: {
     readonly shouldOpenNow: true;
@@ -11,7 +11,7 @@ export declare const SelectBranches: ({ globalEventEmitter, player, interactiveE
     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: Chapter) => void;
+    setManifestChapterEvents: (chapter: LatestChapter) => void;
     setManifestContainerEvents: ({ container, branches, isEOV }: SetManifestContainerEventsArg) => void;
     stopExpect: () => void;
     state: {

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

@@ -1,4 +1,4 @@
-import type { ChapterContainer, Control, ChapterBranch, ControlEvent, ContainerEvent, ChapterEvent } from '../../../manifest';
+import type { LatestContainer, ControlEvent, LatestControl, LatestChapterBranch, ContainerEvent, ChapterEvent } from '../../../movika.core/manifest';
 import type { EventEmitter } from '../../../utils/EventEmitter';
 import type { IPlayer } from '@vkontakte/videoplayer-core';
 import type { InteractiveEventsType } from './InteractiveEvents';
@@ -11,29 +11,29 @@ export type SelectBranchesArg = {
 };
 export type OnControlEventArg = {
     action: ControlEvent['action'];
-    controlType: Control['type'];
-    controlId: Control['id'];
-    containerId: ChapterContainer['id'];
+    controlType: LatestControl['type'];
+    controlId: LatestControl['id'];
+    containerId: LatestContainer['id'];
     onEvent: AnyFn;
-    branches?: ChapterBranch[];
+    branches?: LatestChapterBranch[];
     isEOV?: () => boolean;
     isDisabled?: () => boolean;
 };
 export type OnContainerEventArg = {
     action: ContainerEvent['action'];
-    container: ChapterContainer;
+    container: LatestContainer;
     autoSelected?: boolean;
-    branches?: ChapterBranch[];
+    branches?: LatestChapterBranch[];
     isEOV?: boolean;
 };
 export type OnChapterEventArg = {
     action: ChapterEvent['action'];
     chapterId: string;
-    branches?: ChapterBranch[];
+    branches?: LatestChapterBranch[];
 };
 export type SetManifestContainerEventsArg = {
-    container: ChapterContainer;
-    branches: ChapterBranch[];
+    container: LatestContainer;
+    branches: LatestChapterBranch[];
     isEOV?: boolean;
 };
 export type AnyAction = ControlEvent['action'] | ContainerEvent['action'] | ChapterEvent['action'];
@@ -42,7 +42,7 @@ export type ActionMap = {
     container: ContainerEvent['action'];
     chapter: ChapterEvent['action'];
 };
-export type SubjectType<T extends keyof ActionMap> = T extends 'control' ? Control['type'] : undefined;
+export type SubjectType<T extends keyof ActionMap> = T extends 'control' ? LatestControl['type'] : undefined;
 export type EventActionCommon<T extends keyof ActionMap> = {
     subjectId: string;
     subjectName: T;
@@ -53,7 +53,7 @@ export type EventActionCommonWithAction<T extends keyof ActionMap> = EventAction
 };
 export type OpenURIArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
     payload: {
-        URI?: Nullable<string>;
+        URI?: string;
     };
 };
 export type ChangeManifestArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {

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

@@ -1,7 +1,7 @@
 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 type { LatestManifest } from '../../../movika.core/manifest';
 export interface GlobalEvents {
     noInteraction$: Subject<void>;
     graphVisibilityChanged$: Subject<boolean>;
@@ -10,7 +10,7 @@ export interface GlobalEvents {
     playerChanged$: Subject<PlayerChangedData>;
     error$: Subject<CustomError>;
     eachTick$: Subject<EachTickData>;
-    manifestChanged$: Subject<Manifest>;
+    manifestChanged$: Subject<LatestManifest>;
 }
 export declare const EVENT_NAMES: {
     /**

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

@@ -1,4 +1,4 @@
-import { type ChapterBranch } from '../../../manifest';
+import { type LatestChapterBranch } from '../../../movika.core/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: ChapterBranch[]) => Nullable<ChapterBranch>;
+export declare const minFallbackStrategy: (branches: LatestChapterBranch[]) => Nullable<import("../../../movika.core/manifest/manifest_3_3/chapter").ChapterBranch>;
 /**
  *  Finds the value with maximal weight number
  */
-export declare const maxFallbackStrategy: (branches: ChapterBranch[]) => Nullable<ChapterBranch>;
+export declare const maxFallbackStrategy: (branches: LatestChapterBranch[]) => Nullable<import("../../../movika.core/manifest/manifest_3_3/chapter").ChapterBranch>;
 /**
  *  Finds first branch with `isDefault === true` value
  */
-export declare const defaultFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch | undefined;
+export declare const defaultFallbackStrategy: (branches: LatestChapterBranch[]) => import("../../../movika.core/manifest/manifest_3_3/chapter").ChapterBranch | undefined;
 /**
  *  Returns the random branch
  */
-export declare const weightlessRandomFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch;
-export declare const weightyRandomFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch;
+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;

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

@@ -1,4 +1,4 @@
-import { type Control, type Chapter, type ChapterContainer } from '../../../manifest';
+import { type LatestControl, type LatestChapter, type LatestContainer } from '../../../movika.core/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: 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 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 isExpectEvent: (events?: AnyEvent) => 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 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 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: ChapterContainer, gameControllers: GameController[]) => boolean;
+export declare const shouldIgnoreContainerEvent: (container: LatestContainer, gameControllers: GameController[]) => boolean;
 export {};

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

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

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

@@ -1,4 +1,4 @@
-import { type Control } from '../../../manifest';
+import { type LatestControl } from '../../../movika.core/manifest';
 import { type Dimensions } from '../../../modules/Interactives/controls';
 export declare const classnamesPrefix = "interactive";
 export declare const rootElClassName = "interactive-controls-container";
@@ -33,29 +33,27 @@ export declare enum TEXT_ALIGN {
     end = "right",
     center = "center"
 }
-export type SetTextPositionStylesProps = {
+type SetTextPositionStylesProps = {
     target: HTMLElement;
-    props: Control['props']['text'] & {
-        alignment: Control['layoutParams']['alignment'];
-    };
+    props: LatestControl['props'];
 };
 export declare const setTextPositionStyles: ({ target, props }: SetTextPositionStylesProps) => void;
 type SetTextStylesProps = {
     target: HTMLElement;
-    props: Control['props'];
+    props: LatestControl['props'];
     fallback: ControlStylesFallbacks;
     dependsOn: Dimensions;
 };
 export declare const setTextStyles: ({ target, props, fallback, dependsOn }: SetTextStylesProps) => void;
 type SetBackgroundStylesProps = {
     target: HTMLElement;
-    props: Control['props'];
+    props: LatestControl['props'];
     fallback: ControlStylesFallbacks;
 };
 export declare const setBackgroundStyles: ({ target, props, fallback }: SetBackgroundStylesProps) => void;
 type SetBorderStylesProps = {
     target: HTMLElement;
-    props: Control['props'];
+    props: LatestControl['props'];
     fallback: ControlStylesFallbacks;
     dependsOn: Dimensions;
 };
@@ -63,7 +61,7 @@ export declare const setBorderStyles: ({ target, props, fallback, dependsOn }: S
 type SetAngleProps = {
     target: HTMLElement;
     fallback: ControlStylesFallbacks;
-    layoutParams: Control['layoutParams'];
+    layoutParams: LatestControl['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 '../../../manifest';
-export type { Extension, Standard } from '../../../manifest';
+import type { ManifestVideo, ManifestVideoVariant } from '../../../movika.core/manifest';
+export type { Extensions, Standard } from '../../../movika.core/manifest';
 export interface GetVKVideoParams {
     access_token: string;
     owner_id?: number;

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

@@ -1,3 +1,5 @@
+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;

package/types/modules/ManifestController/ManifestController.d.ts

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

package/types/modules/ManifestController/utils.d.ts

@@ -1,12 +1,12 @@
-import type { Manifest, AnyManifest, Media, Chapter } from '../../manifest';
+import type { Manifest, LatestManifest, Media, Chapter } from '../../movika.core/manifest';
 type ManifestInfo = {
-    manifest: AnyManifest;
+    manifest: Manifest;
     manifestURL: string;
 };
-export declare const convertToObject: (manifest: AnyManifest | string) => Promise<Partial<ManifestInfo>>;
-export declare function fetchManifest(manifest: AnyManifest | string): Promise<Manifest>;
+export declare const convertToObject: (manifest: Manifest | string) => Promise<Partial<ManifestInfo>>;
+export declare function fetchManifest(manifest: Manifest): Promise<LatestManifest>;
 export declare function getInitialChapter(manifest: any): Chapter | undefined;
 export declare function getChapter(chapters: Chapter[], chapterId?: string): Chapter | undefined;
-export declare function getGraphItem(graphObj: Manifest['graph'], chapterId: string): import("../../manifest").GraphEditChapter | import("../../manifest").GraphViewChapter | undefined;
-export declare function getMedia(media: Media, videoId?: string): import("../../manifest").ManifestVideo | undefined;
+export declare function getGraphItem(graphObj: LatestManifest['graph'], chapterId: string): import("../../movika.core/manifest/manifest_3_3/graph").GraphEditChapter | import("../../movika.core/manifest/manifest_3_3/graph").GraphViewChapter | undefined;
+export declare function getMedia(media: Media, videoId?: string): import("../../movika.core/manifest/manifest_3_2/manifest").ManifestVideo | undefined;
 export {};

package/types/modules/SeamlessController/SeamlessController.d.ts

@@ -1,6 +1,6 @@
 import type { IConfig, PlaybackRate, VideoQuality } from '@vkontakte/videoplayer-core';
 import { ValueSubject } from '@vkontakte/videoplayer-shared';
-import type { ManifestVideo, Extension } from '../../manifest';
+import type { ManifestVideo, Extensions } from '../../movika.core/manifest';
 import type { Interactives } from '../../modules/Interactives';
 import type { Instance } from './InstanceManager';
 interface CreatePlayerParams extends Omit<IConfig, 'sources' | 'container'> {
@@ -9,7 +9,7 @@ interface CreatePlayerParams extends Omit<IConfig, 'sources' | 'container'> {
     prefetch?: boolean;
     setAsActive?: boolean;
     autoplay?: boolean;
-    preferredExt?: Array<Extension>;
+    preferredExt?: Array<Extensions>;
     quality?: VideoQuality;
     playbackRate?: PlaybackRate;
     title?: string;

package/types/modules/SeamlessController/utils.d.ts

@@ -1,7 +1,7 @@
 import type { IPlayer, ISources } from '@vkontakte/videoplayer-core';
-import type { ManifestVideo, Extension } from '../../manifest';
+import type { ManifestVideo, Extensions } from '../../movika.core/manifest';
 import { VideoQuality } from '@vkontakte/videoplayer-core';
-export declare function genPlayerCfgVideoData(mediaObj: ManifestVideo, allowList?: Array<Extension>): {
+export declare function genPlayerCfgVideoData(mediaObj: ManifestVideo, allowList?: Array<Extensions>): {
     sources: ISources;
     thumbUrl?: string | null;
     title: string;

package/types/modules/SeekToInteractiveController/SeekToInteractiveController.d.ts

@@ -1,10 +1,10 @@
 import type { IPlayer } from '@vkontakte/videoplayer-core';
-import type { ChapterContainer } from '../../manifest';
+import type { ChapterContainers } from '../../movika.core/manifest/types';
 export declare class SeekToInteractiveController {
     private _containers;
     private _player;
     setPlayer: (player: IPlayer) => void;
-    setContainers: (containers: ChapterContainer[]) => void;
+    setContainers: (containers: ChapterContainers) => void;
     deleteContainer: (id: string) => void;
     getNextInteractiveTime: (offsetMs?: number) => number | null;
 }

package/types/movika.core/manifest/index.d.ts

@@ -0,0 +1,28 @@
+import type { Chapter as Chapter_3_2, ChapterContainer as ChapterContainer_3_2, ChapterBranch as ChapterBranch_3_2 } from './manifest_3_2/chapter';
+import type { Manifest_3_2, ManifestVideo as ManifestVideo_3_2, ManifestVideoVariant as ManifestVideoVariant_3_2, Media as Media_3_2, Metadata as Metadata_3_2 } from './manifest_3_2/manifest';
+import type { Chapter as Chapter_3_3, ChapterContainer as ChapterContainer_3_3, ChapterBranch as ChapterBranch_3_3 } from './manifest_3_3/chapter';
+import type { Manifest_3_3, ManifestVideo as ManifestVideo_3_3, ManifestVideoVariant as ManifestVideoVariant_3_3, Media as Media_3_3, Metadata as Metadata_3_3, ManifestVideoVariantType, Extensions, Standard } from './manifest_3_3/manifest';
+import type { Control, ControlLayoutParams } from './manifest_3_3/control';
+export type Container = ChapterContainer_3_2 | ChapterContainer_3_3;
+export type Media = Media_3_2 | Media_3_3;
+export type Chapter = Chapter_3_2 | Chapter_3_3;
+export type Manifest = Manifest_3_2 | Manifest_3_3;
+export type Metadata = Metadata_3_2 | Metadata_3_3;
+export type ManifestVideo = ManifestVideo_3_2 | ManifestVideo_3_3;
+export type ManifestVideoVariant = ManifestVideoVariant_3_2 | ManifestVideoVariant_3_3;
+export type ChapterBranch = ChapterBranch_3_2 | ChapterBranch_3_3;
+export type { ManifestVideoVariantType, Extensions, Standard };
+export type LatestMedia = Media_3_3;
+export type LatestManifestVideo = ManifestVideo_3_3;
+export type LatestChapter = Chapter_3_3;
+export type LatestManifest = Manifest_3_3;
+export type LatestContainer = ChapterContainer_3_3;
+export type LatestControl = Control;
+export type LatestControlLayoutParams = ControlLayoutParams;
+export type LatestChapterBranch = ChapterBranch_3_3;
+export type { ControlEvent } from './manifest_3_3/control';
+export type { ContainerEvent } from './manifest_3_3/chapter';
+export type { ChapterEvent } from './manifest_3_3/chapter';
+export * from './migrations';
+export * from './types';
+export * from './utils';

package/types/movika.core/manifest/manifest_3_2/chapter.d.ts

@@ -0,0 +1,63 @@
+import type { Control } from './control';
+export type ChapterEventType = 'onSuspense';
+export type ContainerEventType = 'onSuspense';
+export type ChapterSuspenseActionType = 'setNextBranch' | 'setWeightlessRandomBranch' | 'setRandomBranch' | 'setMaxWeightBranch' | 'setMinWeightBranch' | 'setDefaultBranch' | 'continuePlayback' | 'openURI';
+export type ContainerSuspenseActionType = 'setNextBranch' | 'continuePlayback';
+export interface ChapterEvent {
+    type: ChapterEventType;
+    action: {
+        type: ChapterSuspenseActionType;
+        args: {
+            branchId?: string;
+            shouldOpenNow: boolean;
+            isDetachContainer?: boolean;
+        };
+    };
+}
+export interface ChapterBranch {
+    id: string;
+    chapterId: string;
+    weight?: number;
+    manifestUrl?: string;
+    isDefault?: boolean;
+}
+export interface ContainerEvent {
+    type: ContainerEventType;
+    action: {
+        type: ContainerSuspenseActionType;
+        args: {
+            branchId?: string;
+            shouldOpenNow: boolean;
+            isDetachContainer?: boolean;
+            uri?: string;
+        };
+    };
+}
+export interface ChapterContainer {
+    id: string;
+    /**
+     * Interactivity start time in milliseconds
+     */
+    startTime: number;
+    /**
+     * Interactivity end time in milliseconds
+     */
+    endTime?: number | null;
+    controls: Control[];
+    layout: {
+        type: 'Relative';
+    };
+    type: 'Choice' | 'TextInput';
+    events?: ContainerEvent[];
+}
+export interface Chapter {
+    id: string;
+    videoId?: string;
+    containers: ChapterContainer[];
+    branches: ChapterBranch[];
+    events?: ChapterEvent[];
+    label: string;
+    x: number;
+    y: number;
+    order: 'start' | 'end' | 'simple';
+}

package/types/movika.core/manifest/manifest_3_2/control.d.ts

@@ -0,0 +1,67 @@
+export type ControlType = 'Text' | 'Button' | 'Area';
+export type ControlEventType = 'onClick';
+export type ControlActionType = 'setNextBranch' | 'continuePlayback' | 'openURI';
+export interface ControlEvent {
+    type: ControlEventType;
+    action: {
+        type: ControlActionType;
+        args: {
+            branchId?: string;
+            shouldOpenNow: boolean;
+            isDetachContainer?: boolean;
+            uri?: string;
+        };
+    };
+}
+export interface ControlLayoutParams {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    angle: number;
+    innerSizesDependOn?: 'video' | 'self';
+}
+export interface ControlProps {
+    text?: {
+        value: string;
+        gravityHorizontal: 'start' | 'end' | 'center';
+        gravityVertical: 'top' | 'bottom' | 'center';
+        color: string;
+        alpha: number;
+        size: number;
+        paddings?: {
+            top: number;
+            right: number;
+            bottom: number;
+            left: number;
+        };
+        /**
+         * @deprecated accepted but no one uses
+         */
+        alignment?: 'left' | 'right' | 'center';
+    };
+    background: {
+        type: 'color';
+        color: string;
+        alpha: number;
+        src?: string;
+    };
+    shape: {
+        type: 'rectangle';
+        roundCorners: number;
+        border: {
+            width: number;
+            color: string;
+            alpha: number;
+        };
+    };
+}
+export interface Control {
+    id: string;
+    type: 'Button' | 'Area';
+    label: string;
+    subtype: ControlType;
+    layoutParams: ControlLayoutParams;
+    props: ControlProps;
+    events?: ControlEvent[];
+}