@tsparticles/engine 3.0.0-alpha.0

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

@@ -0,0 +1,12 @@
+import type { IMoveCenter } from "../../../Interfaces/Particles/Move/IMoveCenter";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import { SizeMode } from "../../../../Enums/Modes/SizeMode";
+export declare class MoveCenter implements IMoveCenter, IOptionLoader<IMoveCenter> {
+    mode: SizeMode;
+    radius: number;
+    x: number;
+    y: number;
+    constructor();
+    load(data?: RecursivePartial<IMoveCenter>): void;
+}

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

@@ -0,0 +1,12 @@
+import type { IMoveGravity } from "../../../Interfaces/Particles/Move/IMoveGravity";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RangeValue } from "../../../../Types/RangeValue";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class MoveGravity implements IMoveGravity, IOptionLoader<IMoveGravity> {
+    acceleration: RangeValue;
+    enable: boolean;
+    inverse: boolean;
+    maxSpeed: RangeValue;
+    constructor();
+    load(data?: RecursivePartial<IMoveGravity>): void;
+}

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

@@ -0,0 +1,14 @@
+import type { IMoveTrail } from "../../../Interfaces/Particles/Move/IMoveTrail";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { MoveTrailFill } from "./MoveTrailFill";
+import type { OptionsColor } from "../../OptionsColor";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class MoveTrail implements IMoveTrail, IOptionLoader<IMoveTrail> {
+    enable: boolean;
+    fill: MoveTrailFill;
+    length: number;
+    constructor();
+    get fillColor(): string | OptionsColor | undefined;
+    set fillColor(value: string | OptionsColor | undefined);
+    load(data?: RecursivePartial<IMoveTrail>): void;
+}

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

@@ -0,0 +1,9 @@
+import type { IMoveTrailFill } from "../../../Interfaces/Particles/Move/IMoveTrailFill";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../../OptionsColor";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class MoveTrailFill implements IMoveTrailFill, IOptionLoader<IMoveTrailFill> {
+    color?: OptionsColor;
+    image?: string;
+    load(data?: RecursivePartial<IMoveTrailFill>): void;
+}

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

@@ -0,0 +1,14 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IOutModes } from "../../../Interfaces/Particles/Move/IOutModes";
+import { OutMode } from "../../../../Enums/Modes/OutMode";
+import type { OutModeAlt } from "../../../../Enums/Modes/OutMode";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class OutModes implements IOutModes, IOptionLoader<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;
+    constructor();
+    load(data?: RecursivePartial<IOutModes>): void;
+}

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

@@ -0,0 +1,14 @@
+import type { IMovePath } from "../../../../Interfaces/Particles/Move/Path/IMovePath";
+import type { IOptionLoader } from "../../../../Interfaces/IOptionLoader";
+import type { PathOptions } from "../../../../../Types/PathOptions";
+import type { RecursivePartial } from "../../../../../Types/RecursivePartial";
+import { ValueWithRandom } from "../../../ValueWithRandom";
+export declare class MovePath implements IMovePath, IOptionLoader<IMovePath> {
+    clamp: boolean;
+    delay: ValueWithRandom;
+    enable: boolean;
+    generator?: string;
+    options: PathOptions;
+    constructor();
+    load(data?: RecursivePartial<IMovePath>): void;
+}

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

@@ -0,0 +1,12 @@
+import type { ICoordinates } from "../../../../Core/Interfaces/ICoordinates";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { ISpin } from "../../../Interfaces/Particles/Move/ISpin";
+import type { RangeValue } from "../../../../Types/RangeValue";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class Spin implements ISpin, IOptionLoader<ISpin> {
+    acceleration: RangeValue;
+    enable: boolean;
+    position?: ICoordinates;
+    constructor();
+    load(data?: RecursivePartial<ISpin>): void;
+}

package/types/Options/Classes/Particles/Number/ParticlesDensity.d.ts

@@ -0,0 +1,16 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IParticlesDensity } from "../../../Interfaces/Particles/Number/IParticlesDensity";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class ParticlesDensity implements IParticlesDensity, IOptionLoader<IParticlesDensity> {
+    enable: boolean;
+    height: number;
+    width: number;
+    constructor();
+    get area(): number;
+    set area(value: number);
+    get factor(): number;
+    set factor(value: number);
+    get value_area(): number;
+    set value_area(value: number);
+    load(data?: RecursivePartial<IParticlesDensity>): void;
+}

