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

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

@@ -1,54 +1,18 @@
-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;
+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;
     stopExpect: () => void;
     state: {
         isExpect: boolean;

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

@@ -0,0 +1,73 @@
+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';
+export type SubjectName = 'chapter' | 'container' | 'control';
+export type SelectBranchesArg = {
+    globalEventEmitter: EventEmitter;
+    player: IPlayer;
+    interactiveEvents: InteractiveEventsType;
+    removeControllers?: AnyFn;
+};
+export type OnControlEventArg = {
+    action: ControlEvent['action'];
+    controlType: Control['type'];
+    controlId: Control['id'];
+    containerId: ChapterContainer['id'];
+    onEvent: AnyFn;
+    branches?: ChapterBranch[];
+    isEOV?: () => boolean;
+    isDisabled?: () => boolean;
+};
+export type OnContainerEventArg = {
+    action: ContainerEvent['action'];
+    container: ChapterContainer;
+    autoSelected?: boolean;
+    branches?: ChapterBranch[];
+    isEOV?: boolean;
+};
+export type OnChapterEventArg = {
+    action: ChapterEvent['action'];
+    chapterId: string;
+    branches?: ChapterBranch[];
+};
+export type SetManifestContainerEventsArg = {
+    container: ChapterContainer;
+    branches: ChapterBranch[];
+    isEOV?: boolean;
+};
+export type AnyAction = ControlEvent['action'] | ContainerEvent['action'] | ChapterEvent['action'];
+export type ActionMap = {
+    control: ControlEvent['action'];
+    container: ContainerEvent['action'];
+    chapter: ChapterEvent['action'];
+};
+export type SubjectType<T extends keyof ActionMap> = T extends 'control' ? Control['type'] : undefined;
+export type EventActionCommon<T extends keyof ActionMap> = {
+    subjectId: string;
+    subjectName: T;
+    subjectType?: SubjectType<T>;
+};
+export type EventActionCommonWithAction<T extends keyof ActionMap> = EventActionCommon<T> & {
+    action: ActionMap[T];
+};
+export type OpenURIArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
+    payload: {
+        URI?: string;
+    };
+};
+export type ChangeManifestArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
+    payload: {
+        behaviour?: string;
+    };
+};
+export type ChangeChapterArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
+    payload: {
+        chapterId: string;
+        autoSelect: boolean;
+        behaviour?: string;
+    };
+};
+export type ContinuePlaybackArg<T extends keyof ActionMap> = EventActionCommonWithAction<T>;
+export type OnExpectEventArg<T extends keyof ActionMap> = EventActionCommon<T>;
+export type ExpectEventHandlerArg<T extends keyof ActionMap> = EventActionCommon<T>;

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

