tsparticles 1.42.2 → 1.43.0

package/types/Movers/Base/BaseMover.d.ts

@@ -0,0 +1,9 @@
+import type { IDelta } from "../../Core/Interfaces/IDelta";
+import type { IParticleMover } from "../../Core/Interfaces/IParticlesMover";
+import type { Particle } from "../../Core/Particle";
+import type { SpinParticle } from "./Types";
+export declare class BaseMover implements IParticleMover {
+    init(particle: SpinParticle): void;
+    isEnabled(particle: Particle): boolean;
+    move(particle: SpinParticle, delta: IDelta): void;
+}

package/types/Movers/Base/IParticleSpin.d.ts

@@ -0,0 +1,9 @@
+import type { ICoordinates } from "../../Core/Interfaces/ICoordinates";
+import type { RotateDirection } from "../../Enums/Directions/RotateDirection";
+export interface IParticleSpin {
+    acceleration: number;
+    angle: number;
+    direction: RotateDirection;
+    radius: number;
+    center: ICoordinates;
+}

package/types/Movers/Base/Types.d.ts

@@ -0,0 +1,8 @@
+import type { IParticleSpin } from "./IParticleSpin";
+import type { Particle } from "../../Core/Particle";
+export declare type SpinParticle = Particle & {
+    spin?: IParticleSpin;
+    retina: {
+        spinAcceleration?: number;
+    };
+};

package/types/Movers/Base/Utils.d.ts

@@ -0,0 +1,7 @@
+import type { IDelta } from "../../Core/Interfaces/IDelta";
+import type { Particle } from "../../Core/Particle";
+import type { SpinParticle } from "./Types";
+export declare function applyDistance(particle: SpinParticle): void;
+export declare function spin(particle: SpinParticle, moveSpeed: number): void;
+export declare function applyPath(particle: Particle, delta: IDelta): void;
+export declare function getProximitySpeedFactor(particle: Particle): number;

package/types/Movers/Base/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadBaseMover(engine: Engine): Promise<void>;

package/types/Movers/Parallax/ParallaxMover.d.ts

@@ -0,0 +1,7 @@
+import type { IParticleMover } from "../../Core/Interfaces/IParticlesMover";
+import { Particle } from "../../Core/Particle";
+export declare class ParallaxMover implements IParticleMover {
+    init(): void;
+    isEnabled(particle: Particle): boolean;
+    move(particle: Particle): void;
+}

package/types/Movers/Parallax/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadParallaxMover(engine: Engine): Promise<void>;

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/AnimatableGradient.d.ts

@@ -0,0 +1,56 @@
+import type { IAnimatableGradientColor, IGradientColorOpacityAnimation } from "../Interfaces/IOptionsGradient";
+import type { IGradientAngle, IGradientColorOpacity } from "../../Core/Interfaces/Gradients";
+import { RotateDirection, RotateDirectionAlt } from "../../Enums/Directions/RotateDirection";
+import { AnimatableColor } from "./AnimatableColor";
+import { GradientType } from "../../Enums/Types/GradientType";
+import type { IAnimatable } from "../Interfaces/IAnimatable";
+import type { IAnimatableGradient } from "../Interfaces/IAnimatableGradient";
+import type { IAnimation } 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 AnimatableGradient implements IAnimatableGradient, IOptionLoader<IAnimatableGradient> {
+    angle: GradientAngle;
+    colors: AnimatableGradientColor[];
+    type: GradientType;
+    constructor();
+    load(data?: RecursivePartial<IAnimatableGradient>): void;
+}
+export declare class GradientAngle implements IGradientAngle, IAnimatable<IAnimation>, IOptionLoader<IGradientAngle & IAnimatable<IAnimation>> {
+    animation: GradientAngleAnimation;
+    value: number;
+    direction: RotateDirection | keyof typeof RotateDirection | RotateDirectionAlt;
+    constructor();
+    load(data?: RecursivePartial<IGradientAngle & IAnimatable<IAnimation>>): void;
+}
+export declare class GradientColorOpacity implements IGradientColorOpacity, IAnimatable<GradientColorOpacityAnimation>, IOptionLoader<IGradientColorOpacity & IAnimatable<IGradientColorOpacityAnimation>> {
+    animation: GradientColorOpacityAnimation;
+    value: RangeValue;
+    constructor();
+    load(data?: RecursivePartial<IGradientColorOpacity & IAnimatable<IAnimation>>): void;
+}
+export declare class AnimatableGradientColor implements IAnimatableGradientColor, IOptionLoader<IAnimatableGradientColor> {
+    stop: number;
+    value: AnimatableColor;
+    opacity?: GradientColorOpacity;
+    constructor();
+    load(data?: RecursivePartial<IAnimatableGradientColor>): void;
+}
+export declare class GradientAngleAnimation implements IAnimation, IOptionLoader<IAnimation> {
+    count: RangeValue;
+    enable: boolean;
+    speed: RangeValue;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<IAnimation>): void;
+}
+export declare class GradientColorOpacityAnimation implements IGradientColorOpacityAnimation, IOptionLoader<IGradientColorOpacityAnimation> {
+    count: RangeValue;
+    enable: boolean;
+    speed: RangeValue;
+    sync: boolean;
+    startValue: StartValueType | keyof typeof StartValueType;
+    constructor();
+    load(data?: RecursivePartial<IGradientColorOpacityAnimation>): void;
+}

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