package/types/Options/Classes/Particles/Number/ParticlesNumber.d.ts

@@ -0,0 +1,13 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IParticlesNumber } from "../../../Interfaces/Particles/Number/IParticlesNumber";
+import { ParticlesDensity } from "./ParticlesDensity";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class ParticlesNumber implements IParticlesNumber, IOptionLoader<IParticlesNumber> {
+    density: ParticlesDensity;
+    limit: number;
+    value: number;
+    constructor();
+    get max(): number;
+    set max(value: number);
+    load(data?: RecursivePartial<IParticlesNumber>): void;
+}

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

@@ -0,0 +1,10 @@
+import type { IOpacity } from "../../../Interfaces/Particles/Opacity/IOpacity";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { OpacityAnimation } from "./OpacityAnimation";
+import { RangedAnimationValueWithRandom } from "../../ValueWithRandom";
+export declare class Opacity extends RangedAnimationValueWithRandom implements IOpacity, IOptionLoader<IOpacity> {
+    animation: OpacityAnimation;
+    constructor();
+    get anim(): OpacityAnimation;
+    set anim(value: OpacityAnimation);
+}

package/types/Options/Classes/Particles/Opacity/OpacityAnimation.d.ts

@@ -0,0 +1,12 @@
+import { DestroyType } from "../../../../Enums/Types/DestroyType";
+import type { IOpacityAnimation } from "../../../Interfaces/Particles/Opacity/IOpacityAnimation";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { RangedAnimationOptions } from "../../AnimationOptions";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class OpacityAnimation extends RangedAnimationOptions implements IOpacityAnimation, IOptionLoader<IOpacityAnimation> {
+    destroy: DestroyType | keyof typeof DestroyType;
+    constructor();
+    get opacity_min(): number | undefined;
+    set opacity_min(value: number | undefined);
+    load(data?: RecursivePartial<IOpacityAnimation>): void;
+}

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

@@ -0,0 +1,40 @@
+import { AnimatableColor } from "../AnimatableColor";
+import { Collisions } from "./Collisions/Collisions";
+import type { Container } from "../../../Core/Container";
+import type { Engine } from "../../../engine";
+import type { IInteractivity } from "../../Interfaces/Interactivity/IInteractivity";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { IParticlesOptions } from "../../Interfaces/Particles/IParticlesOptions";
+import { Move } from "./Move/Move";
+import { Opacity } from "./Opacity/Opacity";
+import { ParticlesBounce } from "./Bounce/ParticlesBounce";
+import type { ParticlesGroups } from "../../../Types/ParticlesGroups";
+import { ParticlesNumber } from "./Number/ParticlesNumber";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+import { Shadow } from "./Shadow";
+import { Shape } from "./Shape/Shape";
+import type { SingleOrMultiple } from "../../../Types/SingleOrMultiple";
+import { Size } from "./Size/Size";
+import { Stroke } from "./Stroke";
+import { ZIndex } from "./ZIndex/ZIndex";
+export declare class ParticlesOptions implements IParticlesOptions, IOptionLoader<IParticlesOptions> {
+    [name: string]: unknown;
+    bounce: ParticlesBounce;
+    collisions: Collisions;
+    color: AnimatableColor;
+    groups: ParticlesGroups;
+    interactivity?: RecursivePartial<IInteractivity>;
+    move: Move;
+    number: ParticlesNumber;
+    opacity: Opacity;
+    reduceDuplicates: boolean;
+    shadow: Shadow;
+    shape: Shape;
+    size: Size;
+    stroke: SingleOrMultiple<Stroke>;
+    zIndex: ZIndex;
+    private readonly _container;
+    private readonly _engine;
+    constructor(engine: Engine, container?: Container);
+    load(data?: RecursivePartial<IParticlesOptions>): void;
+}

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

