@react-three/postprocessing 2.8.2 → 2.9.0

package/dist/EffectComposer.d.ts

@@ -1,4 +1,4 @@
-import { TextureDataType } from 'three';
+import type { TextureDataType } from 'three';
 import React from 'react';
 import { EffectComposer as EffectComposerImpl, NormalPass, DepthDownsamplingPass } from 'postprocessing';
 export declare const EffectComposerContext: React.Context<{
@@ -7,9 +7,9 @@ export declare const EffectComposerContext: React.Context<{
     downSamplingPass: DepthDownsamplingPass | null;
     camera: THREE.Camera;
     scene: THREE.Scene;
-    resolutionScale?: number;
+    resolutionScale?: number | undefined;
 }>;
-export declare type EffectComposerProps = {
+export type EffectComposerProps = {
     enabled?: boolean;
     children: JSX.Element | JSX.Element[];
     depthBuffer?: boolean;

package/dist/Selection.d.ts

@@ -1,14 +1,14 @@
 import * as THREE from 'three';
 import React from 'react';
-export declare type Api = {
+export type Api = {
     selected: THREE.Object3D[];
     select: React.Dispatch<React.SetStateAction<THREE.Object3D[]>>;
     enabled: boolean;
 };
-export declare type SelectApi = JSX.IntrinsicElements['group'] & {
+export type SelectApi = JSX.IntrinsicElements['group'] & {
     enabled?: boolean;
 };
-export declare const selectionContext: React.Context<Api>;
+export declare const selectionContext: React.Context<Api | null>;
 export declare function Selection({ children, enabled }: {
     enabled?: boolean;
     children: React.ReactNode;

package/dist/effects/BrightnessContrast.d.ts

@@ -1,3 +1,10 @@
 /// <reference types="react" />
 import { BrightnessContrastEffect } from 'postprocessing';
-export declare const BrightnessContrast: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof BrightnessContrastEffect>, "children" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "blendFunction" | "opacity" | keyof BrightnessContrastEffect | "brightness" | "contrast"> & import("react").RefAttributes<typeof BrightnessContrastEffect>>;
+export declare const BrightnessContrast: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<BrightnessContrastEffect>, import("@react-three/fiber").NodeProps<BrightnessContrastEffect, typeof BrightnessContrastEffect>>> & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    brightness?: number | undefined;
+    contrast?: number | undefined;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof BrightnessContrastEffect>>;

package/dist/effects/ChromaticAberration.d.ts

@@ -1,12 +1,14 @@
 import React from 'react';
 import { ChromaticAberrationEffect } from 'postprocessing';
 import { ReactThreeFiber } from '@react-three/fiber';
-export declare type ChromaticAberrationProps = ConstructorParameters<typeof ChromaticAberrationEffect>[0] & Partial<{
+export type ChromaticAberrationProps = ConstructorParameters<typeof ChromaticAberrationEffect>[0] & Partial<{
     offset: ReactThreeFiber.Vector2;
 }>;
 export declare const ChromaticAberration: React.ForwardRefExoticComponent<{
-    blendFunction?: import("postprocessing").BlendFunction;
-    offset?: import("three").Vector2;
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    offset?: import("three").Vector2 | undefined;
+    radialModulation: boolean;
+    modulationOffset: number;
 } & Partial<{
     offset: ReactThreeFiber.Vector2;
 }> & React.RefAttributes<ChromaticAberrationEffect>>;

package/dist/effects/ColorAverage.d.ts

@@ -1,6 +1,6 @@
 import { ColorAverageEffect, BlendFunction } from 'postprocessing';
 import React from 'react';
-export declare type ColorAverageProps = Partial<{
+export type ColorAverageProps = Partial<{
     blendFunction: BlendFunction;
 }>;
 export declare const ColorAverage: React.ForwardRefExoticComponent<Partial<{

package/dist/effects/ColorDepth.d.ts

@@ -1,3 +1,9 @@
 /// <reference types="react" />
 import { ColorDepthEffect } from 'postprocessing';
-export declare const ColorDepth: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof ColorDepthEffect>, "children" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "blendFunction" | "opacity" | keyof ColorDepthEffect | "bits"> & import("react").RefAttributes<typeof ColorDepthEffect>>;
+export declare const ColorDepth: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<ColorDepthEffect>, import("@react-three/fiber").NodeProps<ColorDepthEffect, typeof ColorDepthEffect>>> & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    bits?: number | undefined;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof ColorDepthEffect>>;

package/dist/effects/Depth.d.ts

@@ -1,3 +1,9 @@
 /// <reference types="react" />
 import { DepthEffect } from 'postprocessing';
-export declare const Depth: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof DepthEffect>, "children" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "blendFunction" | "opacity" | keyof DepthEffect> & import("react").RefAttributes<typeof DepthEffect>>;
+export declare const Depth: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<DepthEffect>, import("@react-three/fiber").NodeProps<DepthEffect, typeof DepthEffect>>> & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    inverted?: boolean | undefined;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof DepthEffect>>;

package/dist/effects/DepthOfField.d.ts

@@ -1,15 +1,20 @@
+/// <reference types="react" />
 import { DepthOfFieldEffect } from 'postprocessing';
-import React from 'react';
 import { ReactThreeFiber } from '@react-three/fiber';
-import { Texture, Vector3 } from 'three';
-export declare const DepthOfField: React.ForwardRefExoticComponent<{
-    blendFunction?: import("postprocessing").BlendFunction;
-    focusDistance?: number;
-    focalLength?: number;
-    focusRange?: number;
-    bokehScale?: number;
-    width?: number;
-    height?: number;
+import { type Texture, Vector3 } from 'three';
+export declare const DepthOfField: import("react").ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    worldFocusDistance?: number | undefined;
+    worldFocusRange?: number | undefined;
+    focusDistance?: number | undefined;
+    focalLength?: number | undefined;
+    focusRange?: number | undefined;
+    bokehScale?: number | undefined;
+    resolutionScale?: number | undefined;
+    resolutionX?: number | undefined;
+    resolutionY?: number | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
 } & Partial<{
     target: ReactThreeFiber.Vector3;
     depthTexture: {
@@ -17,4 +22,4 @@ export declare const DepthOfField: React.ForwardRefExoticComponent<{
         packing: number;
     };
     blur: number;
-}> & React.RefAttributes<DepthOfFieldEffect>>;
+}> & import("react").RefAttributes<DepthOfFieldEffect>>;

package/dist/effects/DotScreen.d.ts

@@ -1,3 +1,10 @@
 /// <reference types="react" />
 import { DotScreenEffect } from 'postprocessing';
-export declare const DotScreen: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof DotScreenEffect>, "children" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "scale" | "blendFunction" | "opacity" | "angle" | keyof DotScreenEffect> & import("react").RefAttributes<typeof DotScreenEffect>>;
+export declare const DotScreen: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<DotScreenEffect>, import("@react-three/fiber").NodeProps<DotScreenEffect, typeof DotScreenEffect>>> & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    angle?: number | undefined;
+    scale?: number | undefined;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof DotScreenEffect>>;

package/dist/effects/Glitch.d.ts

@@ -1,29 +1,29 @@
+/// <reference types="react" />
 import { GlitchEffect, GlitchMode } from 'postprocessing';
-import React from 'react';
 import { ReactThreeFiber } from '@react-three/fiber';
-export declare type GlitchProps = ConstructorParameters<typeof GlitchEffect>[0] & Partial<{
-    mode: typeof GlitchMode[keyof typeof GlitchMode];
+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: React.ForwardRefExoticComponent<{
-    blendFunction?: import("postprocessing").BlendFunction;
-    chromaticAberrationOffset?: import("three").Vector2;
-    delay?: import("three").Vector2;
-    duration?: import("three").Vector2;
-    strength?: import("three").Vector2;
-    perturbationMap?: import("three").Texture;
-    dtSize?: number;
-    columns?: number;
-    ratio?: number;
+export declare const Glitch: import("react").ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    chromaticAberrationOffset?: import("three").Vector2 | undefined;
+    delay?: import("three").Vector2 | undefined;
+    duration?: import("three").Vector2 | undefined;
+    strength?: import("three").Vector2 | undefined;
+    perturbationMap?: import("three").Texture | undefined;
+    dtSize?: number | undefined;
+    columns?: number | undefined;
+    ratio?: number | undefined;
 } & Partial<{
-    mode: typeof GlitchMode[keyof typeof GlitchMode];
+    mode: GlitchMode;
     active: boolean;
     delay: ReactThreeFiber.Vector2;
     duration: ReactThreeFiber.Vector2;
     chromaticAberrationOffset: ReactThreeFiber.Vector2;
     strength: ReactThreeFiber.Vector2;
-}> & React.RefAttributes<GlitchEffect>>;
+}> & import("react").RefAttributes<GlitchEffect>>;

package/dist/effects/GodRays.d.ts

@@ -2,17 +2,20 @@ import { GodRaysEffect } from 'postprocessing';
 import React from 'react';
 import { Mesh, Points } from 'three';
 export declare const GodRays: React.ForwardRefExoticComponent<{
-    blendFunction?: import("postprocessing").BlendFunction;
-    samples?: number;
-    density?: number;
-    decay?: number;
-    weight?: number;
-    exposure?: number;
-    clampMax?: number;
-    width?: number;
-    height?: number;
-    kernelSize?: KernelSize;
-    blur?: number;
+    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.RefAttributes<GodRaysEffect>>;

package/dist/effects/Grid.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 import { GridEffect } from 'postprocessing';
-export declare const Grid: React.ForwardRefExoticComponent<Partial<{
-    blendFunction: import("postprocessing").BlendFunction;
-    scale: number;
-    lineWidth: number;
-}> & Partial<{
+export declare const Grid: React.ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    scale?: number | undefined;
+    lineWidth?: number | undefined;
+} & Partial<{
     size: {
         width: number;
         height: number;

package/dist/effects/HueSaturation.d.ts

@@ -1,3 +1,10 @@
 /// <reference types="react" />
 import { HueSaturationEffect } from 'postprocessing';
-export declare const HueSaturation: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof HueSaturationEffect>, "children" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "blendFunction" | "opacity" | keyof HueSaturationEffect | "hue" | "saturation"> & import("react").RefAttributes<typeof HueSaturationEffect>>;
+export declare const HueSaturation: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<HueSaturationEffect>, import("@react-three/fiber").NodeProps<HueSaturationEffect, typeof HueSaturationEffect>>> & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    hue?: number | undefined;
+    saturation?: number | undefined;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof HueSaturationEffect>>;

package/dist/effects/LUT.d.ts

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

package/dist/effects/Outline.d.ts

@@ -1,25 +1,30 @@
 import { OutlineEffect } from 'postprocessing';
-import React, { MutableRefObject } from 'react';
+import { MutableRefObject } from 'react';
 import { Object3D } from 'three';
-declare type ObjectRef = MutableRefObject<Object3D>;
-export declare type OutlineProps = ConstructorParameters<typeof OutlineEffect>[2] & Partial<{
+type ObjectRef = MutableRefObject<Object3D>;
+export type OutlineProps = ConstructorParameters<typeof OutlineEffect>[2] & Partial<{
     selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
     selectionLayer: number;
 }>;
-export declare const Outline: React.ForwardRefExoticComponent<Partial<{
-    blendFunction: import("postprocessing").BlendFunction;
-    patternTexture: number;
-    edgeStrength: number;
-    pulseSpeed: number;
-    visibleEdgeColor: number;
-    hiddenEdgeColor: number;
-    width: number;
-    height: number;
-    kernelSize: KernelSize;
-    blur: boolean;
-    xRay: boolean;
-}> & Partial<{
+export declare const Outline: import("react").ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    patternTexture?: number | 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;
-}> & React.RefAttributes<OutlineEffect>>;
+}> & import("react").RefAttributes<OutlineEffect>>;
 export {};

package/dist/effects/Pixelation.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { PixelationEffect } from 'postprocessing';
-export declare type PixelationProps = {
+export type PixelationProps = {
     granularity?: number;
 };
 export declare const Pixelation: React.ForwardRefExoticComponent<PixelationProps & React.RefAttributes<PixelationEffect>>;

package/dist/effects/SMAA.d.ts

@@ -1,6 +1,10 @@
-import React from 'react';
+/// <reference types="react" />
 import { SMAAEffect } from 'postprocessing';
-export declare const SMAA: React.ForwardRefExoticComponent<{
-    preset?: number;
-    edgeDetectionMode?: number;
-} & React.RefAttributes<SMAAEffect>>;
+export declare const SMAA: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<SMAAEffect>, import("@react-three/fiber").NodeProps<SMAAEffect, typeof SMAAEffect>>> & {
+    preset?: import("postprocessing").SMAAPreset | undefined;
+    edgeDetectionMode?: import("postprocessing").EdgeDetectionMode | undefined;
+    predicationMode?: import("postprocessing").PredicationMode | undefined;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof SMAAEffect>>;

package/dist/effects/SSAO.d.ts

@@ -1,17 +1,30 @@
-import React from 'react';
+/// <reference types="react" />
 import { SSAOEffect, BlendFunction } from 'postprocessing';
-export declare const SSAO: React.ForwardRefExoticComponent<{
-    blendFunction?: BlendFunction;
-    samples?: number;
-    rings?: number;
-    distanceThreshold?: number;
-    distanceFalloff?: number;
-    rangeThreshold?: number;
-    rangeFalloff?: number;
-    luminanceInfluence?: number;
-    radius?: number;
-    scale?: number;
-    bias?: number;
-    intensity?: number;
-    color?: string;
-} & React.RefAttributes<SSAOEffect>>;
+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;
+    worldDistanceFalloff: number;
+    worldProximityThreshold: number;
+    worldProximityFalloff: number;
+    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>>;

package/dist/effects/SSR.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-declare type SSRProps = {
+type SSRProps = {
     /** whether you want to use Temporal Resolving to re-use reflections from the last frames; this will reduce noise tremendously but may result in "smearing" */
     temporalResolve?: boolean;
     /** a value between 0 and 1 to set how much the last frame's reflections should be blended in; higher values will result in less noisy reflections when moving the camera but a more smeary look */

package/dist/effects/SelectiveBloom.d.ts

@@ -1,11 +1,16 @@
 import { SelectiveBloomEffect } from 'postprocessing';
+import type { BloomEffectOptions } from 'postprocessing';
 import React, { MutableRefObject } from 'react';
 import { Object3D } from 'three';
-declare type ObjectRef = MutableRefObject<Object3D>;
-export declare type SelectiveBloomProps = ConstructorParameters<typeof SelectiveBloomEffect>[2] & Partial<{
+type ObjectRef = MutableRefObject<Object3D>;
+export type SelectiveBloomProps = BloomEffectOptions & Partial<{
     lights: Object3D[] | ObjectRef[];
     selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
     selectionLayer: number;
 }>;
-export declare const SelectiveBloom: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<SelectiveBloomEffect>>;
+export declare const SelectiveBloom: React.ForwardRefExoticComponent<BloomEffectOptions & Partial<{
+    lights: Object3D[] | ObjectRef[];
+    selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
+    selectionLayer: number;
+}> & React.RefAttributes<SelectiveBloomEffect>>;
 export {};

package/dist/effects/Sepia.d.ts

@@ -1,3 +1,9 @@
 /// <reference types="react" />
 import { SepiaEffect } from 'postprocessing';
-export declare const Sepia: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof SepiaEffect>, "children" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "blendFunction" | "opacity" | "intensity" | keyof SepiaEffect> & import("react").RefAttributes<typeof SepiaEffect>>;
+export declare const Sepia: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<SepiaEffect>, import("@react-three/fiber").NodeProps<SepiaEffect, typeof SepiaEffect>>> & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    intensity?: number | undefined;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof SepiaEffect>>;

package/dist/effects/ShockWave.d.ts

@@ -1,3 +1,6 @@
 /// <reference types="react" />
 import { ShockWaveEffect } from 'postprocessing';
-export declare const ShockWave: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof ShockWaveEffect>, "children" | "camera" | "quaternion" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "position" | "up" | "scale" | "rotation" | "matrix" | "layers" | "dispose" | "type" | "id" | "uuid" | "name" | "parent" | "modelViewMatrix" | "normalMatrix" | "matrixWorld" | "matrixAutoUpdate" | "matrixWorldNeedsUpdate" | "visible" | "castShadow" | "receiveShadow" | "frustumCulled" | "renderOrder" | "animations" | "userData" | "customDepthMaterial" | "customDistanceMaterial" | "isObject3D" | "onBeforeRender" | "onAfterRender" | "applyMatrix4" | "applyQuaternion" | "setRotationFromAxisAngle" | "setRotationFromEuler" | "setRotationFromMatrix" | "setRotationFromQuaternion" | "rotateOnAxis" | "rotateOnWorldAxis" | "rotateX" | "rotateY" | "rotateZ" | "translateOnAxis" | "translateX" | "translateY" | "translateZ" | "localToWorld" | "worldToLocal" | "lookAt" | "add" | "remove" | "removeFromParent" | "clear" | "getObjectById" | "getObjectByName" | "getObjectByProperty" | "getWorldPosition" | "getWorldQuaternion" | "getWorldScale" | "getWorldDirection" | "raycast" | "traverse" | "traverseVisible" | "traverseAncestors" | "updateMatrix" | "updateMatrixWorld" | "updateWorldMatrix" | "toJSON" | "clone" | "copy" | "addEventListener" | "hasEventListener" | "removeEventListener" | "dispatchEvent" | "blendFunction" | "opacity" | "update" | "setSize" | "initialize" | "attributes" | "fragmentShader" | "vertexShader" | "defines" | "uniforms" | "extensions" | "blendMode" | "setDepthTexture" | "matrixWorldInverse" | "projectionMatrix" | "projectionMatrixInverse" | "isCamera" | "epicenter" | "speed" | "explode"> & import("react").RefAttributes<typeof ShockWaveEffect>>;
+export declare const ShockWave: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<ShockWaveEffect>, import("@react-three/fiber").NodeProps<ShockWaveEffect, typeof ShockWaveEffect>>> & import("three").Camera & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof ShockWaveEffect>>;

package/dist/effects/Texture.d.ts

@@ -1,8 +1,9 @@
+/// <reference types="react" />
 import { TextureEffect } from 'postprocessing';
-import React from 'react';
-export declare const Texture: React.ForwardRefExoticComponent<Partial<{
-    blendFunction: import("postprocessing").BlendFunction;
-    texture: import("three").Texture;
-}> & {
+export declare const Texture: import("react").ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    texture?: import("three").Texture | undefined;
+    aspectCorrection?: boolean | undefined;
+} & {
     textureSrc: string;
-} & React.RefAttributes<TextureEffect>>;
+} & import("react").RefAttributes<TextureEffect>>;

package/dist/effects/TiltShift2.d.ts

@@ -6,14 +6,16 @@ export declare class TiltShiftEffect extends Effect {
     start, // [0,1] percentage x,y of screenspace
     end, // [0,1] percentage x,y of screenspace
     samples, // number of blur samples
-    direction }?: {
-        blendFunction?: BlendFunction;
-        blur?: number;
-        taper?: number;
-        start?: number[];
-        end?: number[];
-        samples?: number;
-        direction?: number[];
+    direction, }?: {
+        blendFunction?: BlendFunction | undefined;
+        blur?: number | undefined;
+        taper?: number | undefined;
+        start?: number[] | undefined;
+        end?: number[] | undefined;
+        samples?: number | undefined;
+        direction?: number[] | undefined;
     });
 }
-export declare const TiltShift2: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof TiltShiftEffect>, "children" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "blendFunction" | "opacity" | "blur" | "samples" | "taper" | "start" | "end" | "direction" | keyof TiltShiftEffect> & import("react").RefAttributes<typeof TiltShiftEffect>>;
+export declare const TiltShift2: import("react").ForwardRefExoticComponent<{
+    blendFunction: BlendFunction;
+} & import("react").RefAttributes<typeof TiltShiftEffect>>;

package/dist/effects/ToneMapping.d.ts

@@ -1,3 +1,17 @@
 /// <reference types="react" />
 import { ToneMappingEffect } from 'postprocessing';
-export declare const ToneMapping: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof ToneMappingEffect>, "children" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "blendFunction" | "opacity" | keyof ToneMappingEffect | "middleGrey" | "maxLuminance" | "averageLuminance"> & import("react").RefAttributes<typeof ToneMappingEffect>>;
+export declare const ToneMapping: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<ToneMappingEffect>, import("@react-three/fiber").NodeProps<ToneMappingEffect, typeof ToneMappingEffect>>> & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    adaptive?: boolean | undefined;
+    mode?: import("postprocessing").ToneMappingMode | undefined;
+    resolution?: number | undefined;
+    maxLuminance?: number | undefined;
+    whitePoint?: number | undefined;
+    middleGrey?: number | undefined;
+    minLuminance?: number | undefined;
+    averageLuminance?: number | undefined;
+    adaptationRate?: number | undefined;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof ToneMappingEffect>>;

package/dist/effects/Vignette.d.ts

@@ -1,3 +1,12 @@
 /// <reference types="react" />
 import { VignetteEffect } from 'postprocessing';
-export declare const Vignette: import("react").ForwardRefExoticComponent<Pick<import("../util").EffectProps<typeof VignetteEffect>, "children" | "attach" | "attachArray" | "attachObject" | "attachFns" | "args" | "key" | "onUpdate" | "blendFunction" | "opacity" | "offset" | keyof VignetteEffect | "darkness"> & import("react").RefAttributes<typeof VignetteEffect>>;
+export declare const Vignette: import("react").ForwardRefExoticComponent<Omit<import("@react-three/fiber").ExtendedColors<import("@react-three/fiber").Overwrite<Partial<VignetteEffect>, import("@react-three/fiber").NodeProps<VignetteEffect, typeof VignetteEffect>>> & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    technique?: import("postprocessing").VignetteTechnique | undefined;
+    eskil?: boolean | undefined;
+    offset?: number | undefined;
+    darkness?: number | undefined;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    opacity?: number | undefined;
+}, "ref"> & import("react").RefAttributes<typeof VignetteEffect>>;