tsparticles 1.40.2 → 1.41.0

package/umd/Options/Interfaces/Particles/Move/IAttract.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Move/IMove.d.ts

@@ -0,0 +1,35 @@
+import type { MoveDirection, MoveDirectionAlt, OutMode, OutModeAlt } from "../../../../Enums";
+import type { IAttract } from "./IAttract";
+import type { IDistance } from "../../../../Core";
+import type { IMoveAngle } from "./IMoveAngle";
+import type { IMoveGravity } from "./IMoveGravity";
+import type { IOutModes } from "./IOutModes";
+import type { IPath } from "./Path/IPath";
+import type { ISpin } from "./ISpin";
+import type { ITrail } from "./ITrail";
+import type { RangeValue } from "../../../../Types";
+export interface IMove {
+    bounce: boolean;
+    collisions: boolean;
+    out_mode: OutMode | keyof typeof OutMode | OutModeAlt;
+    outMode: OutMode | keyof typeof OutMode | OutModeAlt;
+    noise: IPath;
+    angle: number | IMoveAngle;
+    attract: IAttract;
+    decay: number;
+    direction: MoveDirection | keyof typeof MoveDirection | MoveDirectionAlt | number;
+    distance: number | Partial<IDistance>;
+    drift: RangeValue;
+    enable: boolean;
+    gravity: IMoveGravity;
+    outModes: IOutModes | OutMode | keyof typeof OutMode | OutModeAlt;
+    path: IPath;
+    random: boolean;
+    size: boolean;
+    speed: RangeValue;
+    spin: ISpin;
+    straight: boolean;
+    trail: ITrail;
+    vibrate: boolean;
+    warp: boolean;
+}

package/umd/Options/Interfaces/Particles/Move/IMove.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Move/IMoveAngle.d.ts

@@ -0,0 +1,4 @@
+export interface IMoveAngle {
+    offset: number;
+    value: number;
+}

package/umd/Options/Interfaces/Particles/Move/IMoveAngle.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Move/IMoveGravity.d.ts

@@ -0,0 +1,6 @@
+export interface IMoveGravity {
+    acceleration: number;
+    enable: boolean;
+    inverse: boolean;
+    maxSpeed: number;
+}

package/umd/Options/Interfaces/Particles/Move/IMoveGravity.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Move/IOutModes.d.ts

@@ -0,0 +1,8 @@
+import { OutMode, OutModeAlt } from "../../../../Enums/Modes";
+export interface IOutModes {
+    bottom?: OutMode | keyof typeof OutMode | OutModeAlt;
+    default: OutMode | keyof typeof OutMode | OutModeAlt;
+    left?: OutMode | keyof typeof OutMode | OutModeAlt;
+    right?: OutMode | keyof typeof OutMode | OutModeAlt;
+    top?: OutMode | keyof typeof OutMode | OutModeAlt;
+}

package/umd/Options/Interfaces/Particles/Move/IOutModes.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Move/ISpin.d.ts

@@ -0,0 +1,7 @@
+import type { ICoordinates } from "../../../../Core/Interfaces";
+import type { RangeValue } from "../../../../Types";
+export interface ISpin {
+    acceleration: RangeValue;
+    enable: boolean;
+    position?: ICoordinates;
+}

package/umd/Options/Interfaces/Particles/Move/ISpin.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Move/ITrail.d.ts

@@ -0,0 +1,6 @@
+import type { IColor } from "../../../../Core/Interfaces/Colors";
+export interface ITrail {
+    fillColor: string | IColor;
+    enable: boolean;
+    length: number;
+}

package/umd/Options/Interfaces/Particles/Move/ITrail.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Move/Path/IPath.d.ts

@@ -0,0 +1,9 @@
+import type { IValueWithRandom } from "../../../IValueWithRandom";
+import type { PathOptions } from "../../../../../Types";
+export interface IPath {
+    clamp: boolean;
+    delay: IValueWithRandom;
+    enable: boolean;
+    options: PathOptions;
+    generator?: string;
+}

package/umd/Options/Interfaces/Particles/Move/Path/IPath.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Number/IDensity.d.ts

