@vkontakte/videoplayer-interactive 1.0.34 → 1.0.35-beta.1

package/types/modules/Graph/Graph.d.ts

@@ -1,4 +1,4 @@
-import { type InterfaceLanguage } from '@vkontakte/videoplayer-shared';
+import { type InterfaceLanguage, Nullable } from '@vkontakte/videoplayer-shared';
 import type { VideoInfo } from '../../modules/Interactives';
 import type { GraphEditor } from '@interactiveplatform/movika-graph-editor';
 import type { Chapter, Manifest } from '../../manifest';

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

@@ -1,4 +1,4 @@
-import { Observable, ValueSubject } from '@vkontakte/videoplayer-shared';
+import { Observable, ValueSubject, Nullable } from '@vkontakte/videoplayer-shared';
 import type { Chapter, Manifest, AnyManifest } from '../../manifest';
 import { type GlobalEvents } from './utils/events';
 import { type InteractiveRange } from './utils/getInteractiveRanges';
@@ -34,6 +34,7 @@ export declare class Interactives {
     private graph;
     private lastFrame;
     private noInteractionTimeout;
+    private blinkAnimationRef;
     appState: INTERACTIVE_APP_STATES;
     state: {
         prevChapter$: ValueSubject<Nullable<Chapter>>;
@@ -70,6 +71,8 @@ export declare class Interactives {
     private handleFakeRemoval;
     private clearNoInteractionTimeout;
     private reset;
+    private toggleBlinkAnimation;
+    private updateControlsShadowStyles;
     get options(): IInteractiveOptions;
     init(): void;
     setManifest(manifest: AnyManifest | string): Promise<Manifest | undefined>;

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

@@ -1,13 +1,18 @@
+import { Subject } from '@vkontakte/videoplayer-shared';
 import { Container } from './Container';
 import { ChapterContainer } from '../../../manifest';
 import type { ChoiceContainerOptions, ContainerCreateViewParams } from './types';
+import { CustomError } from '../../../utils/Error';
+import { Nullable } from '@vkontakte/videoplayer-shared';
 export declare const createChoiceContainer: (container: ChapterContainer, rootElement: HTMLElement, options?: ChoiceContainerOptions) => ChoiceContainer | undefined;
 export declare class ChoiceContainer extends Container {
     private rootElement;
     private containerElement;
     private layout;
+    private controlSubscriptions;
     isRemoved: boolean;
     isDisabled: boolean;
+    error$: Subject<CustomError>;
     constructor(container: ChapterContainer, rootElement: HTMLElement, options?: ChoiceContainerOptions);
     createView({ eventCallback }: ContainerCreateViewParams): HTMLElement;
     hide(): void;
@@ -19,4 +24,6 @@ export declare class ChoiceContainer extends Container {
     getElement(): Nullable<HTMLElement>;
     onProgress(currentTimeMs: number, isInteractiveTime: boolean): void;
     onResize(isInteractiveTime: boolean): void;
+    updateControlsShadowStyles(isDark?: boolean): void;
+    toggleBlinkAnimation(enable?: boolean): void;
 }

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

@@ -7,7 +7,7 @@ export declare class Container {
     private factories;
     controls: Control[];
     constructor(container: ChapterContainer, options?: Options);
-    featureIsEnabled(name: keyof ChoiceContainerOptions['features']): false | undefined;
+    featureIsEnabled(name: keyof ChoiceContainerOptions['features']): boolean | undefined;
     addControlFactory(type: string, factory: ControlCreator<any>): void;
     removeControlFactory(type: string): void;
     private setControls;

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

@@ -1,7 +1,7 @@
 import { Options, ControlEventCallback } from '../controls';
 import { AnimationsFeatureToggles } from '../types';
 export type ChoiceContainerOptions = {
-    features: Pick<AnimationsFeatureToggles, never>;
+    features: Pick<AnimationsFeatureToggles, 'controlsExpectTimeBlinkAnimation'>;
 };
 export declare function isChoiceContainerOptions(options: Options): options is ChoiceContainerOptions;
 export type ContainerCreateViewParams = {

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

@@ -4,9 +4,15 @@ export declare const createAreaControl: ControlCreator<ControlOptions, AreaContr
 declare class AreaControl extends Control {
     constructor(control: TControl, options?: ControlOptions);
     createView({ parentElement, callbacks }: ControlCreateViewParams): void;
+    registerEvents(): void;
     disable(): void;
     enable(): void;
-    getElement(): Nullable<HTMLElement>;
+    getElement(): import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
+    updateShadowStyles(isDark?: boolean): void;
+    toggleBlinkAnimation(enable?: boolean): void;
+    syncBlinkAnimation(refAnim: HTMLElement): void;
+    onBlinkHovering(): void;
+    onError(message: string | undefined, error: unknown): void;
     onProgress(): void;
     onResize(): void;
 }

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

@@ -4,10 +4,16 @@ export declare const createButtonControl: ControlCreator<ControlOptions, ButtonC
 declare class ButtonControl extends Control {
     constructor(control: TControl, options?: ControlOptions);
     createView({ parentElement, callbacks }: ControlCreateViewParams): void;
+    registerEvents(): void;
     disable(): void;
     enable(): void;
-    getElement(): Nullable<HTMLElement>;
+    getElement(): import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
+    toggleBlinkAnimation(enable?: boolean): void;
+    syncBlinkAnimation(refAnim: HTMLElement): void;
+    onBlinkHovering(): void;
+    onError(message: string | undefined, error: unknown): void;
     onProgress(): void;
     onResize(): void;
+    updateShadowStyles(): void;
 }
 export {};

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

@@ -1,4 +1,7 @@
+import { Subject, Subscription } from '@vkontakte/videoplayer-shared';
 import type { ControlEventCallback, ControlCreateViewParams, Dimensions, Callbacks, Options, TControl, ControlOptions } from './types';
+import { CustomError } from '../../../utils/Error';
+import { Nullable } from '@vkontakte/videoplayer-shared';
 type ControlContainer = {
     element: HTMLElement;
     dimensions: Dimensions;
@@ -9,7 +12,8 @@ export declare abstract class Control {
     options?: Options | undefined;
     container: Nullable<ControlContainer>;
     controlElement: Nullable<HTMLElement>;
-    clickListener: Nullable<ClickListener>;
+    subscriptions: Subscription;
+    error$: Subject<CustomError>;
     constructor(control: TControl, options?: Options | undefined);
     abstract createView(params: ControlCreateViewParams): void;
     abstract getElement(): Nullable<HTMLElement>;
@@ -17,9 +21,12 @@ export declare abstract class Control {
     abstract enable(): void;
     abstract onProgress(currentTimeMs: number): void;
     abstract onResize(): void;
+    abstract onError(message: string, error?: string | Error | CustomError): void;
+    abstract updateShadowStyles(isDark?: boolean): void;
+    abstract toggleBlinkAnimation(enable?: boolean): void;
     createContainerElement(callbacks: Callbacks): void;
     createClickListener(callback: AnyFn): ClickListener;
-    featureIsEnabled(name: keyof ControlOptions['features']): false | undefined;
+    featureIsEnabled(name: keyof ControlOptions['features']): boolean | undefined;
     setEvents(callback: ControlEventCallback): void;
     removeListeners(): void;
 }

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

@@ -4,10 +4,13 @@ export declare const createTextControl: ControlCreator<ControlOptions, TextContr
 declare class TextControl extends Control {
     constructor(control: TControl, options?: ControlOptions);
     createView({ parentElement, callbacks }: ControlCreateViewParams): void;
-    getElement(): Nullable<HTMLElement>;
+    getElement(): import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
     disable(): void;
     enable(): void;
     onProgress(): void;
     onResize(): void;
+    updateShadowStyles(): void;
+    toggleBlinkAnimation(): void;
+    onError(): void;
 }
 export {};

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

@@ -21,7 +21,7 @@ export type ControlCreateViewParams = {
 };
 export type Options = Record<string, unknown>;
 export type ControlOptions = {
-    features: Pick<AnimationsFeatureToggles, never>;
+    features: Pick<AnimationsFeatureToggles, 'controlsExpectTimeBlinkAnimation'>;
 };
 export declare function isControlOptions(options: Options): options is ControlOptions;
 type ControlEventCallbackParams = {

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

@@ -1,9 +1,13 @@
 export declare const CONTROLS_CLASSNAME_PREFIX = "interactive-control";
 export declare const controlsClassNames: {
     common: string;
+    selected: string;
     wrapper: string;
     disabled: string;
     button: string;
     area: string;
     text: string;
+    blinkAnim: string;
+    blinkAnimButton: string;
+    blinkAnimArea: string;
 };

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

@@ -9,43 +9,57 @@ export declare const utils: {
     createChoiceContainer: (container: import("@interactiveplatform/movika-manifest").ChapterContainer, rootElement: HTMLElement, options?: import("./containers/types").ChoiceContainerOptions) => import("./containers/ChoiceContainer").ChoiceContainer | undefined;
     createAreaControl: import("./controls").ControlCreator<import("./controls").ControlOptions, {
         createView({ parentElement, callbacks }: import("./controls").ControlCreateViewParams): void;
+        registerEvents(): void;
         disable(): void;
         enable(): void;
-        getElement(): Nullable<HTMLElement>;
+        getElement(): import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
+        updateShadowStyles(isDark?: boolean): void;
+        toggleBlinkAnimation(enable?: boolean): void;
+        syncBlinkAnimation(refAnim: HTMLElement): void;
+        onBlinkHovering(): void;
+        onError(message: string | undefined, error: unknown): void;
         onProgress(): void;
         onResize(): void;
-        container: Nullable<{
+        container: import("@vkontakte/videoplayer-shared").Nullable<{
             element: HTMLElement;
             dimensions: import("./controls").Dimensions;
         }>;
-        controlElement: Nullable<HTMLElement>;
-        clickListener: Nullable<(event: MouseEvent) => void>;
+        controlElement: import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
+        subscriptions: import("@vkontakte/videoplayer-shared").Subscription;
+        error$: import("@vkontakte/videoplayer-shared").Subject<import("../..").CustomError>;
         control: import("@interactiveplatform/movika-manifest/dist/chapter-DI_7rDZW").e;
-        options?: import("./controls").Options;
+        options?: import("./controls").Options | undefined;
         createContainerElement(callbacks: import("./controls").Callbacks): void;
         createClickListener(callback: AnyFn): (event: MouseEvent) => void;
-        featureIsEnabled(name: keyof import("./controls").ControlOptions["features"]): false | undefined;
+        featureIsEnabled(name: keyof import("./controls").ControlOptions["features"]): boolean | undefined;
         setEvents(callback: import("./controls").ControlEventCallback): void;
         removeListeners(): void;
     }>;
     createButtonControl: import("./controls").ControlCreator<import("./controls").ControlOptions, {
         createView({ parentElement, callbacks }: import("./controls").ControlCreateViewParams): void;
+        registerEvents(): void;
         disable(): void;
         enable(): void;
-        getElement(): Nullable<HTMLElement>;
+        getElement(): import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
+        toggleBlinkAnimation(enable?: boolean): void;
+        syncBlinkAnimation(refAnim: HTMLElement): void;
+        onBlinkHovering(): void;
+        onError(message: string | undefined, error: unknown): void;
         onProgress(): void;
         onResize(): void;
-        container: Nullable<{
+        updateShadowStyles(): void;
+        container: import("@vkontakte/videoplayer-shared").Nullable<{
             element: HTMLElement;
             dimensions: import("./controls").Dimensions;
         }>;
-        controlElement: Nullable<HTMLElement>;
-        clickListener: Nullable<(event: MouseEvent) => void>;
+        controlElement: import("@vkontakte/videoplayer-shared").Nullable<HTMLElement>;
+        subscriptions: import("@vkontakte/videoplayer-shared").Subscription;
+        error$: import("@vkontakte/videoplayer-shared").Subject<import("../..").CustomError>;
         control: import("@interactiveplatform/movika-manifest/dist/chapter-DI_7rDZW").e;
-        options?: import("./controls").Options;
+        options?: import("./controls").Options | undefined;
         createContainerElement(callbacks: import("./controls").Callbacks): void;
         createClickListener(callback: AnyFn): (event: MouseEvent) => void;
-        featureIsEnabled(name: keyof import("./controls").ControlOptions["features"]): false | undefined;
+        featureIsEnabled(name: keyof import("./controls").ControlOptions["features"]): boolean | undefined;
         setEvents(callback: import("./controls").ControlEventCallback): void;
         removeListeners(): void;
     }>;

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

@@ -0,0 +1 @@
+export * from './utils';

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

@@ -4,11 +4,7 @@ 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';
-export type VideoInfo = {
-    id: string;
-    cover: string;
-    title?: string;
-};
+export type { VideoInfo } from '@interactiveplatform/movika-graph-editor';
 export type InteractiveProjectInfo = {
     videoId: string;
     pid?: string;
@@ -19,7 +15,10 @@ export type RequiredOptions = 'parentElement' | 'fullscreenTargetElement';
 export type IOptionalInteractiveOptions = Partial<Omit<IInteractiveOptions, RequiredOptions | 'config'>> & Required<Pick<IInteractiveOptions, RequiredOptions>> & {
     config?: Partial<IInteractiveOptions['config']>;
 };
-export type AnimationsFeatureToggles = {};
+export type AnimationsFeatureToggles = Partial<{
+    areaControlShadow: boolean;
+    controlsExpectTimeBlinkAnimation: boolean;
+}>;
 export interface IInteractiveOptions {
     parentElement: HTMLElement;
     fullscreenTargetElement: HTMLElement;
@@ -45,7 +44,7 @@ export interface IInteractiveOptions {
      * @deprecated
      * */
     disableControlsOnPause?: boolean;
-    animationFeatureToggles?: AnimationsFeatureToggles;
+    animationsFeatureToggles?: AnimationsFeatureToggles;
 }
 export type ChapterChangedData = {
     chapter: Chapter;

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

@@ -0,0 +1,15 @@
+export declare const BLINK_ANIM_CLASSNAME_PREFIX = "interactive-blink-anim-reference";
+export declare const blinkAnimClassNames: {
+    common: string;
+    animation: string;
+    disabled: string;
+};
+export declare class BlinkAnimationRef {
+    private _RAFId;
+    private _element;
+    get element(): HTMLDivElement | undefined;
+    create(): void;
+    restart(): void;
+    private cleanupRAF;
+    destroy(): void;
+}

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

@@ -3,6 +3,7 @@ import { type IPlayer } from '@vkontakte/videoplayer-core';
 import type { InteractiveEventsType } from './InteractiveEvents';
 import type { ChapterBranch } from '../../../manifest';
 import type { EventEmitter } from '../../../utils/EventEmitter';
+import { CustomError } from '../../../utils/Error';
 import type { SelectBranchesType } from './SelectBranches';
 import type { IgnoreExpectState } from '../../../modules/Interactives/types';
 import type { ChoiceContainer } from '../../../modules/Interactives/containers';
@@ -21,6 +22,7 @@ type ConstructorArg = {
     interactiveTimeOpenUri: boolean;
     disabledControls$: IValueSubject<boolean>;
     onRemove: () => void;
+    onError: (error: CustomError) => void;
 };
 export declare class GameController {
     container: ChoiceContainer;
@@ -39,7 +41,8 @@ export declare class GameController {
     isSelectedControlEvent: boolean;
     isSelectedContainerEvent: boolean;
     globalEvents: GlobalEvents;
-    constructor({ player, container, branches, selectBranches, interactiveEvents, globalEvents, globalEventEmitter, getContainerEventState, permanentTextControls, interactiveTimeOpenUri, disabledControls$, onRemove, }: ConstructorArg);
+    onError: ConstructorArg['onError'];
+    constructor({ player, container, branches, selectBranches, interactiveEvents, globalEvents, globalEventEmitter, getContainerEventState, permanentTextControls, interactiveTimeOpenUri, disabledControls$, onRemove, onError, }: ConstructorArg);
     private emitContainerVisibilityEvent;
     registerEvents(): void;
     hide: () => void;
@@ -54,6 +57,8 @@ export declare class GameController {
     reset(): void;
     removeView(): void;
     fakeRemoveView(remove?: boolean): void;
+    updateControlsShadowStyles(isDark?: boolean): void;
+    toggleBlinkAnimation(value: boolean): void;
     destroy(): void;
 }
 export {};

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

@@ -1,4 +1,5 @@
 import type { IPlayer } from '@vkontakte/videoplayer-core';
+import { Nullable } from '@vkontakte/videoplayer-shared';
 type ResizeManagerArg = () => {
     parentElement: HTMLElement;
     player?: Nullable<IPlayer>;

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

@@ -3,6 +3,7 @@ import type { EventEmitter } from '../../../utils/EventEmitter';
 import type { IPlayer } from '@vkontakte/videoplayer-core';
 import type { InteractiveEventsType } from './InteractiveEvents';
 import type { GlobalEvents } from './events';
+import { Nullable } from '@vkontakte/videoplayer-shared';
 export type SubjectName = 'chapter' | 'container' | 'control';
 export type AfterExpectActionType = 'after-expect';
 export type Behaviour = 'change-chapter' | 'change-manifest';

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

@@ -7,11 +7,11 @@ 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: ChapterBranch[]) => ChapterBranch | null;
 /**
  *  Finds the value with maximal weight number
  */
-export declare const maxFallbackStrategy: (branches: ChapterBranch[]) => Nullable<ChapterBranch>;
+export declare const maxFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch | null;
 /**
  *  Finds first branch with `isDefault === true` value
  */

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

@@ -0,0 +1,5 @@
+type Reverse<T extends unknown[]> = T extends [infer First, ...infer Rest] ? [...Reverse<Rest>, First] : T;
+export declare function reverseArgs<Fn extends AnyFn>(fn: Fn): (...args: Reverse<Parameters<Fn>>) => ReturnType<Fn>;
+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 {};

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

@@ -23,7 +23,18 @@ 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>;
+/**
+ * @param {GameController[]} [gameControllers=[]] список контрллеров
+ * @param {(number | null | undefined)} [expectTime=Infinity] expectTime = endTime - какой expectTime мы ищем
+ * @param {string[]} [ignoreIds=[]] какие контейнеры игнорировать
+ */
+export declare function getGameControllerContainersWithExpect(gameControllers?: GameController[], expectTime?: number | null | undefined, ignoreIds?: string[]): GameController[];
+type ExecForAllExpectContainersParamsType = {
+    gameControllers: GameController[];
+    subjectName: string;
+    subjectId: string;
+    execFn: (gameController: GameController) => void;
+};
+export declare function execForAllExpectContainers({ gameControllers, subjectName, subjectId, execFn, }: ExecForAllExpectContainersParamsType): void;
 export declare const evaluateContainerEventStatus: (container: ChapterContainer, gameControllers: GameController[]) => IgnoreExpectState;
 export {};

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

@@ -7,12 +7,17 @@ export declare const controlStylesFallbacks: {
     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 {
@@ -55,8 +60,17 @@ type SetBorderStylesProps = {
     props: Control['props'];
     fallback: ControlStylesFallbacks;
     dependsOn: Dimensions;
+    useRawValues?: boolean;
 };
-export declare const setBorderStyles: ({ target, props, fallback, dependsOn }: SetBorderStylesProps) => void;
+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;

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

@@ -1,4 +1,4 @@
-import type { IValueSubject } from '@vkontakte/videoplayer-shared';
+import type { IValueSubject, Nullable } from '@vkontakte/videoplayer-shared';
 import type { ChapterBranch, ManifestVideo, Chapter, Manifest, GraphEditChapter, GraphViewChapter, AnyManifest } from '../../manifest';
 import { Loadable } from './Loadable';
 type BranchesData = {

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

@@ -1,5 +1,5 @@
 import type { IConfig, PlaybackRate, VideoQuality } from '@vkontakte/videoplayer-core';
-import { ValueSubject } from '@vkontakte/videoplayer-shared';
+import { Nullable, ValueSubject } from '@vkontakte/videoplayer-shared';
 import type { ManifestVideo, Extension } from '../../manifest';
 import type { Interactives } from '../../modules/Interactives';
 import type { Instance } from './InstanceManager';

package/types/utils/typeCheck.d.ts

@@ -8,11 +8,11 @@ export declare enum TypesEnum {
 }
 type TypesEnumKeys = `${TypesEnum}`;
 export declare const isType: (value: unknown, is: TypesEnumKeys) => boolean;
-export declare const isObject: (value: unknown) => value is Object;
+export declare const isObject: (value: unknown) => value is Record<string, unknown>;
 export declare const isString: (value: unknown) => value is string;
 export declare const isArray: (value: unknown) => value is Array<unknown>;
 export declare const isNumber: (value: unknown) => value is number;
-export declare const isFunction: (value: unknown) => value is Function;
+export declare const isFunction: (value: unknown) => value is AnyFn;
 export declare const isBoolean: (value: unknown) => value is boolean;
 export declare const isNotNaNNumber: (value: unknown) => boolean;
 export declare const isNaNNumber: (value: unknown) => boolean;