@tsparticles/engine 3.0.0-alpha.0

package/types/Enums/Modes/ClickMode.d.ts

@@ -0,0 +1,9 @@
+export declare const enum ClickMode {
+    attract = "attract",
+    bubble = "bubble",
+    push = "push",
+    remove = "remove",
+    repulse = "repulse",
+    pause = "pause",
+    trail = "trail"
+}

package/types/Enums/Modes/CollisionMode.d.ts

@@ -0,0 +1,5 @@
+export declare const enum CollisionMode {
+    absorb = "absorb",
+    bounce = "bounce",
+    destroy = "destroy"
+}

package/types/Enums/Modes/DivMode.d.ts

@@ -0,0 +1,5 @@
+export declare const enum DivMode {
+    bounce = "bounce",
+    bubble = "bubble",
+    repulse = "repulse"
+}

package/types/Enums/Modes/HoverMode.d.ts

@@ -0,0 +1,11 @@
+export declare const enum HoverMode {
+    attract = "attract",
+    bounce = "bounce",
+    bubble = "bubble",
+    connect = "connect",
+    grab = "grab",
+    light = "light",
+    repulse = "repulse",
+    slow = "slow",
+    trail = "trail"
+}

package/types/Enums/Modes/OutMode.d.ts

@@ -0,0 +1,10 @@
+export declare const enum OutMode {
+    bounce = "bounce",
+    bounceHorizontal = "bounce-horizontal",
+    bounceVertical = "bounce-vertical",
+    none = "none",
+    out = "out",
+    destroy = "destroy",
+    split = "split"
+}
+export type OutModeAlt = "bounce-horizontal" | "bounce-vertical";

package/types/Enums/Modes/ResponsiveMode.d.ts

@@ -0,0 +1,4 @@
+export declare const enum ResponsiveMode {
+    screen = "screen",
+    canvas = "canvas"
+}

package/types/Enums/Modes/SizeMode.d.ts

@@ -0,0 +1,4 @@
+export declare const enum SizeMode {
+    precise = "precise",
+    percent = "percent"
+}

package/types/Enums/Modes/ThemeMode.d.ts

@@ -0,0 +1,5 @@
+export declare const enum ThemeMode {
+    any = "any",
+    dark = "dark",
+    light = "light"
+}

package/types/Enums/Types/AlterType.d.ts

@@ -0,0 +1,4 @@
+export declare const enum AlterType {
+    darken = "darken",
+    enlighten = "enlighten"
+}

package/types/Enums/Types/DestroyType.d.ts

@@ -0,0 +1,5 @@
+export declare const enum DestroyType {
+    none = "none",
+    max = "max",
+    min = "min"
+}

package/types/Enums/Types/DivType.d.ts

@@ -0,0 +1,4 @@
+export declare const enum DivType {
+    circle = "circle",
+    rectangle = "rectangle"
+}

package/types/Enums/Types/EasingType.d.ts

@@ -0,0 +1,27 @@
+export declare const enum EasingType {
+    easeInBack = "ease-in-back",
+    easeInCirc = "ease-in-circ",
+    easeInCubic = "ease-in-cubic",
+    easeInQuad = "ease-in-quad",
+    easeInQuart = "ease-in-quart",
+    easeInQuint = "ease-in-quint",
+    easeInExpo = "ease-in-expo",
+    easeInSine = "ease-in-sine",
+    easeOutBack = "ease-out-back",
+    easeOutCirc = "ease-out-circ",
+    easeOutCubic = "ease-out-cubic",
+    easeOutQuad = "ease-out-quad",
+    easeOutQuart = "ease-out-quart",
+    easeOutQuint = "ease-out-quint",
+    easeOutExpo = "ease-out-expo",
+    easeOutSine = "ease-out-sine",
+    easeInOutBack = "ease-in-out-back",
+    easeInOutCirc = "ease-in-out-circ",
+    easeInOutCubic = "ease-in-out-cubic",
+    easeInOutQuad = "ease-in-out-quad",
+    easeInOutQuart = "ease-in-out-quart",
+    easeInOutQuint = "ease-in-out-quint",
+    easeInOutExpo = "ease-in-out-expo",
+    easeInOutSine = "ease-in-out-sine"
+}
+export type EasingTypeAlt = "ease-in-back" | "ease-out-back" | "ease-in-out-back" | "ease-in-circ" | "ease-out-circ" | "ease-in-out-circ" | "ease-in-cubic" | "ease-out-cubic" | "ease-in-out-cubic" | "ease-in-quad" | "ease-out-quad" | "ease-in-out-quad" | "ease-in-quart" | "ease-out-quart" | "ease-in-out-quart" | "ease-in-quint" | "ease-out-quint" | "ease-in-out-quint" | "ease-in-expo" | "ease-out-expo" | "ease-in-out-expo" | "ease-in-sine" | "ease-out-sine" | "ease-in-out-sine";

