figureone 0.15.10 → 1.0.0

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

@@ -0,0 +1,1212 @@
+import { Transform, Point, Rect, Plane } from '../tools/g2';
+import Scene from '../tools/geometry/scene';
+import type { OBJ_Scene } from '../tools/geometry/scene';
+import type { TypeParsablePoint, TypeParsableTransform, TypeBorder, TypeParsableBuffer, TypeParsableBounds, TypeParsablePlane } from '../tools/g2';
+import { Recorder } from './Recorder/Recorder';
+import * as m3 from '../tools/m3';
+import type { Type3DMatrix } from '../tools/m3';
+import DrawingObject from './DrawingObjects/DrawingObject';
+import { NotificationManager } from '../tools/tools';
+import TimeKeeper from './TimeKeeper';
+import type { TypeWhen } from './TimeKeeper';
+import type { OBJ_SpaceTransforms, OBJ_FigureForElement } from './Figure';
+import * as animations from './Animation/Animation';
+import WebGLInstance from './webgl/webgl';
+import { FunctionMap } from '../tools/FunctionMap';
+import type { TypeColor, TypeCoordinateSpace } from '../tools/types';
+import type { OBJ_Touch } from './FigurePrimitives/FigurePrimitiveTypes';
+import type FigureCollections from './FigureCollections/FigureCollections';
+import Atlas from './webgl/Atlas';
+/**
+ * Add element Object
+ * @interface
+ * @group Misc Figure Element
+ */
+export type OBJ_AddElement = {
+    path?: string;
+    name?: string;
+    make?: string;
+    options?: Record<string, any>;
+    elements?: Array<OBJ_AddElement | FigureElement>;
+    mods?: {};
+    scenario?: string;
+    position?: TypeParsablePoint;
+    transform?: TypeParsableTransform;
+    color?: TypeColor;
+    touch?: boolean | OBJ_Touch;
+    move?: boolean | OBJ_ElementMove;
+    dimColor?: TypeColor;
+    defaultColor?: TypeColor;
+    scenarios?: OBJ_Scenarios;
+    scene?: Scene | OBJ_Scene;
+    touchScale?: number;
+};
+/**
+ * Transform, color and visbility scenario definition
+ *
+ * `translation` will overwirte `position`, and `translation, `position`,
+ * rotation` and `scale` overwrite the first equivalent transforms in
+ * `transform`
+ *
+ * @property {TypeParsablePoint} position
+ * @property {TypeParsablePoint} translation
+ * @property {TypeParsablePoint | number} scale
+ * @property {number} rotation
+ * @property {TypeParsableTransform} transform
+ * @property {Array<number>} color
+ * @property {boolean} isShown
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_Scenario = {
+    position?: TypeParsablePoint;
+    translation?: TypeParsablePoint;
+    rotation?: number;
+    scale?: TypeParsablePoint | number;
+    transform?: TypeParsableTransform;
+    color?: TypeColor;
+    isShown?: boolean;
+};
+/**
+ * Path to a {@link FigureElement} within a {@link FigureElementCollection}.
+ *
+ * `string | {[name: string]: TypeElementPath } | `{@link FigureElement}` | Array<TypeElementPath>}`
+ *
+ * Consider a collection with the below heirachy. The collection has two
+ * children `diagram` and `description` of which `diagram` is another
+ * collection:
+ * - diagram
+ *   - lineA
+ *   - lineB
+ *   - lines
+ *     - lineC
+ *     - lineD
+ * - description
+ *
+ * The ways to define lineC, lineD and description are:
+ *
+ * - `['description', 'diagram.lines.lineC', 'diagram.lines.lineD']`
+ * - `['description', { diagram: ['lines.lineC', 'lines.lineD'] }]`
+ * - `['description', { 'diagram.lines': ['lineC', 'lineD'] }]`
+ * @group Misc Figure Element
+ */
+export type TypeElementPath = string | {
+    [name: string]: TypeElementPath;
+} | FigureElement | Array<TypeElementPath>;
+/**
+ * Pulse options object
+ *
+ * ![](./apiassets/pulse.gif)
+ *
+ * Pulsing can be useful to highlight a figure element to a user, without
+ * changing its underlying properties.
+ *
+ * When an element is pulsed, it will be scaled, translated or rotated from
+ * a start value (1 for scale, 0 for rotation and translation),
+ * to a maximum value (`scale`, `translate` or `rotate`),
+ * to a `min` value, and then back to the `start` value. An element can
+ * be pulsed through this cycle `frequency` times per second, over some
+ * `duration`.
+ *
+ * The pulse does not change the {@link FigureElement}.transform property, and
+ * only changes the draw transform.
+ *
+ * By default, a scale or rotation pulse will scale or rotate around the the
+ * center of the rectangle encompassing the border of the element. `centerOn`
+ * can be used to define a different {@link FigureElement} or point to center
+ * on. If centering on a {@link FigureElement}, `xAlign` and `yAlign` can be
+ * used to center on a point aligned within it. For instance, `xAlign: 'left'`
+ * will center on a point on the left edte of the {@link FigureElement}.
+ *
+ * The pulse can also draw multiple copies of the element with pulse transforms
+ * distributed between the `min` and maximum pulse values. This is particularly
+ * useful for shapes with outlines that have a regular spacing from a center
+ * point (such as regular polygons) as it will look like the thickness of the
+ * outlines are becomming thicker.
+ *
+ * @property {number} [duration] pulse duration in seconds (`1`)
+ * @property {number} [frequency] pulse frequency in Hz - a frequency of zero
+ * will set the frequency so just one cycle will be performed in the duration
+ * (`0`)
+ * @property {number} [scale] maximum scale value to pulse to (`1.5`)
+ * @property {number} [rotation] maximum rotation value to pulse to
+ * @property {number} [translation] maximum translation displacment value to
+ * pulse to (`1.5`)
+ * @property {number} [angle] translation angle (`0`)
+ * @property {number} [min] minimum value to pulse to
+ * @property {null | FigureElement | TypeParsablePoint | string | 'this'} [centerOn] center
+ * of scale or rotation pulse. `null` is point [0, 0], `string` or
+ * `FigureElement` are elements to centerOn, and `'this'` is the calling
+ * element (`'this'`)
+ * will be the default `centerOn`.
+ * @property {'left' | 'center' | 'right' | 'location' | number} [xAlign]
+ * if `centerOn` is a {@link FigureElement} then this property can be used to
+ * horizontally align the pulse center with the element. `'location'` is the
+ * (0, 0) draw space coordinate of the element. `number` defines the percent
+ * width from the left of the element (`'center'`)
+ * @property {'bottom' | 'middle' | 'top' | 'location' | number} [yAlign]
+ * if `centerOn` is a {@link FigureElement} then this property can be used to
+ * vertically align the pulse center with the element. `'location'` is the
+ * (0, 0) draw space coordinate of the element. `number` defines the percent
+ * width from the left of the element (`'center'`)
+ * @property {'figure' | 'gl' | 'local' | 'draw' | 'pixel'} [space]
+ * if `centerOn` is a point, use this to define the space the point is in
+ * (`'figure'`)
+ * @property {number} [num] the number of draw copies of the pulse to make (`1`)
+ * @property {null | string | function(): void} [done] callback when pulse is
+ * finished. If `string` then the element's {@link FunctionMap} `fnMap` will be
+ * used (`null`)
+ * @property {TypeWhen} [when] when to start the pulse (`'syncNow'`)
+ * @property {'sinusoid' | 'triangle'} [progression] function that defines
+ * how the scale should progress over time (`sinusoid`)
+ *
+ * @example
+ * // For all examples below, use this to add an element to the figure
+ * const p = figure.add({
+ *   make: 'polygon',
+ *   radius: 0.3,
+ *   line: { width: 0.05, },
+ * });
+ *
+ *
+ * @example
+ * // Scale pulse
+ * p.pulse({
+ *   duration: 1,
+ *   scale: 1.3
+ * });
+ *
+ * @example
+ * // Rotation pulse
+ * p.pulse({
+ *   duration: 1,
+ *   rotation: 0.15,
+ *   frequency: 4,
+ * });
+ *
+ * @example
+ * // Translation pulse
+ * p.pulse({
+ *   duration: 1,
+ *   translation: 0.02,
+ *   min: -0.02,
+ *   frequency: 4,
+ * });
+ *
+ * @example
+ * // Thick pulse
+ * p.pulse({
+ *   duration: 1,
+ *   scale: 1.1,
+ *   min: 0.9,
+ *   num: 7,
+ * });
+ * @interface
+ * @group Misc Animation
+ */
+export type OBJ_Pulse = {
+    duration?: number;
+    frequency?: number;
+    scale?: number;
+    rotation?: number;
+    translation?: number;
+    angle?: number;
+    min?: number;
+    centerOn?: null | FigureElement | TypeParsablePoint | string | 'this';
+    x?: 'left' | 'center' | 'right' | 'origin' | number;
+    y?: 'bottom' | 'middle' | 'top' | 'origin' | number;
+    space?: 'figure' | 'gl' | 'local' | 'draw';
+    num?: number;
+    when?: TypeWhen;
+    done?: string | ((...args: any[]) => void) | null;
+    progression?: string | ((n: number) => number);
+};
+/**
+ * Figure element move freely parameters
+ *
+ * If a figure element is released from moving with some velocity
+ * then these parameters will define how it continues to move freely
+ *
+ * @property {TypeTransformValue} zeroVelocityThreshold used to overcome
+ * limitations of floating point numbers not reaching 0
+ * @property {TypeTransformValue} deceleration amount to decelerate in local
+ * space units per second squared
+ * @property {TypeTransformValue} bounceLoss 0.5 results in 50% velocity loss
+ * if bouncing of boundary
+ * @property {?(string | ((boolean) => void))} callback called each frame of
+ * free movement
+ * @interface
+ * @group Interactivity
+ */
+type OBJ_ElementMoveFreely = {
+    zeroVelocityThreshold: number;
+    deceleration: number;
+    bounceLoss: number;
+    callback: string | ((b: boolean) => void) | null;
+};
+/**
+ * Figure element move parameters
+ * @property {type: 'rotation' | 'translation' | 'position' | 'scale' | 'scaleX' | 'scaleY' | 'scaleZ'} type
+ * @property {TypeParsableBounds} bounds rectangle to
+ * limit movement within
+ * @property {Plane} plane movement plane
+ * @property {TypeTransformValue} maxVelocity maximum velocity allowed (5)
+ * @property {OBJ_ElementMoveFreely} freely free movement parameters - use
+ * false for disabling free movement after touch up
+ * @property {FigureElement | null | string} element
+ * @interface
+ * @group Interactivity
+ */
+export type OBJ_ElementMove = {
+    type?: 'rotation' | 'translation' | 'position' | 'scale' | 'scaleX' | 'scaleY' | 'scaleZ';
+    bounds?: TypeParsableBounds;
+    plane?: Plane;
+    maxVelocity?: number | TypeParsablePoint;
+    freely?: OBJ_ElementMoveFreely | false;
+    element?: FigureElement | null | string;
+};
+type OBJ_ElementMoveFixed = {
+    type: 'rotation' | 'translation' | 'position' | 'scale' | 'scaleX' | 'scaleY' | 'scaleZ';
+    bounds: TypeParsableBounds;
+    plane: Plane;
+    maxVelocity: number | TypeParsablePoint;
+    freely: OBJ_ElementMoveFreely | false;
+    element: FigureElement | null | string;
+};
+/**
+ * All scenarios set to element.
+ *
+ * Scenarios are preset transforms, color and visibility settings that can be
+ * easily animated to.
+ *
+ * This is an object where the keys are scenario names and values are
+ * {@link OBJ_Scenario} objects defining the scenario.
+ *
+ * @property {OBJ_Scenario} _scenarioName where scenarioName can be any
+ * string that names the scenario
+ * @interface
+ * @group Misc Figure Element
+ */
+export type OBJ_Scenarios = {
+    [_scenarioName: string]: OBJ_Scenario;
+};
+/**
+ * Element movement state
+ * @group Misc Figure Element
+ */
+type ElementMovementState = {
+    previousTime: number | null;
+    velocity: Point | number;
+};
+/**
+ * Element pulse state
+ * @group Misc Figure Element
+ */
+type ElementPulseState = {
+    startTime: number | null;
+};
+/**
+ * Element state
+ * @group Misc Figure Element
+ */
+type ElementState = {
+    isBeingMoved: boolean;
+    isMovingFreely: boolean;
+    isChanging: boolean;
+    movement: ElementMovementState;
+    isPulsing: boolean;
+    pulse: ElementPulseState;
+    preparingToStop: boolean;
+};
+/**
+ * setTransform event.
+ *
+ * Fired whenever the transform is changed.
+ *
+ * @event FigureElement#setTransform
+ * @type {[Transform]}
+ */
+/**
+ * Figure Element base class
+ *
+ * The set of properties and methods shared by all figure elements
+ *
+ * A figure element has several color related properties. Color is
+ * defined as an RGBA array with values between 0 and 1. The alpha
+ * channel defines the transparency or opacity of the color where
+ * 1 is fully opaque and 0 is fully transparent.
+ *
+ * The `color` property stores the element's current color, while the
+ * `defaultColor` property stores the element's color when not dimmed or
+ * dissolving. Color should only be set using the `setColor` method.
+ *
+ * An element can be "dimmed" or "undimmed". For instance,
+ * a red element might turn grey when dimmed. The property
+ * `dimColor` stores the desired color to dim to and should be set with
+ * `setDimColor()`
+ *
+ * An element can be dissolved in or out with animation. Dissolving
+ * an element out transitions its opacity from its current value to 0.
+ * The `opacity` property is used when dissolving. The opacity is multiplied by
+ * the alpha channel of `color` to net a final opacity. Opacity should not be
+ * set directly as it will be overwritten by dissolve animations.
+ *
+ * Notifications - The notification manager property `notifications` will
+ * publish the following events:
+ * - `beforeSetTransform`: published just before the `transform` property is
+ * changed
+ * - `setTransform`: published whenever the `transform` property is changed
+ * - `startBeingMoved`: published when the element starts being moved by touch
+ * - `stopBeingMoved`: published when the element stops being moved by touch
+ * - `startMovingFreely`
+ * - `stopMovingFreely`
+ * - `show`: published when element is shown
+ * - `hide`: published when element is hidden
+ * - `visibility`: published when element element is shown or hidden
+ * - `onClick`: published when element is clicked on
+ * - `color`: published whenever color is set
+ * - `beforeDraw`
+ * - `afterDraw`
+ * - `setState`: state of element has been set
+ *
+ * @class
+ * @property {string} name reference name of element
+ * @property {boolean} isShown if `false` then element will not be processed on
+ * next draw
+ * @property {Transform} transform transform to apply element
+ * @property {Transform} lastDrawTransform transform last used for drawing -
+ * includes cascade or all parent transforms
+ * @property {FigureElement | null} parent parent figure element - `null` if
+ * at top level of figure
+ * @property {boolean} isTouchable must be `true` to move or execute `onClick`
+ * @property {boolean} isMovable must be `true` to move
+ * @property {string | () => void} onClick callback if touched or clicked
+ * @property {[number, number, number, number]} color element's current
+ * color defined as red, green, blue, alpha with range 0 to 1
+ * @property {[number, number, number, number]} dimColor color to use when
+ * dimming element
+ * @property {[number, number, number, number]} defaultColor color to go to
+ * when undimming element
+ * @property {number} opacity number between 0 and 1 that is multiplied with
+ * `color` alpha channel to get final opacity
+ * @property {OBJ_ElementMove} move movement parameters
+ * @property {OBJ_Scenarios} scenarios scenario presets
+ * @property {ElementState} state current state of element
+ * @property {AnimationManager} animations element animation manager
+ * @property {NotificationManager} notifications notification manager for
+ * element
+ * @property {FunctionMap} fnMap function map for use with {@link Recorder}
+ * @property {Object} customState put any custom state information that needs
+ * to be captured with recorder here - only stringify-able values can go in this
+ * object like strings, numbers, booleans and nested arrays or objects
+ * containing these. Functions should not be put in here - use string
+ * identifiers to `fnMap` if functions are needed.
+ * @group Figure Elements
+ */
+declare class FigureElement {
+    transform: Transform;
+    pulseTransforms: Array<Transform>;
+    frozenPulseTransforms: Array<Transform>;
+    copyTransforms: Array<Transform>;
+    drawTransforms: Array<Transform>;
+    lastDrawPulseTransform: Transform;
+    parentTransform: Array<Transform>;
+    lastDrawOpacity: number;
+    parent: FigureElement | null;
+    isShown: boolean;
+    name: string;
+    isMovable: boolean;
+    isTouchable: boolean;
+    touchScale: Point;
+    isInteractive: boolean | null | undefined;
+    drawPriority: number;
+    cancelSetTransform: boolean;
+    onClick: string | ((arg?: any) => void) | null;
+    setTransformCallback: string | ((t: Transform) => void) | null;
+    internalSetTransformCallback: string | ((t: Transform) => void) | null;
+    beforeDrawCallback: string | ((n: number) => void) | null;
+    afterDrawCallback: string | ((n: number) => void) | null;
+    color: TypeColor;
+    defaultColor: Array<number>;
+    dimColor: Array<number>;
+    opacity: number;
+    interactiveLocation: Point;
+    figure: OBJ_FigureForElement;
+    scene: null | Scene;
+    move: OBJ_ElementMoveFixed;
+    onAdd: null | string | (() => void);
+    scenarios: OBJ_Scenarios;
+    type: 'collection' | 'primitive';
+    pulseSettings: {
+        time: number;
+        frequency: number;
+        A: number | Array<number>;
+        B: number | Array<number>;
+        C: number | Array<number>;
+        progression: string | ((a: number, b: number, c: number, d: number, e: number) => number);
+        num: number;
+        delta: TypeParsablePoint;
+        transformMethod: string | ((a: number, b?: Point) => Transform);
+        callback: string | ((arg: any) => void) | null;
+        allowFreezeOnStop: boolean;
+        type: 'scale' | 'rotation' | number;
+    };
+    pulseDefault: string | ((done?: (() => void) | null) => void) | {
+        scale: null | number | Point;
+        rotation: null | number;
+        translation: null | number | Point;
+        angle: number;
+        duration: number;
+        frequency: number;
+        num: number;
+        xAlign: 'center' | 'left' | 'right' | number;
+        yAlign: 'middle' | 'bottom' | 'top' | number;
+        centerOn: null | FigureElement | string;
+        space: TypeCoordinateSpace;
+        done: null | (() => void);
+        progression: string | ((n: number) => number);
+        when: TypeWhen;
+    };
+    figureTransforms: OBJ_SpaceTransforms;
+    state: ElementState;
+    animations: animations.AnimationManager;
+    animationFinishedCallback: string | (() => void) | null;
+    uid: string;
+    anim: Record<string, any>;
+    tieToHTML: {
+        element: string | null;
+        scale: string;
+        window: Rect;
+        updateOnResize: boolean;
+    };
+    isRenderedAsImage: boolean;
+    renderedOnNextDraw: boolean;
+    unrenderNextDraw: boolean;
+    custom: Record<string, any>;
+    _custom: Record<string, any>;
+    stateProperties: Array<string>;
+    customState: Record<string, any>;
+    fnMap: FunctionMap;
+    notifications: NotificationManager;
+    lastDrawTime: number;
+    dependantTransform: boolean;
+    recorder: Recorder;
+    timeKeeper: TimeKeeper;
+    simple: boolean;
+    uniqueColor: null | TypeColor;
+    touch: {
+        color: null | TypeColor;
+        enabled: boolean;
+        scale: TypeParsablePoint;
+    };
+    drawNumber: number;
+    moveSetTransform: boolean;
+    allowSetColor: string;
+    /**
+     * @hideconstructor
+     */
+    constructor(transform?: Transform, parent?: FigureElement | null, name?: string, timeKeeper?: TimeKeeper);
+    animationFinished(typeOfAnimation?: 'pulse' | 'movingFreely' | 'animation'): void;
+    animateNextFrame(): void;
+    /**
+     * Associate this element with a new scene.
+     * @param {Scene | OBJ_Scene} scene
+     */
+    setScene(scene: Scene | OBJ_Scene): void;
+    setProperties(properties: Record<string, any>, except?: Array<string> | string): void;
+    _getStateProperties(options: {
+        ignoreShown?: boolean;
+    }): string[];
+    _getStatePropertiesMin(): string[];
+    _state(options?: {
+        precision?: number;
+        ignoreShown?: boolean;
+        min?: boolean;
+        returnF1Type?: boolean;
+    }): Record<string, any>;
+    stateSet(): void;
+    setFigure(figure: OBJ_FigureForElement, notify?: boolean): void;
+    setTimeDelta(delta: number): void;
+    getIsShown(): boolean;
+    getRootElement(): FigureElement | null;
+    getScene(): Scene | null;
+    getDrawToFigureTransformDef(): Array<any>;
+    getLocalToFigureTransformDef(): any[];
+    getLocalToFigureTransform(): Transform;
+    getFigureTransform(): Transform;
+    updateHTMLElementTie(figureCanvas: HTMLElement): void;
+    setFirstTransform(parentTransform: Transform): void;
+    clearFrozenPulseTransforms(): void;
+    freezePulseTransforms(forceOverwrite?: boolean): void;
+    getFonts(): Array<any>;
+    fontUpdated(): void;
+    init(_webgl: any): void;
+    _dup(_arg?: any): any;
+    setupDraw(_now?: number, _canvasIndex?: number): void;
+    draw(_now: number, _scene: Scene, ..._args: any[]): void;
+    animateToState(state: Record<string, any>, options: Record<string, any>, independentOnly?: boolean, startTime?: number | 'now' | 'prevFrame' | 'nextFrame' | null): number;
+    dissolveInToState(state: Record<string, any>, duration?: number, startTime?: number | 'now' | 'prevFrame' | 'nextFrame' | null): number;
+    contextLost(): void;
+    isStateSame(state: Record<string, any>, mergePulseTransforms?: boolean, exceptions?: Array<string>): boolean;
+    arePulseTransformsSame(state: Record<string, any>, delta?: number): boolean;
+    getDrawTransforms(initialTransforms: Array<Transform>): Transform[];
+    getDrawTransformsMatrix(initialTransforms: Array<Type3DMatrix>): m3.Type3DMatrix[];
+    exec(execFunctionAndArgs: string | Array<any>): void;
+    getElement(_elementPath?: any): this;
+    getElements(_children?: any): Array<FigureElement>;
+    highlight(): void;
+    /**
+     * Conveniently set the first `translation` of the element's `transform`.
+     * @param {TypeParsablePoint | number} pointOrX x coordinate or full point
+     * definition
+     * @param {number} y y coordinate if `pointOrX` is just the x coordinate (`0`)
+     */
+    setPosition(pointOrX: TypeParsablePoint | number, y?: number, z?: number): void;
+    /**
+     * Conveniently set the first `rotation` of the element's `transform`.
+     * @param {number} rotation
+     */
+    setRotation(r: number, axis?: TypeParsablePoint | null): void;
+    /**
+     * Conveniently set the first `scale` of the element's `transform`.
+     * @param {TypeParsablePoint | number} scaleOrX horizontal scale - either
+     * define as full x-y point, or as a number. If scaleOrX is a `number` and
+     * `y` is null, then both `x` and `y` will be equally scaled
+     * @param {number | null} y y coordinate if `scaleOrX` is a `number` (`null`)
+     */
+    setScale(scaleOrX: TypeParsablePoint | number, y?: number | null, z?: number): void;
+    /**
+     * Set transform of element. Setting through this method will ensure
+     * `setTransfrom` subscription will publish, and transform will be
+     * appropriately clipped.
+     * @param {Transform} transform
+     */
+    setTransform(transform: Transform, publish?: boolean): void;
+    transformSet(publish?: boolean, fromMovement?: boolean): void;
+    nextMovingFreelyFrame(now: number): void;
+    clear(_canvasIndex?: number): void;
+    cleanup(): void;
+    willStartAnimating(): boolean;
+    /**
+     Set element color.
+     @param {[number, number, number, number]} color RGBA color from 0 to 1
+     @param {boolean} [setDefault] also set the default color to this color
+     */
+    setColor(color: TypeColor, setDefault?: boolean): void;
+    /**
+     * Set element color to `dimColor`
+     */
+    dim(): void;
+    /**
+     * Set `dimColor` property
+     */
+    setDimColor(color: TypeColor): void;
+    /**
+     * Set element color to `defaultColor`
+     */
+    undim(): void;
+    setOpacity(opacity: number): void;
+    getScenarioTarget(scenarioIn: string | OBJ_Scenario | null | undefined): {
+        transform?: Transform;
+        color?: TypeColor;
+        isShown?: boolean;
+    };
+    /**
+     * Set transform, color and/or visibility to a predefined scenario.
+     *
+     * @param {string | Array<string>} [scenarioName] name of the scenario to
+     * set. Use an array of names to set multiple scenarios in the array's order.
+     * @param {boolean} [onlyIfVisible] `true` to only set scenario if element is
+     * visible
+     */
+    setScenario(scenario: string | OBJ_Scenario): void;
+    setScenarios(scenarioName: string | Array<string>, _onlyIfVisible?: boolean): void;
+    /**
+     * Save the current transform, color and/or visibility to a scenario.
+     */
+    saveScenario(scenarioName: string, keys?: Array<string>): void;
+    getCurrentScenario(keys?: Array<string>): Record<string, any>;
+    saveScenarios(scenarioName: string, keys: Array<string>): void;
+    getAllElementsWithScenario(scenarioName: string): Array<FigureElement>;
+    getMovingFreelyEnd(): Record<string, any>;
+    getRemainingMovingFreelyTime(): any;
+    decelerate(deltaTime?: number | null): Record<string, any>;
+    /**
+     * Return figure path of element
+     * @return {string} path of element relative to figure
+     */
+    getPath(): string;
+    getMovement(transform: Transform): number | Point | null | undefined;
+    updateTransformWithMovement(valueIn: number | Point, transform: Transform): Transform;
+    setZeroVelocity(): void;
+    startBeingMoved(): void;
+    moved(value: Point | number): void;
+    stopBeingMoved(): void;
+    calcVelocity(prevValue: number | Point, nextValue: number | Point): void;
+    startMovingFreely(callback?: string | ((b: boolean) => void) | null): void;
+    stopMovingFreely(how?: 'freeze' | 'cancel' | 'complete' | 'animateToComplete' | 'dissolveToComplete'): void;
+    getRemainingPulseTime(now?: number): number;
+    getPulseTransforms(now: number): Array<Transform>;
+    /**
+     * Pulse element.
+     *
+     * An element can be pulsed in scale, a rotation or a translation.
+     *
+     * The scale pulse can either be a single pulse, or a number of copies with a
+     * range of scales - which has the effect of making regular polygons thick.
+     *
+     * Either pass in a callback, or an options object defining the pulse and
+     * callback.
+     *
+     * @param {null | OBJ_Pulse | () => void} optionsOrDone
+     */
+    pulse(optionsOrDone?: null | OBJ_Pulse | (() => void)): void;
+    startPulsing(when?: TypeWhen): void;
+    stopPulsing(how?: 'freeze' | 'cancel' | 'complete' | 'animateToComplete' | 'dissolveToComplete'): void;
+    stop(how?: 'freeze' | 'cancel' | 'complete' | 'animateToComplete' | 'dissolveToComplete', _elementOnly?: boolean): void;
+    stopAnimating(how?: 'freeze' | 'cancel' | 'complete' | 'animateToComplete' | 'dissolveToComplete', name?: string | null, _includeChildren?: boolean): void;
+    getRemainingAnimationTime(animationNames?: Array<string> | string): number;
+    getNextAnimationFinishTime(): any;
+    resize(figureHTMLElement?: HTMLElement | null): void;
+    /**
+     * Transform a point between 'draw', 'local', 'figure', 'gl' and 'pixel'
+     * spaces.
+     *
+     * `plane` is only needed when converting from pixel space (a 2D space) to
+     * 'figure', 'local' or 'draw' spaces (a 3D space). A ray from the pixel is
+     * drawn into the screen
+     * and the intersection with the defined `plane` is returned.
+     *
+     * 'pixel' to 'gl' is also a 2D to 3D transformation, but in this case the
+     * XY plane at z = 0 is used in gl space.
+     *
+     * @param {TypeParsablePoint} point
+     * @param {'figure' | 'gl' | 'pixel'} fromSpace space to convert point from
+     * @param {'figure' | 'gl' | 'pixel'} toSpace space to convert point to
+     * @param {TypeParsablePlane} plane figure space intersection plane for
+     * 'pixel' to 'figure' conversion
+     */
+    transformPoint(point: TypeParsablePoint, fromSpace: 'draw' | 'local' | 'figure' | 'gl' | 'pixel', toSpace: 'draw' | 'local' | 'figure' | 'gl' | 'pixel', toSpacePlane?: TypeParsablePlane): Point;
+    getCanvas(): any;
+    /**
+     * Return a matrix that can transform from one coordinate space to another.
+     */
+    spaceTransformMatrix(from: TypeCoordinateSpace, to: TypeCoordinateSpace, precision?: number): Type3DMatrix;
+    pixelToPlane(pixel: TypeParsablePoint, toSpace: 'figure' | 'local' | 'draw', plane: TypeParsablePlane): Point | null;
+    glToPlane(glPoint: TypeParsablePoint, toSpace?: 'figure' | 'local' | 'draw', plane?: TypeParsablePlane): Point | null;
+    pixelToGLPlane(pixelPoint: TypeParsablePoint, glSpacePlane: TypeParsablePlane): Point | null;
+    glToPlaneLegacy(glPoint: TypeParsablePoint, plane?: TypeParsablePlane): Point | null;
+    pointFromSpaceToSpace(point: TypeParsablePoint, fromSpace: TypeCoordinateSpace, toSpace: TypeCoordinateSpace): Point;
+    getBorderPoints(border?: 'border' | 'touchBorder'): TypeBorder;
+    /**
+     * Get the border or touchBorder of a FigureElementPrimitive in a defined
+     * coordinate space.
+     *
+     * @param {TypeCoordinateSpace} space (`'local`)
+     * @param {'border' | 'touchBorder'} border (`'border'`)
+     * @return {Array<Array<Point>>}
+     */
+    getBorder(space?: TypeCoordinateSpace, border?: 'border' | 'touchBorder'): Point[][];
+    getBoundingRect(space?: TypeCoordinateSpace, border?: 'border' | 'touchBorder'): Rect;
+    getRelativeBoundingRect(space?: TypeCoordinateSpace, border?: 'border' | 'touchBorder'): Rect;
+    getCenterFigurePosition(): Point;
+    /**
+     * Return the first scale in the element's transform. Will return
+     * `[1, 1]` if element's transform doesn't have a scale.
+     *
+     * @return {Point} scale
+     */
+    getScale(): Point;
+    /**
+     * Return the first rotation in the element's transform.
+     *
+     * @param {'0to360' | '-180to180' | ''} normalize how to normalize the
+     * returned angle where `''` returns the raw angle
+     * @return {Point} scale
+     */
+    getRotation(normalize?: '0to360' | '-180to180' | ''): number;
+    getPositionInBounds(space?: TypeCoordinateSpace, xAlign?: 'center' | 'left' | 'right' | 'location' | number, yAlign?: 'middle' | 'top' | 'bottom' | 'location' | number, border?: any, ...args: any[]): Point;
+    /**
+     * Get position of element
+     *
+     * By default the first translation of the element's transform is returned.
+     * This is effectively the element's location in 'local' coordinates.
+     *
+     * The position of the element relative to its horizontal and vertical bounds
+     * can also be returned. Use `xAlign` to find the x coordinate of the left,
+     * center, right or percentage width from left of the element. Use `yAlign`
+     * to find the bottom, middle, top or percentage height from bottom of the
+     * element.
+     *
+     * @param {'local' | 'figure' | 'gl' | 'draw'} space the space to return
+     * the position in
+     * @param {'center' | 'left' | 'right' | 'location' | number} xAlign
+     * horizontal alignment of position. Use a `number` to define the horizontal
+     * position in percentage width from the left.
+     * @param {'middle' | 'top' | 'bottom' | 'location' | number} yAlign
+     * vertical alignment of position. Use a `number` to define the vertical
+     * position in percentage height from the bottom.
+     */
+    getPosition(space?: TypeCoordinateSpace, xAlign?: 'center' | 'left' | 'right' | 'location' | number, yAlign?: 'middle' | 'top' | 'bottom' | 'location' | number): Point;
+    /**
+     * Set the element's position in local space such that it lines up with a
+     * figure space target.
+     *
+     * @param {TypeParsablePoint} figurePosition
+     */
+    setFigurePosition(figurePosition: TypeParsablePoint): void;
+    setFigurePositionToElement(element: FigureElement): void;
+    /**
+     * Align element position in local space such that it is in the same position
+     * as the target element (even if that element is in a different local space)
+     *
+     * @param {FigureElement} element
+     */
+    setPositionToElement(element: FigureElement): void;
+    getShown(): (string | this)[][];
+    getUid(uid: string): FigureElement | null;
+    /**
+     * Show element.
+     */
+    show(): void;
+    /**
+     * `true` set this element as touchable and configures all parent elements
+     * to accept touches for their children
+     *
+     * `false` makes this element not touchable.
+     */
+    setTouchable(setOrOptions?: OBJ_Touch | boolean): void;
+    setNotTouchable(): void;
+    /**
+     * Set move options
+     */
+    setMove(options: boolean | OBJ_ElementMove): void;
+    /**
+     * Configure all parents to make this element touchable, and
+     * make this element touchable and movable
+     * @param {boolean} movable `true` to make movable, `false` to not
+     */
+    setMovable(movable?: boolean): void;
+    clearRender(): void;
+    setRenderedOnNextDraw(): void;
+    unrender(): void;
+    showAll(): void;
+    /**
+     * Hide element
+     */
+    hide(): void;
+    hideAll(): void;
+    /**
+     * Toggle hide/show of element
+     */
+    toggleShow(): void;
+    click(glPoint?: Point): void;
+    /**
+     * Get current transform of element.
+     * @return {Transform}
+     */
+    getTransform(): Transform;
+    /**
+     * @return {boolean} `true` if element is moving
+     */
+    isMoving(): boolean;
+    /**
+     * @return {boolean} `true` if element is animating
+     */
+    isAnimating(): boolean;
+    isAnyElementMoving(): boolean;
+    isBeingTouched(glLocation: Point): boolean;
+    getTouched(glLocation: Point): Array<FigureElement>;
+    getSelectionFromBorders(glLocation: Point): null | FigureElement;
+    setUniqueColor(color: null | TypeColor): void;
+    getUniqueColorElement(color: TypeColor): FigureElement | null;
+}
+/**
+ * Primitive figure element
+ *
+ * A primitive figure element is one that handles an object (`drawingObject`)
+ * that draws to the screen. This object may be a {@link GLObject}, a
+ * {@link TextObject} or a {@link HTMLObject}.
+ *
+ * @class
+ * @extends FigureElement
+ * @group Figure Elements
+ */
+declare class FigureElementPrimitive extends FigureElement {
+    drawingObject: DrawingObject;
+    pointsToDraw: number;
+    angleToDraw: number;
+    lengthToDraw: number;
+    cannotTouchHole: boolean;
+    pointsDefinition: Record<string, any>;
+    setPointsFromDefinition: (() => void) | null;
+    border: TypeParsableBuffer | TypeBorder | 'draw' | 'buffer' | 'rect' | number;
+    touchBorder: TypeParsableBuffer | TypeBorder | 'border' | number | 'rect' | 'draw' | 'buffer';
+    drawBorder: TypeBorder;
+    drawBorderBuffer: TypeBorder;
+    /**
+     * Primitive figure element.
+     *
+     * This type of element is responsible for drawing something
+     * to the screen, or managing a HTML element in the DOM
+     *
+     * @param {DrawingObject} drawingObject an object that handles drawing
+     * to the screen or manages a HTML element
+     * @param {Transform} transform initial transform to set
+     * @param {[number, number, number, number]} color color to set
+     * @param {FigureElement | null} parent parent element
+     * @param
+     */
+    constructor(drawingObject: DrawingObject, transform?: Transform, color?: TypeColor, parent?: FigureElement | null, name?: string, timeKeeper?: TimeKeeper);
+    init(webgl: WebGLInstance): void;
+    cleanup(): void;
+    _getStateProperties(options: {
+        ignoreShown?: boolean;
+    }): string[];
+    /**
+     * Set angle to draw.
+     *
+     * Some primitive elements can be partially drawn to some angle.
+     *
+     * An angle of -1 represents the maximum angle allowed by the primitive.
+     *
+     * @param {number} angle Angle to draw
+     */
+    setAngleToDraw(angle?: number): void;
+    contextLost(): void;
+    click(glPoint?: Point): void;
+    _dup(transform?: Transform | null): FigureElementPrimitive;
+    clear(canvasIndex?: number): void;
+    resize(figureHTMLElement?: HTMLElement | null | undefined): void;
+    setColor(color: TypeColor, setDefault?: boolean): void;
+    setOpacity(opacity: number): void;
+    show(): void;
+    hide(): void;
+    resizeHtmlObject(): void;
+    getBorderPoints(border?: 'border' | 'touchBorder'): TypeBorder;
+    setupDraw(now?: number): void;
+    draw(now: number, scene: Scene, parentTransform?: Array<Transform>, parentOpacity?: number, targetTexture?: boolean, parentIsTouchable?: boolean, parentTouchScale?: Point | null, parentUniqueColor?: TypeColor | null, drawNumber?: number | null): void;
+    setFirstTransform(parentTransform?: Transform): void;
+    increaseBorderSize(xMultiplierOrPoint?: number | Point, yMultiplier?: number | null): void;
+}
+/**
+ * {@link FigureElementCollection} options object.
+ * @property {TypeParsableTransform} [transform]
+ * @property {TypeParsablePoint} [position] if defined, will overwrite first
+ * translation of `transform`
+ * @property {TypeColor} [color] default color
+ * @property {FigureElement | null} [parent] parent of collection
+ * @property {TypeBorder | 'children' | 'rect' | number} [border]
+ * @property {TypeBorder | 'border' | number | 'rect'} [touchBorder]
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_FigureElementCollection = {
+    transform?: TypeParsableTransform;
+    position?: TypeParsablePoint;
+    color?: TypeColor;
+    parent?: FigureElement | null;
+    border?: TypeBorder | 'children' | 'rect' | number;
+    touchBorder?: TypeBorder | 'border' | number | 'rect';
+    touch?: boolean | number | TypeParsablePoint;
+    move?: boolean | OBJ_ElementMove;
+    dimColor?: TypeColor;
+    scenarios?: OBJ_Scenarios;
+    scene?: Scene;
+};
+/**
+ * Collection figure element
+ *
+ * A collection manages a number of children {@link FigureElements}, be they
+ * primitives or collections.
+ *
+ * A collection's transform will be passed onto all the children elements.
+ *
+ * @class
+ * @extends FigureElement
+ * @group Figure Elements
+ */
+declare class FigureElementCollection extends FigureElement {
+    elements: Record<string, FigureElement>;
+    drawOrder: Array<string>;
+    border: TypeParsableBuffer | TypeBorder | 'children' | 'rect' | number;
+    touchBorder: TypeParsableBuffer | TypeBorder | 'border' | 'children' | 'rect' | number;
+    eqns: Record<string, any>;
+    collections: FigureCollections;
+    hasTouchableElements: boolean;
+    childrenCanAnimate: boolean;
+    drawNumberOrder: Array<number | null>;
+    preserveChildColor: boolean;
+    textureAtlases: {
+        [textureID: string]: {
+            atlas: Atlas;
+            notif: string | null;
+        };
+    };
+    /**
+     * @param {OBJ_FigureElementCollection} options
+     */
+    constructor(options?: OBJ_FigureElementCollection);
+    cleanup(): void;
+    cleanupChildren(): void;
+    init(webgl: WebGLInstance): void;
+    _getStateProperties(options: {
+        ignoreShown?: boolean;
+    }): string[];
+    _getStatePropertiesMin(): string[];
+    getCanvas(): any;
+    getRootElement(): FigureElement | null;
+    _dup(exceptions?: Array<string>): FigureElementCollection;
+    /**
+     * Move child elements to end of draw order - effectively moving to the start
+     * of the drawn collection. Later elements in the array will be further forward.
+     * @param {Array<string | FigureElement> | string | FigureElement} elements
+     */
+    toFront(elementsIn: Array<string | FigureElement> | string | FigureElement): void;
+    /**
+     * Move child elements to start of draw order - effectively moving them to
+     * the back of the drawn collection. Later elements in the `elements` array
+     * will be drawn further back.
+     * @param {Array<string | FigureElement> | string | FigureElement} elements
+     */
+    toBack(elementsIn: Array<string | FigureElement> | string | FigureElement): void;
+    isAnyElementMoving(): boolean;
+    addElementWithName(name: string, element: FigureElement, index?: number): FigureElement;
+    /**
+     * Add a figure element to this collection.
+     *
+     * If adding an array of elements, then the added elements will be returned
+     * in an array (even if only one element is added). If not adding an array,
+     * then that single element will be returned.
+     *
+     * @param {string | FigureElement | OBJ_AddElement | Array<FigureElement | OBJ_AddElement>} nameOrElementOrElementDefinition
+      reference name of element
+     * @param {FigureElement} elementToAdd element to add
+     *
+     * @return {Array<FigureElement> | FigureElement} added element, or array of
+     * added elements
+     *
+     * @example
+     * // Add name and element
+     * const collection = figure.add({ make: 'collection' });
+     * const element = figure.primitives.polygon({ radius: 1 });
+     * collection.add('name', element);
+     *
+     * @example
+     * // Element only (name will be autogenerated)
+     * const collection = figure.add({ make: 'collection' });
+     * const element = figure.primitives.polygon({ radius: 1 });
+     * collection.add(element);
+     *
+     * @example
+     * // Element definition (if no name is provided, then name will
+     * // be auto generated)
+     * const collection = figure.add({ make: 'collection' });
+     * collection.add({
+     *   make: 'polygon',
+     *   radius: 1,
+     * });
+     *
+     * @example
+     * // Array of elements
+     * const collection = figure.add({ make: 'collection' });
+     * const polygon1 = figure.primitives.polygon({ radius: 1 });
+     * collection.add([
+     *   polygon1,
+     *   {
+     *     make: 'polygon',
+     *     radius: 0.2,
+     *     color: [0, 0, 1, 1],
+     *   },
+     * ]);
+     */
+    add(nameOrElementOrElementDefinition: string | FigureElement | OBJ_AddElement | Array<FigureElement | OBJ_AddElement>, elementToAdd?: FigureElement | null | undefined): any;
+    getMethod(make: string): any;
+    setFigure(figure: OBJ_FigureForElement, notify?: boolean): void;
+    willStartAnimating(): boolean;
+    setupDraw(now?: number, canvasIndex?: number): void;
+    draw(now: number, scene: Scene, parentTransform?: Array<Transform>, parentOpacity?: number, targetTexture?: boolean, parentIsTouchable?: boolean, parentTouchScale?: Point | null, parentUniqueColor?: TypeColor | null, drawNumber?: number | null): void;
+    exec(execFunctionAndArgs: string | Array<string | Record<string, any>>, elementsToExec?: Array<string | FigureElement> | null | undefined): void;
+    pulse(optionsOrElementsOrDone?: ((OBJ_Pulse & {
+        elements?: Array<string | FigureElement>;
+    }) | Array<string | FigureElement> | ((arg: any) => void)) | null | undefined, done?: ((arg: any) => void) | null | undefined): void;
+    /**
+     * Get element from an element path with '.' separators.
+     *
+     * For instance, if a collection has a child collection 'a', which
+     * has a child primitive 'b', then the path would be: 'a.b'.
+     *
+     * @see <a href="#figureelementcollectiongetelement">element.getElement</a>
+     *
+     * @param {null | string} elementPath
+     * @return {FigureElement | null } element at path. If `elementPath`
+     * is `null`, then this element is returned. If `elementPath` is invalid
+     * then `null` is returned.
+     *
+     * @example
+     * // Get all the elements from a figure
+     * figure.add(
+     *   {
+     *     name: 'c',
+     *     make: 'collection',
+     *     elements: [
+     *       {
+     *         name: 'tri',
+     *         make: 'triangle',
+     *         height: 0.4,
+     *         width: 0.4,
+     *       },
+     *       {
+     *         name: 'text',
+     *         make: 'text',
+     *         text: 'triangle',
+     *         position: [0, -0.4],
+     *         xAlign: 'center',
+     *       },
+     *     ],
+     *   },
+     * );
+     *
+     * const c = figure.getElement('c');
+     * // Elements within collections can be found with dot notation
+     * const tri = figure.getElement('c.tri');
+     * // Or the collection can be queried directly
+     * const text = c.getElement('text');
+     */
+    getElement(elementPath?: (string | FigureElement) | null | undefined): any;
+    /**
+     * Returns an array of result from
+     * [getElement](#figureelementcollectiongetelement) calls on an
+     * array of paths.
+     *
+     * @param {TypeElementPath} children
+     * @return {Array<FigureElement>} Array of
+     * [getElement](#figureelementcollectiongetelement) results
+     */
+    getElements(children: TypeElementPath): Array<FigureElement>;
+    getShown(): any[];
+    /**
+     * Returns an array of result from
+     * [getElement](#figureelementcollectiongetelement) calls on an
+     * array of paths. Same as `getElements` but more succinct
+     *
+     * @param {TypeElementPath} children
+     * @return {Array<FigureElement>} Array of
+     * [getElement](#figureelementcollectiongetelement) results
+     */
+    get(children: TypeElementPath): any;
+    getUid(uid: string): FigureElement | null;
+    /**
+     * Show collection or specific elements within the collection
+     */
+    show(toShow?: TypeElementPath): void;
+    showOnly(toShow?: TypeElementPath): void;
+    showAll(): void;
+    /**
+     * Hide collection or specific elements within the collection
+     */
+    hide(toHide?: TypeElementPath | null): void;
+    hideAll(): void;
+    hideOnly(listToHide: TypeElementPath): void;
+    resizeHtmlObject(): void;
+    resize(figureHTMLElement?: HTMLElement | null): void;
+    clear(canvasIndex?: number): void;
+    setFirstTransform(parentTransform?: Transform): void;
+    getBorderPoints(border?: 'border' | 'touchBorder', children?: Array<string | FigureElement> | null, shownOnly?: boolean): TypeBorder;
+    /**
+     * Get the border or touchBorder of a FigureElementCollection in a defined
+     * coordinate space.
+     *
+     * @param {TypeCoordinateSpace} space (`'local`)
+     * @param {'border' | 'touchBorder'} border (`'border'`)
+     * @param {Array<string | FigureElement> | null} children choose specific
+     * children only - use `null` for all children (`null`)
+     * @param {boolean} shownOnly if `true` then only children that are shown
+     * will be used (`true`)
+     * @return {Array<Array<Point>>}
+     */
+    getBorder(space?: TypeCoordinateSpace | Type3DMatrix, border?: 'touchBorder' | 'border', children?: Array<string | FigureElement> | null | undefined, shownOnly?: boolean): any[];
+    getBoundingRect(space?: TypeCoordinateSpace, border?: 'touchBorder' | 'border', children?: Array<string | FigureElement> | null | undefined, shownOnly?: boolean): Rect;
+    getRelativeBoundingRect(space?: TypeCoordinateSpace, border?: 'border' | 'touchBorder', children?: Array<string | FigureElement> | null | undefined, shownOnly?: boolean): Rect;
+    getPositionInBounds(space?: TypeCoordinateSpace, xAlign?: 'center' | 'left' | 'right' | 'location' | number, yAlign?: 'middle' | 'top' | 'bottom' | 'location' | number, children?: Array<string | FigureElement> | null | undefined, border?: 'border' | 'touchBorder', shownOnly?: boolean): Point;
+    setUniqueColor(color: null | TypeColor): void;
+    getUniqueColorElement(color: TypeColor): FigureElement | null;
+    updateHTMLElementTie(container: HTMLElement): void;
+    getTouched(glLocation: Point): Array<FigureElement>;
+    setHasTouchableElements(): void;
+    getSelectionFromBorders(glLocation: Point): FigureElement | null;
+    stop(how?: 'freeze' | 'cancel' | 'complete' | 'animateToComplete' | 'dissolveToComplete', elementOnly?: boolean): void;
+    setFont(fontSize: number): void;
+    setColor(color?: TypeColor, setDefault?: boolean): void;
+    setDimColor(color?: TypeColor): void;
+    undim(children?: TypeElementPath | null | undefined): void;
+    dim(children?: TypeElementPath | null | undefined): void;
+    highlight(elementsToHighlight?: TypeElementPath | null | undefined): void;
+    getElementTransforms(): Record<string, any>;
+    getElementColors(onlyShown?: boolean): Record<string, any>;
+    setElementTransforms(elementTransforms: Record<string, any>): void;
+    setElementColors(elementColors: Record<string, any>): void;
+    reorder(): void;
+    animateToTransforms(elementTransforms: Record<string, any>, time?: number, delay?: number, rotDirection?: number, callback?: (string | ((arg: any | null | undefined) => void)) | null | undefined, name?: string, easeFunction?: string | ((n: number) => number)): number;
+    animateToColors(elementColors: Record<string, any>, time?: number, delay?: number, callback?: (string | ((arg: any | null | undefined) => void)) | null | undefined, name?: string, easeFunction?: string | ((n: number) => number)): number;
+    /**
+     * Get all elements within the collection that are primitives, including
+     * any primitives that are children of this element, and any primitives that
+     * are children of this element's children and so forth.
+     *
+     * @return {Array<FigureElement>}
+     */
+    getAllPrimitives(): FigureElement[];
+    /**
+     * Get an array of all elements of in this collection, including this element,
+     * children, children of children and so forth.
+     *
+     * @return {Array<FigureElement>}
+     */
+    getAllElements(): FigureElement[];
+    fontUpdated(): void;
+    getAtlases(callback?: (() => void) | null): void;
+    /**
+     * Recreate all atlases associated with children of this collection.
+     */
+    recreateAtlases(): void;
+    /**
+     * Get array of all children elements.
+     *
+     * @return {Array<FigureElement>}
+     */
+    getChildren(): FigureElement[];
+    getAllElementsWithScenario(scenario: string): Array<FigureElement>;
+    getNextAnimationFinishTime(): number | null;
+    getRemainingAnimationTime(animationNames?: Array<string> | string): number;
+    getAllPossiblyInteractiveElements(): FigureElement[];
+    goToStep(step: number): void;
+    setupWebGLBuffers(newWebgl: WebGLInstance): void;
+    changeWebGLInstance(newWebgl: WebGLInstance): any;
+    getLoadingElements(): any[];
+    setPointsFromDefinition(): void;
+    setPrimitiveColors(): void;
+    unrenderAll(): void;
+    setScenarios(scenarioName: string | Array<string>, onlyIfVisible?: boolean): void;
+    saveScenarios(scenarioName: string, keys: Array<string>): void;
+    animateToState(state: Record<string, any>, options: Record<string, any>, independentOnly?: boolean, startTime?: number | 'now' | 'prevFrame' | 'nextFrame' | null | undefined): number;
+    dissolveInToState(state: Record<string, any>, durationIn?: number, startTime?: number | 'now' | 'prevFrame' | 'nextFrame' | null | undefined): number;
+    setTimeDelta(delta: number): void;
+    isStateSame(state: Record<string, any>, mergePulseTransforms?: boolean, exceptions?: Array<string>): boolean;
+    clearFrozenPulseTransforms(): void;
+    freezePulseTransforms(forceOverwrite?: boolean): void;
+    isAnimating(): boolean;
+    remove(elementName: string): void;
+    stopAnimating(how?: 'freeze' | 'cancel' | 'complete' | 'animateToComplete' | 'dissolveToComplete', name?: string | null, includeChildren?: boolean): void;
+    stateSet(): void;
+    contextLost(): void;
+    _state(options?: {
+        precision?: number;
+        ignoreShown?: boolean;
+        min?: boolean;
+        returnF1Type?: boolean;
+    }): Record<string, any>;
+    align(xAlign: 'left' | 'center' | 'right' | number, yAlign: 'bottom' | 'middle' | 'top' | number): void;
+    getFonts(): any[];
+}
+export { FigureElementPrimitive, FigureElementCollection, FigureElement, };