@@ -0,0 +1,12 @@
+import type { IAnimation } from "../Interfaces/IAnimation";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { RangeValue } from "../../Types/RangeValue";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+export declare class AnimationOptions implements IAnimation, IOptionLoader<IAnimation> {
+    count: RangeValue;
+    enable: boolean;
+    speed: RangeValue;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<IAnimation>): 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;
+    position: string;
+    repeat: string;
+    size: string;
+    opacity: number;
+    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,13 @@
+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;
+    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;
+    s: ColorAnimation;
+    l: ColorAnimation;
+    constructor();
+    load(data?: RecursivePartial<IHslAnimation>): void;
+}

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

@@ -0,0 +1,11 @@
+import { 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 { 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> {
+    get elementId(): SingleOrMultiple<string>;
+    set elementId(value: SingleOrMultiple<string>);
+    get el(): SingleOrMultiple<string>;
+    set el(value: SingleOrMultiple<string>);
+    get ids(): SingleOrMultiple<string>;
+    set ids(value: SingleOrMultiple<string>);
+    selectors: SingleOrMultiple<string>;
+    enable: boolean;
+    mode: SingleOrMultiple<DivMode | keyof typeof DivMode | string>;
+    type: DivType;
+    constructor();
+    load(data?: RecursivePartial<IDivEvent>): void;
+}

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

@@ -0,0 +1,21 @@
+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 type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class Events implements IEvents, IOptionLoader<IEvents> {
+    get onclick(): ClickEvent;
+    set onclick(value: ClickEvent);
+    get ondiv(): SingleOrMultiple<DivEvent>;
+    set ondiv(value: SingleOrMultiple<DivEvent>);
+    get onhover(): HoverEvent;
+    set onhover(value: HoverEvent);
+    onClick: ClickEvent;
+    onDiv: SingleOrMultiple<DivEvent>;
+    onHover: HoverEvent;
+    resize: boolean;
+    constructor();
+    load(data?: RecursivePartial<IEvents>): void;
+}

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

@@ -0,0 +1,13 @@
+import { 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/Interactivity.d.ts

@@ -0,0 +1,15 @@
+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> {
+    get detect_on(): InteractivityDetect | keyof typeof InteractivityDetect;
+    set detect_on(value: InteractivityDetect | keyof typeof InteractivityDetect);
+    detectsOn: InteractivityDetect | keyof typeof InteractivityDetect;
+    events: Events;
+    modes: Modes;
+    constructor();
+    load(data?: RecursivePartial<IInteractivity>): void;
+}

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

@@ -0,0 +1,14 @@
+import { EasingType } from "../../../../Enums/Types/EasingType";
+import type { IAttract } from "../../../Interfaces/Interactivity/Modes/IAttract";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Attract implements IAttract, IOptionLoader<IAttract> {
+    distance: number;
+    duration: number;
+    easing: EasingType;
+    factor: number;
+    maxSpeed: number;
+    speed: number;
+    constructor();
+    load(data?: RecursivePartial<IAttract>): void;
+}

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

@@ -0,0 +1,8 @@
+import type { IBounce } from "../../../Interfaces/Interactivity/Modes/IBounce";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Bounce implements IBounce, IOptionLoader<IBounce> {
+    distance: number;
+    constructor();
+    load(data?: RecursivePartial<IBounce>): void;
+}

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

@@ -0,0 +1,10 @@
+import { BubbleBase } from "./BubbleBase";
+import { BubbleDiv } from "./BubbleDiv";
+import type { IBubble } from "../../../Interfaces/Interactivity/Modes/IBubble";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class Bubble extends BubbleBase implements IBubble, IOptionLoader<IBubble> {
+    divs?: SingleOrMultiple<BubbleDiv>;
+    load(data?: RecursivePartial<IBubble>): void;
+}

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

@@ -0,0 +1,14 @@
+import type { IBubbleBase } from "../../../Interfaces/Interactivity/Modes/IBubbleBase";
+import { OptionsColor } from "../../OptionsColor";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare abstract class BubbleBase implements IBubbleBase {
+    distance: number;
+    duration: number;
+    mix: boolean;
+    opacity?: number;
+    size?: number;
+    color?: SingleOrMultiple<OptionsColor>;
+    constructor();
+    load(data?: RecursivePartial<IBubbleBase>): void;
+}

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

@@ -0,0 +1,12 @@
+import { BubbleBase } from "./BubbleBase";
+import type { IBubbleDiv } from "../../../Interfaces/Interactivity/Modes/IBubbleDiv";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class BubbleDiv extends BubbleBase implements IBubbleDiv, IOptionLoader<IBubbleDiv> {
+    get ids(): SingleOrMultiple<string>;
+    set ids(value: SingleOrMultiple<string>);
+    selectors: SingleOrMultiple<string>;
+    constructor();
+    load(data?: RecursivePartial<IBubbleDiv>): void;
+}

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

@@ -0,0 +1,15 @@
+import { ConnectLinks } from "./ConnectLinks";
+import type { IConnect } from "../../../Interfaces/Interactivity/Modes/IConnect";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Connect implements IConnect, IOptionLoader<IConnect> {
+    get line_linked(): ConnectLinks;
+    set line_linked(value: ConnectLinks);
+    get lineLinked(): ConnectLinks;
+    set lineLinked(value: ConnectLinks);
+    distance: number;
+    links: ConnectLinks;
+    radius: number;
+    constructor();
+    load(data?: RecursivePartial<IConnect>): void;
+}

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

@@ -0,0 +1,8 @@
+import type { IConnectLinks } from "../../../Interfaces/Interactivity/Modes/IConnectLinks";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class ConnectLinks implements IConnectLinks, IOptionLoader<IConnectLinks> {
+    opacity: number;
+    constructor();
+    load(data?: RecursivePartial<IConnectLinks>): void;
+}

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

@@ -0,0 +1,14 @@
+import { GrabLinks } from "./GrabLinks";
+import type { IGrab } from "../../../Interfaces/Interactivity/Modes/IGrab";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Grab implements IGrab, IOptionLoader<IGrab> {
+    get line_linked(): GrabLinks;
+    set line_linked(value: GrabLinks);
+    get lineLinked(): GrabLinks;
+    set lineLinked(value: GrabLinks);
+    distance: number;
+    links: GrabLinks;
+    constructor();
+    load(data?: RecursivePartial<IGrab>): void;
+}

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

@@ -0,0 +1,12 @@
+import type { IGrabLinks } from "../../../Interfaces/Interactivity/Modes/IGrabLinks";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../../OptionsColor";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class GrabLinks implements IGrabLinks, IOptionLoader<IGrabLinks> {
+    blink: boolean;
+    color?: OptionsColor;
+    consent: boolean;
+    opacity: number;
+    constructor();
+    load(data?: RecursivePartial<IGrabLinks>): void;
+}

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

@@ -0,0 +1,11 @@
+import type { ILight } from "../../../Interfaces/Interactivity/Modes/ILight";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { LightArea } from "./LightArea";
+import { LightShadow } from "./LightShadow";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Light implements ILight, IOptionLoader<ILight> {
+    area: LightArea;
+    shadow: LightShadow;
+    constructor();
+    load(data?: RecursivePartial<ILight>): void;
+}

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

@@ -0,0 +1,10 @@
+import type { ILightArea } from "../../../Interfaces/Interactivity/Modes/ILightArea";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { LightGradient } from "./LightGradient";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class LightArea implements ILightArea, IOptionLoader<ILightArea> {
+    gradient: LightGradient;
+    radius: number;
+    constructor();
+    load(data?: RecursivePartial<ILightArea>): void;
+}

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

@@ -0,0 +1,10 @@
+import type { ILightGradient } from "../../../Interfaces/Interactivity/Modes/ILightArea";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../../OptionsColor";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class LightGradient implements ILightGradient, IOptionLoader<ILightGradient> {
+    start: OptionsColor;
+    stop: OptionsColor;
+    constructor();
+    load(data?: RecursivePartial<ILightGradient>): void;
+}

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

@@ -0,0 +1,10 @@
+import type { ILightShadow } from "../../../Interfaces/Interactivity/Modes/ILightShadow";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../../OptionsColor";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class LightShadow implements ILightShadow, IOptionLoader<ILightShadow> {
+    color: OptionsColor;
+    length: number;
+    constructor();
+    load(data?: RecursivePartial<ILightShadow>): void;
+}

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

