@vkontakte/videoplayer-interactive 1.0.63-dev.baccd7d5.0 → 1.0.63-dev.ef2fa986.0

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

@@ -1,11 +1,11 @@
-import { type Container } from '#/manifest';
+import { type Container } from "../../../manifest";
 export type Subject = {
-    id: string;
-    isRemoved: boolean;
+	id: string;
+	isRemoved: boolean;
 };
 export type InteractiveRange = {
-    subjects: Subject[];
-    range: [number, number];
+	subjects: Subject[];
+	range: [number, number];
 };
 export type InteractiveRanges = Array<InteractiveRange>;
 export declare const getInteractiveRanges: (containers?: Container[]) => InteractiveRanges;

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

@@ -0,0 +1,75 @@
+import { type Control } from "../../../manifest";
+import { type Dimensions } from "../controls";
+export declare const classnamesPrefix = "interactive";
+export declare const controlStylesFallbacks: {
+	textColor: string;
+	textSize: number;
+	textContent: string;
+	roundCorners: number;
+	borderWidth: number;
+	borderWidthRawValue: string;
+	roundCornersRawValue: string;
+	borderColor: string;
+	borderAlpha: number;
+	backgroundColor: string;
+	backgroundAlpha: number;
+	innerSizesDependOn: string;
+	angle: number;
+	shadowColorLight: string;
+	shadowColorDark: string;
+	shadowColorAlpha: number;
+};
+type ControlStylesFallbacks = typeof controlStylesFallbacks;
+export declare enum ALIGN_ITEMS {
+	top = "flex-start",
+	bottom = "flex-end",
+	center = "center"
+}
+export declare enum JUSTIFY_CONTENT {
+	start = "flex-start",
+	end = "flex-end",
+	center = "center"
+}
+export type SetTextPositionStylesProps = {
+	target: HTMLElement;
+	props: Control["props"]["text"] & {
+		alignment: Control["layoutParams"]["alignment"];
+	};
+};
+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;
+	useRawValues?: boolean;
+};
+export declare const setBorderStyles: ({ target, props, fallback, dependsOn, useRawValues }: SetBorderStylesProps) => void;
+type SetShadowStylesProps = {
+	target: HTMLElement;
+	props?: Control["props"];
+	fallback: ControlStylesFallbacks;
+	isDark: boolean;
+	baseDimension: string;
+};
+export declare const setShadowStyles: ({ target, isDark, baseDimension, fallback }: SetShadowStylesProps) => void;
+type SetAngleProps = {
+	target: HTMLElement;
+	fallback: ControlStylesFallbacks;
+	layoutParams: Control["layoutParams"];
+};
+export declare const setAngle: ({ target, layoutParams, fallback }: SetAngleProps) => void;
+export {};

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

@@ -0,0 +1 @@
+export { movikaProjectIdLoader } from "./movikaProjectIdLoader";

package/types/modules/Loaders/movikaProjectIdLoader/index.d.ts

@@ -0,0 +1 @@
+export { movikaProjectIdLoader } from "./movikaProjectIdLoader";

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

@@ -0,0 +1,10 @@
+import type { GetVKVideoParams, VKVideoLoaderInterface } from "./types";
+export declare class CustomVkVideoLoader implements VKVideoLoaderInterface {
+	private _requestData;
+	private _mediaMap;
+	private _abortController;
+	constructor(options: GetVKVideoParams);
+	resolve({ actions, result, errors, ...args }: Record<string, any>): Promise<Promise<Record<string, any>>>;
+	private _transform;
+	private _send;
+}

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

@@ -0,0 +1 @@
+export { CustomVkVideoLoader } from "./CustomVkVideoLoader";

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