@@ -0,0 +1,13 @@
+import type { ICoordinates } from "../../../Core/Interfaces/ICoordinates";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { IShadow } from "../../Interfaces/Particles/IShadow";
+import { OptionsColor } from "../OptionsColor";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+export declare class Shadow implements IShadow, IOptionLoader<IShadow> {
+    blur: number;
+    color: OptionsColor;
+    enable: boolean;
+    offset: ICoordinates;
+    constructor();
+    load(data?: RecursivePartial<IShadow>): void;
+}

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

@@ -0,0 +1,11 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IShape } from "../../../Interfaces/Particles/Shape/IShape";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import type { ShapeData } from "../../../../Types/ShapeData";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export declare class Shape implements IShape, IOptionLoader<IShape> {
+    options: ShapeData;
+    type: SingleOrMultiple<string>;
+    constructor();
+    load(data?: RecursivePartial<IShape>): void;
+}

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

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { ISize } from "../../../Interfaces/Particles/Size/ISize";
+import { RangedAnimationValueWithRandom } from "../../ValueWithRandom";
+import { SizeAnimation } from "./SizeAnimation";
+export declare class Size extends RangedAnimationValueWithRandom implements ISize, IOptionLoader<ISize> {
+    animation: SizeAnimation;
+    constructor();
+    get anim(): SizeAnimation;
+    set anim(value: SizeAnimation);
+}

package/types/Options/Classes/Particles/Size/SizeAnimation.d.ts

@@ -0,0 +1,12 @@
+import { DestroyType } from "../../../../Enums/Types/DestroyType";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { ISizeAnimation } from "../../../Interfaces/Particles/Size/ISizeAnimation";
+import { RangedAnimationOptions } from "../../AnimationOptions";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+export declare class SizeAnimation extends RangedAnimationOptions implements ISizeAnimation, IOptionLoader<ISizeAnimation> {
+    destroy: DestroyType | keyof typeof DestroyType;
+    constructor();
+    get size_min(): number | undefined;
+    set size_min(value: number | undefined);
+    load(data?: RecursivePartial<ISizeAnimation>): void;
+}

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

@@ -0,0 +1,12 @@
+import { AnimatableColor } from "../AnimatableColor";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { IStroke } from "../../Interfaces/Particles/IStroke";
+import type { RangeValue } from "../../../Types/RangeValue";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+export declare class Stroke implements IStroke, IOptionLoader<IStroke> {
+    color?: AnimatableColor;
+    opacity?: RangeValue;
+    width: RangeValue;
+    constructor();
+    load(data?: RecursivePartial<IStroke>): void;
+}

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

@@ -0,0 +1,11 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IZIndex } from "../../../Interfaces/Particles/ZIndex/IZIndex";
+import type { RecursivePartial } from "../../../../Types/RecursivePartial";
+import { ValueWithRandom } from "../../ValueWithRandom";
+export declare class ZIndex extends ValueWithRandom implements IZIndex, IOptionLoader<IZIndex> {
+    opacityRate: number;
+    sizeRate: number;
+    velocityRate: number;
+    constructor();
+    load(data?: RecursivePartial<IZIndex>): void;
+}

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

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

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

@@ -0,0 +1,12 @@
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { IResponsive } from "../Interfaces/IResponsive";
+import type { ISourceOptions } from "../../Types/ISourceOptions";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+import { ResponsiveMode } from "../../Enums/Modes/ResponsiveMode";
+export declare class Responsive implements IResponsive, IOptionLoader<IResponsive> {
+    maxWidth: number;
+    mode: ResponsiveMode;
+    options: ISourceOptions;
+    constructor();
+    load(data?: RecursivePartial<IResponsive>): void;
+}

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

@@ -0,0 +1,12 @@
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { ISourceOptions } from "../../../Types/ISourceOptions";
+import type { ITheme } from "../../Interfaces/Theme/ITheme";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+import { ThemeDefault } from "./ThemeDefault";
+export declare class Theme implements ITheme, IOptionLoader<ITheme> {
+    default: ThemeDefault;
+    name: string;
+    options?: ISourceOptions;
+    constructor();
+    load(data?: RecursivePartial<ITheme>): void;
+}

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