@@ -0,0 +1,6 @@
+export interface IDensity {
+    area: number;
+    enable: boolean;
+    factor: number;
+    value_area: number;
+}

package/umd/Options/Interfaces/Particles/Number/IDensity.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Number/IParticlesNumber.d.ts

@@ -0,0 +1,7 @@
+import type { IDensity } from "./IDensity";
+export interface IParticlesNumber {
+    max: number;
+    density: IDensity;
+    limit: number;
+    value: number;
+}

package/umd/Options/Interfaces/Particles/Number/IParticlesNumber.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Opacity/IOpacity.d.ts

@@ -0,0 +1,6 @@
+import type { IOpacityAnimation } from "./IOpacityAnimation";
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface IOpacity extends IValueWithRandom {
+    anim: IOpacityAnimation;
+    animation: IOpacityAnimation;
+}

package/umd/Options/Interfaces/Particles/Opacity/IOpacity.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Opacity/IOpacityAnimation.d.ts

@@ -0,0 +1,8 @@
+import type { DestroyType, StartValueType } from "../../../../Enums";
+import type { IAnimation } from "../../IAnimation";
+export interface IOpacityAnimation extends IAnimation {
+    opacity_min?: number;
+    minimumValue?: number;
+    destroy: DestroyType | keyof typeof DestroyType;
+    startValue: StartValueType | keyof typeof StartValueType;
+}

package/umd/Options/Interfaces/Particles/Opacity/IOpacityAnimation.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Orbit/IOrbit.d.ts

@@ -0,0 +1,12 @@
+import type { IAnimatable } from "../../IAnimatable";
+import type { IAnimation } from "../../IAnimation";
+import type { IColor } from "../../../../Core";
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface IOrbit extends IAnimatable<IAnimation> {
+    color?: string | IColor;
+    enable: boolean;
+    radius?: number;
+    rotation: IValueWithRandom;
+    opacity: number;
+    width: number;
+}

package/umd/Options/Interfaces/Particles/Orbit/IOrbit.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Repulse/IRepulse.d.ts

@@ -0,0 +1,8 @@
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface IRepulse extends IValueWithRandom {
+    enabled: boolean;
+    distance: number;
+    duration: number;
+    factor: number;
+    speed: number;
+}

package/umd/Options/Interfaces/Particles/Repulse/IRepulse.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Roll/IRoll.d.ts

@@ -0,0 +1,12 @@
+import type { RangeValue, SingleOrMultiple } from "../../../../Types";
+import type { IColor } from "../../../../Core";
+import type { IRollLight } from "./IRollLight";
+import type { RollMode } from "../../../../Enums";
+export interface IRoll {
+    backColor?: SingleOrMultiple<string> | IColor;
+    darken: IRollLight;
+    enable: boolean;
+    enlighten: IRollLight;
+    mode: RollMode | keyof typeof RollMode;
+    speed: RangeValue;
+}

package/umd/Options/Interfaces/Particles/Roll/IRoll.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Roll/IRollLight.d.ts

@@ -0,0 +1,4 @@
+export interface IRollLight {
+    enable: boolean;
+    value: number;
+}

package/umd/Options/Interfaces/Particles/Roll/IRollLight.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Rotate/IRotate.d.ts

@@ -0,0 +1,8 @@
+import type { RotateDirection, RotateDirectionAlt } from "../../../../Enums";
+import type { IRotateAnimation } from "./IRotateAnimation";
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface IRotate extends IValueWithRandom {
+    animation: IRotateAnimation;
+    direction: RotateDirection | keyof typeof RotateDirection | RotateDirectionAlt;
+    path: boolean;
+}

package/umd/Options/Interfaces/Particles/Rotate/IRotate.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Rotate/IRotateAnimation.d.ts

@@ -0,0 +1,5 @@
+export interface IRotateAnimation {
+    enable: boolean;
+    speed: number;
+    sync: boolean;
+}

package/umd/Options/Interfaces/Particles/Rotate/IRotateAnimation.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Shape/ICharacterShape.d.ts