@@ -0,0 +1,29 @@
+import { Attract } from "./Attract";
+import { Bounce } from "./Bounce";
+import { Bubble } from "./Bubble";
+import { Connect } from "./Connect";
+import { Grab } from "./Grab";
+import type { IModes } from "../../../Interfaces/Interactivity/Modes/IModes";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { Light } from "./Light";
+import { Push } from "./Push";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import { Remove } from "./Remove";
+import { Repulse } from "./Repulse";
+import { Slow } from "./Slow";
+import { Trail } from "./Trail";
+export declare class Modes implements IModes, IOptionLoader<IModes> {
+    attract: Attract;
+    bounce: Bounce;
+    bubble: Bubble;
+    connect: Connect;
+    grab: Grab;
+    light: Light;
+    push: Push;
+    remove: Remove;
+    repulse: Repulse;
+    slow: Slow;
+    trail: Trail;
+    constructor();
+    load(data?: RecursivePartial<IModes>): void;
+}

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

@@ -0,0 +1,12 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IPush } from "../../../Interfaces/Interactivity/Modes/IPush";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Push implements IPush, IOptionLoader<IPush> {
+    get particles_nb(): number;
+    set particles_nb(value: number);
+    default: boolean;
+    groups: string[];
+    quantity: number;
+    constructor();
+    load(data?: RecursivePartial<IPush>): void;
+}

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

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRemove } from "../../../Interfaces/Interactivity/Modes/IRemove";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Remove implements IRemove, IOptionLoader<IRemove> {
+    get particles_nb(): number;
+    set particles_nb(value: number);
+    quantity: number;
+    constructor();
+    load(data?: RecursivePartial<IRemove>): void;
+}

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

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRepulse } from "../../../Interfaces/Interactivity/Modes/IRepulse";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import { RepulseBase } from "./RepulseBase";
+import { RepulseDiv } from "./RepulseDiv";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class Repulse extends RepulseBase implements IRepulse, IOptionLoader<IRepulse> {
+    divs?: SingleOrMultiple<RepulseDiv>;
+    load(data?: RecursivePartial<IRepulse>): void;
+}

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