package/types/Enums/Types/EventType.d.ts

@@ -0,0 +1,12 @@
+export declare const enum EventType {
+    containerInit = "containerInit",
+    particlesSetup = "particlesSetup",
+    containerStarted = "containerStarted",
+    containerStopped = "containerStopped",
+    containerDestroyed = "containerDestroyed",
+    containerPaused = "containerPaused",
+    containerPlay = "containerPlay",
+    containerBuilt = "containerBuilt",
+    particleAdded = "particleAdded",
+    particleRemoved = "particleRemoved"
+}

package/types/Enums/Types/GradientType.d.ts

@@ -0,0 +1,5 @@
+export declare const enum GradientType {
+    linear = "linear",
+    radial = "radial",
+    random = "random"
+}

package/types/Enums/Types/InteractorType.d.ts

@@ -0,0 +1,4 @@
+export declare const enum InteractorType {
+    external = "external",
+    particles = "particles"
+}

package/types/Enums/Types/ParticleOutType.d.ts

@@ -0,0 +1,5 @@
+export declare const enum ParticleOutType {
+    normal = "normal",
+    inside = "inside",
+    outside = "outside"
+}

package/types/Enums/Types/StartValueType.d.ts

@@ -0,0 +1,5 @@
+export declare const enum StartValueType {
+    max = "max",
+    min = "min",
+    random = "random"
+}

package/types/Options/Classes/AnimatableColor.d.ts

@@ -0,0 +1,12 @@
+import { HslAnimation } from "./HslAnimation";
+import type { IAnimatableColor } from "../Interfaces/IAnimatableColor";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import { OptionsColor } from "./OptionsColor";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../Types/SingleOrMultiple";
+export declare class AnimatableColor extends OptionsColor implements IAnimatableColor, IOptionLoader<IAnimatableColor> {
+    animation: HslAnimation;
+    constructor();
+    static create(source?: AnimatableColor, data?: SingleOrMultiple<string> | RecursivePartial<IAnimatableColor>): AnimatableColor;
+    load(data?: RecursivePartial<IAnimatableColor>): void;
+}

package/types/Options/Classes/AnimationOptions.d.ts

@@ -0,0 +1,20 @@
+import type { IAnimation, IRangedAnimation } from "../Interfaces/IAnimation";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { RangeValue } from "../../Types/RangeValue";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+import { StartValueType } from "../../Enums/Types/StartValueType";
+export declare class AnimationOptions implements IAnimation, IOptionLoader<IAnimation> {
+    count: RangeValue;
+    decay: RangeValue;
+    enable: boolean;
+    speed: RangeValue;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<IAnimation>): void;
+}
+export declare class RangedAnimationOptions extends AnimationOptions implements IOptionLoader<IRangedAnimation> {
+    minimumValue?: number;
+    startValue: StartValueType | keyof typeof StartValueType;
+    constructor();
+    load(data?: RecursivePartial<IRangedAnimation>): void;
+}

package/types/Options/Classes/Background/Background.d.ts

@@ -0,0 +1,14 @@
+import type { IBackground } from "../../Interfaces/Background/IBackground";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../OptionsColor";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+export declare class Background implements IBackground, IOptionLoader<IBackground> {
+    color: OptionsColor;
+    image: string;
+    opacity: number;
+    position: string;
+    repeat: string;
+    size: string;
+    constructor();
+    load(data?: RecursivePartial<IBackground>): void;
+}

package/types/Options/Classes/BackgroundMask/BackgroundMask.d.ts

@@ -0,0 +1,11 @@
+import { BackgroundMaskCover } from "./BackgroundMaskCover";
+import type { IBackgroundMask } from "../../Interfaces/BackgroundMask/IBackgroundMask";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+export declare class BackgroundMask implements IBackgroundMask, IOptionLoader<IBackgroundMask> {
+    composite: GlobalCompositeOperation;
+    cover: BackgroundMaskCover;
+    enable: boolean;
+    constructor();
+    load(data?: RecursivePartial<IBackgroundMask>): void;
+}

