@types/three 0.177.0 → 0.178.1

three/src/nodes/core/ContextNode.d.ts

@@ -1,4 +1,4 @@
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import { NodeBuilderContext } from "./NodeBuilder.js";
 
@@ -13,8 +13,8 @@ declare class ContextNode extends Node {
 
 export default ContextNode;
 
-export const context: (node: NodeRepresentation, context?: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
-export const label: (node: NodeRepresentation, label: string) => ShaderNodeObject<ContextNode>;
+export const context: (node: Node, context?: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
+export const label: (node: Node, label: string) => ShaderNodeObject<ContextNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {

three/src/nodes/core/StackNode.d.ts

@@ -1,4 +1,4 @@
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 declare class StackNode extends Node {
@@ -16,21 +16,11 @@ declare class StackNode extends Node {
 
     Else(method: () => void): this;
 
-    Switch(expression: NodeRepresentation): this;
+    Switch(expression: Node): this;
 
-    Case(...params: NodeRepresentation[]): this;
+    Case(...params: Node[]): this;
 
     Default(method: () => void): this;
-
-    /**
-     * @deprecated Use {@link StackNode#ElseIf Else()} instead.
-     */
-    elseif(boolNode: Node, method: () => void): this;
-
-    /**
-     * @deprecated Use {@link StackNode#Else Else()} instead.
-     */
-    else(method: () => void): this;
 }
 
 export default StackNode;

three/src/nodes/core/SubBuildNode.d.ts

@@ -0,0 +1,15 @@
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import Node from "./Node.js";
+
+declare class SubBuildNode extends Node {
+    node: Node;
+    name: string;
+
+    readonly isSubBuildNode: true;
+
+    constructor(node: Node, name: string, nodeType?: string | null);
+}
+
+export default SubBuildNode;
+
+export const subBuild: (node: Node, name: string, type?: string | null) => ShaderNodeObject<SubBuildNode>;

three/src/nodes/core/VarNode.d.ts

@@ -1,4 +1,4 @@
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class VarNode extends Node {
@@ -18,15 +18,15 @@ export const Const: (node: Node, name?: string | null) => ShaderNodeObject<VarNo
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
-        toVar: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
-        toConst: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+        toVar: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
+        toConst: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
     }
 }
 
 /**
  * @deprecated Use ".toVar()" instead.
  */
-export const temp: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+export const temp: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {

three/src/nodes/core/VaryingNode.d.ts

@@ -1,5 +1,5 @@
 import { InterpolationSamplingMode, InterpolationSamplingType } from "../../constants.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeVarying from "./NodeVarying.js";
@@ -18,9 +18,9 @@ export default class VaryingNode extends Node {
     setupVarying(builder: NodeBuilder): NodeVarying;
 }
 
-export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;
+export const varying: (node: Node, name?: string) => ShaderNodeObject<VaryingNode>;
 
-export const vertexStage: (node: NodeRepresentation) => ShaderNodeObject<VaryingNode>;
+export const vertexStage: (node: Node) => ShaderNodeObject<VaryingNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {

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

@@ -1,36 +1,36 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const blendBurn: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+export const blendBurn: (base: Node, blend: Node) => ShaderNodeObject<Node>;
 
-export const blendDodge: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+export const blendDodge: (base: Node, blend: Node) => ShaderNodeObject<Node>;
 
-export const blendScreen: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+export const blendScreen: (base: Node, blend: Node) => ShaderNodeObject<Node>;
 
-export const blendOverlay: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+export const blendOverlay: (base: Node, blend: Node) => ShaderNodeObject<Node>;
 
-export const blendColor: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+export const blendColor: (base: Node, blend: Node) => ShaderNodeObject<Node>;
 
-export const premult: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const premultiplyAlpha: (color: Node) => ShaderNodeObject<Node>;
 
-export const unpremult: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const unpremultiplyAlpha: (color: Node) => ShaderNodeObject<Node>;
 
 /**
  * @deprecated
  */
-export const burn: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+export const burn: (base: Node, blend: Node) => ShaderNodeObject<Node>;
 
 /**
  * @deprecated
  */
-export const dodge: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+export const dodge: (base: Node, blend: Node) => ShaderNodeObject<Node>;
 
 /**
  * @deprecated
  */
-export const screen: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+export const screen: (base: Node, blend: Node) => ShaderNodeObject<Node>;
 
 /**
  * @deprecated
  */
-export const overlay: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+export const overlay: (base: Node, blend: Node) => ShaderNodeObject<Node>;

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

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

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

@@ -1,30 +1,30 @@
 import Node from "../core/Node.js";
 import MathNode from "../math/MathNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const grayscale: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const grayscale: (color: Node) => ShaderNodeObject<Node>;
 
 export const saturation: (
-    color: NodeRepresentation,
-    adjustment?: NodeRepresentation,
+    color: Node,
+    adjustment?: Node | number,
 ) => ShaderNodeObject<Node>;
 
 export const vibrance: (
-    color: NodeRepresentation,
-    adjustment?: NodeRepresentation,
+    color: Node,
+    adjustment?: Node | number,
 ) => ShaderNodeObject<Node>;
 
 export const hue: (
-    color: NodeRepresentation,
-    adjustment?: NodeRepresentation,
+    color: Node,
+    adjustment?: Node | number,
 ) => ShaderNodeObject<Node>;
 
 export const luminance: (
-    color: NodeRepresentation,
-    luminanceCoefficients?: NodeRepresentation,
+    color: Node,
+    luminanceCoefficients?: Node,
 ) => ShaderNodeObject<MathNode>;
 
-export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;
+export const threshold: (color: Node, thershold: Node) => ShaderNodeObject<MathNode>;
 
 /**
  * Color Decision List (CDL) v1.2
@@ -47,10 +47,10 @@ export const threshold: (color: NodeRepresentation, thershold: NodeRepresentatio
  * @return Output, -Infinity < output < +Infinity
  */
 export const cdl: (
-    color: NodeRepresentation,
-    slope?: NodeRepresentation,
-    offset?: NodeRepresentation,
-    power?: NodeRepresentation,
-    saturation?: NodeRepresentation,
-    luminanceCoefficients?: NodeRepresentation,
+    color: Node,
+    slope?: Node,
+    offset?: Node,
+    power?: Node,
+    saturation?: Node,
+    luminanceCoefficients?: Node,
 ) => ShaderNodeObject<Node>;

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

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

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

@@ -2,7 +2,7 @@ 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 { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type WorkingOrOutputColorSpace = "WorkingColorSpace" | "OutputColorSpace";
 
@@ -28,16 +28,16 @@ export default class ColorSpaceNode extends TempNode {
 }
 
 export const workingToColorSpace: (
-    node: NodeRepresentation,
+    node: Node,
     targetColorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 export const colorSpaceToWorking: (
-    node: NodeRepresentation,
+    node: Node,
     sourceColorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 
 export const convertColorSpace: (
-    node: NodeRepresentation,
+    node: Node,
     sourceColorSpace: string,
     targetColorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;

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

@@ -10,3 +10,4 @@ export default FrontFacingNode;
 
 export const frontFacing: ShaderNodeObject<FrontFacingNode>;
 export const faceDirection: ShaderNodeObject<Node>;
+export const directionToFaceDirection: (direction: Node) => ShaderNodeObject<Node>;

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

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

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

@@ -1,7 +1,7 @@
 import { ToneMapping } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class RenderOutputNode extends TempNode {
     colorNode: Node;
@@ -16,7 +16,7 @@ declare class RenderOutputNode extends TempNode {
 export default RenderOutputNode;
 
 export const renderOutput: (
-    color: NodeRepresentation,
+    color: Node,
     toneMapping?: ToneMapping | null,
     outputColorSpace?: string | null,
 ) => ShaderNodeObject<RenderOutputNode>;

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

@@ -41,13 +41,3 @@ export const viewportUV: ShaderNodeObject<Node>;
  * @deprecated "viewportResolution" is deprecated. Use "screenSize" instead.
  */
 export const viewportResolution: ShaderNodeObject<ScreenNode>;
-
-/**
- * @deprecated "viewportTopLeft" is deprecated. Use "viewportUV" instead.
- */
-export const viewportTopLeft: ShaderNodeObject<ScreenNode>;
-
-/**
- * @deprecated "viewportBottomLeft" is deprecated. Use "viewportUV.flipY()" instead.
- */
-export const viewportBottomLeft: ShaderNodeObject<ScreenNode>;

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

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

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

@@ -2,7 +2,7 @@ import { ToneMapping } from "../../constants.js";
 import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ToneMappingNode extends TempNode {
     toneMapping: ToneMapping;
@@ -16,17 +16,17 @@ export default ToneMappingNode;
 
 export const toneMapping: (
     mapping: ToneMapping,
-    exposure: NodeRepresentation,
-    color?: NodeRepresentation,
+    exposure: Node,
+    color?: Node,
 ) => ShaderNodeObject<ToneMappingNode>;
 export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         toneMapping: (
-            color: NodeRepresentation,
-            mapping?: NodeRepresentation,
-            exposure?: NodeRepresentation,
+            color: Node,
+            mapping?: ToneMapping,
+            exposure?: Node,
         ) => ShaderNodeObject<ToneMappingNode>;
     }
 }

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,10 @@
+import { Color } from "../../math/Color.js";
+import { Vector2 } from "../../math/Vector2.js";
+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 { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RangeNode extends Node {
     minNode: Node;
@@ -11,4 +15,7 @@ export default class RangeNode extends Node {
     getVectorLength(builder: NodeBuilder): number;
 }
 
-export const range: (minNode: NodeRepresentation, maxNode: NodeRepresentation) => ShaderNodeObject<RangeNode>;
+export const range: (
+    minNode: Node | number | Color | Vector2 | Vector3 | Vector4,
+    maxNode: Node | number | Color | Vector2 | Vector3 | Vector4,
+) => ShaderNodeObject<RangeNode>;

three/src/nodes/gpgpu/AtomicFunctionNode.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type AtomicMethod =
     | typeof AtomicFunctionNode.ATOMIC_LOAD
@@ -33,50 +33,50 @@ declare class AtomicFunctionNode extends Node {
 
 export const atomicFunc: (
     method: AtomicMethod,
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicLoad: (
-    pointerNode: NodeRepresentation,
+    pointerNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicStore: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node | number,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicAdd: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node | number,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicSub: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node | number,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicMax: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicMin: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicAnd: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicOr: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicXor: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;

three/src/nodes/gpgpu/ComputeNode.d.ts

@@ -1,6 +1,6 @@
 import Renderer from "../../renderers/common/Renderer.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ComputeNode extends Node {
     isComputeNode: true;
@@ -22,7 +22,7 @@ export default class ComputeNode extends Node {
 }
 
 export const compute: (
-    node: NodeRepresentation,
+    node: Node,
     count: number,
     workgroupSize?: number[],
 ) => ShaderNodeObject<ComputeNode>;

three/src/nodes/lighting/PointShadowNode.d.ts

@@ -1,24 +1,24 @@
 import { Light } from "../../lights/Light.js";
 import { LightShadow } from "../../lights/LightShadow.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ShadowNode from "./ShadowNode.js";
 
-export const cubeToUV: (pos: NodeRepresentation, texelSizeY: NodeRepresentation) => ShaderNodeObject<Node>;
+export const cubeToUV: (pos: Node, texelSizeY: Node) => ShaderNodeObject<Node>;
 
 export const BasicPointShadowFilter: (
-    depthTexture: NodeRepresentation,
-    bd3D: NodeRepresentation,
-    dp: NodeRepresentation,
-    texelSize: NodeRepresentation,
+    depthTexture: Node,
+    bd3D: Node,
+    dp: Node,
+    texelSize: Node,
 ) => ShaderNodeObject<Node>;
 
 export const PointShadowFilter: (
-    depthTexture: NodeRepresentation,
-    bd3D: NodeRepresentation,
-    dp: NodeRepresentation,
-    texelSize: NodeRepresentation,
-    shadow: NodeRepresentation,
+    depthTexture: Node,
+    bd3D: Node,
+    dp: Node,
+    texelSize: Node,
+    shadow: Node,
 ) => ShaderNodeObject<Node>;
 
 declare class PointShadowNode extends ShadowNode {