figureone 0.15.10 → 1.0.1

package/types/js/figure/Animation/Animation.d.ts

@@ -0,0 +1,36 @@
+import type { OBJ_PositionAnimationStep } from './AnimationStep/ElementAnimationStep/PositionAnimationStep';
+import PositionAnimationStep from './AnimationStep/ElementAnimationStep/PositionAnimationStep';
+import type { OBJ_ScenarioAnimationStep, OBJ_ScenariosAnimationStep } from './AnimationStep/ElementAnimationStep/ScenarioAnimationStep';
+import ScenarioAnimationStep from './AnimationStep/ElementAnimationStep/ScenarioAnimationStep';
+import type { OBJ_ColorAnimationStep } from './AnimationStep/ElementAnimationStep/ColorAnimationStep';
+import { ColorAnimationStep, DimAnimationStep, UndimAnimationStep, dim, undim } from './AnimationStep/ElementAnimationStep/ColorAnimationStep';
+import type { OBJ_OpacityAnimationStep } from './AnimationStep/ElementAnimationStep/OpacityAnimationStep';
+import { OpacityAnimationStep, DissolveInAnimationStep, dissolveIn, DissolveOutAnimationStep, dissolveOut } from './AnimationStep/ElementAnimationStep/OpacityAnimationStep';
+import type { OBJ_TransformAnimationStep } from './AnimationStep/ElementAnimationStep/TransformAnimationStep';
+import TransformAnimationStep from './AnimationStep/ElementAnimationStep/TransformAnimationStep';
+import type { OBJ_PulseTransformAnimationStep } from './AnimationStep/ElementAnimationStep/PulseTransformAnimationStep';
+import PulseTransformAnimationStep from './AnimationStep/ElementAnimationStep/PulseTransformAnimationStep';
+import type { OBJ_RotationAnimationStep } from './AnimationStep/ElementAnimationStep/RotationAnimationStep';
+import RotationAnimationStep from './AnimationStep/ElementAnimationStep/RotationAnimationStep';
+import type { OBJ_ScaleAnimationStep } from './AnimationStep/ElementAnimationStep/ScaleAnimationStep';
+import ScaleAnimationStep from './AnimationStep/ElementAnimationStep/ScaleAnimationStep';
+import type { OBJ_PulseAnimationStep } from './AnimationStep/ElementAnimationStep/PulseAnimationStep';
+import PulseAnimationStep from './AnimationStep/ElementAnimationStep/PulseAnimationStep';
+import type { OBJ_TriggerAnimationStep } from './AnimationStep/TriggerStep';
+import { TriggerAnimationStep, trigger } from './AnimationStep/TriggerStep';
+import type { OBJ_CustomAnimationStep } from './AnimationStep/CustomStep';
+import { CustomAnimationStep, custom } from './AnimationStep/CustomStep';
+import type { OBJ_ElementAnimationStep } from './AnimationStep/ElementAnimationStep';
+import type { OBJ_ParallelAnimationStep } from './AnimationStep/ParallelAnimationStep';
+import { ParallelAnimationStep, inParallel } from './AnimationStep/ParallelAnimationStep';
+import type { OBJ_SerialAnimationStep } from './AnimationStep/SerialAnimationStep';
+import { SerialAnimationStep, inSerial } from './AnimationStep/SerialAnimationStep';
+import { DelayAnimationStep, delay } from './AnimationStep/DelayStep';
+import type { OBJ_AnimationStep } from './AnimationStep';
+import AnimationStep from './AnimationStep';
+import type { TypeAnimationManagerInputOptions } from './AnimationManager';
+import AnimationManager from './AnimationManager';
+import type { OBJ_AnimationBuilder } from './AnimationBuilder';
+import AnimationBuilder from './AnimationBuilder';
+export type { OBJ_PositionAnimationStep, OBJ_AnimationBuilder, OBJ_ParallelAnimationStep, OBJ_SerialAnimationStep, OBJ_TransformAnimationStep, OBJ_AnimationStep, OBJ_TriggerAnimationStep, OBJ_ColorAnimationStep, OBJ_CustomAnimationStep, TypeAnimationManagerInputOptions, OBJ_RotationAnimationStep, OBJ_ScaleAnimationStep, OBJ_PulseAnimationStep, OBJ_OpacityAnimationStep, OBJ_ScenarioAnimationStep, OBJ_PulseTransformAnimationStep, OBJ_ElementAnimationStep, OBJ_ScenariosAnimationStep, };
+export { PositionAnimationStep, AnimationBuilder, ParallelAnimationStep, SerialAnimationStep, TransformAnimationStep, AnimationStep, DelayAnimationStep, TriggerAnimationStep, inParallel, inSerial, trigger, delay, ColorAnimationStep, DissolveInAnimationStep, dissolveIn, DissolveOutAnimationStep, dissolveOut, CustomAnimationStep, custom, AnimationManager, RotationAnimationStep, ScaleAnimationStep, PulseAnimationStep, OpacityAnimationStep, DimAnimationStep, dim, UndimAnimationStep, undim, ScenarioAnimationStep, PulseTransformAnimationStep, };

