angular-three-postprocessing 2.0.0-beta.27 → 2.0.0-beta.270

package/lib/effect.d.ts

@@ -1,27 +1,56 @@
-import { type NgtAnyRecord } from 'angular-three';
-import { BlendFunction, Effect } from 'postprocessing';
+import { BlendFunction } from 'postprocessing';
 import * as i0 from "@angular/core";
-export type NgtpEffectState = {
+export declare const injectDefaultEffectOptions: {
+    (): {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false;
+    } & {
+        injector?: import("@angular/core").Injector;
+    }): {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector;
+    }): {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    } | null;
+}, provideDefaultEffectOptions: ((value: {
     blendFunction?: BlendFunction;
     opacity?: number;
-};
-export declare abstract class NgtpEffect<TEffect extends Effect> {
-    inputs: import("angular-three").NgtSignalStore<NgtpEffectState>;
-    effectRef: import("angular-three").NgtInjectedRef<TEffect>;
-    set _blendFunction(blendFunction: BlendFunction);
-    set _opacity(opacity: number);
-    protected defaultBlendFunction: BlendFunction;
-    protected nativeArgs: () => NgtAnyRecord[];
-    blendFunction: import("@angular/core").Signal<BlendFunction | undefined>;
-    opacity: import("@angular/core").Signal<number | undefined>;
-    protected store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
-    protected camera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
-    private invalidate;
-    private previousInputs?;
-    private nativeInputs;
-    args: import("@angular/core").Signal<NgtAnyRecord[]>;
-    constructor();
-    private setBlendMode;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffect<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtpEffect<any>, never, never, { "effectRef": { "alias": "effectRef"; "required": false; }; "_blendFunction": { "alias": "blendFunction"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; }, {}, never, never, false, never>;
+} | (() => {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+})) => import("@angular/core").Provider) & ((value: {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+} | (() => {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+})) => import("@angular/core").Provider);
+export declare class NgtpEffectBlendMode {
+    effect: NgtpEffect | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffectBlendMode, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpEffectBlendMode, "ngtp-effect-blend-mode", never, {}, {}, never, never, true, never>;
 }
+export declare class NgtpEffect {
+    defaultEffectOptions: {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    } | null;
+    blendFunction: import("@angular/core").InputSignal<BlendFunction | undefined>;
+    opacity: import("@angular/core").InputSignal<number | undefined>;
+    private store;
+    camera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
+    invalidate: import("@angular/core").Signal<(frames?: number) => void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffect, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtpEffect, never, never, { "blendFunction": { "alias": "blendFunction"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare const NgtpEffectHostDirective: {
+    directive: typeof NgtpEffect;
+    inputs: string[];
+};

package/lib/effects/ascii.d.ts

@@ -0,0 +1,23 @@
+import { Effect } from 'postprocessing';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+interface ASCIIEffectOptions {
+    font?: string;
+    characters?: string;
+    fontSize?: number;
+    cellSize?: number;
+    color?: string;
+    invert?: boolean;
+}
+export declare class ASCIIEffect extends Effect {
+    constructor({ font, characters, fontSize, cellSize, color, invert, }?: ASCIIEffectOptions);
+    /** Draws the characters on a Canvas and returns a texture */
+    createCharactersTexture(characters: string, font: string, fontSize: number): Texture;
+}
+export declare class NgtpASCII {
+    options: import("@angular/core").InputSignalWithTransform<ASCIIEffectOptions, "" | Partial<ASCIIEffectOptions>>;
+    effect: import("@angular/core").Signal<ASCIIEffect>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpASCII, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpASCII, "ngtp-ascii", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/effects/bloom.d.ts

@@ -0,0 +1,10 @@
+import { BloomEffectOptions } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export declare class NgtpBloom {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<BloomEffectOptions, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpBloom, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpBloom, "ngtp-bloom", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/brightness-contrast.d.ts

@@ -0,0 +1,15 @@
+import { BrightnessContrastEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type BrightnessEffectOptions = NonNullable<ConstructorParameters<typeof BrightnessContrastEffect>[0]>;
+export declare class NgtpBrightnessContrast {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        brightness?: number;
+        contrast?: number;
+    }, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpBrightnessContrast, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpBrightnessContrast, "ngtp-brightness-contrast", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/chromatic-abberation.d.ts

@@ -0,0 +1,16 @@
+import { ChromaticAberrationEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type ChromaticAberrationEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ChromaticAberrationEffect>[0]>>;
+export declare class NgtpChromaticAberration {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        offset?: import("three").Vector2;
+        radialModulation: boolean;
+        modulationOffset: number;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpChromaticAberration, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpChromaticAberration, "ngtp-chromatic-aberration", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/color-average.d.ts

@@ -0,0 +1,11 @@
+import { BlendFunction } from 'postprocessing';
+import * as i0 from "@angular/core";
+export declare class NgtpColorAverage {
+    options: import("@angular/core").InputSignalWithTransform<{
+        blendFunction: BlendFunction;
+    }, "" | Partial<{
+        blendFunction: BlendFunction;
+    }>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpColorAverage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpColorAverage, "ngtp-color-average", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/lib/effects/color-depth.d.ts

@@ -0,0 +1,14 @@
+import { ColorDepthEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type ColorDepthEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ColorDepthEffect>[0]>>;
+export declare class NgtpColorDepth {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        bits?: number;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpColorDepth, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpColorDepth, "ngtp-color-depth", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/depth-of-field.d.ts

@@ -0,0 +1,22 @@
+import { NgtVector3 } from 'angular-three';
+import { DepthOfFieldEffect } from 'postprocessing';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+type DOFOptions = NonNullable<ConstructorParameters<typeof DepthOfFieldEffect>[1]> & Partial<{
+    target: NgtVector3;
+    depthTexture: {
+        texture: Texture;
+        packing: number;
+    };
+}>;
+export declare class NgtpDepthOfField {
+    private autoEffect;
+    private effectComposer;
+    options: import("@angular/core").InputSignal<DOFOptions>;
+    private autoFocus;
+    effect: import("@angular/core").Signal<DepthOfFieldEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpDepthOfField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDepthOfField, "ngtp-depth-of-field", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/effects/depth.d.ts

@@ -0,0 +1,14 @@
+import { DepthEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type DepthEffectOptions = Partial<NonNullable<ConstructorParameters<typeof DepthEffect>[0]>>;
+export declare class NgtpDepth {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        inverted?: boolean;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpDepth, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDepth, "ngtp-depth", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/dot-screen.d.ts

@@ -0,0 +1,15 @@
+import { DotScreenEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type DotScreenEffectOptions = Partial<NonNullable<ConstructorParameters<typeof DotScreenEffect>[0]>>;
+export declare class NgtpDotScreen {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        angle?: number;
+        scale?: number;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpDotScreen, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDotScreen, "ngtp-dot-screen", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/fxaa.d.ts

@@ -0,0 +1,13 @@
+import { FXAAEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type FXAAEffectOptions = Partial<NonNullable<ConstructorParameters<typeof FXAAEffect>[0]>>;
+export declare class NgtpFXAA {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpFXAA, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpFXAA, "ngtp-fxaa", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/glitch.d.ts

@@ -0,0 +1,29 @@
+import { NgtVector2 } from 'angular-three';
+import { GlitchEffect, GlitchMode } from 'postprocessing';
+import * as i0 from "@angular/core";
+export type GlitchOptions = NonNullable<ConstructorParameters<typeof GlitchEffect>[0]> & Partial<{
+    mode: GlitchMode;
+    active: boolean;
+    delay: NgtVector2;
+    duration: NgtVector2;
+    chromaticAberrationOffset: NgtVector2;
+    strength: NgtVector2;
+}>;
+export declare class NgtpGlitch {
+    private autoEffect;
+    private store;
+    private invalidate;
+    options: import("@angular/core").InputSignalWithTransform<GlitchOptions, "" | Partial<{
+        active: boolean;
+    }>>;
+    private active;
+    private mode;
+    private delay;
+    private duration;
+    private chromaticAberrationOffset;
+    private strength;
+    effect: import("@angular/core").Signal<GlitchEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGlitch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpGlitch, "ngtp-glitch", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/god-rays.d.ts

@@ -0,0 +1,30 @@
+import { ElementRef } from '@angular/core';
+import { GodRaysEffect } from 'postprocessing';
+import { Mesh, Points } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtpGodRays {
+    private autoEffect;
+    private effectComposer;
+    options: import("@angular/core").InputSignal<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        samples?: number;
+        density?: number;
+        decay?: number;
+        weight?: number;
+        exposure?: number;
+        clampMax?: number;
+        resolutionScale?: number;
+        resolutionX?: number;
+        resolutionY?: number;
+        width?: number;
+        height?: number;
+        kernelSize?: import("postprocessing").KernelSize;
+        blur?: boolean;
+    } & {
+        sun: Mesh | Points | ElementRef<Mesh | Points>;
+    }>;
+    effect: import("@angular/core").Signal<GodRaysEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGodRays, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpGodRays, "ngtp-god-rays", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/grid.d.ts

@@ -0,0 +1,20 @@
+import { GridEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+type GridOptions = NonNullable<ConstructorParameters<typeof GridEffect>[0]> & Partial<{
+    size: {
+        width: number;
+        height: number;
+    };
+}>;
+export declare class NgtpGrid {
+    private autoEffect;
+    private store;
+    private invalidate;
+    options: import("@angular/core").InputSignal<GridOptions>;
+    private size;
+    effect: import("@angular/core").Signal<GridEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGrid, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpGrid, "ngtp-grid", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/effects/hue-saturation.d.ts

@@ -0,0 +1,15 @@
+import { HueSaturationEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type HueSaturationEffectOptions = Partial<NonNullable<ConstructorParameters<typeof HueSaturationEffect>[0]>>;
+export declare class NgtpHueSaturation {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        hue?: number;
+        saturation?: number;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpHueSaturation, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpHueSaturation, "ngtp-hue-saturation", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/index.d.ts

@@ -1,17 +1,26 @@
-export * from './bloom/bloom';
-export * from './brightness-contrast/brightness-contrast';
-export * from './color-depth/color-depth';
-export * from './depth/depth';
-export * from './dot-screen/dot-screen';
-export * from './hue-saturation/hue-saturation';
-export * from './lut/lut';
-export * from './noise/noise';
-export * from './pixelation/pixelation';
-export * from './scanline/scanline';
-export * from './sepia/sepia';
-export * from './shock-wave/shock-wave';
-export * from './smaa/smaa';
-export * from './ssao/ssao';
-export * from './tilt-shift/tilt-shift';
-export * from './tone-mapping/tone-mapping';
-export * from './vignette/vignette';
+export * from './ascii';
+export * from './bloom';
+export * from './brightness-contrast';
+export * from './chromatic-abberation';
+export * from './color-average';
+export * from './color-depth';
+export * from './depth';
+export * from './depth-of-field';
+export * from './dot-screen';
+export * from './fxaa';
+export * from './glitch';
+export * from './god-rays';
+export * from './grid';
+export * from './hue-saturation';
+export * from './lens-flare';
+export * from './lut';
+export * from './noise';
+export * from './pixelation';
+export * from './scanline';
+export * from './sepia';
+export * from './shock-wave';
+export * from './smaa';
+export * from './tilt-shift';
+export * from './tilt-shift-2';
+export * from './vignette';
+export * from './water';

package/lib/effects/lens-flare.d.ts

@@ -0,0 +1,96 @@
+import { BlendFunction, Effect } from 'postprocessing';
+import { Color, Texture, Vector3 } from 'three';
+import { NgtpEffectComposer } from '../effect-composer';
+import * as i0 from "@angular/core";
+export declare class LensFlareEffect extends Effect {
+    constructor({ blendFunction, enabled, glareSize, lensPosition, iResolution, starPoints, flareSize, flareSpeed, flareShape, animated, anamorphic, colorGain, lensDirtTexture, haloScale, secondaryGhosts, aditionalStreaks, ghostScale, opacity, starBurst, }?: {
+        blendFunction?: BlendFunction | undefined;
+        enabled?: boolean | undefined;
+        glareSize?: number | undefined;
+        lensPosition?: number[] | undefined;
+        iResolution?: number[] | undefined;
+        starPoints?: number | undefined;
+        flareSize?: number | undefined;
+        flareSpeed?: number | undefined;
+        flareShape?: number | undefined;
+        animated?: boolean | undefined;
+        anamorphic?: boolean | undefined;
+        colorGain?: Color | undefined;
+        lensDirtTexture?: Texture | null | undefined;
+        haloScale?: number | undefined;
+        secondaryGhosts?: boolean | undefined;
+        aditionalStreaks?: boolean | undefined;
+        ghostScale?: number | undefined;
+        opacity?: number | undefined;
+        starBurst?: boolean | undefined;
+    });
+    update(_renderer: any, _inputBuffer: any, deltaTime: number): void;
+}
+export type LensFlareOptions = ConstructorParameters<typeof LensFlareEffect>[0] & {
+    position: Vector3;
+    followMouse: boolean;
+    smoothTime: number;
+};
+export declare class NgtpLensFlare {
+    private autoEffect;
+    private store;
+    private viewport;
+    private raycaster;
+    private pointer;
+    effectComposer: NgtpEffectComposer;
+    options: import("@angular/core").InputSignalWithTransform<{
+        blendFunction?: BlendFunction | undefined;
+        enabled?: boolean | undefined;
+        glareSize?: number | undefined;
+        lensPosition?: number[] | undefined;
+        iResolution?: number[] | undefined;
+        starPoints?: number | undefined;
+        flareSize?: number | undefined;
+        flareSpeed?: number | undefined;
+        flareShape?: number | undefined;
+        animated?: boolean | undefined;
+        anamorphic?: boolean | undefined;
+        colorGain?: Color | undefined;
+        lensDirtTexture?: Texture | null | undefined;
+        haloScale?: number | undefined;
+        secondaryGhosts?: boolean | undefined;
+        aditionalStreaks?: boolean | undefined;
+        ghostScale?: number | undefined;
+        opacity?: number | undefined;
+        starBurst?: boolean | undefined;
+    } & {
+        position: Vector3;
+        followMouse: boolean;
+        smoothTime: number;
+    }, "" | Partial<{
+        blendFunction?: BlendFunction | undefined;
+        enabled?: boolean | undefined;
+        glareSize?: number | undefined;
+        lensPosition?: number[] | undefined;
+        iResolution?: number[] | undefined;
+        starPoints?: number | undefined;
+        flareSize?: number | undefined;
+        flareSpeed?: number | undefined;
+        flareShape?: number | undefined;
+        animated?: boolean | undefined;
+        anamorphic?: boolean | undefined;
+        colorGain?: Color | undefined;
+        lensDirtTexture?: Texture | null | undefined;
+        haloScale?: number | undefined;
+        secondaryGhosts?: boolean | undefined;
+        aditionalStreaks?: boolean | undefined;
+        ghostScale?: number | undefined;
+        opacity?: number | undefined;
+        starBurst?: boolean | undefined;
+    } & {
+        position: Vector3;
+        followMouse: boolean;
+        smoothTime: number;
+    }>>;
+    private projectedPosition;
+    private mouse2d;
+    effect: import("@angular/core").Signal<LensFlareEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpLensFlare, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpLensFlare, "ngtp-lens-flare", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/lut.d.ts

@@ -0,0 +1,19 @@
+import { BlendFunction, LUT3DEffect } from 'postprocessing';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+export interface LUTOptions {
+    lut: Texture;
+    blendFunction?: BlendFunction;
+    tetrahedralInterpolation?: boolean;
+}
+export declare class NgtpLUT {
+    private autoEffect;
+    private store;
+    private invalidate;
+    options: import("@angular/core").InputSignal<LUTOptions>;
+    private lut;
+    effect: import("@angular/core").Signal<LUT3DEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpLUT, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpLUT, "ngtp-lut", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/noise.d.ts

@@ -0,0 +1,14 @@
+import { BlendFunction, NoiseEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type NoiseEffectOptions = Partial<NonNullable<ConstructorParameters<typeof NoiseEffect>[0]>>;
+export declare class NgtpNoise {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: BlendFunction;
+        premultiply?: boolean;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpNoise, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpNoise, "ngtp-noise", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/pixelation.d.ts

@@ -0,0 +1,16 @@
+import { PixelationEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export interface PixelationOptions {
+    granularity: number;
+}
+export declare class NgtpPixelation {
+    options: import("@angular/core").InputSignalWithTransform<{
+        granularity: number;
+    }, "" | Partial<{
+        granularity: number;
+    }>>;
+    private granularity;
+    effect: import("@angular/core").Signal<PixelationEffect>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpPixelation, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpPixelation, "ngtp-pixelation", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/scanline.d.ts

@@ -0,0 +1,17 @@
+import { BlendFunction, ScanlineEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type ScanlineEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ScanlineEffect>[0]>>;
+export declare class NgtpScanline {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignalWithTransform<Omit<Partial<{
+        blendFunction?: BlendFunction;
+        density?: number;
+    }>, "blendFunction">, "" | Partial<Omit<Partial<{
+        blendFunction?: BlendFunction;
+        density?: number;
+    }>, "blendFunction">>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpScanline, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpScanline, "ngtp-scanline", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/sepia.d.ts

@@ -0,0 +1,14 @@
+import { SepiaEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type SepiaEffectOptions = Partial<NonNullable<ConstructorParameters<typeof SepiaEffect>[0]>>;
+export declare class NgtpSepia {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        intensity?: number;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSepia, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSepia, "ngtp-sepia", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/shock-wave.d.ts

@@ -0,0 +1,11 @@
+import { ShockWaveEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type ShockWaveEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ShockWaveEffect>[0]>>;
+export declare class NgtpShockWave {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<import("three").Camera>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpShockWave, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpShockWave, "ngtp-shock-wave", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/smaa.d.ts

@@ -0,0 +1,15 @@
+import { SMAAEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type SMAAEffectOptions = Partial<NonNullable<ConstructorParameters<typeof SMAAEffect>[0]>>;
+export declare class NgtpSMAA {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        preset?: import("postprocessing").SMAAPreset;
+        edgeDetectionMode?: import("postprocessing").EdgeDetectionMode;
+        predicationMode?: import("postprocessing").PredicationMode;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSMAA, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSMAA, "ngtp-smaa", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}