@@ -0,0 +1,14 @@
+import { EasingType } from "../../../../Enums/Types/EasingType";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRepulseBase } from "../../../Interfaces/Interactivity/Modes/IRepulseBase";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare abstract class RepulseBase implements IRepulseBase, IOptionLoader<IRepulseBase> {
+    distance: number;
+    duration: number;
+    easing: EasingType;
+    factor: number;
+    maxSpeed: number;
+    speed: number;
+    constructor();
+    load(data?: RecursivePartial<IRepulseBase>): void;
+}

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

@@ -0,0 +1,12 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRepulseDiv } from "../../../Interfaces/Interactivity/Modes/IRepulseDiv";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import { RepulseBase } from "./RepulseBase";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class RepulseDiv extends RepulseBase implements IRepulseDiv, IOptionLoader<IRepulseDiv> {
+    get ids(): SingleOrMultiple<string>;
+    set ids(value: SingleOrMultiple<string>);
+    selectors: SingleOrMultiple<string>;
+    constructor();
+    load(data?: RecursivePartial<IRepulseDiv>): void;
+}

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

@@ -0,0 +1,11 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { ISlow } from "../../../Interfaces/Interactivity/Modes/ISlow";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Slow implements ISlow, IOptionLoader<ISlow> {
+    get active(): boolean;
+    set active(_value: boolean);
+    factor: number;
+    radius: number;
+    constructor();
+    load(data?: RecursivePartial<ISlow>): void;
+}

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

@@ -0,0 +1,12 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IParticles } from "../../../Interfaces/Particles/IParticles";
+import type { ITrail } from "../../../Interfaces/Interactivity/Modes/ITrail";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Trail implements ITrail, IOptionLoader<ITrail> {
+    delay: number;
+    particles?: RecursivePartial<IParticles>;
+    pauseOnStop: boolean;
+    quantity: number;
+    constructor();
+    load(data?: RecursivePartial<ITrail>): void;
+}