@@ -0,0 +1,8 @@
+import type { IShapeValues } from "./IShapeValues";
+import type { SingleOrMultiple } from "../../../../Types";
+export interface ICharacterShape extends IShapeValues {
+    value: SingleOrMultiple<string>;
+    font: string;
+    style: string;
+    weight: string;
+}

package/umd/Options/Interfaces/Particles/Shape/ICharacterShape.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Shape/IImageShape.d.ts

@@ -0,0 +1,8 @@
+import type { IShapeValues } from "./IShapeValues";
+export interface IImageShape extends IShapeValues {
+    replace_color: boolean;
+    replaceColor: boolean;
+    src: string;
+    width: number;
+    height: number;
+}

package/umd/Options/Interfaces/Particles/Shape/IImageShape.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Shape/IPolygonShape.d.ts

@@ -0,0 +1,5 @@
+import type { IShapeValues } from "./IShapeValues";
+export interface IPolygonShape extends IShapeValues {
+    nb_sides: number;
+    sides: number;
+}

package/umd/Options/Interfaces/Particles/Shape/IPolygonShape.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Shape/IShape.d.ts

@@ -0,0 +1,16 @@
+import type { ShapeData, SingleOrMultiple } from "../../../../Types";
+import type { ICharacterShape } from "./ICharacterShape";
+import type { IImageShape } from "./IImageShape";
+import type { IPolygonShape } from "./IPolygonShape";
+import type { IStroke } from "../IStroke";
+import type { ShapeType } from "../../../../Enums";
+export interface IShape {
+    type: SingleOrMultiple<ShapeType | keyof typeof ShapeType | string>;
+    stroke: SingleOrMultiple<IStroke>;
+    polygon: SingleOrMultiple<IPolygonShape>;
+    character: SingleOrMultiple<ICharacterShape>;
+    image: SingleOrMultiple<IImageShape>;
+    images: SingleOrMultiple<IImageShape>;
+    custom: ShapeData;
+    options: ShapeData;
+}

package/umd/Options/Interfaces/Particles/Shape/IShape.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Shape/IShapeValues.d.ts

@@ -0,0 +1 @@
+export * from "../../../../Core/Interfaces/IShapeValues";

package/umd/Options/Interfaces/Particles/Shape/IShapeValues.js

@@ -0,0 +1,23 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../../../Core/Interfaces/IShapeValues"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("../../../../Core/Interfaces/IShapeValues"), exports);
+});

package/umd/Options/Interfaces/Particles/Shape/IStarShape.d.ts

@@ -0,0 +1,6 @@
+import { IShapeValues } from "./IShapeValues";
+export interface IStarShape extends IShapeValues {
+    nb_sides: number;
+    sides: number;
+    inset: number;
+}

package/umd/Options/Interfaces/Particles/Shape/IStarShape.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Size/ISize.d.ts

@@ -0,0 +1,6 @@
+import type { ISizeAnimation } from "./ISizeAnimation";
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface ISize extends IValueWithRandom {
+    anim: ISizeAnimation;
+    animation: ISizeAnimation;
+}

package/umd/Options/Interfaces/Particles/Size/ISize.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Size/ISizeAnimation.d.ts

@@ -0,0 +1,8 @@
+import type { DestroyType, StartValueType } from "../../../../Enums";
+import type { IAnimation } from "../../IAnimation";
+export interface ISizeAnimation extends IAnimation {
+    size_min?: number;
+    minimumValue?: number;
+    destroy: DestroyType | keyof typeof DestroyType;
+    startValue: StartValueType | keyof typeof StartValueType;
+}

package/umd/Options/Interfaces/Particles/Size/ISizeAnimation.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Options/Interfaces/Particles/Tilt/ITilt.d.ts

@@ -0,0 +1,8 @@
+import type { TiltDirection, TiltDirectionAlt } from "../../../../Enums";
+import type { ITiltAnimation } from "./ITiltAnimation";
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface ITilt extends IValueWithRandom {
+    animation: ITiltAnimation;
+    direction: TiltDirection | keyof typeof TiltDirection | TiltDirectionAlt;
+    enable: boolean;
+}