@@ -0,0 +1,257 @@
+import type { ManifestVideo, ManifestVideoVariant } from "../../../manifest";
+export type { Extension, Standard } from "../../../manifest";
+export interface GetVKVideoParams {
+	access_token: string;
+	owner_id?: number;
+	videos?: string;
+	album_id?: number;
+	count?: number;
+	offset?: number;
+	extended?: boolean;
+	fields?: string;
+	v: number;
+}
+export interface FullRequestParams {
+	baseURL: string;
+	requestParams: GetVKVideoParams;
+}
+export interface VKVideoLoaderInterface {
+	resolve(arg: Record<string, any>): Promise<Record<string, any>>;
+}
+export type ExtendedManifestVideoVariant = ManifestVideoVariant & {
+	vkVideoModel?: VideoVideoFull;
+};
+export type ExtendedManifestVideo = Omit<ManifestVideo, "variants"> & {
+	variants: ExtendedManifestVideoVariant[];
+};
+/**
+* video.get
+*
+* Returns detailed information about videos.
+*/
+export interface VideoGetParams {
+	/**
+	* ID of the user or community that owns the video(s).
+	*/
+	owner_id?: number;
+	group_id?: number;
+	for_user_id?: number;
+	/**
+	* Video IDs, in the following format: "<owner_id>_<media_id>,<owner_id>_<media_id>", Use a negative value to designate a community ID. Example: "-4363_136089719,13245770_137352259"
+	*/
+	videos?: string;
+	/**
+	* ID of the album containing the video(s).
+	*/
+	album_id?: number;
+	width?: number;
+	/**
+	* Number of videos to return.
+	*/
+	count?: number;
+	/**
+	* Offset needed to return a specific subset of videos.
+	*/
+	offset?: number;
+	need_privacy?: 0 | 1;
+	need_embed?: 0 | 1;
+	/**
+	* '1' - to return an extended response with additional fields
+	*/
+	extended?: 0 | 1;
+	fields?: string;
+	device_id?: string;
+	ok_session_key?: string;
+	united_video_only?: 0 | 1;
+	ok_client_params?: string;
+}
+export interface VideoGetResponse {
+	/**
+	* Total number
+	*/
+	[key: string]: unknown;
+	count: number;
+	items: VideoVideoFull;
+}
+export interface VideoVideoFull {
+	[key: string]: any;
+	/**
+	* List of video episodes with timecodes
+	*/
+	episodes?: VideoEpisode[];
+	qualities_info?: VideoQualityInfo[];
+	/**
+	* Video duration in seconds
+	*/
+	duration?: number;
+	image?: VideoVideoImage[];
+	first_frame?: VideoVideoImage[];
+	files?: VideoVideoFiles;
+	trailer?: VideoVideoFiles;
+	timeline_thumbs?: VideoTimelineThumbs;
+}
+export interface VideoVideoFiles {
+	/**
+	* URL of the external player
+	*/
+	external?: string;
+	/**
+	* URL of the mpeg4 file with 144p quality
+	*/
+	mp4_144?: string;
+	/**
+	* URL of the mpeg4 file with 240p quality
+	*/
+	mp4_240?: string;
+	/**
+	* URL of the mpeg4 file with 360p quality
+	*/
+	mp4_360?: string;
+	/**
+	* URL of the mpeg4 file with 480p quality
+	*/
+	mp4_480?: string;
+	/**
+	* URL of the mpeg4 file with 720p quality
+	*/
+	mp4_720?: string;
+	/**
+	* URL of the mpeg4 file with 1080p quality
+	*/
+	mp4_1080?: string;
+	/**
+	* URL of the mpeg4 file with 2K quality
+	*/
+	mp4_1440?: string;
+	/**
+	* URL of the mpeg4 file with 4K quality
+	*/
+	mp4_2160?: string;
+	/**
+	* URL of the flv file with 320p quality
+	*/
+	flv_320?: string;
+	/**
+	* Instant streaming mp4 URL
+	*/
+	src?: string;
+	/**
+	* Live stream URL
+	*/
+	live?: string;
+	/**
+	* HLS playlist URL
+	*/
+	hls?: string;
+	/**
+	* RTMP stream URL
+	*/
+	rtmp?: string;
+	/**
+	* OKMP RTMP stream URL
+	*/
+	okmp_rtmp?: string;
+	/**
+	* WebSocket stream URL
+	*/
+	ws?: string;
+	/**
+	* CMAF stream URL
+	*/
+	cmaf?: string;
+	/**
+	* DASH manifest URL
+	*/
+	dash_uni?: string;
+	/**
+	* Separated DASH manifest URL
+	*/
+	dash_sep?: string;
+	/**
+	* VP9 DASH manifest URL
+	*/
+	dash_webm?: string;
+	/**
+	* HEVC DASH manifest URL
+	*/
+	dash_hevc?: string;
+	/**
+	* VP9 DASH manifest URL live
+	*/
+	dash_webm_live?: string;
+	/**
+	* HLS live playback URL
+	*/
+	hls_live_playback?: string;
+	/**
+	* DASH live playback URL
+	*/
+	dash_live_playback?: string;
+	/**
+	* HLS ondemand URL
+	*/
+	hls_ondemand?: string;
+	/**
+	* DASH ondemand URL
+	*/
+	dash_ondemand?: string;
+	/**
+	* Failover host
+	*/
+	failover_host?: string;
+	/**
+	* UV migration location info
+	*/
+	united_migration_location?: string;
+	/**
+	* UV migration video size in location
+	*/
+	united_migration_size?: number;
+}
+export interface VideoQualityInfo {
+	/**
+	* Size of video: 144, 240, 360 and etc
+	*/
+	quality?: number;
+	/**
+	* List of quality features
+	*/
+	params?: Array<"neurohd">;
+}
+export interface VideoEpisode {
+	/**
+	* Seconds from start of the video
+	*/
+	time?: number;
+	/**
+	* Description of episode
+	*/
+	text?: string;
+}
+export interface VideoTimelineThumbs {
+	count_per_image?: number;
+	count_per_row?: number;
+	count_total?: number;
+	frame_height?: number;
+	frame_width?: number;
+	links?: string[];
+	is_uv?: boolean;
+	frequency?: number;
+}
+export interface VideoVideoImage {
+	id?: string;
+	/**
+	* Image url
+	*/
+	url: string;
+	/**
+	* Image width
+	*/
+	width: number;
+	/**
+	* Image height
+	*/
+	height: number;
+	theme?: "light" | "dark";
+	with_padding?: 1;
+}

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