package/types/js/figure/Animation/AnimationBuilder.d.ts

@@ -0,0 +1,173 @@
+import { FigureElement } from '../Element';
+import type { OBJ_Scenario } from '../Element';
+import type { OBJ_SerialAnimationStep } from './AnimationStep/SerialAnimationStep';
+import type { OBJ_PositionAnimationStep, OBJ_ParallelAnimationStep, OBJ_AnimationStep, OBJ_TriggerAnimationStep, OBJ_ColorAnimationStep, OBJ_CustomAnimationStep, OBJ_TransformAnimationStep, OBJ_RotationAnimationStep, OBJ_ScaleAnimationStep, OBJ_PulseAnimationStep, OBJ_OpacityAnimationStep, OBJ_PulseTransformAnimationStep, AnimationStep, OBJ_ScenarioAnimationStep, OBJ_ElementAnimationStep, OBJ_ScenariosAnimationStep } from './Animation';
+import type { TypeParsablePoint, TypeParsableTransform } from '../../tools/g2';
+import * as animation from './Animation';
+import type { TypeColor } from '../../tools/types';
+/**
+ * Animation builder options object
+ * @extends OBJ_SerialAnimationStep
+ * @property {FigureElement} [element]
+ * @interface
+ * @group Misc Animation
+ */
+export type OBJ_AnimationBuilder = {
+    element?: FigureElement;
+    customSteps?: Array<{
+        step: (options: Record<string, any>) => AnimationStep;
+        name: string;
+    }>;
+} & OBJ_SerialAnimationStep;
+/**
+ * Animation Builder
+ *
+ * Convenient way to build animation steps in serial. Each step returns the
+ * same builder object, and so chaining in a fluent like API can be achieved.
+ *
+ * @extends SerialAnimationStep
+ * @see <a href="#animationmanagernew">AnimationManager.new</a>
+ *
+ * @example
+ * p.animations.new()
+ *   .delay(1)
+ *   .position({ target: [1, 0], duration: 2 })
+ *   .delay(1)
+ *   .rotation({ target: Math.PI, duration: 2 })
+ *   .start();
+ * @group Animation
+ */
+export default class AnimationBuilder extends animation.SerialAnimationStep {
+    /**
+     * @hideconstructor
+     */
+    constructor(elementOrOptions?: FigureElement | OBJ_AnimationBuilder, ...options: Array<OBJ_AnimationBuilder>);
+    fnExec(idOrFn: string | Function | null, ...args: any): any;
+    _getStateProperties(): string[];
+    _getStateName(): string;
+    /**
+     * Add a custom animation step that uses this element by default
+     * @param {string | ((number) => void) | OBJ_CustomAnimationStep} callbackOrOptions
+     * @return {AnimationBuilder}
+     */
+    custom(callbackOrOptions: string | ((percent: number) => void) | OBJ_CustomAnimationStep): this;
+    /**
+     * Add a rotation animation step that uses this element by default
+     * @param {OBJ_RotationAnimationStep | number} targetOrOptions
+     * @return {AnimationBuilder}
+     */
+    rotation(targetOrOptions: OBJ_RotationAnimationStep | number, ry?: number | null, rz?: number): this;
+    /**
+     * Add a position animation step that uses this element by default
+     * @param {TypeParsablePoint | OBJ_PositionAnimationStep | number} targetOrOptionsOrX
+     * @param {number} y define if `targetOrOptionsOrX` is x (number)
+     * @return {AnimationBuilder}
+     */
+    position(targetOrOptionsOrX: TypeParsablePoint | OBJ_PositionAnimationStep | number, y?: number, z?: number): this;
+    /**
+     * Add a translation animation step that uses this element by default
+     * @param {TypeParsablePoint | OBJ_PositionAnimationStep | number} targetOrOptionsOrX
+     * @param {number} y define if `targetOrOptionsOrX` is x (number)
+     * @return {AnimationBuilder}
+     */
+    translation(targetOrOptionsOrX: TypeParsablePoint | OBJ_PositionAnimationStep | number, y?: number, z?: number): this;
+    /**
+     * Add a scale animation step that uses this element by default
+     * @param {TypeParsablePoint | OBJ_ScaleAnimationStep | number} targetOrOptionsOrX
+     * when a number is used, it will apply to both x and y if y is null
+     * @param {number | null} y use a number to define the y scale, or use null
+     * to use the `x` value (`null`)
+     * @return {AnimationBuilder}
+     */
+    scale(targetOrOptionsOrX: TypeParsablePoint | OBJ_ScaleAnimationStep | number, y?: null | number, z?: number): this;
+    /**
+     * Add a transform animation step that uses this element by default
+     * @param {OBJ_TransformAnimationStep | TypeParsableTransform} transformOrOptions
+     * @return {AnimationBuilder}
+     */
+    transform(transformOrOptions: OBJ_TransformAnimationStep | TypeParsableTransform): this;
+    pulseTransforms(...options: Array<OBJ_PulseTransformAnimationStep>): this;
+    /**
+     * Add a scenario animation step that uses this element by default
+     * @param {OBJ_ScenarioAnimationStep | OBJ_Scenario | string} scenarioOrOptions
+     * @return {AnimationBuilder}
+     */
+    scenario(scenarioOrOptions: string | OBJ_Scenario | OBJ_ScenarioAnimationStep): this;
+    /**
+     * Add a scenarios animation step that uses this element by default
+     * @param {string | OBJ_ScenariosAnimationStep} scenarioNameOrOptions
+     * @return {AnimationBuilder}
+     */
+    scenarios(scenarioOrOptions: string | OBJ_ScenariosAnimationStep): this;
+    /**
+     * Add a color animation step that uses this element by default
+     * @param {OBJ_ColorAnimationStep | TypeColor} colorOrOptions
+     * @return {AnimationBuilder}
+     */
+    color(colorOrOptions: OBJ_ColorAnimationStep | TypeColor): this;
+    /**
+     * Add an opacity animation step that uses this element by default
+     * @param {OBJ_OpacityAnimationStep | number} opacityOrOptions
+     * @return {AnimationBuilder}
+     */
+    opacity(opacityOrOptions: OBJ_OpacityAnimationStep | number): this;
+    /**
+     * Add an dissolve out animation step that uses this element by default
+     * @param {number | OBJ_ElementAnimationStep} durationOrOptions
+     * @return {AnimationBuilder}
+     */
+    dissolveOut(durationOrOptions?: number | OBJ_ElementAnimationStep): this;
+    /**
+     * Add an dissolve in animation step that uses this element by default
+     * @param {number | OBJ_ElementAnimationStep} durationOrOptions
+     * @return {AnimationBuilder}
+     */
+    dissolveIn(durationOrOptions?: number | OBJ_ElementAnimationStep): this;
+    addStep(animName: string, ...params: Array<any>): this;
+    /**
+     * Add an dim animation step that uses this element by default
+     * @param {OBJ_ElementAnimationStep | number} durationOrOptions
+     * @return {AnimationBuilder}
+     */
+    dim(durationOrOptions?: number | OBJ_ElementAnimationStep): this;
+    /**
+     * Add an undim animation step that uses this element by default
+     * @param {OBJ_ElementAnimationStep | number} durationOrOptions
+     * @return {AnimationBuilder}
+     */
+    undim(durationOrOptions?: number | OBJ_ElementAnimationStep): this;
+    /**
+     * Add a delay animation step
+     * @param {OBJ_AnimationStep | number} delayOrOptions
+     * @return {AnimationBuilder}
+     */
+    delay(delayOrOptions?: number | OBJ_AnimationStep): this;
+    /**
+     * Add a trigger animation step
+     * @param {OBJ_TriggerAnimationStep | function(): void | string} callbackOrOptions
+     * callback can be a function or an id to a function map
+     * @return {AnimationBuilder}
+     */
+    trigger(callbackOrOptions: (() => void) | string | OBJ_TriggerAnimationStep): this;
+    /**
+     * Add a parallel animation step
+     * @param {Array<AnimationStep | null> | OBJ_ParallelAnimationStep} stepsOrOptions
+     * @return {AnimationBuilder}
+     */
+    inParallel(stepsOrOptions?: Array<animation.AnimationStep | null> | OBJ_ParallelAnimationStep, ...options: Array<OBJ_ParallelAnimationStep>): this;
+    /**
+     * Add a serial animation step
+     * @param {Array<AnimationStep | null> | OBJ_SerialAnimationStep} stepsOrOptions
+     * @return {AnimationBuilder}
+     */
+    inSerial(stepsOrOptions?: Array<animation.AnimationStep> | OBJ_SerialAnimationStep, ...options: Array<OBJ_SerialAnimationStep>): this;
+    /**
+     * Add a pulse animation step
+     * @param {OBJ_PulseAnimationStep | number} scaleOrOptions pulse scale
+     * (number) or pulse animation step options
+     * @return {PulseAnimationStep}
+     */
+    pulse(scaleOrOptions: OBJ_PulseAnimationStep | number): this;
+    reset(): void;
+    _dup(): animation.AnimationBuilder;
+}

