@vkontakte/videoplayer-interactive 1.0.19-dev.d432d6cd.0 → 1.0.19-dev.d6f5a76a.0

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

@@ -1,49 +1,32 @@
-import { type ISubscription, type IValueSubject } from '@vkontakte/videoplayer-shared';
-import { type IPlayer } from '@vkontakte/videoplayer-core';
-import type { InteractiveEventsType } from './InteractiveEvents';
-import type { ChapterBranch, ChapterContainer } from '../../../manifest';
-import type { EventEmitter } from '../../../utils/EventEmitter';
-import { SelectBranches } from './SelectBranches';
-import { GameStates } from './gameUtils';
-type Container = {
-    container: ChapterContainer;
-    getElement: () => HTMLElement;
-    disable: () => void;
-    enable: () => void;
-    hide: () => void;
-    show: () => void;
-    createView: AnyFn;
-    removeView: () => void;
-    isDisabled: boolean;
-    isRemoved: boolean;
-};
-export declare class GameController {
-    container: Container;
-    branches: ChapterBranch[];
-    selectBranches: ReturnType<typeof SelectBranches>;
-    subscription: ISubscription;
-    player: IPlayer;
-    interactiveEvents: InteractiveEventsType;
-    ignoreContainerEvent: () => boolean;
-    isPermanentText: boolean;
-    disabledControls$: IValueSubject<boolean>;
-    onRemove: () => void;
-    globalEventEmitter: EventEmitter;
-    gameState: GameStates;
-    isSelectedControlEvent: boolean;
-    isSelectedContainerEvent: boolean;
-    constructor({ player, container, branches, selectBranches, interactiveEvents, globalEventEmitter, ignoreContainerEvent, permanentTextControls, disabledControls$, onRemove, }: {
+export class GameController {
+    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;
     });
+    container: any;
+    branches: any;
+    selectBranches: any;
+    subscription: Subscription;
+    player: any;
+    interactiveEvents: any;
+    ignoreContainerEvent: any;
+    isPermanentText: any;
+    disabledControls$: any;
+    onRemove: any;
+    globalEventEmitter: any;
+    globalEvents: any;
+    gameState: 0;
+    isSelectedControlEvent: boolean;
+    isSelectedContainerEvent: boolean;
     registerEvents(): void;
     hide: () => void;
     show: () => void;
@@ -57,4 +40,4 @@ export declare class GameController {
     removeView(): void;
     destroy(): void;
 }
-export {};
+import { Subscription } from '@vkontakte/videoplayer-shared';

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

@@ -1,32 +1,22 @@
-import type { EventActionKeys } from '../../../manifest';
-export type TPriority = 'chapter' | 'container' | 'control';
-export type TPayload = {
-    actionType: EventActionKeys;
-    action: AnyFn;
+export function GroupsStack(): {
+    map: {};
+    remove: ({ timestamp, priority, initiator }: {
+        timestamp: any;
+        priority: any;
+        initiator: any;
+    }) => boolean | undefined;
+    add: ({ timestamp, priority, initiator, ...rest }: {
+        [x: string]: any;
+        timestamp: any;
+        priority: any;
+        initiator: any;
+    }) => void;
+    removeAll: () => boolean;
+    get: ({ timestamp, priority, initiator }: {
+        timestamp: any;
+        priority: any;
+        initiator: any;
+    }) => any;
+    getLte: (timestamp: any) => {};
+    getGte: (timestamp: any) => {};
 };
-export type TMapInitiator = {
-    [initiator: string]: TPayload[];
-};
-type TMapPriority = {
-    [priority in TPriority]?: TMapInitiator;
-};
-type TMap = {
-    [timestamp: number]: TMapPriority;
-};
-export type TMapFlattened = {
-    timestamp: number;
-    priority: TPriority;
-    initiator: string;
-} & TPayload;
-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 }: TMapFlattened) => void;
-    removeAll: () => void;
-    get: ({ timestamp, priority, initiator }: GetAndRemoveArgType) => TMapInitiator | TPayload[] | TMapPriority | null;
-    getLte: (timestamp: number) => TMap;
-    getGte: (timestamp: number) => TMap;
-};
-export {};

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