@@ -1,3 +1,3 @@
-import type { FullRequestParams, VideoVideoImage } from './types';
+import type { FullRequestParams, VideoVideoImage } from "./types";
 export declare function createRequestURL({ baseURL, requestParams }: FullRequestParams): string;
 export declare function findMaxResolutionFrame(frames?: VideoVideoImage[]): VideoVideoImage | undefined;

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

@@ -1,12 +1,12 @@
-type LoaderTypes = 'chapterLoaders' | 'manifestLoaders';
+type LoaderTypes = "chapterLoaders" | "manifestLoaders";
 export type Loaders = Record<LoaderTypes, AnyFn[]>;
 interface ILoadable {
-    exec(type: LoaderTypes, inputArg: Record<string, any>): Promise<any>;
+	exec(type: LoaderTypes, inputArg: Record<string, any>): Promise<any>;
 }
 export declare class Loadable implements ILoadable {
-    loaders: Loaders;
-    constructor(loaders: Partial<Loaders>);
-    exec(type: LoaderTypes, inputArg: Record<string, any>): Promise<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>>;
 export declare function defaultLoader({ actions, errors, chapterId, ...args }: Record<string, any>): Record<string, any>;

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

@@ -0,0 +1,34 @@
+import type { IValueSubject, Nullable } from "@vkontakte/videoplayer-shared";
+import type { ChapterBranch, ManifestVideo, Chapter, Manifest, GraphEditChapter, GraphViewChapter, AnyManifest } from "../../manifest";
+import { Loadable, type Loaders } from "./Loadable";
+type BranchesData = {
+	chapter: Chapter;
+	graph: GraphEditChapter | GraphViewChapter | undefined;
+	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>;
+	onError: (err: unknown) => void;
+	constructor(loaders: Partial<Loaders>, onError: (err: unknown) => void);
+	release(): this;
+	setManifest(source: AnyManifest | string): Promise<ManifestController>;
+	setInitial(): Promise<ManifestController>;
+	setNext(chapterId?: string | undefined): Promise<ManifestController>;
+	errorHandler(errors: unknown): void;
+	getInitial(): Nullable<BranchesData>;
+	getByChapterId(chapterId?: string | undefined): Nullable<BranchesData>;
+	getBranches(chapterId?: string | undefined): BranchesData[];
+	getByBranches(branches?: ChapterBranch[]): BranchesData[];
+	getCurrent(): {
+		chapter: Nullable<Chapter>;
+		media: Nullable<ManifestVideo>;
+		graph: Nullable<Manifest["graph"]>;
+	};
+	isInitialChapter(): boolean;
+	isEndChapter(): boolean;
+}
+export {};

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

@@ -0,0 +1 @@
+export { ManifestController } from "./ManifestController";

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

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

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

@@ -0,0 +1,15 @@
+import type { ISubscription } from "@vkontakte/videoplayer-shared";
+import type { IPlayer } from "@vkontakte/videoplayer-core";
+import type { IOneStat } from "@vkontakte/videoplayer-statistics";
+export interface InstanceStatistics {
+	oneStat: IOneStat;
+	statSubscription: ISubscription;
+}
+export interface Instance {
+	[key: string]: any;
+	container: HTMLElement;
+	player: IPlayer;
+	subscription: ISubscription;
+	statistics?: InstanceStatistics;
+}
+export default function InstanceManager(): Record<string, any>;

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

@@ -0,0 +1,33 @@
+import type { IConfig, IPlayer, PlaybackRate, VideoQuality } from "@vkontakte/videoplayer-core";
+import type { Nullable } from "@vkontakte/videoplayer-shared";
+import { ValueSubject } from "@vkontakte/videoplayer-shared";
+import type { ManifestVideo, Extension } from "../../manifest";
+import type { Interactives } from "../Interactives";
+import { type InstanceStatistics } from "./InstanceManager";
+import type { Instance } from "./InstanceManager";
+interface CreatePlayerParams extends Omit<IConfig, "sources" | "container"> {
+	media: ManifestVideo;
+	chapterId: string;
+	prefetch?: boolean;
+	setAsActive?: boolean;
+	autoplay?: boolean;
+	preferredExt?: Array<Extension>;
+	quality?: VideoQuality;
+	playbackRate?: PlaybackRate;
+	title?: string;
+}
+export type ActivePlayer = Nullable<Pick<Instance, "player" | "config" | "statistics">>;
+export default function SeamlessController(interactiveController?: Interactives): {
+	map: Map<string, Record<string, Instance>>;
+	createPlayer: (params: CreatePlayerParams) => Promise<{
+		player: IPlayer;
+		config: IConfig;
+		statistics: Nullable<InstanceStatistics>;
+	}>;
+	removePlayer: (listId: string, itemId?: string) => void;
+	removeAll: () => void;
+	init: () => Promise<void>;
+	setInteractiveController: (instance: Interactives) => void;
+	getActivePlayer: () => Record<string, unknown>;
+	activePlayerChanged: ValueSubject<ActivePlayer>;
+};

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

@@ -0,0 +1,9 @@
+import type { IPlayer, ISources } from "@vkontakte/videoplayer-core";
+import type { ManifestVideo, Extension } from "../../manifest";
+import type { VideoQuality } from "@vkontakte/videoplayer-core";
+export declare function genPlayerCfgVideoData(mediaObj: ManifestVideo, allowList?: Array<Extension>): {
+	sources: ISources;
+	thumbUrl?: string | null;
+	title: string;
+};
+export declare const setVideoQuality: (player: IPlayer, quality: VideoQuality) => void;

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

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

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

@@ -0,0 +1 @@
+export { SeekToInteractiveController } from "./SeekToInteractiveController";

package/types/types/CustomError.d.ts

@@ -0,0 +1,13 @@
+export declare enum ErrorSeverityEnum {
+	RECOVERABLE = 1,
+	CRITICAL = 2
+}
+export declare enum ErrorCategoryEnum {
+	VIDEO = 0,
+	INTERACTIVES = 1,
+	GRAPH = 2,
+	MANIFEST = 3,
+	LOADERS = 4,
+	HISTORY = 5,
+	SEAMLESS = 6
+}

package/types/types/index.d.ts

@@ -0,0 +1,2 @@
+export type * from "./dom";
+export * from "./CustomError";

package/types/utils/CssVarsManager.d.ts

@@ -0,0 +1,23 @@
+export declare class CssVarsManager {
+	rootElement: HTMLElement;
+	private readonly isCssVarsSupported;
+	private rootElementProps;
+	constructor(rootElement: HTMLElement);
+	private static checkCssVarsSupport;
+	/**
+	* Возвращает значение CSS-переменной или фолбэк из JS.
+	*/
+	getPropValue(propKey: string): string | undefined;
+	/**
+	* Применяет несколько свойств
+	*/
+	setup(props: Record<string, string>): void;
+	/**
+	* Удаляет все сохранённые переменные со стилевого элемента
+	*/
+	cleanup(): void;
+	/**
+	* Применяет одну переменную
+	*/
+	setProp(key: string, value: string): void;
+}

package/types/utils/Error.d.ts

@@ -0,0 +1,8 @@
+import type { ErrorSeverityEnum, ErrorCategoryEnum } from "../types";
+export declare class CustomError {
+	severity: ErrorSeverityEnum;
+	category: ErrorCategoryEnum;
+	data: unknown;
+	constructor(severity: ErrorSeverityEnum, category: ErrorCategoryEnum, ...varArgs: unknown[]);
+	toString(): string;
+}

package/types/utils/EventEmitter.d.ts

@@ -0,0 +1,12 @@
+export declare class EventEmitter {
+	listeners: Record<string, Function[]>;
+	addListener(eventName: string, fn: Function): EventEmitter;
+	on(eventName: string, fn: Function): EventEmitter;
+	once(eventName: string, fn: Function): EventEmitter;
+	off(eventName: string, fn: Function): EventEmitter;
+	reset(): void;
+	removeListener(eventName: string, fn: Function): EventEmitter;
+	emit(eventName: string, ...args: unknown[]): boolean;
+	listenerCount(eventName: string): number;
+	rawListeners(eventName: string): Function[];
+}

package/types/utils/LastFrame.d.ts

@@ -0,0 +1,35 @@
+import type { Chapter } from "../manifest";
+import { LastFrameCanvasAPI } from "./LastFrameCanvasAPI";
+type ConstructorParams = {
+	parentElement: HTMLElement;
+	endOffsetMs?: number;
+	onError: (err?: Error) => void;
+};
+export declare class LastFrame {
+	lastFrameCanvas: LastFrameCanvasAPI;
+	endOffsetMs: number;
+	currentChapter?: Chapter;
+	currentVideoDurationMs: number;
+	rootElement: HTMLElement;
+	private _containerTimeFrameShouldReceived;
+	private _endTimeFrameReceived;
+	private _shouldCallSkip;
+	private _callbacks?;
+	constructor({ parentElement, endOffsetMs, onError }: ConstructorParams);
+	destroy(): void;
+	setVideoDuration(videoDurationMs: number): void;
+	setVideoElement(videoElement: HTMLVideoElement): void;
+	setCurrentChapter(chapter: Chapter): void;
+	show(): void;
+	hide(): void;
+	updateCanvasDimensions(shouldSave?: boolean): Promise<void>;
+	draw(): void;
+	isChapterEndTime(currentTimeMs: number): boolean;
+	isContainerTime(currentTimeMs: number): boolean | undefined;
+	onEachTick: (timeMs?: number) => void;
+	onSeek: () => void;
+	reset(): void;
+	private _onError;
+}
+export declare function waitForMs(waitTimeMs?: number): Promise<unknown>;
+export {};

package/types/utils/LastFrameCanvasAPI.d.ts

@@ -0,0 +1,19 @@
+export declare class LastFrameCanvasAPI {
+	rootElement: HTMLCanvasElement;
+	canvasImgSrc?: CanvasImageSource;
+	private _prevSizeId;
+	constructor();
+	clear(): void;
+	isImageDrawn(): boolean;
+	destroy(): void;
+	show(): void;
+	hide(): void;
+	setCanvasImageSource(canvasImgSrc: CanvasImageSource): void;
+	draw(): void;
+	updateCanvasDimensions(dimensions: {
+		width: number;
+		height: number;
+	}, shouldSave?: boolean): Promise<void>;
+	save(): Promise<HTMLImageElement>;
+	restore(imgEl: HTMLImageElement): void;
+}

package/types/utils/MultiMap.d.ts

@@ -0,0 +1,10 @@
+export declare class MultiMap<T> {
+	map: Record<string, T[]>;
+	push(key: string, value: T): void;
+	get(key: string): T[] | null;
+	getAll(): T[];
+	remove(key: string, value: T): void;
+	clear(): void;
+	keys(): string[];
+	size(): number;
+}

package/types/utils/Raf.d.ts

@@ -0,0 +1,13 @@
+export declare class Raf {
+	raf: number | undefined;
+	fn: VoidFunction | undefined;
+	fns: Array<VoidFunction>;
+	constructor(fn?: VoidFunction);
+	addFn: (fn: VoidFunction, shouldRequest?: boolean) => void;
+	removeFn: (fn: VoidFunction, shouldRequest?: boolean) => void;
+	updateFn: () => void;
+	forceRequestAnimation: () => void;
+	requestAnimation: () => void;
+	cancelAnimation: () => void;
+	release(): void;
+}