@types/three 0.167.2 → 0.169.0

three/src/nodes/display/BlendMode.d.ts

@@ -0,0 +1,10 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const burn: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const dodge: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const screen: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const overlay: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;

three/src/nodes/display/BloomNode.d.ts

@@ -2,7 +2,7 @@ import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class BloomNode extends TempNode {
     inputNode: Node;
@@ -26,10 +26,4 @@ export const bloom: (
     threshold?: number,
 ) => ShaderNodeObject<BloomNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        bloom: typeof bloom;
-    }
-}
-
 export default BloomNode;

three/src/nodes/display/BumpMapNode.d.ts

@@ -0,0 +1,16 @@
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class BumpMapNode extends TempNode {
+    textureNode: Node;
+    scaleNode: Node | null;
+
+    constructor(textureNode: Node, scaleNode?: Node | null);
+}
+
+export default BumpMapNode;
+
+export const bumpMap: (
+    textureNode: NodeRepresentation,
+    scaleNode?: NodeRepresentation | null,
+) => ShaderNodeObject<BumpMapNode>;

three/src/nodes/display/ColorAdjustment.d.ts

@@ -0,0 +1,27 @@
+import Node from "../core/Node.js";
+import MathNode from "../math/MathNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const grayscale: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const saturation: (
+    color: NodeRepresentation,
+    adjustment?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const vibrance: (
+    color: NodeRepresentation,
+    adjustment?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const hue: (
+    color: NodeRepresentation,
+    adjustment?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const luminance: (
+    color: NodeRepresentation,
+    luminanceCoefficients?: NodeRepresentation,
+) => ShaderNodeObject<MathNode>;
+
+export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;

three/src/nodes/display/ColorSpaceFunctions.d.ts

@@ -0,0 +1,6 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const sRGBToLinearSRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const linearSRGBTosRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;

three/src/nodes/display/ColorSpaceNode.d.ts

@@ -1,35 +1,54 @@
-import { ColorSpace } from "../../constants.js";
+import { ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from "../../constants.js";
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export type ColorSpaceNodeMethod =
-    | typeof ColorSpaceNode.LINEAR_TO_LINEAR
-    | typeof ColorSpaceNode.LINEAR_TO_sRGB
-    | typeof ColorSpaceNode.sRGB_TO_LINEAR;
+export type WorkingOrOutputColorSpace = "WorkingColorSpace" | "OutputColorSpace";
+
+export type ColorSpaceMethod = "LinearTosRGB" | "sRGBToLinear" | "LinearToLinear" | "sRGBTosRGB";
+
+export function getColorSpaceMethod(
+    source: typeof LinearSRGBColorSpace | typeof SRGBColorSpace,
+    target: typeof LinearSRGBColorSpace | typeof SRGBColorSpace,
+): ColorSpaceMethod;
 
 export default class ColorSpaceNode extends TempNode {
-    static LINEAR_TO_LINEAR: "LinearToLinear";
-    static LINEAR_TO_sRGB: "LinearTosRGB";
-    static sRGB_TO_LINEAR: "sRGBToLinear";
+    colorNode: Node;
+    source: WorkingOrOutputColorSpace | ColorSpace;
+    target: WorkingOrOutputColorSpace | ColorSpace;
 
-    method: ColorSpaceNodeMethod;
-    node: Node;
+    constructor(
+        colorNode: Node,
+        source: WorkingOrOutputColorSpace | ColorSpace,
+        target: WorkingOrOutputColorSpace | ColorSpace,
+    );
 
-    constructor(method: ColorSpaceNodeMethod | null, node: Node);
+    getColorSpace(nodeBuilder: NodeBuilder, colorSpace: WorkingOrOutputColorSpace): ColorSpace;
 }
 
-export const linearToColorSpace: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
-export const colorSpaceToLinear: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
+export const toOutputColorSpace: (
+    node: NodeRepresentation,
+) => ShaderNodeObject<ColorSpaceNode>;
+export const toWorkingColorSpace: (
+    node: NodeRepresentation,
+) => ShaderNodeObject<ColorSpaceNode>;
 
-export const linearTosRGB: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
-export const sRGBToLinear: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
+export const workingToColorSpace: (
+    node: NodeRepresentation,
+    colorSpace: ColorSpace,
+) => ShaderNodeObject<ColorSpaceNode>;
+export const colorSpaceToWorking: (
+    node: NodeRepresentation,
+    colorSpace: ColorSpace,
+) => ShaderNodeObject<ColorSpaceNode>;
 
-declare module "../shadernode/ShaderNode.js" {
+declare module "../tsl/TSLCore.js" {
     interface NodeElements {
-        linearTosRGB: typeof linearTosRGB;
-        sRGBToLinear: typeof sRGBToLinear;
-        linearToColorSpace: typeof linearToColorSpace;
-        colorSpaceToLinear: typeof colorSpaceToLinear;
+        toOutputColorSpace: typeof toOutputColorSpace;
+        toWorkingColorSpace: typeof toWorkingColorSpace;
+
+        workingToColorSpace: typeof workingToColorSpace;
+        colorSpaceToWorking: typeof colorSpaceToWorking;
     }
 }

three/src/nodes/display/DenoiseNode.d.ts

@@ -3,7 +3,7 @@ import { Matrix4 } from "../../math/Matrix4.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class DenoiseNode extends TempNode {
     textureNode: Node;
@@ -21,6 +21,8 @@ declare class DenoiseNode extends TempNode {
     constructor(textureNode: Node, depthNode: Node, normalNode: Node, noiseNode: Node, camera: Camera);
 }
 
+export default DenoiseNode;
+
 export const denoise: (
     node: NodeRepresentation,
     depthNode: NodeRepresentation,
@@ -28,11 +30,3 @@ export const denoise: (
     noiseNode: NodeRepresentation,
     camera: Camera,
 ) => ShaderNodeObject<DenoiseNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        denoise: typeof denoise;
-    }
-}
-
-export default DenoiseNode;

three/src/nodes/display/DepthOfFieldNode.d.ts

@@ -2,9 +2,9 @@ import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export default class DepthOfFieldNode extends TempNode {
+declare class DepthOfFieldNode extends TempNode {
     textureNode: TextureNode;
     viewZNode: Node;
 
@@ -15,6 +15,8 @@ export default class DepthOfFieldNode extends TempNode {
     constructor(textureNode: TextureNode, viewZNode: Node, focusNode: Node, apertureNode: Node, maxblurNode: Node);
 }
 
+export default DepthOfFieldNode;
+
 export const dof: (
     node: NodeRepresentation,
     viewZNode: NodeRepresentation,
@@ -22,9 +24,3 @@ export const dof: (
     aperture?: NodeRepresentation,
     maxblur?: NodeRepresentation,
 ) => ShaderNodeObject<DepthOfFieldNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        dof: typeof dof;
-    }
-}

three/src/nodes/display/DotScreenNode.d.ts

@@ -2,9 +2,9 @@ import { Vector2 } from "../../math/Vector2.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export default class DotScreenNode extends TempNode {
+declare class DotScreenNode extends TempNode {
     inputNode: Node;
     center: UniformNode<Vector2>;
     angle: UniformNode<number>;
@@ -13,15 +13,11 @@ export default class DotScreenNode extends TempNode {
     constructor(inputNode: Node, center?: Vector2, angle?: number, scale?: number);
 }
 
+export default DotScreenNode;
+
 export const dotScreen: (
     node: NodeRepresentation,
     center?: Vector2,
     angle?: number,
     scale?: number,
 ) => ShaderNodeObject<DotScreenNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        dotScreen: typeof dotScreen;
-    }
-}

three/src/nodes/display/FXAANode.d.ts

@@ -1,6 +1,6 @@
 import TextureNode from "../accessors/TextureNode.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class FXAANode extends TempNode {
     textureNode: TextureNode;
@@ -8,12 +8,6 @@ declare class FXAANode extends TempNode {
     constructor(textureNode: TextureNode);
 }
 
-export const fxaa: (node: NodeRepresentation) => ShaderNodeObject<FXAANode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        fxaa: typeof fxaa;
-    }
-}
-
 export default FXAANode;
+
+export const fxaa: (node: NodeRepresentation) => ShaderNodeObject<FXAANode>;

three/src/nodes/display/FilmNode.d.ts

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class FilmNode extends TempNode {
     inputNode: Node;
@@ -10,16 +10,10 @@ declare class FilmNode extends TempNode {
     constructor(inputNode: Node, intensityNode?: Node | null, uvNode?: Node | null);
 }
 
+export default FilmNode;
+
 export const film: (
     inputNode: NodeRepresentation,
     intensityNode?: NodeRepresentation | null,
     uvNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<FilmNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        film: typeof film;
-    }
-}
-
-export default FilmNode;

three/src/nodes/display/FrontFacingNode.d.ts

@@ -1,10 +1,12 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export default class FrontFacingNode extends Node {
+declare class FrontFacingNode extends Node {
     isFrontFacingNode: true;
     constructor();
 }
 
+export default FrontFacingNode;
+
 export const frontFacing: ShaderNodeObject<FrontFacingNode>;
 export const faceDirection: ShaderNodeObject<Node>;

three/src/nodes/display/GTAONode.d.ts

@@ -5,7 +5,7 @@ import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class GTAONode extends TempNode {
     depthNode: Node;
@@ -31,16 +31,10 @@ declare class GTAONode extends TempNode {
     setSize(width: number, height: number): void;
 }
 
+export default GTAONode;
+
 export const ao: (
     depthNode: NodeRepresentation,
     normalNode: NodeRepresentation,
     camera: Camera,
 ) => ShaderNodeObject<GTAONode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        ao: typeof ao;
-    }
-}
-
-export default GTAONode;

three/src/nodes/display/GaussianBlurNode.d.ts

@@ -2,9 +2,9 @@ import { Vector2 } from "../../math/Vector2.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export default class GaussianBlurNode extends TempNode {
+declare class GaussianBlurNode extends TempNode {
     textureNode: TextureNode;
     directionNode: Node | null;
     sigma: number;
@@ -18,14 +18,10 @@ export default class GaussianBlurNode extends TempNode {
     getTextureNode(): TextureNode;
 }
 
+export default GaussianBlurNode;
+
 export const gaussianBlur: (
     node: NodeRepresentation,
     directionNode?: NodeRepresentation | null,
     sigma?: number,
 ) => ShaderNodeObject<GaussianBlurNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        gaussianBlur: typeof gaussianBlur;
-    }
-}