package/types/Options/Classes/BackgroundMask/BackgroundMaskCover.d.ts

@@ -0,0 +1,10 @@
+import type { IBackgroundMaskCover } from "../../Interfaces/BackgroundMask/IBackgroundMaskCover";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../OptionsColor";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+export declare class BackgroundMaskCover implements IBackgroundMaskCover, IOptionLoader<IBackgroundMaskCover> {
+    color: OptionsColor;
+    opacity: number;
+    constructor();
+    load(data?: RecursivePartial<IBackgroundMaskCover> | undefined): void;
+}

package/types/Options/Classes/ColorAnimation.d.ts

@@ -0,0 +1,14 @@
+import type { IColorAnimation } from "../Interfaces/IColorAnimation";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { RangeValue } from "../../Types/RangeValue";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+export declare class ColorAnimation implements IColorAnimation, IOptionLoader<IColorAnimation> {
+    count: RangeValue;
+    decay: RangeValue;
+    enable: boolean;
+    offset: RangeValue;
+    speed: RangeValue;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<IColorAnimation>): void;
+}

package/types/Options/Classes/FullScreen/FullScreen.d.ts

@@ -0,0 +1,9 @@
+import type { IFullScreen } from "../../Interfaces/FullScreen/IFullScreen";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+export declare class FullScreen implements IFullScreen, IOptionLoader<IFullScreen> {
+    enable: boolean;
+    zIndex: number;
+    constructor();
+    load(data?: RecursivePartial<IFullScreen>): void;
+}

package/types/Options/Classes/HslAnimation.d.ts

@@ -0,0 +1,11 @@
+import { ColorAnimation } from "./ColorAnimation";
+import type { IHslAnimation } from "../Interfaces/IHslAnimation";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+export declare class HslAnimation implements IHslAnimation, IOptionLoader<IHslAnimation> {
+    h: ColorAnimation;
+    l: ColorAnimation;
+    s: ColorAnimation;
+    constructor();
+    load(data?: RecursivePartial<IHslAnimation>): void;
+}

package/types/Options/Classes/Interactivity/Events/ClickEvent.d.ts

@@ -0,0 +1,11 @@
+import type { ClickMode } from "../../../../Enums/Modes/ClickMode";
+import type { IClickEvent } from "../../../Interfaces/Interactivity/Events/IClickEvent";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class ClickEvent implements IClickEvent, IOptionLoader<IClickEvent> {
+    enable: boolean;
+    mode: SingleOrMultiple<ClickMode | keyof typeof ClickMode | string>;
+    constructor();
+    load(data?: RecursivePartial<IClickEvent>): void;
+}

package/types/Options/Classes/Interactivity/Events/DivEvent.d.ts

@@ -0,0 +1,20 @@
+import type { DivMode } from "../../../../Enums/Modes/DivMode";
+import { DivType } from "../../../../Enums/Types/DivType";
+import type { IDivEvent } from "../../../Interfaces/Interactivity/Events/IDivEvent";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class DivEvent implements IDivEvent, IOptionLoader<IDivEvent> {
+    enable: boolean;
+    mode: SingleOrMultiple<DivMode | keyof typeof DivMode | string>;
+    selectors: SingleOrMultiple<string>;
+    type: DivType | keyof typeof DivType;
+    constructor();
+    get el(): SingleOrMultiple<string>;
+    set el(value: SingleOrMultiple<string>);
+    get elementId(): SingleOrMultiple<string>;
+    set elementId(value: SingleOrMultiple<string>);
+    get ids(): SingleOrMultiple<string>;
+    set ids(value: SingleOrMultiple<string>);
+    load(data?: RecursivePartial<IDivEvent>): void;
+}

package/types/Options/Classes/Interactivity/Events/Events.d.ts

@@ -0,0 +1,22 @@
+import { ClickEvent } from "./ClickEvent";
+import { DivEvent } from "./DivEvent";
+import { HoverEvent } from "./HoverEvent";
+import type { IEvents } from "../../../Interfaces/Interactivity/Events/IEvents";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import { ResizeEvent } from "./ResizeEvent";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class Events implements IEvents, IOptionLoader<IEvents> {
+    onClick: ClickEvent;
+    onDiv: SingleOrMultiple<DivEvent>;
+    onHover: HoverEvent;
+    resize: ResizeEvent;
+    constructor();
+    get onclick(): ClickEvent;
+    set onclick(value: ClickEvent);
+    get ondiv(): SingleOrMultiple<DivEvent>;
+    set ondiv(value: SingleOrMultiple<DivEvent>);
+    get onhover(): HoverEvent;
+    set onhover(value: HoverEvent);
+    load(data?: RecursivePartial<IEvents>): void;
+}