@@ -0,0 +1,11 @@
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { IThemeDefault } from "../../Interfaces/Theme/IThemeDefault";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+import { ThemeMode } from "../../../Enums/Modes/ThemeMode";
+export declare class ThemeDefault implements IThemeDefault, IOptionLoader<IThemeDefault> {
+    auto: boolean;
+    mode: ThemeMode | keyof typeof ThemeMode;
+    value: boolean;
+    constructor();
+    load(data?: RecursivePartial<IThemeDefault>): void;
+}

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

@@ -0,0 +1,26 @@
+import type { IAnimationValueWithRandom, IRangedAnimationValueWithRandom, IValueWithRandom } from "../Interfaces/IValueWithRandom";
+import { AnimationOptions } from "./AnimationOptions";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { ISize } from "../Interfaces/Particles/Size/ISize";
+import { Random } from "./Random";
+import type { RangeValue } from "../../Types/RangeValue";
+import { RangedAnimationOptions } from "./AnimationOptions";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+export declare class ValueWithRandom implements IValueWithRandom, IOptionLoader<IValueWithRandom> {
+    random: Random;
+    value: RangeValue;
+    constructor();
+    load(data?: RecursivePartial<IValueWithRandom>): void;
+}
+export declare class AnimationValueWithRandom extends ValueWithRandom implements IOptionLoader<IAnimationValueWithRandom> {
+    animation: AnimationOptions;
+    constructor();
+    get anim(): AnimationOptions;
+    set anim(value: AnimationOptions);
+    load(data?: RecursivePartial<ISize>): void;
+}
+export declare class RangedAnimationValueWithRandom extends AnimationValueWithRandom implements IOptionLoader<IRangedAnimationValueWithRandom> {
+    animation: RangedAnimationOptions;
+    constructor();
+    load(data?: RecursivePartial<IRangedAnimationValueWithRandom>): void;
+}

package/types/Options/Interfaces/Background/IBackground.d.ts

@@ -0,0 +1,9 @@
+import type { IOptionsColor } from "../IOptionsColor";
+export interface IBackground {
+    color: string | IOptionsColor;
+    image: string;
+    opacity: number;
+    position: string;
+    repeat: string;
+    size: string;
+}

package/types/Options/Interfaces/BackgroundMask/IBackgroundMask.d.ts

@@ -0,0 +1,7 @@
+import type { IBackgroundMaskCover } from "./IBackgroundMaskCover";
+import type { IColor } from "../../../Core/Interfaces/Colors";
+export interface IBackgroundMask {
+    composite: GlobalCompositeOperation;
+    cover: IBackgroundMaskCover | IColor | string;
+    enable: boolean;
+}

package/types/Options/Interfaces/BackgroundMask/IBackgroundMaskCover.d.ts

@@ -0,0 +1,5 @@
+import type { IOptionsColor } from "../IOptionsColor";
+export interface IBackgroundMaskCover {
+    color: string | IOptionsColor;
+    opacity: number;
+}

package/types/Options/Interfaces/FullScreen/IFullScreen.d.ts

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

package/types/Options/Interfaces/IAnimatable.d.ts

@@ -0,0 +1,4 @@
+import type { IAnimation } from "./IAnimation";
+export interface IAnimatable<T extends IAnimation> {
+    animation: T;
+}

package/types/Options/Interfaces/IAnimatableColor.d.ts

@@ -0,0 +1,6 @@
+import type { IColorAnimation } from "./IColorAnimation";
+import type { IHslAnimation } from "./IHslAnimation";
+import type { IOptionsColor } from "./IOptionsColor";
+export interface IAnimatableColor extends IOptionsColor {
+    animation: IColorAnimation | IHslAnimation;
+}

package/types/Options/Interfaces/IAnimation.d.ts

@@ -0,0 +1,13 @@
+import type { RangeValue } from "../../Types/RangeValue";
+import type { StartValueType } from "../../Enums/Types/StartValueType";
+export interface IAnimation {
+    count: RangeValue;
+    decay: RangeValue;
+    enable: boolean;
+    speed: RangeValue;
+    sync: boolean;
+}
+export interface IRangedAnimation extends IAnimation {
+    minimumValue?: number;
+    startValue: StartValueType | keyof typeof StartValueType;
+}

package/types/Options/Interfaces/IColorAnimation.d.ts

@@ -0,0 +1,5 @@
+import type { IAnimation } from "./IAnimation";
+import type { RangeValue } from "../../Types/RangeValue";
+export interface IColorAnimation extends IAnimation {
+    offset: RangeValue;
+}