three/src/nodes/display/Lut3DNode.d.ts

@@ -3,7 +3,7 @@ import Texture3DNode from "../accessors/Texture3DNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class Lut3DNode extends TempNode {
     inputNode: Node;
@@ -14,17 +14,11 @@ declare class Lut3DNode extends TempNode {
     constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
 }
 
+export default Lut3DNode;
+
 export const lut3D: (
     node: NodeRepresentation,
     lut: NodeRepresentation,
     size: number,
     intensity: NodeRepresentation,
 ) => ShaderNodeObject<Lut3DNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        lut3D: typeof lut3D;
-    }
-}
-
-export default Lut3DNode;

three/src/nodes/display/MotionBlur.d.ts

@@ -0,0 +1,8 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const motionBlur: (
+    inputNode: NodeRepresentation,
+    velocity: NodeRepresentation,
+    numSamples?: NodeRepresentation,
+) => ShaderNodeObject<Node>;

three/src/nodes/display/NormalMapNode.d.ts

@@ -1,9 +1,9 @@
 import { NormalMapTypes } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export default class NormalMapNode extends TempNode {
+declare class NormalMapNode extends TempNode {
     node: Node;
     scaleNode: Node | null;
 
@@ -12,10 +12,6 @@ export default class NormalMapNode extends TempNode {
     constructor(node: Node, scaleNode?: Node | null);
 }
 
-export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
+export default NormalMapNode;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        normalMap: typeof normalMap;
-    }
-}
+export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;

