@types/three 0.176.0 → 0.178.0

three/src/nodes/accessors/TextureSizeNode.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";
 
 declare class TextureSizeNode extends Node {
     readonly isTextureSizeNode: true;
@@ -13,6 +13,6 @@ declare class TextureSizeNode extends Node {
 export default TextureSizeNode;
 
 export const textureSize: (
-    textureNode: NodeRepresentation,
-    levelNode?: NodeRepresentation | null,
+    textureNode: Node,
+    levelNode?: Node | null,
 ) => ShaderNodeObject<TextureSizeNode>;

three/src/nodes/accessors/UniformArrayNode.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 ArrayElementNode from "../utils/ArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
@@ -18,14 +18,9 @@ declare class UniformArrayNode extends BufferNode<unknown[]> {
 
     getPaddedType(): string;
 
-    element(indexNode: NodeRepresentation): ShaderNodeObject<UniformArrayElementNode>;
+    element(indexNode: Node): ShaderNodeObject<UniformArrayElementNode>;
 }
 
 export default UniformArrayNode;
 
 export const uniformArray: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformArrayNode>;
-
-/**
- * @deprecated uniforms() has been renamed to uniformArray().
- */
-export const uniforms: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformArrayNode>;

three/src/nodes/code/FunctionCallNode.d.ts

@@ -3,7 +3,9 @@ import TempNode from "../core/TempNode.js";
 import { ProxiedObject, ShaderNodeObject } from "../tsl/TSLCore.js";
 import FunctionNode, { FunctionNodeArguments } from "./FunctionNode.js";
 
-export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
+export default class FunctionCallNode<P extends Array<Node | number> | { [name: string]: Node | number }>
+    extends TempNode
+{
     functionNode: FunctionNode<P>;
     parameters: { [name: string]: Node };
 

three/src/nodes/code/FunctionNode.d.ts

@@ -6,9 +6,9 @@ import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from "../tsl/TSLCore.js
 import CodeNode, { CodeNodeInclude } from "./CodeNode.js";
 import FunctionCallNode from "./FunctionCallNode.js";
 
-export type FunctionNodeArguments = Node[] | { [name: string]: Node };
+export type FunctionNodeArguments = Array<Node | number> | { [name: string]: Node | number };
 
-export default class FunctionNode<P extends Node[] | { [name: string]: Node }> extends CodeNode {
+export default class FunctionNode<P extends Array<Node | number> | { [name: string]: Node | number }> extends CodeNode {
     constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
 
     getInputs(builder: NodeBuilder): NodeFunctionInput[];

three/src/nodes/code/ScriptableNode.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";
 
 declare class Resources extends Map<string, unknown> {
     get<TArgs extends unknown[]>(key: string, callback?: ((...args: TArgs) => void) | null, ...params: TArgs): unknown;
@@ -17,6 +17,6 @@ declare class ScriptableNode extends Node {
 export default ScriptableNode;
 
 export const scriptable: (
-    codeNode: NodeRepresentation,
+    codeNode: Node,
     parameters?: Record<string, unknown>,
 ) => ShaderNodeObject<ScriptableNode>;

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

@@ -1,15 +1,19 @@
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import TempNode from "./TempNode.js";
 
-export default class AssignNode extends TempNode {
+declare class AssignNode extends TempNode {
+    readonly isAssignNode: true;
+
     constructor(targetNode: Node, sourceNode: Node);
 
     needsSplitAssign(builder: NodeBuilder): boolean;
 }
 
-export const assign: (targetNode: NodeRepresentation, sourceNode: NodeRepresentation) => ShaderNodeObject<AssignNode>;
+export default AssignNode;
+
+export const assign: (targetNode: Node, sourceNode: Node | number) => ShaderNodeObject<AssignNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {

three/src/nodes/core/AttributeNode.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 NodeBuilder from "./NodeBuilder.js";
 

three/src/nodes/core/BypassNode.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 BypassNode extends Node {
@@ -9,7 +9,7 @@ export default class BypassNode extends Node {
     constructor(returnNode: Node, callNode: Node);
 }
 
-export const bypass: (returnNode: NodeRepresentation, callNode: NodeRepresentation) => ShaderNodeObject<BypassNode>;
+export const bypass: (returnNode: Node, callNode: Node) => ShaderNodeObject<BypassNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {

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

@@ -1,4 +1,5 @@
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import ContextNode from "./ContextNode.js";
 import Node from "./Node.js";
 import NodeCache from "./NodeCache.js";
 

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/Node.d.ts

@@ -157,7 +157,7 @@ declare class Node extends EventDispatcher<{
     /**
      * By default this method returns the value of the {@link Node#global} flag. This method
      * can be overwritten in derived classes if an analytical way is required to determine the
-     * global status.
+     * global cache referring to the current shader-stage.
      *
      * @param {NodeBuilder} builder - The current node builder.
      * @return {boolean} Whether this node is global or not.
@@ -281,8 +281,9 @@ declare class Node extends EventDispatcher<{
      * This stage analyzes the node hierarchy and ensures descendent nodes are built.
      *
      * @param {NodeBuilder} builder - The current node builder.
+     * @param {?Node} output - The target output node.
      */
-    analyze(builder: NodeBuilder): void;
+    analyze(builder: NodeBuilder, output?: Node | null): void;
     /**
      * Represents the generate stage which is the third step of the build process, see {@link Node#build} method.
      * This state builds the output node and returns the resulting shader string.
@@ -326,10 +327,10 @@ declare class Node extends EventDispatcher<{
      * - **generate**: Generates the shader code for the node. Returns the generated shader string.
      *
      * @param {NodeBuilder} builder - The current node builder.
-     * @param {?string} [output=null] - Can be used to define the output type.
+     * @param {string|Node|null} [output=null] - Can be used to define the output type.
      * @return {Node|string|null} The result of the build process, depending on the build stage.
      */
-    build(builder: NodeBuilder, output?: string | null): Node | string | null;
+    build(builder: NodeBuilder, output?: string | Node | null): Node | string | null;
     /**
      * Returns the child nodes as a JSON object.
      *

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

@@ -24,6 +24,10 @@ export function getTypeFromLength(length: number): string | undefined;
 
 export function getLengthFromType(type: string): number | undefined;
 
+export function getMemoryLengthFromType(type: string): number | undefined;
+
+export function getByteBoundaryFromType(type: string): number | undefined;
+
 export function getValueType(value: unknown): string | null;
 
 export function getValueFromType(

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,32 +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 premultiplyAlpha: (color: Node) => 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";
 
@@ -27,33 +27,23 @@ export default class ColorSpaceNode extends TempNode {
     resolveColorSpace(nodeBuilder: NodeBuilder, colorSpace: WorkingOrOutputColorSpace): string;
 }
 
-export const toOutputColorSpace: (
-    node: NodeRepresentation,
-) => ShaderNodeObject<ColorSpaceNode>;
-export const toWorkingColorSpace: (
-    node: NodeRepresentation,
-) => ShaderNodeObject<ColorSpaceNode>;
-
 export const workingToColorSpace: (
-    node: NodeRepresentation,
-    colorSpace: string,
+    node: Node,
+    targetColorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 export const colorSpaceToWorking: (
-    node: NodeRepresentation,
-    colorSpace: string,
+    node: Node,
+    sourceColorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 
 export const convertColorSpace: (
-    node: NodeRepresentation,
+    node: Node,
     sourceColorSpace: string,
     targetColorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
-        toOutputColorSpace: typeof toOutputColorSpace;
-        toWorkingColorSpace: typeof toWorkingColorSpace;
-
         workingToColorSpace: typeof workingToColorSpace;
         colorSpaceToWorking: typeof colorSpaceToWorking;
     }

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>;