@types/three 0.177.0 → 0.178.0

three/src/materials/nodes/SpriteNodeMaterial.d.ts

@@ -1,28 +1,76 @@
-import { Color } from "../../math/Color.js";
 import Node from "../../nodes/core/Node.js";
-import { Texture } from "../../textures/Texture.js";
-import { SpriteMaterialParameters } from "../SpriteMaterial.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
-
-export interface SpriteNodeMaterialParameters extends NodeMaterialParameters, SpriteMaterialParameters {
-    rotationNode?: Node | null | undefined;
-    scaleNode?: Node | null | undefined;
-}
-
-export default class SpriteNodeMaterial extends NodeMaterial {
-    isSpriteNodeMaterial: true;
+import NodeBuilder from "../../nodes/core/NodeBuilder.js";
+import { MapColorPropertiesToColorRepresentations } from "../Material.js";
+import { SpriteMaterialParameters, SpriteMaterialProperties } from "../SpriteMaterial.js";
+import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
+export interface SpriteNodeMaterialNodeProperties extends NodeMaterialNodeProperties {
+    /**
+     * The rotation of sprite materials is by default inferred from the `rotation`,
+     * property. This node property allows to overwrite the default and define
+     * the rotation with a node instead.
+     *
+     * If you don't want to overwrite the rotation but modify the existing
+     * value instead, use {@link materialRotation}.
+     *
+     * @default null
+     */
     rotationNode: Node | null;
+    /**
+     * This node property provides an additional way to scale sprites next to
+     * `Object3D.scale`. The scale transformation based in `Object3D.scale`
+     * is multiplied with the scale value of this node in the vertex shader.
+     *
+     * @default null
+     */
     scaleNode: Node | null;
+    set sizeAttenuation(value: boolean);
+    /**
+     * Whether to use size attenuation or not.
+     *
+     * @type {boolean}
+     * @default true
+     */
+    get sizeAttenuation(): boolean;
+}
 
-    // Properties from SpriteMaterial
-    readonly isSpriteMaterial: true;
-    color: Color;
-    map: Texture | null;
-    alphaMap: Texture | null;
-    rotation: number;
-    sizeAttenuation: boolean;
-    fog: boolean;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface SpriteNodeMaterialParameters
+    extends
+        Partial<MapColorPropertiesToColorRepresentations<SpriteNodeMaterialNodeProperties>>,
+        SpriteMaterialParameters
+{}
 
+/**
+ * Node material version of {@link SpriteMaterial}.
+ */
+declare class SpriteNodeMaterial extends NodeMaterial {
+    /**
+     * Constructs a new sprite node material.
+     *
+     * @param {Object} [parameters] - The configuration parameter.
+     */
     constructor(parameters?: SpriteNodeMaterialParameters);
+    readonly isSpriteMaterial: boolean;
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isSpriteNodeMaterial: boolean;
+    /**
+     * Setups the position node in view space. This method implements
+     * the sprite specific vertex shader.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {Node<vec3>} The position in view space.
+     */
+    setupPositionView(builder: NodeBuilder): Node;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface SpriteNodeMaterial extends SpriteNodeMaterialNodeProperties, SpriteMaterialProperties {}
+
+export default SpriteNodeMaterial;

three/src/materials/nodes/VolumeNodeMaterial.d.ts

@@ -1,22 +1,58 @@
-import FunctionNode from "../../nodes/code/FunctionNode.js";
 import Node from "../../nodes/core/Node.js";
+import VolumetricLightingModel from "../../nodes/functions/VolumetricLightingModel.js";
 import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
-
-export interface VolumeNodeMaterialParameters extends NodeMaterialParameters {
-    steps?: number | undefined;
-
-    scatteringNode?: Node | null | undefined;
-}
-
-export default class VolumeNodeMaterial extends NodeMaterial {
-    readonly isVolumeNodeMaterial: true;
+import { MapColorPropertiesToColorRepresentations, MaterialParameters, MaterialProperties } from "../Material.js";
+import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
+export interface VolumeNodeMaterialNodeProperties extends NodeMaterialNodeProperties {
+    /**
+     * Number of steps used for raymarching.
+     *
+     * @default 25
+     */
     steps: number;
-
+    /**
+     * Offsets the distance a ray has been traveled through a volume.
+     * Can be used to implement dithering to reduce banding.
+     *
+     * @default null
+     */
+    offsetNode: Node;
+    /**
+     * Node used for scattering calculations.
+     *
+     * @default null
+     */
     scatteringNode: (params: { positionRay: ShaderNodeObject<Node> }) => Node | null;
+}
 
-    offsetNode?: Node | undefined;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface VolumeNodeMaterialParameters
+    extends Partial<MapColorPropertiesToColorRepresentations<VolumeNodeMaterialNodeProperties>>, MaterialParameters
+{}
 
-    constructor(parameters?: NodeMaterialParameters);
+/**
+ * Volume node material.
+ *
+ * @augments NodeMaterial
+ */
+declare class VolumeNodeMaterial extends NodeMaterial {
+    /**
+     * Constructs a new volume node material.
+     *
+     * @param {Object} [parameters] - The configuration parameter.
+     */
+    constructor(parameters?: VolumeNodeMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isVolumeNodeMaterial: boolean;
+    setupLightingModel(): VolumetricLightingModel;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface VolumeNodeMaterial extends VolumeNodeMaterialNodeProperties, MaterialProperties {}
+
+export default VolumeNodeMaterial;

three/src/math/Color.d.ts

@@ -302,7 +302,7 @@ export class Color {
     getHex(colorSpace?: string): number;
 
     /**
-     * Returns the string formated hexadecimal value of this color.
+     * Returns the string formatted hexadecimal value of this color.
      */
     getHexString(colorSpace?: string): string;
 

three/src/nodes/Nodes.d.ts

@@ -39,6 +39,7 @@ export { default as PropertyNode } from "./core/PropertyNode.js";
 export { default as StackNode } from "./core/StackNode.js";
 export { default as StructNode } from "./core/StructNode.js";
 export { default as StructTypeNode } from "./core/StructTypeNode.js";
+export { default as SubBuildNode } from "./core/SubBuildNode.js";
 export { default as TempNode } from "./core/TempNode.js";
 export { default as UniformGroupNode } from "./core/UniformGroupNode.js";
 export { default as UniformNode } from "./core/UniformNode.js";
@@ -52,11 +53,9 @@ export { NodeUtils };
 export { default as ArrayElementNode } from "./utils/ArrayElementNode.js";
 export { default as ConvertNode } from "./utils/ConvertNode.js";
 export { default as DebugNode } from "./utils/DebugNode.js";
-export { default as EquirectUVNode } from "./utils/EquirectUVNode.js";
 export { default as FunctionOverloadingNode } from "./utils/FunctionOverloadingNode.js";
 export { default as JoinNode } from "./utils/JoinNode.js";
 export { default as LoopNode } from "./utils/LoopNode.js";
-export { default as MatcapUVNode } from "./utils/MatcapUVNode.js";
 export { default as MaxMipLevelNode } from "./utils/MaxMipLevelNode.js";
 export { default as MemberNode } from "./utils/MemberNode.js";
 export { default as ReflectorNode, ReflectorNodeParameters } from "./utils/ReflectorNode.js";
@@ -67,7 +66,6 @@ export { default as SetNode } from "./utils/SetNode.js";
 export { default as SplitNode } from "./utils/SplitNode.js";
 export { default as SpriteSheetUVNode } from "./utils/SpriteSheetUVNode.js";
 export { default as StorageArrayElementNode } from "./utils/StorageArrayElementNode.js";
-export { default as TriplanarTexturesNode } from "./utils/TriplanarTexturesNode.js";
 
 // accessors
 export { default as BatchNode } from "./accessors/BatchNode.js";

three/src/nodes/TSL.d.ts

@@ -24,10 +24,10 @@ export * from "./math/MathUtils.js";
 export * from "./math/TriNoise3D.js";
 
 // utils
-export * from "./utils/EquirectUVNode.js";
+export * from "./utils/EquirectUV.js";
 export * from "./utils/FunctionOverloadingNode.js";
 export * from "./utils/LoopNode.js";
-export * from "./utils/MatcapUVNode.js";
+export * from "./utils/MatcapUV.js";
 export * from "./utils/MaxMipLevelNode.js";
 export * from "./utils/Oscillators.js";
 export * from "./utils/Packing.js";
@@ -36,10 +36,11 @@ export * from "./utils/ReflectorNode.js";
 export * from "./utils/RemapNode.js";
 export * from "./utils/RotateNode.js";
 export * from "./utils/RTTNode.js";
+export * from "./utils/SampleNode.js";
 export * from "./utils/SpriteSheetUVNode.js";
 export * from "./utils/SpriteUtils.js";
 export * from "./utils/Timer.js";
-export * from "./utils/TriplanarTexturesNode.js";
+export * from "./utils/TriplanarTextures.js";
 export * from "./utils/UVUtils.js";
 export * from "./utils/ViewportUtils.js";
 

three/src/nodes/accessors/AccessorsUtils.d.ts

@@ -1,9 +1,9 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const TBNViewMatrix: ShaderNodeObject<Node>;
 
 export const parallaxDirection: ShaderNodeObject<Node>;
-export const parallaxUV: (uv: ShaderNodeObject<Node>, scale: NodeRepresentation) => ShaderNodeObject<Node>;
+export const parallaxUV: (uv: ShaderNodeObject<Node>, scale: Node) => ShaderNodeObject<Node>;
 
-export const transformedBentNormalView: ShaderNodeObject<Node>;
+export const bentNormalView: ShaderNodeObject<Node>;

three/src/nodes/accessors/Bitangent.d.ts

@@ -5,5 +5,3 @@ export const bitangentGeometry: ShaderNodeObject<MathNode>;
 export const bitangentLocal: ShaderNodeObject<MathNode>;
 export const bitangentView: ShaderNodeObject<MathNode>;
 export const bitangentWorld: ShaderNodeObject<MathNode>;
-export const transformedBitangentView: ShaderNodeObject<MathNode>;
-export const transformedBitangentWorld: ShaderNodeObject<MathNode>;

three/src/nodes/accessors/CubeTextureNode.d.ts

@@ -1,6 +1,6 @@
 import { CubeTexture } from "../../textures/CubeTexture.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import TextureNode from "./TextureNode.js";
 
 declare class CubeTextureNode extends TextureNode {
@@ -22,16 +22,16 @@ export default CubeTextureNode;
 
 export const cubeTextureBase: (
     value: CubeTexture,
-    uvNode?: NodeRepresentation,
-    levelNode?: NodeRepresentation,
-    biasNode?: NodeRepresentation,
+    uvNode?: Node,
+    levelNode?: Node,
+    biasNode?: Node,
 ) => ShaderNodeObject<CubeTextureNode>;
 
 export const cubeTexture: (
     value?: CubeTexture,
-    uvNode?: NodeRepresentation | null,
-    levelNode?: NodeRepresentation | null,
-    biasNode?: NodeRepresentation | null,
+    uvNode?: Node | null,
+    levelNode?: Node | null,
+    biasNode?: Node | null,
 ) => ShaderNodeObject<CubeTextureNode>;
 
 export const uniformCubeTexture: (

three/src/nodes/accessors/Normal.d.ts

@@ -1,4 +1,3 @@
-import { Matrix4 } from "../../math/Matrix4.js";
 import AttributeNode from "../core/AttributeNode.js";
 import Node from "../core/Node.js";
 import VarNode from "../core/VarNode.js";
@@ -10,16 +9,31 @@ export const normalLocal: ShaderNodeObject<VarNode>;
 
 export const normalFlat: ShaderNodeObject<VarNode>;
 
+export const normalViewGeometry: ShaderNodeObject<VarNode>;
+
+export const normalWorldGeometry: ShaderNodeObject<VarNode>;
+
 export const normalView: ShaderNodeObject<VarNode>;
 
 export const normalWorld: ShaderNodeObject<VarNode>;
 
+export const clearcoatNormalView: ShaderNodeObject<VarNode>;
+
+export const transformNormal: (normal: Node, matrix?: Node) => ShaderNodeObject<Node>;
+
+export const transformNormalToView: (normal: Node) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated since r178. Use `normalView` instead.
+ */
 export const transformedNormalView: ShaderNodeObject<VarNode>;
 
+/**
+ * @deprecated since r178. Use `normalWorld` instead.
+ */
 export const transformedNormalWorld: ShaderNodeObject<VarNode>;
 
+/**
+ * @deprecated since r178. Use `clearcoatNormalView` instead.
+ */
 export const transformedClearcoatNormalView: ShaderNodeObject<VarNode>;
-
-export const transformNormal: (normal: Node, matrix?: Node) => ShaderNodeObject<Node>;
-
-export const transformNormalToView: (normal: Node) => ShaderNodeObject<Node>;

three/src/nodes/accessors/ReferenceBaseNode.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 ReferenceBaseNode<T> extends Node {
     property: string;

three/src/nodes/accessors/StorageBufferNode.d.ts

@@ -1,9 +1,10 @@
 import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
 import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
 import { NodeAccess } from "../core/constants.js";
+import Node from "../core/Node.js";
 import { Struct } from "../core/StructNode.js";
 import StructTypeNode from "../core/StructTypeNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import StorageArrayElementNode from "../utils/StorageArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
@@ -24,7 +25,7 @@ export default class StorageBufferNode extends BufferNode<StorageBufferAttribute
         bufferCount?: number,
     );
 
-    element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
+    element(indexNode: Node | number): ShaderNodeObject<StorageArrayElementNode>;
 
     setPBO(value: boolean): this;
 

three/src/nodes/accessors/StorageTextureNode.d.ts

@@ -2,7 +2,7 @@ import { Texture } from "../../textures/Texture.js";
 import { NodeAccess } from "../core/constants.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";
 import TextureNode from "./TextureNode.js";
 
 export default class StorageTextureNode extends TextureNode {
@@ -31,12 +31,12 @@ export default class StorageTextureNode extends TextureNode {
 
 export const storageTexture: (
     value: Texture,
-    uvNode?: NodeRepresentation | null,
-    storeNode?: NodeRepresentation,
+    uvNode?: Node | null,
+    storeNode?: Node,
 ) => ShaderNodeObject<StorageTextureNode>;
 
 export const textureStore: (
     value: Texture,
-    uvNode?: NodeRepresentation | null,
-    storeNode?: NodeRepresentation,
+    uvNode?: Node | null,
+    storeNode?: Node,
 ) => ShaderNodeObject<StorageTextureNode>;

three/src/nodes/accessors/Tangent.d.ts

@@ -8,5 +8,3 @@ export const tangentGeometry: ShaderNodeObject<AttributeNode>;
 export const tangentLocal: ShaderNodeObject<VaryingNode>;
 export const tangentView: ShaderNodeObject<MathNode>;
 export const tangentWorld: ShaderNodeObject<MathNode>;
-export const transformedTangentView: ShaderNodeObject<VarNode>;
-export const transformedTangentWorld: ShaderNodeObject<MathNode>;

three/src/nodes/accessors/TangentUtils.d.ts

@@ -0,0 +1,22 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+/**
+ * Tangent vector in view space, computed dynamically from geometry and UV derivatives.
+ * Useful for normal mapping without precomputed tangents.
+ *
+ * Reference: http://www.thetenthplanet.de/archives/1180
+ *
+ * @tsl
+ */
+export const tangentViewFrame: ShaderNodeObject<Node>;
+
+/**
+ * Bitangent vector in view space, computed dynamically from geometry and UV derivatives.
+ * Complements the tangentViewFrame for constructing the tangent space basis.
+ *
+ * Reference: http://www.thetenthplanet.de/archives/1180
+ *
+ * @tsl
+ */
+export const bitangentViewFrame: ShaderNodeObject<Node>;

three/src/nodes/accessors/Texture3DNode.d.ts

@@ -1,17 +1,18 @@
-import { CubeTexture } from "../../textures/CubeTexture.js";
 import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import TextureNode from "./TextureNode.js";
 
 export default class Texture3DNode extends TextureNode {
     readonly isTexture3DNode: true;
 
     constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
+
+    normal(uvNode: Node): ShaderNodeObject<Node>;
 }
 
 export const texture3D: (
     value: Texture,
-    uvNode?: NodeRepresentation | null,
-    levelNode?: NodeRepresentation | null,
+    uvNode?: Node | null,
+    levelNode?: Node | number | null,
 ) => ShaderNodeObject<Texture3DNode>;

three/src/nodes/accessors/TextureBicubic.d.ts

@@ -1,4 +1,6 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const textureBicubic: (textureNode: Node, lodNode?: NodeRepresentation) => ShaderNodeObject<Node>;
+export const textureBicubicLevel: (textureNode: Node, lodNode: Node) => ShaderNodeObject<Node>;
+
+export const textureBicubic: (textureNode: Node, strength: Node) => ShaderNodeObject<Node>;

three/src/nodes/accessors/TextureNode.d.ts

@@ -1,7 +1,7 @@
 import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class TextureNode extends UniformNode<Texture> {
     readonly isTextureNode: true;
@@ -34,32 +34,32 @@ export default class TextureNode extends UniformNode<Texture> {
     /**
      * @deprecated
      */
-    uv(uvNode: NodeRepresentation): ShaderNodeObject<Node>;
+    uv(uvNode: Node): ShaderNodeObject<Node>;
 
-    sample(uvNode: NodeRepresentation): ShaderNodeObject<Node>;
+    sample(uvNode: Node): ShaderNodeObject<Node>;
 
-    blur(amountNode: NodeRepresentation): ShaderNodeObject<Node>;
+    blur(amountNode: Node): ShaderNodeObject<Node>;
 
-    level(levelNode: NodeRepresentation): ShaderNodeObject<Node>;
+    level(levelNode: Node): ShaderNodeObject<Node>;
 
-    size(levelNode: NodeRepresentation): ShaderNodeObject<Node>;
+    size(levelNode: Node): ShaderNodeObject<Node>;
 
-    bias(biasNode: NodeRepresentation): ShaderNodeObject<Node>;
+    bias(biasNode: Node): ShaderNodeObject<Node>;
 
-    compare(compareNode: NodeRepresentation): ShaderNodeObject<Node>;
+    compare(compareNode: Node): ShaderNodeObject<Node>;
 
-    grad(gradeNodeX: NodeRepresentation, gradeNodeY: NodeRepresentation): ShaderNodeObject<Node>;
+    grad(gradeNodeX: Node, gradeNodeY: Node): ShaderNodeObject<Node>;
 
-    depth(depthNode: NodeRepresentation): ShaderNodeObject<Node>;
+    depth(depthNode: Node): ShaderNodeObject<Node>;
 
     clone(): this;
 }
 
 export const texture: (
     value?: Texture,
-    uvNode?: NodeRepresentation | null,
-    levelNode?: NodeRepresentation | null,
-    biasNode?: NodeRepresentation | null,
+    uvNode?: Node | null,
+    levelNode?: Node | number | null,
+    biasNode?: Node | null,
 ) => ShaderNodeObject<TextureNode>;
 
 export const uniformTexture: (
@@ -68,9 +68,9 @@ export const uniformTexture: (
 
 export const textureLoad: (
     value?: Texture,
-    uvNode?: NodeRepresentation,
-    levelNode?: NodeRepresentation,
-    biasNode?: NodeRepresentation,
+    uvNode?: Node,
+    levelNode?: Node | number,
+    biasNode?: Node,
 ) => ShaderNodeObject<TextureNode>;
 
 export const sampler: (value: Texture | TextureNode) => ShaderNodeObject<Node>;

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,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";
 import TempNode from "./TempNode.js";
@@ -13,7 +13,7 @@ declare class AssignNode extends TempNode {
 
 export default AssignNode;
 
-export const assign: (targetNode: NodeRepresentation, sourceNode: NodeRepresentation) => ShaderNodeObject<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

@@ -14,8 +14,6 @@ export default class CacheNode extends Node {
 
 export const cache: (node: Node, cache?: NodeCache) => ShaderNodeObject<CacheNode>;
 
-export const namespace: (node: Node, namespace: string) => ShaderNodeObject<ContextNode>;
-
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         cache: typeof cache;