package/types/Options/Classes/Interactivity/Events/HoverEvent.d.ts

@@ -0,0 +1,13 @@
+import type { HoverMode } from "../../../../Enums/Modes/HoverMode";
+import type { IHoverEvent } from "../../../Interfaces/Interactivity/Events/IHoverEvent";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { Parallax } from "./Parallax";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class HoverEvent implements IHoverEvent, IOptionLoader<IHoverEvent> {
+    enable: boolean;
+    mode: SingleOrMultiple<HoverMode | keyof typeof HoverMode | string>;
+    parallax: Parallax;
+    constructor();
+    load(data?: RecursivePartial<IHoverEvent>): void;
+}

package/types/Options/Classes/Interactivity/Events/Parallax.d.ts

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IParallax } from "../../../Interfaces/Interactivity/Events/IParallax";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Parallax implements IParallax, IOptionLoader<IParallax> {
+    enable: boolean;
+    force: number;
+    smooth: number;
+    constructor();
+    load(data?: RecursivePartial<IParallax>): void;
+}

package/types/Options/Classes/Interactivity/Events/ResizeEvent.d.ts

@@ -0,0 +1,9 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IResizeEvent } from "../../../Interfaces/Interactivity/Events/IResizeEvent";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class ResizeEvent implements IResizeEvent, IOptionLoader<IResizeEvent> {
+    delay: number;
+    enable: boolean;
+    constructor();
+    load(data?: RecursivePartial<IResizeEvent>): void;
+}

package/types/Options/Classes/Interactivity/Interactivity.d.ts

@@ -0,0 +1,18 @@
+import type { Container } from "../../../Core/Container";
+import type { Engine } from "../../../engine";
+import { Events } from "./Events/Events";
+import type { IInteractivity } from "../../Interfaces/Interactivity/IInteractivity";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import { InteractivityDetect } from "../../../Enums/InteractivityDetect";
+import { Modes } from "./Modes/Modes";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+export declare class Interactivity implements IInteractivity, IOptionLoader<IInteractivity> {
+    [name: string]: unknown;
+    detectsOn: InteractivityDetect | keyof typeof InteractivityDetect;
+    events: Events;
+    modes: Modes;
+    constructor(engine: Engine, container?: Container);
+    get detect_on(): InteractivityDetect | keyof typeof InteractivityDetect;
+    set detect_on(value: InteractivityDetect | keyof typeof InteractivityDetect);
+    load(data?: RecursivePartial<IInteractivity>): void;
+}

package/types/Options/Classes/Interactivity/Modes/Modes.d.ts

@@ -0,0 +1,12 @@
+import type { Container } from "../../../../Core/Container";
+import type { Engine } from "../../../../engine";
+import type { IModes } from "../../../Interfaces/Interactivity/Modes/IModes";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Modes implements IModes, IOptionLoader<IModes> {
+    [name: string]: unknown;
+    private readonly _container;
+    private readonly _engine;
+    constructor(engine: Engine, container?: Container);
+    load(data?: RecursivePartial<IModes>): void;
+}

package/types/Options/Classes/ManualParticle.d.ts

@@ -0,0 +1,10 @@
+import type { ICoordinates } from "../../Core/Interfaces/ICoordinates";
+import type { IManualParticle } from "../Interfaces/IManualParticle";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { IParticlesOptions } from "../Interfaces/Particles/IParticlesOptions";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+export declare class ManualParticle implements IManualParticle, IOptionLoader<IManualParticle> {
+    options?: RecursivePartial<IParticlesOptions>;
+    position?: ICoordinates;
+    load(data?: RecursivePartial<IManualParticle>): void;
+}

package/types/Options/Classes/Options.d.ts

