@types/three 0.180.0 → 0.181.0

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

@@ -2,7 +2,6 @@ import { LinearSRGBColorSpace, SRGBColorSpace } from "../../constants.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type WorkingOrOutputColorSpace = "WorkingColorSpace" | "OutputColorSpace";
 
@@ -30,21 +29,32 @@ export default class ColorSpaceNode extends TempNode {
 export const workingToColorSpace: (
     node: Node,
     targetColorSpace: string,
-) => ShaderNodeObject<ColorSpaceNode>;
+) => ColorSpaceNode;
 export const colorSpaceToWorking: (
     node: Node,
     sourceColorSpace: string,
-) => ShaderNodeObject<ColorSpaceNode>;
+) => ColorSpaceNode;
 
 export const convertColorSpace: (
     node: Node,
     sourceColorSpace: string,
     targetColorSpace: string,
-) => ShaderNodeObject<ColorSpaceNode>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        workingToColorSpace: typeof workingToColorSpace;
-        colorSpaceToWorking: typeof colorSpaceToWorking;
+) => ColorSpaceNode;
+
+declare module "../Nodes.js" {
+    interface Node {
+        workingToColorSpace: (
+            targetColorSpace: string,
+        ) => ColorSpaceNode;
+        workingToColorSpaceAssign: (
+            targetColorSpace: string,
+        ) => this;
+
+        colorSpaceToWorking: (
+            sourceColorSpace: string,
+        ) => ColorSpaceNode;
+        colorSpaceToWorkingAssign: (
+            sourceColorSpace: string,
+        ) => this;
     }
 }

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class FrontFacingNode extends Node {
     isFrontFacingNode: true;
@@ -8,6 +7,6 @@ declare class FrontFacingNode extends Node {
 
 export default FrontFacingNode;
 
-export const frontFacing: ShaderNodeObject<FrontFacingNode>;
-export const faceDirection: ShaderNodeObject<Node>;
-export const directionToFaceDirection: (direction: Node) => ShaderNodeObject<Node>;
+export const frontFacing: FrontFacingNode;
+export const faceDirection: Node;
+export const directionToFaceDirection: (direction: Node) => Node;

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

@@ -1,7 +1,6 @@
 import { NormalMapTypes } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class NormalMapNode extends TempNode {
     node: Node;
@@ -14,4 +13,4 @@ declare class NormalMapNode extends TempNode {
 
 export default NormalMapNode;
 
-export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
+export const normalMap: (node: Node, scaleNode?: Node) => NormalMapNode;

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

@@ -1,15 +1,14 @@
 import { Camera } from "../../cameras/Camera.js";
 import { Layers } from "../../core/Layers.js";
+import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
 import { Vector4 } from "../../math/Vector4.js";
 import Renderer from "../../renderers/common/Renderer.js";
-import { Scene } from "../../scenes/Scene.js";
 import { Texture } from "../../textures/Texture.js";
 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 "../tsl/TSLCore.js";
 
 declare class PassTextureNode extends TextureNode {
     passNode: PassNode;
@@ -28,17 +27,27 @@ declare class PassMultipleTextureNode extends PassTextureNode {
 
 declare class PassNode extends TempNode {
     scope: PassNodeScope;
-    scene: Scene;
+    scene: Object3D;
     camera: Camera;
 
     renderTarget: RenderTarget;
 
     readonly isPassNode: true;
 
-    constructor(scope: PassNodeScope, scene: Scene, camera: Camera, options?: RenderTargetOptions);
+    constructor(scope: PassNodeScope, scene: Object3D, camera: Camera, options?: RenderTargetOptions);
 
+    setResolutionScale(resolution: number): this;
+
+    getResolutionScale(): number;
+
+    /**
+     * @deprecated Use {@link PassNode#setResolutionScale `setResolutionScale()`} instead.
+     */
     setResolution(resolution: number): this;
 
+    /**
+     * @deprecated Use {@link PassNode#getResolutionScale `getResolutionScale()`} instead.
+     */
     getResolution(): number;
 
     setLayers(layers: Layers): this;
@@ -55,13 +64,13 @@ declare class PassNode extends TempNode {
 
     toggleTexture(name: string): void;
 
-    getTextureNode(name?: string): ShaderNodeObject<TextureNode>;
+    getTextureNode(name?: string): TextureNode;
 
-    getPreviousTextureNode(name?: string): ShaderNodeObject<Node>;
+    getPreviousTextureNode(name?: string): Node;
 
-    getViewZNode(name?: string): ShaderNodeObject<Node>;
+    getViewZNode(name?: string): Node;
 
-    getLinearDepthNode(name?: string): ShaderNodeObject<Node>;
+    getLinearDepthNode(name?: string): Node;
 
     compileAsync(renderer: Renderer): Promise<void>;
 
@@ -85,6 +94,6 @@ export type PassNodeScope = typeof PassNode.COLOR | typeof PassNode.DEPTH;
 
 export default PassNode;
 
-export const pass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;
-export const passTexture: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
-export const depthPass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;
+export const pass: (scene: Object3D, camera: Camera, options?: RenderTargetOptions) => PassNode;
+export const passTexture: (pass: PassNode, texture: Texture) => PassTextureNode;
+export const depthPass: (scene: Object3D, camera: Camera, options?: RenderTargetOptions) => PassNode;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class PosterizeNode extends Node {
     sourceNode: Node;
@@ -11,4 +10,4 @@ export default class PosterizeNode extends Node {
 export const posterize: (
     sourceNode: Node,
     stepsNode: Node | number,
-) => ShaderNodeObject<PosterizeNode>;
+) => PosterizeNode;

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

@@ -1,11 +1,9 @@
 import { ToneMapping } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class RenderOutputNode extends TempNode {
     colorNode: Node;
-    toneMapping: ToneMapping | null;
     outputColorSpace: string | null;
 
     readonly isRenderOutput: true;
@@ -19,10 +17,17 @@ export const renderOutput: (
     color: Node,
     toneMapping?: ToneMapping | null,
     outputColorSpace?: string | null,
-) => ShaderNodeObject<RenderOutputNode>;
+) => RenderOutputNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        renderOutput: typeof renderOutput;
+declare module "../Nodes.js" {
+    interface Node {
+        renderOutput: (
+            toneMapping?: ToneMapping | null,
+            outputColorSpace?: string | null,
+        ) => RenderOutputNode;
+        renderOutputAssign: (
+            toneMapping?: ToneMapping | null,
+            outputColorSpace?: string | null,
+        ) => this;
     }
 }

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type ScreenNodeScope =
     | typeof ScreenNode.COORDINATE
@@ -26,21 +25,21 @@ export default ScreenNode;
 
 // Screen
 
-export const screenDPR: ShaderNodeObject<ScreenNode>;
-export const screenUV: ShaderNodeObject<ScreenNode>;
-export const screenSize: ShaderNodeObject<ScreenNode>;
-export const screenCoordinate: ShaderNodeObject<ScreenNode>;
+export const screenDPR: ScreenNode;
+export const screenUV: ScreenNode;
+export const screenSize: ScreenNode;
+export const screenCoordinate: ScreenNode;
 
 // Viewport
 
-export const viewport: ShaderNodeObject<ScreenNode>;
-export const viewportSize: ShaderNodeObject<Node>;
-export const viewportCoordinate: ShaderNodeObject<Node>;
-export const viewportUV: ShaderNodeObject<Node>;
+export const viewport: ScreenNode;
+export const viewportSize: Node;
+export const viewportCoordinate: Node;
+export const viewportUV: Node;
 
 // Deprecated
 
 /**
  * @deprecated "viewportResolution" is deprecated. Use "screenSize" instead.
  */
-export const viewportResolution: ShaderNodeObject<ScreenNode>;
+export const viewportResolution: ScreenNode;

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

@@ -1,14 +1,13 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const linearToneMapping: (color: Node, exposure: Node) => ShaderNodeObject<Node>;
+export const linearToneMapping: (color: Node, exposure: Node) => Node;
 
-export const reinhardToneMapping: (color: Node, exposure: Node) => ShaderNodeObject<Node>;
+export const reinhardToneMapping: (color: Node, exposure: Node) => Node;
 
-export const cineonToneMapping: (color: Node, exposure: Node) => ShaderNodeObject<Node>;
+export const cineonToneMapping: (color: Node, exposure: Node) => Node;
 
-export const acesFilmicToneMapping: (color: Node, exposure: Node) => ShaderNodeObject<Node>;
+export const acesFilmicToneMapping: (color: Node, exposure: Node) => Node;
 
-export const agxToneMapping: (color: Node, exposure: Node) => ShaderNodeObject<Node>;
+export const agxToneMapping: (color: Node, exposure: Node) => Node;
 
-export const neutralToneMapping: (color: Node, exposure: Node) => ShaderNodeObject<Node>;
+export const neutralToneMapping: (color: Node, exposure: Node) => Node;

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

@@ -2,10 +2,8 @@ import { ToneMapping } from "../../constants.js";
 import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ToneMappingNode extends TempNode {
-    toneMapping: ToneMapping;
     exposureNode: Node;
     colorNode: Node | null;
 
@@ -18,15 +16,18 @@ export const toneMapping: (
     mapping: ToneMapping,
     exposure: Node | number,
     color?: Node,
-) => ShaderNodeObject<ToneMappingNode>;
-export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
+) => ToneMappingNode;
+export const toneMappingExposure: RendererReferenceNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
+declare module "../Nodes.js" {
+    interface Node {
         toneMapping: (
-            color: Node,
             mapping?: ToneMapping,
             exposure?: Node | number,
-        ) => ShaderNodeObject<ToneMappingNode>;
+        ) => ToneMappingNode;
+        toneMappingAssign: (
+            mapping?: ToneMapping,
+            exposure?: Node | number,
+        ) => this;
     }
 }

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

@@ -2,7 +2,6 @@ import { Camera } from "../../cameras/Camera.js";
 import { Color } from "../../math/Color.js";
 import { Scene } from "../../scenes/Scene.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import PassNode from "./PassNode.js";
 
 declare class ToonOutlinePassNode extends PassNode {
@@ -21,4 +20,4 @@ export const toonOutlinePass: (
     color?: Color,
     thickness?: number,
     alpha?: number,
-) => ShaderNodeObject<ToonOutlinePassNode>;
+) => ToonOutlinePassNode;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ViewportDepthNode extends Node {
     scope: ViewportDepthNodeScope;
@@ -33,6 +32,6 @@ export const viewZToLogarithmicDepth: (viewZ: Node, near: Node, far: Node) => No
 
 export const logarithmicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
 
-export const depth: ShaderNodeObject<ViewportDepthNode>;
-export const linearDepth: (valueNode?: Node | null) => ShaderNodeObject<ViewportDepthNode>;
-export const viewportLinearDepth: ShaderNodeObject<ViewportDepthNode>;
+export const depth: ViewportDepthNode;
+export const linearDepth: (valueNode?: Node | null) => ViewportDepthNode;
+export const viewportLinearDepth: ViewportDepthNode;

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

@@ -1,6 +1,5 @@
 import { DepthTexture } from "../../textures/DepthTexture.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ViewportTextureNode from "./ViewportTextureNode.js";
 
 declare class ViewportDepthTextureNode extends ViewportTextureNode {
@@ -14,4 +13,4 @@ export default ViewportDepthTextureNode;
 export const viewportDepthTexture: (
     uvNode?: Node,
     levelNode?: Node,
-) => ShaderNodeObject<ViewportDepthTextureNode>;
+) => ViewportDepthTextureNode;

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

@@ -1,6 +1,5 @@
 import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ViewportTextureNode from "./ViewportTextureNode.js";
 
 declare class ViewportSharedTextureNode extends ViewportTextureNode {
@@ -14,4 +13,4 @@ export default ViewportSharedTextureNode;
 export const viewportSharedTexture: (
     uvNode?: Node,
     levelNode?: Node | null,
-) => ShaderNodeObject<ViewportSharedTextureNode>;
+) => ViewportSharedTextureNode;

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

@@ -4,7 +4,6 @@ import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
 import { NodeUpdateType } from "../core/constants.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ViewportTextureNode extends TextureNode {
     generateMipmaps: boolean;
@@ -24,9 +23,9 @@ export const viewportTexture: (
     uvNode?: Node,
     levelNode?: Node | null,
     framebufferTexture?: FramebufferTexture | null,
-) => ShaderNodeObject<ViewportTextureNode>;
+) => ViewportTextureNode;
 export const viewportMipTexture: (
     uvNode?: Node,
     levelNode?: Node | null,
     framebufferTexture?: FramebufferTexture | null,
-) => ShaderNodeObject<Node>;
+) => Node;

three/src/nodes/fog/Fog.d.ts

@@ -1,11 +1,10 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const rangeFogFactor: (near: Node | number, far: Node | number) => ShaderNodeObject<Node>;
+export const rangeFogFactor: (near: Node | number, far: Node | number) => Node;
 
-export const densityFogFactor: (density: Node) => ShaderNodeObject<Node>;
+export const densityFogFactor: (density: Node) => Node;
 
-export const fog: (color: Node, factor: Node) => ShaderNodeObject<Node>;
+export const fog: (color: Node, factor: Node) => Node;
 
 /**
  * @deprecated
@@ -14,7 +13,7 @@ export function rangeFog(
     color: Node,
     near: Node,
     far: Node,
-): ShaderNodeObject<Node>;
+): Node;
 
 /**
  * @deprecated
@@ -23,4 +22,4 @@ export function densityFog(
     color: Node,
     near: Node,
     far: Node,
-): ShaderNodeObject<Node>;
+): Node;

three/src/nodes/functions/BSDF/BRDF_GGX.d.ts

@@ -1,15 +1,14 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const BRDF_GGX: (args: {
     lightDirection: Node;
     f0: Node;
     f90: Node;
     roughness: Node;
-    f?: Node;
-    USE_IRIDESCENCE?: Node;
-    USE_ANISOTROPY?: Node;
-}) => ShaderNodeObject<OperatorNode>;
+    f?: Node | undefined;
+    USE_IRIDESCENCE?: Node | undefined;
+    USE_ANISOTROPY?: Node | undefined;
+}) => OperatorNode;
 
 export default BRDF_GGX;

three/src/nodes/functions/BSDF/BRDF_GGX_Multiscatter.d.ts

@@ -0,0 +1,14 @@
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+
+declare const BRDF_GGX_Multiscatter: (args: {
+    lightDirection: Node;
+    f0: Node;
+    f90: Node;
+    roughness: Node;
+    f?: Node | undefined;
+    USE_IRIDESCENCE?: Node | undefined;
+    USE_ANISOTROPY?: Node | undefined;
+}) => OperatorNode;
+
+export default BRDF_GGX_Multiscatter;

three/src/nodes/functions/BSDF/BRDF_Lambert.d.ts

@@ -1,7 +1,6 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const BRDF_Lambert: (args: { diffuseColor: Node }) => ShaderNodeObject<OperatorNode>;
+declare const BRDF_Lambert: (args: { diffuseColor: Node }) => OperatorNode;
 
 export default BRDF_Lambert;

three/src/nodes/functions/BSDF/BRDF_Sheen.d.ts

@@ -1,7 +1,6 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const BRDF_Sheen: (args: { lightDirection: Node }) => ShaderNodeObject<OperatorNode>;
+declare const BRDF_Sheen: (args: { lightDirection: Node }) => OperatorNode;
 
 export default BRDF_Sheen;

three/src/nodes/functions/BSDF/DFGApprox.d.ts

@@ -1,11 +1,10 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 // Analytical approximation of the DFG LUT, one half of the
 // split-sum approximation used in indirect specular lighting.
 // via 'environmentBRDF' from "Physically Based Shading on Mobile"
 // https://www.unrealengine.com/blog/physically-based-shading-on-mobile
-declare const DFGApprox: (args: { roughness: Node; dotNV: Node }) => ShaderNodeObject<OperatorNode>;
+declare const DFGApprox: (args: { roughness: Node; dotNV: Node }) => OperatorNode;
 
 export default DFGApprox;

three/src/nodes/functions/BSDF/D_GGX.d.ts

@@ -1,10 +1,9 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 // Microfacet Models for Refraction through Rough Surfaces - equation (33)
 // http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
 // alpha is "roughness squared" in Disney’s reparameterization
-declare const D_GGX: (args: { alpha: Node; dotNH: Node }) => ShaderNodeObject<OperatorNode>;
+declare const D_GGX: (args: { alpha: Node; dotNH: Node }) => OperatorNode;
 
 export default D_GGX;

three/src/nodes/functions/BSDF/D_GGX_Anisotropic.d.ts

@@ -1,10 +1,9 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 // https://google.github.io/filament/Filament.md.html#materialsystem/anisotropicmodel/anisotropicspecularbrdf
 declare const D_GGX_Anisotropic: (
     args: { alphaT: Node; alphaB: Node; dotNH: Node; dotTH: Node; dotBH: Node },
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 
 export default D_GGX_Anisotropic;

three/src/nodes/functions/BSDF/F_Schlick.d.ts

@@ -1,7 +1,6 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const F_Schlick: (args: { f0: Node; f90: Node; dotVH: Node }) => ShaderNodeObject<OperatorNode>;
+declare const F_Schlick: (args: { f0: Node; f90: Node; dotVH: Node }) => OperatorNode;
 
 export default F_Schlick;

three/src/nodes/functions/BSDF/Schlick_to_F0.d.ts

@@ -1,10 +1,9 @@
 import Node from "../../core/Node.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const Schlick_to_F0: (
     f: Node,
     f90: Node,
     dotVH: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export default Schlick_to_F0;

three/src/nodes/functions/BSDF/V_GGX_SmithCorrelated.d.ts

@@ -1,11 +1,10 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const V_GGX_SmithCorrelated: (inputs: {
     alpha: Node;
     dotNL: Node;
     dotNV: Node;
-}) => ShaderNodeObject<OperatorNode>;
+}) => OperatorNode;
 
 export default V_GGX_SmithCorrelated;

three/src/nodes/functions/BSDF/V_GGX_SmithCorrelated_Anisotropic.d.ts

@@ -1,6 +1,5 @@
 import Node from "../../core/Node.js";
 import MathNode from "../../math/MathNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const V_GGX_SmithCorrelated: (inputs: {
     alphaT: Node;
@@ -11,6 +10,6 @@ declare const V_GGX_SmithCorrelated: (inputs: {
     dotBL: Node;
     dotNV: Node;
     dotNL: Node;
-}) => ShaderNodeObject<MathNode>;
+}) => MathNode;
 
 export default V_GGX_SmithCorrelated;

three/src/nodes/functions/ShadowMaskModel.d.ts

@@ -1,9 +1,8 @@
 import LightingModel from "../core/LightingModel.js";
 import VarNode from "../core/VarNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ShadowMaskModel extends LightingModel {
-    shadowNode: ShaderNodeObject<VarNode>;
+    shadowNode: VarNode;
 
     constructor();
 }

three/src/nodes/functions/material/getAlphaHashThreshold.d.ts

@@ -1,6 +1,5 @@
 import Node from "../../core/Node.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const getAlphaHashThreshold: (position: Node) => ShaderNodeObject<Node>;
+declare const getAlphaHashThreshold: (position: Node) => Node;
 
 export default getAlphaHashThreshold;

three/src/nodes/functions/material/getGeometryRoughness.d.ts

@@ -1,6 +1,5 @@
 import MathNode from "../../math/MathNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const getGeometryRoughness: () => ShaderNodeObject<MathNode>;
+declare const getGeometryRoughness: () => MathNode;
 
 export default getGeometryRoughness;

three/src/nodes/functions/material/getParallaxCorrectNormal.d.ts

@@ -1,10 +1,9 @@
 import Node from "../../core/Node.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const getParallaxCorrectNormal: (
     normal: Node,
     cubeSize: Node,
     cubePos: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export default getParallaxCorrectNormal;

three/src/nodes/functions/material/getRoughness.d.ts

@@ -1,7 +1,6 @@
 import Node from "../../core/Node.js";
 import MathNode from "../../math/MathNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const getRoughness: (args: { roughness: Node }) => ShaderNodeObject<MathNode>;
+declare const getRoughness: (args: { roughness: Node }) => MathNode;
 
 export default getRoughness;

three/src/nodes/functions/material/getShIrradianceAt.d.ts

@@ -1,6 +1,5 @@
 import Node from "../../core/Node.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const getShIrradianceAt: (normal: Node, shCoefficients: Node) => ShaderNodeObject<Node>;
+declare const getShIrradianceAt: (normal: Node, shCoefficients: Node) => Node;
 
 export default getShIrradianceAt;

three/src/nodes/geometry/RangeNode.d.ts

@@ -4,7 +4,6 @@ import { Vector3 } from "../../math/Vector3.js";
 import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RangeNode extends Node {
     minNode: Node;
@@ -18,4 +17,4 @@ export default class RangeNode extends Node {
 export const range: (
     minNode: Node | number | Color | Vector2 | Vector3 | Vector4,
     maxNode: Node | number | Color | Vector2 | Vector3 | Vector4,
-) => ShaderNodeObject<RangeNode>;
+) => RangeNode;