@@ -1,8 +1,9 @@
-import { Nullable } from '@vkontakte/videoplayer-shared';
+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 { 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[]>;
     save: (rawId: string, videoIds: number[]) => Promise<void>;
@@ -25,9 +26,18 @@ export interface HistoryControllerState {
     isInitialChapter$: IValueSubject<boolean>;
     isGoBackLimited$: IValueSubject<boolean>;
 }
+interface HistoryInitedEventData {
+    initChapterId: string;
+    videosInfo?: VideoInfo[];
+}
 export default class HistoryController {
     #private;
     state: HistoryControllerState;
+    events: {
+        inited$: Subject<HistoryInitedEventData>;
+        destroyed$: Subject<void>;
+        error$: Subject<CustomError>;
+    };
     constructor({ globalEventEmitter, videoId, interactiveController, historyApi, settings }: HistoryControllerParams);
     setManifest(manifest: any): Promise<void>;
     get inited(): boolean;

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

@@ -1,17 +1,12 @@
-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
+ * @param  {object} player
  */
-export declare function InteractiveEvents(player: IPlayer): {
-    setPlayer: (player: IPlayer) => void;
-    add: (args: AddMethodParamType) => void;
-    remove: (args: RemoveMethodParamType) => void;
-    exec: (timestamp: number) => void;
+export function InteractiveEvents(player: object): {
+    setPlayer: (player: any) => void;
+    add: (args: any) => void;
+    remove: (args: any) => void;
+    exec: (timestamp: any) => void;
     execEndOfVideo: () => void;
     listen: () => void;
     unlisten: () => void;
@@ -21,11 +16,10 @@ export declare function InteractiveEvents(player: IPlayer): {
             timestamp: any;
             id: any;
         }) => void;
-        setData: (containers?: Container[]) => void;
-        resetCalled: (timestamp: number) => void;
-        isReady: (timestamp: number) => boolean;
+        setData: (containers?: any[]) => void;
+        resetCalled: (timestamp: any) => void;
+        isReady: (timestamp: any) => boolean;
         release: () => void;
     };
-    getPreparedToExecActions: (timestamp?: number) => TPayload[];
+    getPreparedToExecActions: (timestamp?: number) => any[];
 };
-export {};

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

@@ -1,12 +1,5 @@
-import type { IPlayer } from '@vkontakte/videoplayer-core';
-type ResizeManagerArg = () => {
-    parentElement: HTMLElement;
-    player?: Nullable<IPlayer>;
-    fns?: AnyFn[];
-};
-export declare function ResizeManager(getOptions: ResizeManagerArg): {
+export function ResizeManager(getOptions: any): {
     resizeObserver: ResizeObserver;
     calc: () => void;
     release: () => void;
 };
-export {};

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

@@ -1,18 +1,54 @@
-import type { Chapter } from '../../../manifest';
-import type { SelectBranchesArg, OnControlEventArg, ContinuePlaybackArg, ExpectEventHandlerArg, OnChapterEventArg, OnContainerEventArg, OnExpectEventArg, SetManifestContainerEventsArg, ActionMap, AnyAction } from './SelectBranches.types';
-export declare const defaultArgs: {
-    readonly shouldOpenNow: true;
-    readonly isDetachContainer: true;
-};
-export declare const extendArgs: <T extends AnyAction>(action: T, rewrite?: boolean) => T;
-export declare const SelectBranches: ({ globalEventEmitter, 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: Chapter) => void;
-    setManifestContainerEvents: ({ container, branches, isEOV }: SetManifestContainerEventsArg) => void;
+export const defaultArgs: Readonly<{
+    shouldOpenNow: true;
+    isDetachContainer: true;
+}>;
+export function extendArgs(action: any, rewrite?: boolean): any;
+export function SelectBranches({ globalEventEmitter, player, interactiveEvents, removeControllers }: {
+    globalEventEmitter: any;
+    player: any;
+    interactiveEvents: any;
+    removeControllers: any;
+}): {
+    onControlEvent: ({ action, controlType, controlId, containerId, branches, onEvent, isEOV, isDisabled, }: {
+        action: any;
+        controlType: any;
+        controlId: any;
+        containerId: any;
+        branches?: any[] | undefined;
+        onEvent: any;
+        isEOV?: (() => boolean) | undefined;
+        isDisabled?: (() => boolean) | undefined;
+    }) => void;
+    onContainerEvent: ({ action, container: { id: containerId, endTime }, branches, isEOV, autoSelected, }: {
+        action: any;
+        container: {
+            id: any;
+            endTime: any;
+        };
+        branches?: any[] | undefined;
+        isEOV?: boolean | undefined;
+        autoSelected?: boolean | undefined;
+    }) => void;
+    onChapterEvent: ({ chapterId, action, branches }: {
+        chapterId: any;
+        action: any;
+        branches?: any[] | undefined;
+    }) => (() => void) | undefined;
+    onExpectEvent: ({ subjectId, subjectName, action }: {
+        subjectId: any;
+        subjectName: any;
+        action: any;
+    }) => void;
+    expectEventHandler: ({ subjectId, subjectName }: {
+        subjectId: any;
+        subjectName: any;
+    }) => void;
+    setManifestChapterEvents: (chapter: any) => void;
+    setManifestContainerEvents: ({ container, branches, isEOV }: {
+        container: any;
+        branches: any;
+        isEOV?: boolean | undefined;
+    }) => void;
     stopExpect: () => void;
     state: {
         isExpect: boolean;

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

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

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

@@ -1,28 +1,26 @@
-import { type Control, type Chapter, type ChapterContainer } from '../../../manifest';
-import type { GameController } from './GameController';
-export declare enum GameStates {
-    nothing = 0,
-    beforeInteractive = 1,
-    interactive = 2,
-    afterInteractive = 3,
-    end = 4,
-    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['events'] | Chapter['events'] | Control['events'];
-export declare const isExpectEvent: (events?: AnyEvent) => boolean;
-export declare const getExpectEvent: (events?: AnyEvent) => import("@interactiveplatform/movika-graph-editor").ChapterEvent | import("@interactiveplatform/movika-graph-editor").ContainerEvent | import("@interactiveplatform/movika-graph-editor").ControlEvent | 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: ChapterContainer, gameControllers: GameController[]) => boolean;
-export {};
+export function excludeTextControl(containers?: any[]): any[];
+export const gameStates: Readonly<{
+    nothing: 0;
+    beforeInteractive: 1;
+    interactive: 2;
+    afterInteractive: 3;
+    end: 4;
+    removed: 5;
+    destroyed: 6;
+}>;
+export function isControlsExist(controls: any): boolean;
+export function isLastChapter(chapter: any): boolean;
+export function hasEndTemplate(chapter: any): boolean;
+export function isBeforeStartTime(currentTime: any, container: any): boolean;
+export function isInteractiveTime(currentTime: any, container: any): boolean;
+export function isAfterInteractiveTime(currentTime: any, container: any): boolean;
+export function isExpectEvent(events: any): any;
+export function getExpectEvent(events: any): any;
+export function isOneCtrlOneContainer(controls: any): boolean;
+export function isOneTextCtrlContainer(controls: any): boolean;
+export function isEOVEndTime(target: any, endTime: any): boolean;
+export function partial({ fn, type }: {
+    fn: any;
+    type?: number | undefined;
+}, ...presetArgs: any[]): (...laterArgs: any[]) => any;
+export function shouldIgnoreContainerEvent(container: any, gameControllers: any): any;

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,67 +1,62 @@
-import { type Control } from '../../../manifest';
-import { type Dimensions } from '../../../modules/Interactives/controls';
-export declare const classnamesPrefix = "interactive";
-export declare const rootElClassName = "interactive-controls-container";
-export declare const getRootEl: () => Element | null;
-export declare const DISABLE_OPACITY = 0.4;
-export declare const controlStylesFallbacks: {
-    textColor: string;
-    textSize: number;
-    textContent: string;
-    roundCorners: number;
-    borderWidth: number;
-    borderColor: string;
-    borderAlpha: number;
-    backgroundColor: string;
-    backgroundAlpha: number;
-    innerSizesDependOn: string;
-    angle: number;
-};
-type ControlStylesFallbacks = typeof controlStylesFallbacks;
-export declare enum ALIGN_ITEMS {
-    top = "flex-start",
-    bottom = "flex-end",
-    center = "center"
+export const classnamesPrefix: "interactive";
+export const rootElClassName: "interactive-controls-container";
+export function getRootEl(): Element | null;
+export const DISABLE_OPACITY: 0.4;
+export namespace controlStylesFallbacks {
+    let textColor: string;
+    let textSize: number;
+    let textContent: string;
+    let roundCorners: number;
+    let borderWidth: number;
+    let borderColor: string;
+    let borderAlpha: number;
+    let backgroundColor: string;
+    let backgroundAlpha: number;
+    let innerSizesDependOn: string;
+    let angle: number;
 }
-export declare enum JUSTIFY_CONTENT {
-    start = "flex-start",
-    end = "flex-end",
-    center = "center"
+export namespace ALIGN_ITEMS {
+    let top: string;
+    let bottom: string;
+    let center: string;
 }
-export declare enum TEXT_ALIGN {
-    start = "left",
-    end = "right",
-    center = "center"
+export namespace JUSTIFY_CONTENT {
+    export let start: string;
+    export let end: string;
+    let center_1: string;
+    export { center_1 as center };
 }
-type SetTextPositionStylesProps = {
-    target: HTMLElement;
-    props: Control['props'];
-};
-export declare const setTextPositionStyles: ({ target, props }: SetTextPositionStylesProps) => void;
-type SetTextStylesProps = {
-    target: HTMLElement;
-    props: Control['props'];
-    fallback: ControlStylesFallbacks;
-    dependsOn: Dimensions;
-};
-export declare const setTextStyles: ({ target, props, fallback, dependsOn }: SetTextStylesProps) => void;
-type SetBackgroundStylesProps = {
-    target: HTMLElement;
-    props: Control['props'];
-    fallback: ControlStylesFallbacks;
-};
-export declare const setBackgroundStyles: ({ target, props, fallback }: SetBackgroundStylesProps) => void;
-type SetBorderStylesProps = {
-    target: HTMLElement;
-    props: Control['props'];
-    fallback: ControlStylesFallbacks;
-    dependsOn: Dimensions;
-};
-export declare const setBorderStyles: ({ target, props, fallback, dependsOn }: SetBorderStylesProps) => void;
-type SetAngleProps = {
-    target: HTMLElement;
-    fallback: ControlStylesFallbacks;
-    layoutParams: Control['layoutParams'];
-};
-export declare const setAngle: ({ target, layoutParams, fallback }: SetAngleProps) => void;
-export {};
+export namespace TEXT_ALIGN {
+    let start_1: string;
+    export { start_1 as start };
+    let end_1: string;
+    export { end_1 as end };
+    let center_2: string;
+    export { center_2 as center };
+}
+export function setTextPositionStyles({ target, props }: {
+    target: any;
+    props: any;
+}): void;
+export function setTextStyles({ target, props, fallback, dependsOn }: {
+    target: any;
+    props: any;
+    fallback: any;
+    dependsOn: any;
+}): void;
+export function setBackgroundStyles({ target, props, fallback }: {
+    target: any;
+    props: any;
+    fallback: any;
+}): void;
+export function setBorderStyles({ target, props, fallback, dependsOn }: {
+    target: any;
+    props: any;
+    fallback: any;
+    dependsOn: any;
+}): void;
+export function setAngle({ target, layoutParams, fallback }: {
+    target: any;
+    layoutParams: any;
+    fallback: any;
+}): void;

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,4 +1,4 @@
-import type { ManifestVideoVariant } from '../../../manifest';
+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;

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-graph-editor").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("@interactiveplatform/movika-graph-editor").GraphEditChapter | import("@interactiveplatform/movika-graph-editor").GraphViewChapter | undefined;
-export declare function getMedia(media: Media, videoId?: string): import("@interactiveplatform/movika-graph-editor").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;
 }