@@ -0,0 +1,58 @@
+import { Background } from "./Background/Background";
+import { BackgroundMask } from "./BackgroundMask/BackgroundMask";
+import type { Container } from "../../Core/Container";
+import type { Engine } from "../../engine";
+import { FullScreen } from "./FullScreen/FullScreen";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { IOptions } from "../Interfaces/IOptions";
+import type { ISourceOptions } from "../../Types/ISourceOptions";
+import { Interactivity } from "./Interactivity/Interactivity";
+import { ManualParticle } from "./ManualParticle";
+import type { RangeValue } from "../../Types/RangeValue";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+import { Responsive } from "./Responsive";
+import type { SingleOrMultiple } from "../../Types/SingleOrMultiple";
+import { Theme } from "./Theme/Theme";
+interface DefaultThemes {
+    dark?: string;
+    light?: string;
+}
+export declare class Options implements IOptions, IOptionLoader<IOptions> {
+    [name: string]: unknown;
+    autoPlay: boolean;
+    background: Background;
+    backgroundMask: BackgroundMask;
+    defaultThemes: DefaultThemes;
+    delay: RangeValue;
+    detectRetina: boolean;
+    duration: RangeValue;
+    fpsLimit: number;
+    fullScreen: FullScreen;
+    interactivity: Interactivity;
+    manualParticles: ManualParticle[];
+    name: string;
+    particles: import("./Particles/ParticlesOptions").ParticlesOptions;
+    pauseOnBlur: boolean;
+    pauseOnOutsideViewport: boolean;
+    preset?: SingleOrMultiple<string>;
+    responsive: Responsive[];
+    smooth: boolean;
+    style: RecursivePartial<CSSStyleDeclaration>;
+    themes: Theme[];
+    zLayers: number;
+    private readonly _container;
+    private readonly _engine;
+    constructor(engine: Engine, container: Container);
+    get backgroundMode(): FullScreen;
+    set backgroundMode(value: FullScreen);
+    get fps_limit(): number;
+    set fps_limit(value: number);
+    get retina_detect(): boolean;
+    set retina_detect(value: boolean);
+    load(data?: ISourceOptions): void;
+    setResponsive(width: number, pxRatio: number, defaultOptions: IOptions): number | undefined;
+    setTheme(name?: string): void;
+    private _findDefaultTheme;
+    private _importPreset;
+}
+export {};

package/types/Options/Classes/OptionsColor.d.ts

@@ -0,0 +1,11 @@
+import type { IRangeHsl, IRangeHsv, IRangeRgb, IRangeValueColor } from "../../Core/Interfaces/Colors";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { IOptionsColor } from "../Interfaces/IOptionsColor";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../Types/SingleOrMultiple";
+export declare class OptionsColor implements IOptionsColor, IOptionLoader<IOptionsColor> {
+    value: SingleOrMultiple<SingleOrMultiple<string> | IRangeValueColor | IRangeRgb | IRangeHsl | IRangeHsv>;
+    constructor();
+    static create(source?: OptionsColor, data?: SingleOrMultiple<string> | RecursivePartial<IOptionsColor>): OptionsColor;
+    load(data?: RecursivePartial<IOptionsColor>): void;
+}

package/types/Options/Classes/Particles/Bounce/ParticlesBounce.d.ts

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IParticlesBounce } from "../../../Interfaces/Particles/Bounce/IParticlesBounce";
+import { ParticlesBounceFactor } from "./ParticlesBounceFactor";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class ParticlesBounce implements IParticlesBounce, IOptionLoader<IParticlesBounce> {
+    horizontal: ParticlesBounceFactor;
+    vertical: ParticlesBounceFactor;
+    constructor();
+    load(data?: RecursivePartial<IParticlesBounce>): void;
+}

package/types/Options/Classes/Particles/Bounce/ParticlesBounceFactor.d.ts

@@ -0,0 +1,4 @@
+import { ValueWithRandom } from "../../ValueWithRandom";
+export declare class ParticlesBounceFactor extends ValueWithRandom {
+    constructor();
+}

package/types/Options/Classes/Particles/Collisions/Collisions.d.ts

@@ -0,0 +1,16 @@
+import { CollisionMode } from "../../../../Enums/Modes/CollisionMode";
+import { CollisionsAbsorb } from "./CollisionsAbsorb";
+import { CollisionsOverlap } from "./CollisionsOverlap";
+import type { ICollisions } from "../../../Interfaces/Particles/Collisions/ICollisions";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { ParticlesBounce } from "../Bounce/ParticlesBounce";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Collisions implements ICollisions, IOptionLoader<ICollisions> {
+    absorb: CollisionsAbsorb;
+    bounce: ParticlesBounce;
+    enable: boolean;
+    mode: CollisionMode | keyof typeof CollisionMode;
+    overlap: CollisionsOverlap;
+    constructor();
+    load(data?: RecursivePartial<ICollisions>): void;
+}

package/types/Options/Classes/Particles/Collisions/CollisionsAbsorb.d.ts