package/types/js/figure/Animation/AnimationManager.d.ts

@@ -0,0 +1,392 @@
+import { FigureElement } from '../Element';
+import * as anim from './Animation';
+import type { Recorder } from '../Recorder/Recorder';
+import type { AnimationStep, OBJ_AnimationBuilder, OBJ_AnimationStep, OBJ_RotationAnimationStep, OBJ_ScaleAnimationStep, OBJ_TriggerAnimationStep, OBJ_PositionAnimationStep, OBJ_ColorAnimationStep, OBJ_OpacityAnimationStep, OBJ_TransformAnimationStep, OBJ_PulseTransformAnimationStep, OBJ_PulseAnimationStep, OBJ_ElementAnimationStep, OBJ_ScenarioAnimationStep, OBJ_ScenariosAnimationStep, OBJ_CustomAnimationStep } from './Animation';
+import TimeKeeper from '../TimeKeeper';
+import { NotificationManager } from '../../tools/tools';
+import { FunctionMap } from '../../tools/FunctionMap';
+import type { TypeWhen } from '../TimeKeeper';
+import type { TypeParsablePoint, TypeParsableTransform } from '../../tools/g2';
+import type { TypeColor } from '../../tools/types';
+import type { OBJ_Scenario } from '../Element';
+/**
+ * Animation start time options.
+ *
+ * {@link TypeWhen} | number | null
+ *
+ * When multiple animations need to be started, it is often
+ * desirable to synchronise their start times.
+ *
+ * `'nextFrame'` will start the animation on the
+ * next animation frame. Starting several animations with `nextFrame`
+ * will ensure they are all synchronized to that frame time.
+ *
+ * Similarly `'prevFrame'` starts the animation on the last animation
+ * frame.
+ *
+ * `'syncNow'` will start an animation at a synchronized 'now' time. The
+ * first time 'syncNow' is used, the current time will be stored and used
+ * for all subsequent calls to 'syncNow'. 'syncNow' is reset every
+ * time a new animation frame is drawn.
+ *
+ * Alternately, `'now'` can be used which will use the current time as
+ * the animation start time. As javascript is single threaded, using `'now`
+ * on multiple animations will result in them all having slightly different
+ * start times.
+ *
+ * A custom time can be used if a `number` is defined.
+ *
+ * `null` will result in `'nextFrame'` being used
+ * @typedef {TypeWhen | number | null} AnimationStartTime
+ * @group Misc Animation
+ */
+export type AnimationStartTime = TypeWhen | number | null;
+/**
+ * Start animation options object.
+ *
+ * @property {null | string} [name] name of animation to start - f null, then
+ * all animations associated with this animation manager will start (`null`)
+ * @property {AnimationStartTime} startTime when to
+ * start the animation
+ * @interface
+ * @group Misc Animation
+ */
+export type OBJ_AnimationStart = {
+    name?: string;
+    startTime: AnimationStartTime;
+};
+export type TypeAnimationManagerInputOptions = {
+    element?: FigureElement;
+    finishedCallback?: (string | (() => void)) | null;
+    recorder?: Recorder;
+    timeKeeper: TimeKeeper;
+};
+/**
+ * Animation Manager
+ *
+ * This class manages animations and creates animation steps for use in
+ * animations.
+ *
+ * Each {@link FigureElement} has its own `AnimationManager` in the
+ * `animations` property, though any
+ * animation manager can animate any other element. Therefore all parallel
+ * animations can go through the same manager, or be spread throughout
+ * different element's animation managers. Spread animations out between
+ * elements, or keeping them all in one `AnimationManager` can change how
+ * readable code is, how convenient it is to cancel running animations, and
+ * what order the animations are performed in (`AnimationManager`s tied
+ * to elements drawn earlier will perform their animation steps before those
+ * tied to elements drawn later). `AnimationManager`s will only be processed
+ * on each animation frame if the element they are tied to is not hidden.
+ *
+ * The `animations` property within `AnimationManager` is simply an array that
+ * contains a number {@link AnimationStep}s that are executed in parallel.
+ * Typically, these steps would themselves be {@link SerialAnimationStep}s or a
+ * series of animations. This means the animation manager is running a number of
+ * animation series in parallel.
+ *
+ *
+ * The `AnimationManager`s on {@link FigureElement}s should be used instead
+ * of instantiating this class separately, as those on `FigureElements` will
+ * be automatically processed every animation frame.
+ *
+ * @param
+ * @property {'animating' | 'idle' | 'waitingToStart'} state
+ * @property {Array<AnimationStep>} animations
+ * @property {NotificationManager} notifications
+ * @see {@link FigureElement}
+ * @see {@link AnimationBuilder}
+ * @example
+ * // At its heart the `AnimationManager` is just executing
+ * // an array of animation steps.
+ *
+ * // Create animation steps
+ * const position = new Fig.Animation.PositionAnimationStep({
+ *   element: p,
+ *   target: [1, 0],
+ *   duration: 2,
+ * });
+ * const rotation = new Fig.Animation.RotationAnimationStep({
+ *   element: p,
+ *   target: Math.PI,
+ *   duration: 2,
+ * });
+ *
+ * // Combine the animations into a SerialAnimationStep
+ * const series = new Fig.Animation.SerialAnimationStep([
+ *   position,
+ *   rotation,
+ * ]);
+ *
+ * // Add the animations to the animation manager and start
+ * p.animations.animations.push(series);
+ * p.animations.start();
+ *
+ * @example
+ * // Using the `new` method in `AnimationManager` creates a convenient
+ * // `AnimationBuilder` which extends a `SerialAnimationStep` by using
+ * // a fluent API pattern
+ * //
+ * // Create animation steps
+ * const position = new Fig.Animation.PositionAnimationStep({
+ *   element: p,
+ *   target: [1, 0],
+ *   duration: 2,
+ * });
+ * const rotation = new Fig.Animation.RotationAnimationStep({
+ *   element: p,
+ *   target: Math.PI,
+ *   duration: 2,
+ * });
+ *
+ * // Build and start the animation
+ * p.animations.new()
+ *   .then(position)
+ *   .then(rotation)
+ *   .start();
+ *
+ * @example
+ * // `AnimationStep`s can also be created from the `AnimationManager`
+ * // with the added convenience that the `FigureElement` that
+ * // has the `AnimationManager` will be used as the default
+ * // `element` property. This combined with the `AnimationBuilder`
+ * // makes defining most animations clean and readable code
+ *
+ * // Build and start the animation
+ * p.animations.new()
+ *   .position({ target: [1, 0], duration: 2 })
+ *   .rotation({ target: Math.PI, duration: 2 })
+ *   .start();
+ *
+ * @example
+ * // Parallel animations however still need to use explicit animation steps.
+ * // Creating the steps from the `AnimationManager` means the `element` doesn't
+ * // need to be defined.
+ * //
+ * p.animations.new()
+ *   .inParallel([
+ *     p.animations.position({ target: [1, 0], duration: 2 }),
+ *     p.animations.rotation({ target: Math.PI, duration: 2 })
+ *   ])
+ *   .start();
+ * @group Animation
+ */
+export default class AnimationManager {
+    element: FigureElement | null | undefined;
+    animations: Array<anim.AnimationStep>;
+    state: 'animating' | 'idle' | 'waitingToStart';
+    fnMap: FunctionMap;
+    finishedCallback: (string | (() => void)) | null;
+    notifications: NotificationManager;
+    options: {
+        translation?: {
+            style: 'curve' | 'linear';
+            angle: number;
+            magnitude: number;
+            offset: number;
+            controlPoint: TypeParsablePoint | null;
+            direction: 'positive' | 'negative' | 'up' | 'down' | 'left' | 'right';
+        };
+    };
+    recorder: Recorder;
+    timeKeeper: TimeKeeper;
+    animationSpeed: number;
+    customSteps: Array<{
+        step: (options: Record<string, any>) => AnimationStep;
+        name: string;
+    }>;
+    /**
+     * @hideconstructor
+     */
+    constructor(elementOrOptionsIn?: FigureElement | TypeAnimationManagerInputOptions, ...optionsIn: Array<TypeAnimationManagerInputOptions>);
+    /**
+     * New animation builder attached to this animation manager
+     * @return AnimationBuilder
+     * @example
+     * p.animations.new()
+     *   .position({ target: [0.5, 0], duration: 2 })
+     *   .rotation({ target: Math.PI, duration: 2 })
+     *   .start();
+     *
+     */
+    new(name?: string | null): anim.AnimationBuilder;
+    /**
+     * Set time speed of animation relative to real time, where 1 is real time,
+     * <1 is slower than real time and >1 is faster than real time.
+     *
+     * @param {number} speed
+     */
+    setTimeSpeed(speed?: number): void;
+    /**
+     * Animation builder object
+     * @param {OBJ_AnimationBuilder} options
+     * @return {AnimationBuilder}
+     */
+    builder(...options: Array<OBJ_AnimationBuilder>): anim.AnimationBuilder;
+    /**
+     * Create a Rotation animation step that uses this element by default
+     * @param {OBJ_RotationAnimationStep} options
+     * @return {RotationAnimationStep}
+     * @example
+     * const rot = p.animations.rotation({ target: Math.PI, duration: 2 });
+     * p.animations.new()
+     *   .then(rot)
+     *   .start();
+     */
+    rotation(targetOrOptions: OBJ_RotationAnimationStep | number): any;
+    /**
+     * Create a Scale animation step tied to this element
+     * @param {TypeParsablePoint | OBJ_ScaleAnimationStep | number} targetOrOptionsOrX
+     * when a number is used, it will apply to both x and y if y is null
+     * @param {number | null} y use a number to define the y scale, or use null
+     * to use the `x` value (`null`)
+     * @return {ScaleAnimationStep}
+     */
+    scale(targetOrOptionsOrX: TypeParsablePoint | OBJ_ScaleAnimationStep | number, y?: null | number, z?: number): any;
+    /**
+     * Create a Trigger animation step
+     * @param {OBJ_TriggerAnimationStep | function(): void | string} callbackOrOptions
+     * callback can be a function or an id to a function map
+     * @return {TriggerAnimationStep}
+     */
+    trigger(callbackOrOptions: (() => void) | string | OBJ_TriggerAnimationStep): anim.TriggerAnimationStep;
+    /**
+     * Add a custom animation step that uses this element by default
+     * @param {string | ((number) => void) | OBJ_CustomAnimationStep} callbackOrOptions
+     * @return {AnimationBuilder}
+     */
+    custom(callbackOrOptions: string | ((percent: number) => void) | OBJ_CustomAnimationStep): anim.CustomAnimationStep;
+    /**
+     * Create a Delay animation step
+     * Use the `duration` value in `options` to define delay duration
+     * @param {number | OBJ_AnimationStep} delayOrOptions
+     * @return {DelayAnimationStep}
+     */
+    delay(delayOrOptions?: number | OBJ_AnimationStep): anim.DelayAnimationStep;
+    /**
+     * Create a Translation or Position animation step tied to this element
+     * @param {OBJ_PositionAnimationStep | TypeParsablePoint | number} targetOrOptionsOrX
+     * @param {number} y define if `targetOrOptionsOrX` is x (number)
+     * @return {PositionAnimationStep}
+     */
+    translation(targetOrOptionsOrX: TypeParsablePoint | OBJ_PositionAnimationStep | number, y?: number, z?: number): void;
+    /**
+     * Create a Translation or Position animation step tied to this element
+     * @param {OBJ_PositionAnimationStep | TypeParsablePoint | number} targetOrOptionsOrX
+     * @param {number} y define if `targetOrOptionsOrX` is x (number)
+     * @return {PositionAnimationStep}
+     */
+    position(targetOrOptionsOrX: TypeParsablePoint | OBJ_PositionAnimationStep | number, y?: number, z?: number): any;
+    /**
+     * Create a Color animation step tied to this element
+     * @param {OBJ_ColorAnimationStep | TypeColor} colorOrOptions
+     * @return {ColorAnimationStep}
+     */
+    color(colorOrOptions: OBJ_ColorAnimationStep | TypeColor): any;
+    /**
+     * Create a Opacity animation step tied to this element
+     * @param {OBJ_OpacityAnimationStep | number} opacityOrOptions
+     * @return {OpacityAnimationStep}
+     */
+    opacity(opacityOrOptions: OBJ_OpacityAnimationStep | number): any;
+    /**
+     * Create a Transform animation step tied to this element
+     * @param {OBJ_TransformAnimationStep | TypeParsableTransform} transformOrOptions
+     * @return {TransformAnimationStep}
+     */
+    transform(transformOrOptions: OBJ_TransformAnimationStep | TypeParsableTransform): any;
+    pulseTransform(...options: Array<OBJ_PulseTransformAnimationStep>): any;
+    /**
+     * Create a pulse animation step tied to this element
+     * @param {OBJ_PulseAnimationStep | number} scaleOrOptions pulse scale
+     * (number) or pulse animation step options
+     * @return {PulseAnimationStep}
+     */
+    pulse(scaleOrOptions: OBJ_PulseAnimationStep | number): any;
+    /**
+     * Create a Dissolve in animation step
+     * Use the `duration` value in `options` to define dissolving duration
+     * @param {number | OBJ_ElementAnimationStep} timeOrOptions
+     * @return {DissolveInAnimationStep}
+     */
+    dissolveIn(durationOrOptions?: number | OBJ_ElementAnimationStep): any;
+    /**
+     * Create a Dissolve out animation step
+     * Use the `duration` value in `options` to define dissolving duration
+     * @param {number | OBJ_ElementAnimationStep} durationOrOptions
+     * @return {DissolveOutAnimationStep}
+     */
+    dissolveOut(durationOrOptions?: number | OBJ_ElementAnimationStep): any;
+    /**
+     * Create a Dim color animation step
+     * Use the `duration` value in `options` to define dimming duration
+     * @param {number | OBJ_ElementAnimationStep} durationOrOptions
+     * @return {DimAnimationStep}
+     */
+    dim(durationOrOptions?: number | OBJ_ElementAnimationStep): any;
+    /**
+     * Create a Undim color animation step
+     * Use the `duration` value in `options` to define undimming duration
+     * @param {number | OBJ_ElementAnimationStep} durationOrOptions
+     * @return {UndimAnimationStep}
+     */
+    undim(durationOrOptions?: number | OBJ_ColorAnimationStep): any;
+    getStep(options: Record<string, any>, animName: string): any;
+    /**
+     * Create a Scenario animation step tied to this element
+     * @param {OBJ_ScenarioAnimationStep | OBJ_Scenario | string} scenarioOrOptions
+     * @return {ScenarioAnimationStep}
+     */
+    scenario(scenarioOrOptions: string | OBJ_Scenario | OBJ_ScenarioAnimationStep): any;
+    /**
+     * Create a Parallel animation step that animates
+     * all child elements with the target scenario name
+     * @param {string | OBJ_ScenariosAnimationStep} scenarioNameOrOptions
+     * @return {ParallelAnimationStep}
+     */
+    scenarios(scenarioOrOptions: string | OBJ_ScenariosAnimationStep): anim.ParallelAnimationStep;
+    _state(options: Record<string, any>): Record<string, any>;
+    setTimeDelta(delta: number | null | undefined): void;
+    willStartAnimating(): boolean;
+    isAnimating(): boolean;
+    nextFrame(now: number): number | null;
+    cleanAnimations(): void;
+    /**
+     * Cancel one or all animations managed by this manager (in the `animations`
+     * array).
+     * @param {null | string} name name of animation or `null` to cancel all
+     * (`null`)
+     * @param {null | 'complete' | 'freeze'} force force the animation to complete
+     * or freeze - `null` will perform the default operation (`null`)
+     */
+    cancel(name?: string | null | undefined, force?: 'complete' | 'freeze' | null): void;
+    /**
+     * Get an animation by name.
+     @param {string} name
+     @return {AnimationStep | null}
+     */
+    get(name: string): anim.AnimationStep | null;
+    cancelAll(how?: 'complete' | 'freeze' | null, force?: boolean): void;
+    getFrameTime(frame: 'nextFrame' | 'prevFrame' | 'now' | 'syncNow'): void;
+    /**
+     * Start one or all animations managed by this manager (in the `animations`
+     * array).
+     *
+     * @param {OBJ_AnimationStart} [options]
+     */
+    start(options: OBJ_AnimationStart): void;
+    startAll(optionsIn: {
+        startTime?: AnimationStartTime;
+    }): void;
+    getTotalDuration(): number | null;
+    /**
+     * Get remaining duration of all animations
+     * @param {number} now define this if you want remaining duration from a
+     * custom time
+     */
+    getRemainingTime(animationNames?: Array<string> | string, now?: number): number;
+    getNextAnimationFinishTime(now?: number): null | number;
+    addTo(name: string): anim.AnimationStep | anim.AnimationBuilder;
+    newFromStep(nameOrStep: anim.AnimationStep): anim.AnimationStep;
+    _dup(): anim.AnimationManager;
+}