@@ -1,4 +1,8 @@
 export declare const EVENT_NAMES: {
+    /**
+    * @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$
+    * & interactivesInstance.events.watchAgainIsClicked$
+    */
     readonly graph: "graph";
     readonly interactives: "interactives";
     readonly chapterChanged: "chapter-changed";
@@ -9,6 +13,10 @@ export declare const EVENT_NAMES: {
     readonly historyInited: "history-inited";
     readonly historyDestroyed: "history-destroyed";
 };
+/**
+* @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$ &
+* interactivesInstance.events.watchAgainIsClicked$
+*/
 export declare const graphEventTypes: {
     readonly visibility: "visibility";
     readonly watchAgainClicked: "watchAgainClicked";

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

@@ -1,6 +1,23 @@
-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;
+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;

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

@@ -1,26 +1,28 @@
-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;
+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 {};

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

@@ -1,7 +1,7 @@
-import { type Container } from '../../../movika.core/manifest';
-export type ReduceAccItem = {
+import { type Container } from '../../../manifest';
+export type InteractiveRange = {
     subjects: string[];
     range: [number, number];
 };
-export type ReduceAcc = Array<ReduceAccItem>;
-export declare const getInteractiveRanges: (containers?: Container[]) => ReduceAcc;
+export type InteractiveRanges = Array<InteractiveRange>;
+export declare const getInteractiveRanges: (containers?: Container[]) => InteractiveRanges;

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

@@ -1,62 +1,67 @@
-export const classnamesPrefix: "SDK_NAME";
-export const rootElClassName: "SDK_NAME-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;
+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 namespace ALIGN_ITEMS {
-    let top: string;
-    let bottom: string;
-    let center: string;
+export declare enum JUSTIFY_CONTENT {
+    start = "flex-start",
+    end = "flex-end",
+    center = "center"
 }
-export namespace JUSTIFY_CONTENT {
-    export let start: string;
-    export let end: string;
-    let center_1: string;
-    export { center_1 as center };
+export declare enum TEXT_ALIGN {
+    start = "left",
+    end = "right",
+    center = "center"
 }
-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;
+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 {};

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

@@ -1,14 +1,11 @@
-declare const LoaderTypes: {
-    readonly chapterLoaders: "chapterLoaders";
-    readonly manifestLoaders: "manifestLoaders";
-};
-type LoaderTypes = (typeof LoaderTypes)[keyof typeof LoaderTypes];
+type LoaderTypes = 'chapterLoaders' | 'manifestLoaders';
+export type Loaders = Record<LoaderTypes, Function[]>;
 interface ILoadable {
     exec(type: LoaderTypes, inputArg: Record<string, any>): Promise<any>;
 }
 export declare class Loadable implements ILoadable {
-    loaders: Record<LoaderTypes, any>;
-    constructor(loaders: Record<LoaderTypes, any>);
+    loaders: Loaders;
+    constructor(loaders: Partial<Loaders>);
     exec(type: LoaderTypes, inputArg: Record<string, any>): Promise<any>;
 }
 export declare function addErrorMessage(errObj: Record<string, Array<string>> | null, loaderName: string, message: string): Record<string, Array<string>>;

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

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

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

@@ -1,12 +1,12 @@
-import type { Manifest, LatestManifest, Media, Chapter } from '../../movika.core/manifest';
+import type { Manifest, AnyManifest, Media, Chapter } from '../../manifest';
 type ManifestInfo = {
-    manifest: Manifest;
+    manifest: AnyManifest;
     manifestURL: string;
 };
-export declare const convertToObject: (manifest: Manifest | string) => Promise<Partial<ManifestInfo>>;
-export declare function fetchManifest(manifest: Manifest): Promise<LatestManifest>;
+export declare const convertToObject: (manifest: AnyManifest | string) => Promise<Partial<ManifestInfo>>;
+export declare function fetchManifest(manifest: AnyManifest | string): Promise<Manifest>;
 export declare function getInitialChapter(manifest: any): Chapter | undefined;
 export declare function getChapter(chapters: Chapter[], chapterId?: string): Chapter | 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 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 {};

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

@@ -1,32 +1,30 @@
 import type { IConfig, PlaybackRate, VideoQuality } from '@vkontakte/videoplayer-core';
-import { EventEmitter } from '../../utils/EventEmitter';
-import type { ManifestVideo, Extensions } from '../../movika.core/manifest';
+import { ValueSubject } from '@vkontakte/videoplayer-shared';
+import type { ManifestVideo, Extension } from '../../manifest';
+import { type Interactives } from '../../modules/Interactives';
+import type { Instance } from './InstanceManager';
 interface CreatePlayerParams extends Omit<IConfig, 'sources' | 'container'> {
     media: ManifestVideo;
     chapterId: string;
     prefetch?: boolean;
     setAsActive?: boolean;
     autoplay?: boolean;
-    preferredExt?: Array<Extensions>;
+    preferredExt?: Array<Extension>;
     quality?: VideoQuality;
     playbackRate?: PlaybackRate;
     title?: string;
 }
-export declare const SEAMLESS_CONTROLLER_EVENTS: {
-    activePlayerChanged: string;
-    playerCreated: string;
-};
-export default function SeamlessController(interactiveController?: Record<string, any>): {
-    on: (eventName: string, fn: Function) => EventEmitter;
-    off: (eventName: string, fn: Function) => EventEmitter;
+export type ActivePlayer = Nullable<Pick<Instance, 'player' | 'config' | 'statistics'>>;
+export default function SeamlessController(interactiveController?: Interactives): {
     init: () => Promise<void>;
-    setInteractiveController: (instance: Record<string, any>) => void;
-    createPlayer: ({ media, chapterId, prefetch, setAsActive, autoplay, preferredExt, title, playbackRate }: CreatePlayerParams) => Promise<{
+    setInteractiveController: (instance: Interactives) => void;
+    createPlayer: ({ media, chapterId, prefetch, setAsActive, autoplay, preferredExt, title, playbackRate, }: CreatePlayerParams) => Promise<{
         player: any;
         config: any;
         statistics: any;
     }>;
     removeAll: () => void;
     getActivePlayer: () => Record<string, any>;
+    activePlayerChanged: ValueSubject<ActivePlayer>;
 };
 export {};

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

@@ -1,7 +1,7 @@
 import type { IPlayer, ISources } from '@vkontakte/videoplayer-core';
-import type { ManifestVideo, Extensions } from '../../movika.core/manifest';
+import type { ManifestVideo, Extension } from '../../manifest';
 import { VideoQuality } from '@vkontakte/videoplayer-core';
-export declare function genPlayerCfgVideoData(mediaObj: ManifestVideo, allowList?: Array<Extensions>): {
+export declare function genPlayerCfgVideoData(mediaObj: ManifestVideo, allowList?: Array<Extension>): {
     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 { ChapterContainers } from '../../movika.core/manifest/types';
+import type { ChapterContainer } from '../../manifest';
 export declare class SeekToInteractiveController {
     private _containers;
     private _player;
     setPlayer: (player: IPlayer) => void;
-    setContainers: (containers: ChapterContainers) => void;
+    setContainers: (containers: ChapterContainer[]) => void;
     deleteContainer: (id: string) => void;
     getNextInteractiveTime: (offsetMs?: number) => number | null;
 }

package/types/utils/EventManager.d.ts

@@ -1,12 +1,12 @@
 import { Binding } from './Binding';
 import { MultiMap } from './MultiMap';
 import type { HtmlEventType } from '../types';
-type OptionsType = undefined | boolean | AddEventListenerOptions;
+type OptionsType = boolean | AddEventListenerOptions;
 export declare class EventManager {
     bindingMap: MultiMap<Binding> | null;
     release(): void;
-    listen(target: Element, type: HtmlEventType, listener: EventListener, options: OptionsType): void;
-    listenOnce(target: Element, type: HtmlEventType, listener: EventListener, options: OptionsType): void;
+    listen(target: Element, type: HtmlEventType, listener: EventListener, options?: OptionsType): void;
+    listenOnce(target: Element, type: HtmlEventType, listener: EventListener, options?: OptionsType): void;
     unlisten(target: Element, type: HtmlEventType, listener: EventListener): void;
     removeAll(): void;
 }

package/types/utils/LastFrame.d.ts

@@ -1,4 +1,4 @@
-import type { Chapter } from '../movika.core/manifest';
+import type { Chapter } from '../manifest';
 import { LastFrameCanvasAPI } from './LastFrameCanvasAPI';
 type ConstructorParams = {
     parentElement: HTMLElement;

package/types/utils/Raf.d.ts

@@ -2,7 +2,7 @@ export declare class Raf {
     raf: number | undefined;
     fn: VoidFunction | undefined;
     fns: Array<VoidFunction>;
-    constructor(fn: VoidFunction);
+    constructor(fn?: VoidFunction);
     addFn: (fn: VoidFunction, shouldRequest?: boolean) => void;
     removeFn: (fn: VoidFunction, shouldRequest?: boolean) => void;
     updateFn: () => void;

package/types/utils/chapterHelpers.d.ts

@@ -1,4 +1,4 @@
-import type { Manifest, ManifestVideoVariant, ManifestVideo, VideoId } from '../movika.core/manifest';
+import type { Manifest, ManifestVideoVariant, ManifestVideo, VideoId } from '../manifest';
 export declare const chapterIdsToVKVideoIds: (chapterIds: string[], interactiveManifest: Manifest) => number[];
 export declare const getVideoRawIdByMedia: (mediaVideo: ManifestVideo) => string | undefined;
 export declare const isVKVariantItem: (variantItem: ManifestVideoVariant) => boolean;

package/types/utils/extractVkMovieId.d.ts

@@ -1,2 +1,2 @@
-import type { ManifestVideo } from '../movika.core/manifest';
-export declare const extractVkMovieId: (media: ManifestVideo) => string[];
+import type { ManifestVideo } from '../manifest';
+export declare const extractVkMovieId: (media: ManifestVideo) => [] | [string, string];

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

@@ -1,5 +0,0 @@
-export namespace CONTROLLER_IDS {
-    let AREA: string;
-    let TEXT: string;
-    let BUTTON: string;
-}