@@ -0,0 +1,8 @@
+import type { ICollisionsAbsorb } from "../../../Interfaces/Particles/Collisions/ICollisionsAbsorb";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class CollisionsAbsorb implements ICollisionsAbsorb, IOptionLoader<ICollisionsAbsorb> {
+    speed: number;
+    constructor();
+    load(data?: RecursivePartial<ICollisionsAbsorb>): void;
+}

package/types/Options/Classes/Particles/Collisions/CollisionsOverlap.d.ts

@@ -0,0 +1,9 @@
+import type { ICollisionsOverlap } from "../../../Interfaces/Particles/Collisions/ICollisionsOverlap";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class CollisionsOverlap implements ICollisionsOverlap, IOptionLoader<ICollisionsOverlap> {
+    enable: boolean;
+    retries: number;
+    constructor();
+    load(data?: RecursivePartial<ICollisionsOverlap>): void;
+}

package/types/Options/Classes/Particles/Move/Move.d.ts

@@ -0,0 +1,49 @@
+import type { OutMode, OutModeAlt } from "../../../../Enums/Modes/OutMode";
+import type { IDistance } from "../../../../Core/Interfaces/IDistance";
+import type { IMove } from "../../../Interfaces/Particles/Move/IMove";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { MoveAngle } from "./MoveAngle";
+import { MoveAttract } from "./MoveAttract";
+import { MoveCenter } from "./MoveCenter";
+import { MoveDirection } from "../../../../Enums/Directions/MoveDirection";
+import type { MoveDirectionAlt } from "../../../../Enums/Directions/MoveDirection";
+import { MoveGravity } from "./MoveGravity";
+import { MovePath } from "./Path/MovePath";
+import { MoveTrail } from "./MoveTrail";
+import { OutModes } from "./OutModes";
+import type { RangeValue } from "../../../../Types/RangeValue";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import { Spin } from "./Spin";
+export declare class Move implements IMove, IOptionLoader<IMove> {
+    angle: MoveAngle;
+    attract: MoveAttract;
+    center: MoveCenter;
+    decay: RangeValue;
+    direction: MoveDirection | keyof typeof MoveDirection | MoveDirectionAlt | number;
+    distance: Partial<IDistance>;
+    drift: RangeValue;
+    enable: boolean;
+    gravity: MoveGravity;
+    outModes: OutModes;
+    path: MovePath;
+    random: boolean;
+    size: boolean;
+    speed: RangeValue;
+    spin: Spin;
+    straight: boolean;
+    trail: MoveTrail;
+    vibrate: boolean;
+    warp: boolean;
+    constructor();
+    get bounce(): boolean;
+    set bounce(value: boolean);
+    get collisions(): boolean;
+    set collisions(_: boolean);
+    get noise(): MovePath;
+    set noise(value: MovePath);
+    get outMode(): OutMode | keyof typeof OutMode | OutModeAlt;
+    set outMode(value: OutMode | keyof typeof OutMode | OutModeAlt);
+    get out_mode(): OutMode | keyof typeof OutMode | OutModeAlt;
+    set out_mode(value: OutMode | keyof typeof OutMode | OutModeAlt);
+    load(data?: RecursivePartial<IMove>): void;
+}

package/types/Options/Classes/Particles/Move/MoveAngle.d.ts

@@ -0,0 +1,10 @@
+import type { IMoveAngle } from "../../../Interfaces/Particles/Move/IMoveAngle";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RangeValue } from "../../../../Types/RangeValue";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class MoveAngle implements IMoveAngle, IOptionLoader<IMoveAngle> {
+    offset: RangeValue;
+    value: RangeValue;
+    constructor();
+    load(data?: RecursivePartial<IMoveAngle>): void;
+}

package/types/Options/Classes/Particles/Move/MoveAttract.d.ts

@@ -0,0 +1,16 @@
+import type { ICoordinates } from "../../../../Core/Interfaces/ICoordinates";
+import type { IMoveAttract } from "../../../Interfaces/Particles/Move/IMoveAttract";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RangeValue } from "../../../../Types/RangeValue";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class MoveAttract implements IMoveAttract, IOptionLoader<IMoveAttract> {
+    distance: RangeValue;
+    enable: boolean;
+    rotate: ICoordinates;
+    constructor();
+    get rotateX(): number;
+    set rotateX(value: number);
+    get rotateY(): number;
+    set rotateY(value: number);
+    load(data?: RecursivePartial<IMoveAttract>): void;
+}