three/src/nodes/display/ParallaxBarrierPassNode.d.ts

@@ -0,0 +1,14 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Scene } from "../../scenes/Scene.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import StereoCompositePassNode from "./StereoCompositePassNode.js";
+
+declare class ParallaxBarrierPassNode extends StereoCompositePassNode {
+    readonly isParallaxBarrierPassNode: true;
+
+    constructor(scene: Scene, camera: Camera);
+}
+
+export default ParallaxBarrierPassNode;
+
+export const parallaxBarrierPass: (scene: Scene, camera: Camera) => ShaderNodeObject<ParallaxBarrierPassNode>;

three/src/nodes/display/PassNode.d.ts

@@ -6,7 +6,7 @@ import TextureNode from "../accessors/TextureNode.js";
 import MRTNode from "../core/MRTNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class PassTextureNode extends TextureNode {
     passNode: PassNode;
@@ -16,8 +16,11 @@ declare class PassTextureNode extends TextureNode {
 
 declare class PassMultipleTextureNode extends PassTextureNode {
     textureName: string;
+    previousTexture: boolean;
 
-    constructor(passNode: PassNode, textureName: string);
+    constructor(passNode: PassNode, textureName: string, previousTexture?: boolean);
+
+    updateTexture(): void;
 }
 
 declare class PassNode extends TempNode {
@@ -37,8 +40,14 @@ declare class PassNode extends TempNode {
 
     getTexture(name: string): Texture;
 
+    getPreviousTexture(name: string): Texture;
+
+    toggleTexture(name: string): void;
+
     getTextureNode(name?: string): ShaderNodeObject<Node>;
 
+    getPreviousTextureNode(name?: string): ShaderNodeObject<Node>;
+
     getViewZNode(name?: string): ShaderNodeObject<Node>;
 
     getLinearDepthNode(name?: string): ShaderNodeObject<Node>;

three/src/nodes/display/PixelationPassNode.d.ts

@@ -1,45 +1,9 @@
 import { Camera } from "../../cameras/Camera.js";
 import { Scene } from "../../scenes/Scene.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import PassNode from "./PassNode.js";
 
-declare class PixelationNode extends TempNode {
-    textureNode: Node;
-    depthNode: Node;
-    normalNode: Node;
-
-    pixelSize: Node;
-    normalEdgeStrength: Node;
-    depthEdgeStrength: Node;
-
-    constructor(
-        textureNode: Node,
-        depthNode: Node,
-        normalNode: Node,
-        pixelSize: Node,
-        normalEdgeStrength: Node,
-        depthEdgeStrength: Node,
-    );
-}
-
-declare const pixelation: (
-    node: NodeRepresentation,
-    depthNode: NodeRepresentation,
-    normalNode: NodeRepresentation,
-    pixelSize?: number,
-    normalEdgeStrength?: number,
-    depthEdgeStrength?: number,
-) => ShaderNodeObject<PixelationNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        pixelation: typeof pixelation;
-    }
-}
-
 declare class PixelationPassNode extends PassNode {
     pixelSize: UniformNode<number>;
     normalEdgeStrength: UniformNode<number>;

three/src/nodes/display/PosterizeNode.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class PosterizeNode extends Node {
     sourceNode: Node;
@@ -12,9 +12,3 @@ export const posterize: (
     sourceNode: NodeRepresentation,
     stepsNode: NodeRepresentation,
 ) => ShaderNodeObject<PosterizeNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        posterize: typeof posterize;
-    }
-}

three/src/nodes/display/RGBShiftNode.d.ts

@@ -1,7 +1,7 @@
 import TextureNode from "../accessors/TextureNode.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RGBShiftNode extends TempNode {
     textureNode: TextureNode;
@@ -16,9 +16,3 @@ export default class RGBShiftNode extends TempNode {
 }
 
 export const rgbShift: (node: NodeRepresentation, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        rgbShift: typeof rgbShift;
-    }
-}

