@react-three/postprocessing 3.0.4 → 3.1.0

package/dist/effects/Glitch.d.ts

@@ -1,30 +1,18 @@
-/// <reference types="react" />
-import { Vector2 } from 'three';
+import type { ReactThreeFiber } from '@react-three/fiber';
 import { GlitchEffect, GlitchMode } from 'postprocessing';
-import { ReactThreeFiber } from '@react-three/fiber';
-export type GlitchProps = ConstructorParameters<typeof GlitchEffect>[0] & Partial<{
-    mode: GlitchMode;
-    active: boolean;
-    delay: ReactThreeFiber.Vector2;
-    duration: ReactThreeFiber.Vector2;
-    chromaticAberrationOffset: ReactThreeFiber.Vector2;
-    strength: ReactThreeFiber.Vector2;
-}>;
-export declare const Glitch: import("react").ForwardRefExoticComponent<{
-    blendFunction?: import("postprocessing").BlendFunction | undefined;
-    chromaticAberrationOffset?: Vector2 | undefined;
-    delay?: Vector2 | undefined;
-    duration?: Vector2 | undefined;
-    strength?: Vector2 | undefined;
-    perturbationMap?: import("three").Texture | undefined;
-    dtSize?: number | undefined;
-    columns?: number | undefined;
-    ratio?: number | undefined;
-} & Partial<{
-    mode: GlitchMode;
-    active: boolean;
-    delay: ReactThreeFiber.Vector2;
-    duration: ReactThreeFiber.Vector2;
-    chromaticAberrationOffset: ReactThreeFiber.Vector2;
-    strength: ReactThreeFiber.Vector2;
-}> & import("react").RefAttributes<GlitchEffect>>;
+import type { Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+type GlitchOptions = Omit<EffectOptions<typeof GlitchEffect>, 'delay' | 'duration' | 'strength' | 'chromaticAberrationOffset'> & {
+    delay?: ReactThreeFiber.Vector2;
+    duration?: ReactThreeFiber.Vector2;
+    strength?: ReactThreeFiber.Vector2;
+    chromaticAberrationOffset?: ReactThreeFiber.Vector2;
+    mode?: GlitchMode;
+};
+export type GlitchProps = GlitchOptions & {
+    active?: boolean;
+    opacity?: number;
+    ref?: Ref<GlitchEffect>;
+};
+export declare function Glitch({ active, mode, dtSize, ...props }: GlitchProps): import("react").JSX.Element;
+export {};

package/dist/effects/GodRays.d.ts

@@ -1,21 +1,9 @@
 import { GodRaysEffect } from 'postprocessing';
-import React from 'react';
+import { Ref, RefObject } from 'react';
 import { Mesh, Points } from 'three';
-export declare const GodRays: React.ForwardRefExoticComponent<{
-    blendFunction?: import("postprocessing").BlendFunction | undefined;
-    samples?: number | undefined;
-    density?: number | undefined;
-    decay?: number | undefined;
-    weight?: number | undefined;
-    exposure?: number | undefined;
-    clampMax?: number | undefined;
-    resolutionScale?: number | undefined;
-    resolutionX?: number | undefined;
-    resolutionY?: number | undefined;
-    width?: number | undefined;
-    height?: number | undefined;
-    kernelSize?: import("postprocessing").KernelSize | undefined;
-    blur?: boolean | undefined;
-} & {
-    sun: Mesh | Points | React.RefObject<Mesh | Points>;
-} & React.RefAttributes<GodRaysEffect>>;
+type GodRaysProps = ConstructorParameters<typeof GodRaysEffect>[2] & {
+    sun: Mesh | Points | RefObject<Mesh | Points>;
+    ref?: Ref<GodRaysEffect>;
+};
+export declare function GodRays({ sun, blendFunction, density, decay, weight, exposure, clampMax, blur, kernelSize, samples, width, height, resolutionScale, resolutionX, resolutionY, ref, }: GodRaysProps): import("react").JSX.Element;
+export {};

package/dist/effects/Grid.d.ts

@@ -1,12 +1,12 @@
-import React from 'react';
 import { GridEffect } from 'postprocessing';
-export declare const Grid: React.ForwardRefExoticComponent<{
-    blendFunction?: import("postprocessing").BlendFunction | undefined;
-    scale?: number | undefined;
-    lineWidth?: number | undefined;
-} & Partial<{
-    size: {
+import { type Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+export type GridProps = EffectOptions<typeof GridEffect> & {
+    size?: {
         width: number;
         height: number;
     };
-}> & React.RefAttributes<GridEffect>>;
+    opacity?: number;
+    ref?: Ref<GridEffect>;
+};
+export declare function Grid({ size, ref, ...props }: GridProps): import("react").JSX.Element;

package/dist/effects/HueSaturation.d.ts

@@ -1,5 +1,15 @@
-export declare const HueSaturation: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+import { HueSaturationEffect } from 'postprocessing';
+export declare const HueSaturation: (props: {
+    blendFunction?: import("postprocessing").BlendFunction;
+    hue?: number;
+    saturation?: number;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction;
+    opacity?: number;
+    args?: [({
+        blendFunction?: import("postprocessing").BlendFunction;
+        hue?: number;
+        saturation?: number;
+    } | undefined)?] | undefined;
+    ref?: import("react").Ref<HueSaturationEffect> | undefined;
+}) => import("react").JSX.Element;

package/dist/effects/LUT.d.ts

@@ -1,9 +1,10 @@
-import { LUT3DEffect, BlendFunction } from 'postprocessing';
-import React from 'react';
+import { BlendFunction, LUT3DEffect } from 'postprocessing';
+import { Ref } from 'react';
 import type { Texture } from 'three';
 export type LUTProps = {
     lut: Texture;
     blendFunction?: BlendFunction;
     tetrahedralInterpolation?: boolean;
+    ref?: Ref<LUT3DEffect>;
 };
-export declare const LUT: React.ForwardRefExoticComponent<LUTProps & React.RefAttributes<LUT3DEffect>>;
+export declare function LUT({ lut, blendFunction, tetrahedralInterpolation, ref }: LUTProps): import("react").JSX.Element;

package/dist/effects/LensFlare.d.ts

@@ -1,5 +1,7 @@
-import * as THREE from 'three';
+import { type ReactThreeFiber } from '@react-three/fiber';
 import { BlendFunction, Effect } from 'postprocessing';
+import { type Ref } from 'react';
+import { Color, Texture, Vector2, Vector3 } from 'three';
 type LensFlareEffectOptions = {
     /** The blend function of this effect */
     blendFunction: BlendFunction;
@@ -8,9 +10,9 @@ type LensFlareEffectOptions = {
     /** The glare size */
     glareSize: number;
     /** The position of the lens flare in 3d space */
-    lensPosition: THREE.Vector3;
+    lensPosition: Vector3;
     /** Effect resolution */
-    screenRes: THREE.Vector2;
+    screenRes: Vector2;
     /** The number of points for the star */
     starPoints: number;
     /** The flare side */
@@ -23,10 +25,10 @@ type LensFlareEffectOptions = {
     animated: boolean;
     /** Set the appearance to full anamorphic */
     anamorphic: boolean;
-    /** Set the color gain for the lens flare. Must be a THREE.Color in RBG format */
-    colorGain: THREE.Color;
+    /** Set the color gain for the lens flare. Must be a Color in RBG format */
+    colorGain: Color;
     /** Texture to be used as color dirt for starburst effect */
-    lensDirtTexture: THREE.Texture | null;
+    lensDirtTexture: Texture | null;
     /** The halo scale */
     haloScale: number;
     /** Option to enable/disable secondary ghosts */
@@ -41,14 +43,53 @@ type LensFlareEffectOptions = {
     starBurst: boolean;
 };
 export declare class LensFlareEffect extends Effect {
-    constructor({ blendFunction, enabled, glareSize, lensPosition, screenRes, starPoints, flareSize, flareSpeed, flareShape, animated, anamorphic, colorGain, lensDirtTexture, haloScale, secondaryGhosts, aditionalStreaks, ghostScale, opacity, starBurst, }: LensFlareEffectOptions);
+    constructor({ blendFunction, enabled, glareSize, lensPosition, screenRes, starPoints, flareSize, flareSpeed, flareShape, animated, anamorphic, colorGain, lensDirtTexture, haloScale, secondaryGhosts, aditionalStreaks, ghostScale, opacity, starBurst, }?: Partial<LensFlareEffectOptions>);
     update(_renderer: any, _inputBuffer: any, deltaTime: number): void;
+    private u;
+    private setU;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get glareSize(): number;
+    set glareSize(value: number);
+    get lensPosition(): Vector3;
+    set lensPosition(value: Vector3);
+    get screenRes(): Vector2;
+    set screenRes(value: Vector2);
+    get starPoints(): number;
+    set starPoints(value: number);
+    get flareSize(): number;
+    set flareSize(value: number);
+    get flareSpeed(): number;
+    set flareSpeed(value: number);
+    get flareShape(): number;
+    set flareShape(value: number);
+    get animated(): boolean;
+    set animated(value: boolean);
+    get anamorphic(): boolean;
+    set anamorphic(value: boolean);
+    get colorGain(): Color;
+    set colorGain(value: Color);
+    get lensDirtTexture(): Texture | null;
+    set lensDirtTexture(value: Texture | null);
+    get haloScale(): number;
+    set haloScale(value: number);
+    get secondaryGhosts(): boolean;
+    set secondaryGhosts(value: boolean);
+    get aditionalStreaks(): boolean;
+    set aditionalStreaks(value: boolean);
+    get ghostScale(): number;
+    set ghostScale(value: number);
+    get starBurst(): boolean;
+    set starBurst(value: boolean);
+    get opacity(): number;
+    set opacity(value: number);
 }
-type LensFlareProps = {
+type LensFlareProps = Omit<Partial<LensFlareEffectOptions>, 'lensPosition'> & {
     /** Position of the effect */
-    lensPosition?: THREE.Vector3;
+    lensPosition?: ReactThreeFiber.Vector3;
     /** The time that it takes to fade the occlusion */
     smoothTime?: number;
-} & Partial<LensFlareEffectOptions>;
-export declare const LensFlare: ({ smoothTime, blendFunction, enabled, glareSize, lensPosition, screenRes, starPoints, flareSize, flareSpeed, flareShape, animated, anamorphic, colorGain, lensDirtTexture, haloScale, secondaryGhosts, aditionalStreaks, ghostScale, opacity, starBurst, }: LensFlareProps) => import("react/jsx-runtime").JSX.Element;
+    ref?: Ref<LensFlareEffect>;
+};
+export declare const LensFlare: (props: LensFlareProps) => import("react").JSX.Element;
 export {};

package/dist/effects/Noise.d.ts

@@ -1,5 +1,8 @@
-export declare const Noise: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+import { NoiseEffect } from 'postprocessing';
+import type { Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+export type NoiseProps = EffectOptions<typeof NoiseEffect> & {
+    opacity?: number;
+    ref?: Ref<NoiseEffect>;
+};
+export declare function Noise({ blendFunction, ...props }: NoiseProps): import("react").JSX.Element;

package/dist/effects/Outline.d.ts

@@ -1,30 +1,14 @@
 import { OutlineEffect } from 'postprocessing';
-import { RefObject } from 'react';
-import { Object3D } from 'three';
-type ObjectRef = RefObject<Object3D>;
-export type OutlineProps = ConstructorParameters<typeof OutlineEffect>[2] & Partial<{
+import { Ref, RefObject } from 'react';
+import { Object3D, type ColorRepresentation } from 'three';
+type ObjectRef = RefObject<Object3D | null>;
+type OutlineEffectOptions = NonNullable<ConstructorParameters<typeof OutlineEffect>[2]>;
+export type OutlineProps = Omit<OutlineEffectOptions, 'visibleEdgeColor' | 'hiddenEdgeColor'> & Partial<{
     selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
     selectionLayer: number;
+    visibleEdgeColor: ColorRepresentation;
+    hiddenEdgeColor: ColorRepresentation;
+    ref?: Ref<OutlineEffect>;
 }>;
-export declare const Outline: import("react").ForwardRefExoticComponent<{
-    blendFunction?: import("postprocessing").BlendFunction | undefined;
-    patternTexture?: import("three").Texture | undefined;
-    patternScale?: number | undefined;
-    edgeStrength?: number | undefined;
-    pulseSpeed?: number | undefined;
-    visibleEdgeColor?: number | undefined;
-    hiddenEdgeColor?: number | undefined;
-    multisampling?: number | undefined;
-    resolutionScale?: number | undefined;
-    resolutionX?: number | undefined;
-    resolutionY?: number | undefined;
-    width?: number | undefined;
-    height?: number | undefined;
-    kernelSize?: import("postprocessing").KernelSize | undefined;
-    blur?: boolean | undefined;
-    xRay?: boolean | undefined;
-} & Partial<{
-    selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
-    selectionLayer: number;
-}> & import("react").RefAttributes<OutlineEffect>>;
+export declare function Outline({ selection, selectionLayer, blendFunction, resolutionScale, resolutionX, resolutionY, ref, ...liveProps }: OutlineProps): import("react").JSX.Element;
 export {};

package/dist/effects/Pixelation.d.ts

@@ -1,6 +1,7 @@
-/// <reference types="react" />
 import { PixelationEffect } from 'postprocessing';
+import type { Ref } from 'react';
 export type PixelationProps = {
     granularity?: number;
+    ref?: Ref<PixelationEffect>;
 };
-export declare const Pixelation: import("react").ForwardRefExoticComponent<PixelationProps & import("react").RefAttributes<PixelationEffect>>;
+export declare function Pixelation({ granularity, ref }: PixelationProps): import("react").JSX.Element;

package/dist/effects/Ramp.d.ts

@@ -1,9 +1,12 @@
-import { Effect } from 'postprocessing';
+import { BlendFunction, Effect } from 'postprocessing';
+import type { Ref } from 'react';
 export declare enum RampType {
     Linear = 0,
     Radial = 1,
     MirroredLinear = 2
 }
+type RampTuple2 = [number, number];
+type RampTuple4 = [number, number, number, number];
 export declare class RampEffect extends Effect {
     constructor({ 
     /**
@@ -61,18 +64,63 @@ export declare class RampEffect extends Effect {
      */
     rampInvert, ...params }?: {
         rampType?: RampType | undefined;
-        rampStart?: number[] | undefined;
-        rampEnd?: number[] | undefined;
-        startColor?: number[] | undefined;
-        endColor?: number[] | undefined;
+        rampStart?: RampTuple2 | undefined;
+        rampEnd?: RampTuple2 | undefined;
+        startColor?: RampTuple4 | undefined;
+        endColor?: RampTuple4 | undefined;
         rampBias?: number | undefined;
         rampGain?: number | undefined;
         rampMask?: boolean | undefined;
         rampInvert?: boolean | undefined;
     });
+    private u;
+    private setU;
+    get rampType(): RampType;
+    set rampType(value: RampType);
+    get rampStart(): RampTuple2;
+    set rampStart(value: RampTuple2);
+    get rampEnd(): RampTuple2;
+    set rampEnd(value: RampTuple2);
+    get startColor(): RampTuple4;
+    set startColor(value: RampTuple4);
+    get endColor(): RampTuple4;
+    set endColor(value: RampTuple4);
+    get rampBias(): number;
+    set rampBias(value: number);
+    get rampGain(): number;
+    set rampGain(value: number);
+    get rampMask(): boolean;
+    set rampMask(value: boolean);
+    get rampInvert(): boolean;
+    set rampInvert(value: boolean);
 }
-export declare const Ramp: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+export type RampProps = {
+    blendFunction?: BlendFunction;
+    rampType?: RampType;
+    rampStart?: RampTuple2;
+    rampEnd?: RampTuple2;
+    startColor?: RampTuple4;
+    endColor?: RampTuple4;
+    rampBias?: number;
+    rampGain?: number;
+    rampMask?: boolean;
+    rampInvert?: boolean;
+    ref?: Ref<RampEffect>;
+};
+export declare const Ramp: (props: RampProps & {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+    args?: [({
+        rampType?: RampType | undefined;
+        rampStart?: RampTuple2 | undefined;
+        rampEnd?: RampTuple2 | undefined;
+        startColor?: RampTuple4 | undefined;
+        endColor?: RampTuple4 | undefined;
+        rampBias?: number | undefined;
+        rampGain?: number | undefined;
+        rampMask?: boolean | undefined;
+        rampInvert?: boolean | undefined;
+    } | undefined)?] | undefined;
+    ref?: Ref<RampEffect> | undefined;
+}) => import("react").JSX.Element;
+export {};

package/dist/effects/SMAA.d.ts

@@ -1,5 +1,10 @@
-export declare const SMAA: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+import { SMAAEffect } from 'postprocessing';
+import type { Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+type SMAAOptions = EffectOptions<typeof SMAAEffect>;
+export type SMAAProps = SMAAOptions & {
+    opacity?: number;
+    ref?: Ref<SMAAEffect>;
+};
+export declare function SMAA({ preset, edgeDetectionMode, predicationMode, ...liveProps }: SMAAProps): import("react").JSX.Element;
+export {};

package/dist/effects/SSAO.d.ts

@@ -1,30 +1,7 @@
-/// <reference types="react" />
-import { SSAOEffect, BlendFunction } from 'postprocessing';
-export declare const SSAO: import("react").ForwardRefExoticComponent<{
-    blendFunction?: BlendFunction | undefined;
-    distanceScaling?: boolean | undefined;
-    depthAwareUpsampling?: boolean | undefined;
-    normalDepthBuffer?: import("three").Texture | undefined;
-    samples?: number | undefined;
-    rings?: number | undefined;
-    worldDistanceThreshold?: number | undefined;
-    worldDistanceFalloff?: number | undefined;
-    worldProximityThreshold?: number | undefined;
-    worldProximityFalloff?: number | undefined;
-    distanceThreshold?: number | undefined;
-    distanceFalloff?: number | undefined;
-    rangeThreshold?: number | undefined;
-    rangeFalloff?: number | undefined;
-    minRadiusScale?: number | undefined;
-    luminanceInfluence?: number | undefined;
-    radius?: number | undefined;
-    intensity?: number | undefined;
-    bias?: number | undefined;
-    fade?: number | undefined;
-    color?: import("three").Color | undefined;
-    resolutionScale?: number | undefined;
-    resolutionX?: number | undefined;
-    resolutionY?: number | undefined;
-    width?: number | undefined;
-    height?: number | undefined;
-} & import("react").RefAttributes<SSAOEffect>>;
+import { SSAOEffect } from 'postprocessing';
+import { Ref } from 'react';
+type SSAOProps = ConstructorParameters<typeof SSAOEffect>[2] & {
+    ref?: Ref<SSAOEffect>;
+};
+export declare function SSAO({ blendFunction, samples, rings, distanceThreshold, distanceFalloff, rangeThreshold, rangeFalloff, luminanceInfluence, radius, bias, intensity, color, worldDistanceThreshold, worldDistanceFalloff, worldProximityThreshold, worldProximityFalloff, minRadiusScale, fade, depthAwareUpsampling, resolutionScale, resolutionX, resolutionY, width, height, ref, }: SSAOProps): import("react").JSX.Element;
+export {};

package/dist/effects/ScanlineEffect.d.ts

@@ -1,5 +1,13 @@
-export declare const Scanline: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+import { ScanlineEffect } from 'postprocessing';
+export declare const Scanline: (props: {
+    blendFunction?: import("postprocessing").BlendFunction;
+    density?: number;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction;
+    opacity?: number;
+    args?: [({
+        blendFunction?: import("postprocessing").BlendFunction;
+        density?: number;
+    } | undefined)?] | undefined;
+    ref?: import("react").Ref<ScanlineEffect> | undefined;
+}) => import("react").JSX.Element;

package/dist/effects/SelectiveBloom.d.ts

@@ -1,20 +1,15 @@
-import { SelectiveBloomEffect } from 'postprocessing';
 import type { BloomEffectOptions } from 'postprocessing';
-import React, { RefObject } from 'react';
+import { SelectiveBloomEffect } from 'postprocessing';
+import { Ref, RefObject } from 'react';
 import { Object3D } from 'three';
-type ObjectRef = RefObject<Object3D>;
+type ObjectRef = RefObject<Object3D | null>;
 export type SelectiveBloomProps = BloomEffectOptions & Partial<{
     lights: Object3D[] | ObjectRef[];
     selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
     selectionLayer: number;
     inverted: boolean;
     ignoreBackground: boolean;
+    ref?: Ref<SelectiveBloomEffect>;
 }>;
-export declare const SelectiveBloom: React.ForwardRefExoticComponent<BloomEffectOptions & Partial<{
-    lights: Object3D[] | ObjectRef[];
-    selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
-    selectionLayer: number;
-    inverted: boolean;
-    ignoreBackground: boolean;
-}> & React.RefAttributes<SelectiveBloomEffect>>;
+export declare function SelectiveBloom({ selection, selectionLayer, lights, luminanceThreshold, luminanceSmoothing, mipmapBlur, radius, levels, resolutionScale, resolutionX, resolutionY, ref, ...liveProps }: SelectiveBloomProps): import("react").JSX.Element;
 export {};

package/dist/effects/Sepia.d.ts

@@ -1,5 +1,13 @@
-export declare const Sepia: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+import { SepiaEffect } from 'postprocessing';
+export declare const Sepia: (props: {
+    blendFunction?: import("postprocessing").BlendFunction;
+    intensity?: number;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction;
+    opacity?: number;
+    args?: [({
+        blendFunction?: import("postprocessing").BlendFunction;
+        intensity?: number;
+    } | undefined)?] | undefined;
+    ref?: import("react").Ref<SepiaEffect> | undefined;
+}) => import("react").JSX.Element;

package/dist/effects/ShockWave.d.ts

@@ -1,5 +1,12 @@
-export declare const ShockWave: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+import type { ReactThreeFiber } from '@react-three/fiber';
+import { ShockWaveEffect } from 'postprocessing';
+import { Ref } from 'react';
+export type ShockWaveProps = {
+    position?: ReactThreeFiber.Vector3;
+    speed?: number;
+    maxRadius?: number;
+    waveSize?: number;
+    amplitude?: number;
+    ref?: Ref<ShockWaveEffect>;
+};
+export declare function ShockWave(props: ShockWaveProps): import("react").JSX.Element;

package/dist/effects/Texture.d.ts

@@ -1,11 +1,10 @@
-/// <reference types="react" />
 import { TextureEffect } from 'postprocessing';
-export declare const Texture: import("react").ForwardRefExoticComponent<{
-    blendFunction?: import("postprocessing").BlendFunction | undefined;
-    texture?: import("three").Texture | undefined;
-    aspectCorrection?: boolean | undefined;
-} & {
+import type { Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+export type TextureProps = EffectOptions<typeof TextureEffect> & {
     textureSrc: string;
     /** opacity of provided texture */
-    opacity?: number | undefined;
-} & import("react").RefAttributes<TextureEffect>>;
+    opacity?: number;
+    ref?: Ref<TextureEffect>;
+};
+export declare function Texture({ textureSrc, texture, opacity, ...props }: TextureProps): import("react").JSX.Element;

package/dist/effects/TiltShift.d.ts

@@ -1,5 +1,10 @@
-export declare const TiltShift: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+import { TiltShiftEffect } from 'postprocessing';
+import type { Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+type TiltShiftOptions = EffectOptions<typeof TiltShiftEffect>;
+export type TiltShiftProps = TiltShiftOptions & {
+    opacity?: number;
+    ref?: Ref<TiltShiftEffect>;
+};
+export declare function TiltShift({ blendFunction, kernelSize, resolutionScale, resolutionX, resolutionY, ...liveProps }: TiltShiftProps): import("react").JSX.Element;
+export {};

package/dist/effects/TiltShift2.d.ts

@@ -1,4 +1,6 @@
 import { BlendFunction, Effect } from 'postprocessing';
+import type { Ref } from 'react';
+type Vec2Tuple = [number, number];
 export declare class TiltShiftEffect extends Effect {
     constructor({ blendFunction, blur, // [0, 1], can go beyond 1 for extra
     taper, // [0, 1], can go beyond 1 for extra
@@ -9,14 +11,48 @@ export declare class TiltShiftEffect extends Effect {
         blendFunction?: BlendFunction | undefined;
         blur?: number | undefined;
         taper?: number | undefined;
-        start?: number[] | undefined;
-        end?: number[] | undefined;
+        start?: Vec2Tuple | undefined;
+        end?: Vec2Tuple | undefined;
         samples?: number | undefined;
-        direction?: number[] | undefined;
+        direction?: Vec2Tuple | undefined;
     });
+    private u;
+    private setU;
+    get blur(): number;
+    set blur(value: number);
+    get taper(): number;
+    set taper(value: number);
+    get start(): Vec2Tuple;
+    set start(value: Vec2Tuple);
+    get end(): Vec2Tuple;
+    set end(value: Vec2Tuple);
+    get samples(): number;
+    set samples(value: number);
+    get direction(): Vec2Tuple;
+    set direction(value: Vec2Tuple);
 }
-export declare const TiltShift2: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+export type TiltShift2Props = {
+    blendFunction?: BlendFunction;
+    blur?: number;
+    taper?: number;
+    start?: Vec2Tuple;
+    end?: Vec2Tuple;
+    samples?: number;
+    direction?: Vec2Tuple;
+    ref?: Ref<TiltShiftEffect>;
+};
+export declare const TiltShift2: (props: TiltShift2Props & {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+    args?: [({
+        blendFunction?: BlendFunction | undefined;
+        blur?: number | undefined;
+        taper?: number | undefined;
+        start?: Vec2Tuple | undefined;
+        end?: Vec2Tuple | undefined;
+        samples?: number | undefined;
+        direction?: Vec2Tuple | undefined;
+    } | undefined)?] | undefined;
+    ref?: Ref<TiltShiftEffect> | undefined;
+}) => import("react").JSX.Element;
+export {};

package/dist/effects/ToneMapping.d.ts

@@ -1,8 +1,10 @@
 import { ToneMappingEffect } from 'postprocessing';
-import { type EffectProps } from '../util';
-export type ToneMappingProps = EffectProps<typeof ToneMappingEffect>;
-export declare const ToneMapping: ({ blendFunction, opacity, ...props }: {
-    [x: string]: any;
-    blendFunction?: any;
-    opacity?: any;
-}) => import("react/jsx-runtime").JSX.Element;
+import type { Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+type ToneMappingOptions = EffectOptions<typeof ToneMappingEffect>;
+export type ToneMappingProps = ToneMappingOptions & {
+    opacity?: number;
+    ref?: Ref<ToneMappingEffect>;
+};
+export declare function ToneMapping({ minLuminance, maxLuminance, ...liveProps }: ToneMappingProps): import("react").JSX.Element;
+export {};