package/types/Options/Interfaces/IHslAnimation.d.ts

@@ -0,0 +1,6 @@
+import type { IColorAnimation } from "./IColorAnimation";
+export interface IHslAnimation {
+    h: IColorAnimation;
+    l: IColorAnimation;
+    s: IColorAnimation;
+}

package/types/Options/Interfaces/IManualParticle.d.ts

@@ -0,0 +1,7 @@
+import type { ICoordinates } from "../../Core/Interfaces/ICoordinates";
+import type { IParticlesOptions } from "./Particles/IParticlesOptions";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+export interface IManualParticle {
+    options?: RecursivePartial<IParticlesOptions>;
+    position?: ICoordinates;
+}

package/types/Options/Interfaces/IOptionLoader.d.ts

@@ -0,0 +1,4 @@
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+export interface IOptionLoader<T> {
+    load(data?: RecursivePartial<T>): void;
+}

package/types/Options/Interfaces/IOptions.d.ts

@@ -0,0 +1,37 @@
+import type { IBackground } from "./Background/IBackground";
+import type { IBackgroundMask } from "./BackgroundMask/IBackgroundMask";
+import type { IFullScreen } from "./FullScreen/IFullScreen";
+import type { IInteractivity } from "./Interactivity/IInteractivity";
+import type { IManualParticle } from "./IManualParticle";
+import type { IParticlesOptions } from "./Particles/IParticlesOptions";
+import type { IResponsive } from "./IResponsive";
+import type { ITheme } from "./Theme/ITheme";
+import type { RangeValue } from "../../Types/RangeValue";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../Types/SingleOrMultiple";
+export interface IOptions {
+    [name: string]: unknown;
+    autoPlay: boolean;
+    background: IBackground;
+    backgroundMask: IBackgroundMask;
+    backgroundMode: RecursivePartial<IFullScreen> | boolean;
+    delay: RangeValue;
+    detectRetina: boolean;
+    duration: RangeValue;
+    fpsLimit: number;
+    fps_limit: number;
+    fullScreen: RecursivePartial<IFullScreen> | boolean;
+    interactivity: IInteractivity;
+    manualParticles: IManualParticle[];
+    name: string;
+    particles: IParticlesOptions;
+    pauseOnBlur: boolean;
+    pauseOnOutsideViewport: boolean;
+    preset?: SingleOrMultiple<string>;
+    responsive: IResponsive[];
+    retina_detect: boolean;
+    smooth: boolean;
+    style: RecursivePartial<CSSStyleDeclaration>;
+    themes: ITheme[];
+    zLayers: number;
+}

package/types/Options/Interfaces/IOptionsColor.d.ts

@@ -0,0 +1,2 @@
+import type { IRangeColor } from "../../Core/Interfaces/Colors";
+export type IOptionsColor = IRangeColor;

package/types/Options/Interfaces/IRandom.d.ts

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

package/types/Options/Interfaces/IResponsive.d.ts

@@ -0,0 +1,7 @@
+import type { ISourceOptions } from "../../Types/ISourceOptions";
+import type { ResponsiveMode } from "../../Enums/Modes/ResponsiveMode";
+export interface IResponsive {
+    maxWidth: number;
+    mode: ResponsiveMode;
+    options: ISourceOptions;
+}

package/types/Options/Interfaces/IValueWithRandom.d.ts

@@ -0,0 +1,13 @@
+import type { IAnimation, IRangedAnimation } from "./IAnimation";
+import type { IRandom } from "./IRandom";
+import type { RangeValue } from "../../Types/RangeValue";
+export interface IValueWithRandom {
+    random: boolean | IRandom;
+    value: RangeValue;
+}
+export interface IAnimationValueWithRandom extends IValueWithRandom {
+    animation: IAnimation;
+}
+export interface IRangedAnimationValueWithRandom extends IAnimationValueWithRandom {
+    animation: IRangedAnimation;
+}

package/types/Options/Interfaces/Interactivity/Events/IClickEvent.d.ts

@@ -0,0 +1,6 @@
+import type { ClickMode } from "../../../../Enums/Modes/ClickMode";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export interface IClickEvent {
+    enable: boolean;
+    mode: SingleOrMultiple<ClickMode | keyof typeof ClickMode | string>;
+}