three/src/nodes/display/RenderOutputNode.d.ts

@@ -1,7 +1,7 @@
 import { ColorSpace, ToneMapping } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class RenderOutputNode extends TempNode {
     colorNode: Node;
@@ -21,7 +21,7 @@ export const renderOutput: (
     outputColorSpace?: ColorSpace | null,
 ) => ShaderNodeObject<RenderOutputNode>;
 
-declare module "../shadernode/ShaderNode.js" {
+declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         renderOutput: typeof renderOutput;
     }

three/src/nodes/display/SSAAPassNode.d.ts

@@ -0,0 +1,26 @@
+import { Camera } from "../../cameras/Camera.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Color } from "../../math/Color.js";
+import { Scene } from "../../scenes/Scene.js";
+import UniformNode from "../core/UniformNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import PassNode from "./PassNode.js";
+
+declare class SSAAPassNode extends PassNode {
+    readonly isSSAAPassNode: boolean;
+
+    sampleLevel: number;
+    unbiased: boolean;
+    clearColor: Color;
+    clearAlpha: number;
+
+    sampleWeight: UniformNode<number>;
+
+    sampleRenderTarget: RenderTarget | null;
+
+    constructor(scene: Scene, camera: Camera);
+}
+
+export default SSAAPassNode;
+
+export const ssaaPass: (scene: Scene, camera: Camera) => ShaderNodeObject<SSAAPassNode>;