package/types/Options/Interfaces/Interactivity/Events/IDivEvent.d.ts

@@ -0,0 +1,12 @@
+import type { DivMode } from "../../../../Enums/Modes/DivMode";
+import type { DivType } from "../../../../Enums/Types/DivType";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export interface IDivEvent {
+    el: SingleOrMultiple<string>;
+    elementId: SingleOrMultiple<string>;
+    enable: boolean;
+    ids: SingleOrMultiple<string>;
+    mode: SingleOrMultiple<DivMode | keyof typeof DivMode | string>;
+    selectors: SingleOrMultiple<string>;
+    type: DivType | keyof typeof DivType;
+}

package/types/Options/Interfaces/Interactivity/Events/IEvents.d.ts

@@ -0,0 +1,14 @@
+import type { IClickEvent } from "./IClickEvent";
+import type { IDivEvent } from "./IDivEvent";
+import type { IHoverEvent } from "./IHoverEvent";
+import type { IResizeEvent } from "./IResizeEvent";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export interface IEvents {
+    onClick: IClickEvent;
+    onDiv: SingleOrMultiple<IDivEvent>;
+    onHover: IHoverEvent;
+    onclick: IClickEvent;
+    ondiv: SingleOrMultiple<IDivEvent>;
+    onhover: IHoverEvent;
+    resize: boolean | IResizeEvent;
+}

package/types/Options/Interfaces/Interactivity/Events/IHoverEvent.d.ts

@@ -0,0 +1,8 @@
+import type { HoverMode } from "../../../../Enums/Modes/HoverMode";
+import type { IParallax } from "./IParallax";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export interface IHoverEvent {
+    enable: boolean;
+    mode: SingleOrMultiple<HoverMode | keyof typeof HoverMode | string>;
+    parallax: IParallax;
+}

package/types/Options/Interfaces/Interactivity/Events/IParallax.d.ts

@@ -0,0 +1,5 @@
+export interface IParallax {
+    enable: boolean;
+    force: number;
+    smooth: number;
+}

package/types/Options/Interfaces/Interactivity/Events/IResizeEvent.d.ts

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

package/types/Options/Interfaces/Interactivity/IInteractivity.d.ts

@@ -0,0 +1,10 @@
+import type { IEvents } from "./Events/IEvents";
+import type { IModes } from "./Modes/IModes";
+import type { InteractivityDetect } from "../../../Enums/InteractivityDetect";
+export interface IInteractivity {
+    [name: string]: unknown;
+    detect_on: InteractivityDetect | keyof typeof InteractivityDetect;
+    detectsOn: InteractivityDetect | keyof typeof InteractivityDetect;
+    events: IEvents;
+    modes: IModes;
+}

package/types/Options/Interfaces/Interactivity/Modes/IModeDiv.d.ts

@@ -0,0 +1,5 @@
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export interface IModeDiv {
+    ids: SingleOrMultiple<string>;
+    selectors: SingleOrMultiple<string>;
+}

package/types/Options/Interfaces/Interactivity/Modes/IModes.d.ts

@@ -0,0 +1,3 @@
+export interface IModes {
+    [name: string]: unknown;
+}

package/types/Options/Interfaces/Particles/Bounce/IParticlesBounce.d.ts

@@ -0,0 +1,5 @@
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface IParticlesBounce {
+    horizontal: IValueWithRandom;
+    vertical: IValueWithRandom;
+}

package/types/Options/Interfaces/Particles/Collisions/ICollisions.d.ts

@@ -0,0 +1,11 @@
+import type { CollisionMode } from "../../../../Enums/Modes/CollisionMode";
+import type { ICollisionsAbsorb } from "./ICollisionsAbsorb";
+import type { ICollisionsOverlap } from "./ICollisionsOverlap";
+import type { IParticlesBounce } from "../Bounce/IParticlesBounce";
+export interface ICollisions {
+    absorb: ICollisionsAbsorb;
+    bounce: IParticlesBounce;
+    enable: boolean;
+    mode: CollisionMode | keyof typeof CollisionMode;
+    overlap: ICollisionsOverlap;
+}