@types/three 0.158.3 → 0.160.0

three/examples/jsm/nodes/accessors/CubeTextureNode.d.ts

@@ -1,6 +1,7 @@
-import TextureNode from './TextureNode.js';
-import { Node } from '../Nodes.js';
 import { CubeTexture } from '../../../../src/Three.js';
+import TextureNode from './TextureNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class CubeTextureNode extends TextureNode {
     isCubeTextureNode: boolean;
@@ -11,3 +12,9 @@ export default class CubeTextureNode extends TextureNode {
 
     getDefaultUV(): Node;
 }
+
+export const cubeTexture: (
+    value: CubeTexture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+) => ShaderNodeObject<CubeTextureNode>;

three/examples/jsm/nodes/accessors/InstanceNode.d.ts

@@ -1,5 +1,6 @@
 import { InstancedMesh } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class InstanceNode extends Node {
     instanceMesh: InstancedMesh;
@@ -7,3 +8,5 @@ export default class InstanceNode extends Node {
 
     constructor(instanceMesh: InstancedMesh);
 }
+
+export const instance: (instanceMesh: InstancedMesh) => ShaderNodeObject<InstanceNode>;

three/examples/jsm/nodes/accessors/MaterialNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type MaterialNodeScope =
     | typeof MaterialNode.ALPHA_TEST
@@ -21,3 +22,14 @@ export default class MaterialNode extends Node {
     scope: MaterialNodeScope;
     constructor(scope?: MaterialNodeScope);
 }
+
+export const materialAlphaTest: ShaderNodeObject<MaterialNode>;
+export const materialColor: ShaderNodeObject<MaterialNode>;
+export const materialShininess: ShaderNodeObject<MaterialNode>;
+export const materialEmissive: ShaderNodeObject<MaterialNode>;
+export const materialOpacity: ShaderNodeObject<MaterialNode>;
+export const materialSpecularColor: ShaderNodeObject<MaterialNode>;
+export const materialReflectivity: ShaderNodeObject<MaterialNode>;
+export const materialRoughness: ShaderNodeObject<MaterialNode>;
+export const materialMetalness: ShaderNodeObject<MaterialNode>;
+export const materialRotation: ShaderNodeObject<MaterialNode>;

three/examples/jsm/nodes/accessors/MaterialReferenceNode.d.ts

@@ -1,6 +1,13 @@
 import { Material } from '../../../../src/Three.js';
 import ReferenceNode from './ReferenceNode.js';
+import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class MaterialReferenceNode extends ReferenceNode<Material | null> {
     constructor(property: string, inputType: string, material?: Material | null);
 }
+
+export const materialReference: (
+    name: string,
+    nodeOrType: NodeOrType,
+    material: Material,
+) => ShaderNodeObject<MaterialReferenceNode>;

three/examples/jsm/nodes/accessors/ModelNode.d.ts

@@ -1,5 +1,5 @@
-import { NodeFrame } from '../Nodes.js';
 import Object3DNode, { Object3DNodeScope } from './Object3DNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 /**
  * Similar to {@link Object3DNode} but the object comes from {@link NodeFrame}
@@ -7,3 +7,9 @@ import Object3DNode, { Object3DNodeScope } from './Object3DNode.js';
 export default class ModelNode extends Object3DNode {
     constructor(scope?: Object3DNodeScope);
 }
+
+export const modelViewMatrix: ShaderNodeObject<ModelNode>;
+export const modelNormalMatrix: ShaderNodeObject<ModelNode>;
+export const modelWorldMatrix: ShaderNodeObject<ModelNode>;
+export const modelPosition: ShaderNodeObject<ModelNode>;
+export const modelViewPosition: ShaderNodeObject<ModelNode>;

three/examples/jsm/nodes/accessors/ModelViewProjectionNode.d.ts

@@ -1,6 +1,9 @@
 import Node from '../core/Node.js';
 import PositionNode from './PositionNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ModelViewProjectionNode extends Node {
     constructor(positionNode?: PositionNode);
 }
+
+export const modelViewProjection: (position?: NodeRepresentation) => ShaderNodeObject<ModelViewProjectionNode>;

three/examples/jsm/nodes/accessors/NormalNode.d.ts

@@ -1,4 +1,6 @@
 import Node from '../core/Node.js';
+import VarNode from '../core/VarNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type NormalNodeScope = typeof NormalNode.GEOMETRY | typeof NormalNode.LOCAL | typeof NormalNode.VIEW;
 
@@ -10,3 +12,9 @@ export default class NormalNode extends Node {
 
     constructor(scope?: NormalNodeScope);
 }
+
+export const normalGeometry: ShaderNodeObject<NormalNode>;
+export const normalLocal: ShaderNodeObject<NormalNode>;
+export const normalView: ShaderNodeObject<NormalNode>;
+export const normalWorld: ShaderNodeObject<NormalNode>;
+export const transformedNormalView: ShaderNodeObject<VarNode>;

three/examples/jsm/nodes/accessors/PointUVNode.d.ts

@@ -1,7 +1,10 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class PointUVNode extends Node {
     isPointUVNode: true;
 
     constructor();
 }
+
+export const pointUV: ShaderNodeObject<PointUVNode>;

three/examples/jsm/nodes/accessors/PositionNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type PositionNodeScope =
     | typeof PositionNode.GEOMETRY
@@ -19,3 +20,10 @@ export default class PositionNode extends Node {
 
     constructor(scope?: PositionNodeScope);
 }
+
+export const positionGeometry: ShaderNodeObject<PositionNode>;
+export const positionLocal: ShaderNodeObject<PositionNode>;
+export const positionWorld: ShaderNodeObject<PositionNode>;
+export const positionWorldDirection: ShaderNodeObject<PositionNode>;
+export const positionView: ShaderNodeObject<PositionNode>;
+export const positionViewDirection: ShaderNodeObject<PositionNode>;

three/examples/jsm/nodes/accessors/ReferenceNode.d.ts

@@ -1,5 +1,6 @@
 import Node from '../core/Node.js';
-import { NodeTypeOption } from '../Nodes.js';
+import { NodeTypeOption } from '../core/constants.js';
+import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ReferenceNode<T> extends Node {
     object: T;
@@ -11,3 +12,5 @@ export default class ReferenceNode<T> extends Node {
 
     setNodeType(uniformType: NodeTypeOption): void;
 }
+
+export const reference: <T>(name: string, nodeOrType: NodeOrType, object: T) => ShaderNodeObject<ReferenceNode<T>>;

three/examples/jsm/nodes/accessors/ReflectVectorNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ReflectVectorNode extends Node {
     constructor();
@@ -6,3 +7,5 @@ export default class ReflectVectorNode extends Node {
     getHash(): 'reflectVector';
     setup(): Node;
 }
+
+export const reflectVector: ShaderNodeObject<ReflectVectorNode>;

three/examples/jsm/nodes/accessors/SkinningNode.d.ts

@@ -1,5 +1,6 @@
 import { SkinnedMesh } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SkinningNode extends Node {
     skinIndexNode: Node;
@@ -11,3 +12,5 @@ export default class SkinningNode extends Node {
 
     constructor(skinnedMesh: SkinnedMesh);
 }
+
+export function skinning(skinnedMesh: SkinnedMesh): ShaderNodeObject<SkinningNode>;

three/examples/jsm/nodes/accessors/StorageBufferNode.d.ts

@@ -1,6 +1,13 @@
-import { NodeTypeOption } from '../Nodes.js';
 import BufferNode from './BufferNode.js';
+import { NodeTypeOption } from '../core/constants.js';
+import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class StorageBufferNode extends BufferNode {
     constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
 }
+
+export const storage: (
+    value: ArrayLike<number>,
+    nodeOrType: NodeOrType,
+    count: number,
+) => ShaderNodeObject<StorageBufferNode>;

three/examples/jsm/nodes/accessors/TangentNode.d.ts

@@ -1,4 +1,6 @@
 import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type TangentNodeScope =
     | typeof TangentNode.LOCAL
@@ -16,3 +18,10 @@ export default class TangentNode extends Node {
 
     constructor(scope?: TangentNodeScope);
 }
+
+export const tangentGeometry: ShaderNodeObject<TangentNode>;
+export const tangentLocal: ShaderNodeObject<TangentNode>;
+export const tangentView: ShaderNodeObject<TangentNode>;
+export const tangentWorld: ShaderNodeObject<TangentNode>;
+export const transformedTangentView: ShaderNodeObject<MathNode>;
+export const transformedTangentWorld: ShaderNodeObject<MathNode>;

three/examples/jsm/nodes/accessors/TextureNode.d.ts

@@ -1,8 +1,9 @@
 import { Texture } from '../../../../src/Three.js';
 import UniformNode from '../core/UniformNode.js';
-import { Node } from '../Nodes.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export default class TextureNode extends UniformNode {
+export default class TextureNode extends UniformNode<Texture> {
     isTextureNode: true;
 
     uvNode: Node | null;
@@ -12,3 +13,10 @@ export default class TextureNode extends UniformNode {
 
     getDefaultUV(): Node;
 }
+
+export const texture: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+) => ShaderNodeObject<TextureNode>;
+export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/accessors/UVNode.d.ts

@@ -1,4 +1,5 @@
 import AttributeNode from '../core/AttributeNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class UVNode extends AttributeNode {
     isUVNode: true;
@@ -6,3 +7,5 @@ export default class UVNode extends AttributeNode {
 
     constructor(index?: number);
 }
+
+export const uv: (index?: number) => ShaderNodeObject<UVNode>;

three/examples/jsm/nodes/accessors/UserDataNode.d.ts

@@ -1,7 +1,14 @@
 import { NodeTypeOption, NodeUserData } from '../core/constants.js';
 import ReferenceNode from './ReferenceNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class UserDataNode extends ReferenceNode<NodeUserData> {
     userData: NodeUserData | null;
     constructor(property: string, inputType: NodeTypeOption, userData?: NodeUserData | null);
 }
+
+export const userData: (
+    name: string,
+    inputType: NodeTypeOption,
+    userData?: NodeUserData,
+) => ShaderNodeObject<UserDataNode>;

three/examples/jsm/nodes/code/CodeNode.d.ts

@@ -1,5 +1,7 @@
 import Node from '../core/Node.js';
 import NodeBuilder from '../core/NodeBuilder.js';
+import { NodeTypeOption } from '../core/constants.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export interface CodeNodeInclude {
     build(builder: NodeBuilder): void;
@@ -13,3 +15,5 @@ export default class CodeNode extends Node {
     setIncludes(includes: CodeNodeInclude[]): this;
     getIncludes(builder: NodeBuilder): CodeNodeInclude[];
 }
+
+export const code: (code: string, nodeType?: NodeTypeOption) => ShaderNodeObject<CodeNode>;

three/examples/jsm/nodes/code/ExpressionNode.d.ts

@@ -1,7 +1,10 @@
 import { NodeTypeOption } from '../core/constants.js';
 import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ExpressionNode extends TempNode {
     snipped: string; /* sic */
     constructor(snipped?: string, nodeType?: NodeTypeOption);
 }
+
+export const expression: (snipped?: string, nodeType?: NodeTypeOption) => ShaderNodeObject<ExpressionNode>;

three/examples/jsm/nodes/code/FunctionCallNode.d.ts

@@ -1,6 +1,7 @@
-import FunctionNode from './FunctionNode.js';
+import FunctionNode, { FunctionNodeArguments } from './FunctionNode.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { ProxiedObject, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
     functionNode: FunctionNode<P>;
@@ -11,3 +12,8 @@ export default class FunctionCallNode<P extends Node[] | { [name: string]: Node
     setParameters(parameters: P): this;
     getParameters(): P;
 }
+
+export const call: <P extends FunctionNodeArguments>(
+    functionNode?: FunctionNode<P>,
+    parameters?: ProxiedObject<P>,
+) => ShaderNodeObject<FunctionCallNode<P>>;

three/examples/jsm/nodes/code/FunctionNode.d.ts

@@ -4,6 +4,7 @@ import NodeBuilder from '../core/NodeBuilder.js';
 import NodeFunction from '../core/NodeFunction.js';
 import NodeFunctionInput from '../core/NodeFunctionInput.js';
 import Node from '../core/Node.js';
+import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type FunctionNodeArguments = Node[] | { [name: string]: Node };
 
@@ -15,3 +16,19 @@ export default class FunctionNode<P extends Node[] | { [name: string]: Node }> e
     getNodeFunction(builder: NodeBuilder): NodeFunction;
     call(parameters: P): FunctionCallNode<P>;
 }
+
+export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]]
+    ? ProxiedTuple<P>
+    : readonly [ProxiedObject<P>];
+
+export const func: <P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => { call: (...params: Fn<P>) => ShaderNodeObject<Node> };
+
+export const fn: <P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => (...params: Fn<P>) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/core/ArrayUniformNode.d.ts

@@ -1,7 +1,7 @@
 import UniformNode from './UniformNode.js';
 import Node from './Node.js';
 
-export default class ArrayUniformNode extends UniformNode {
+export default class ArrayUniformNode extends UniformNode<undefined> {
     isArrayUniformNode: true;
     nodes: Node[];
     constructor(nodes?: Node[]);

three/examples/jsm/nodes/core/AttributeNode.d.ts

@@ -1,9 +1,12 @@
 import { NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeBuilder from './NodeBuilder.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class AttributeNode extends Node {
     constructor(attributeName: string, nodeType?: NodeTypeOption | null);
     setAttributeName(attributeName: string): this;
     getAttributeName(builder: NodeBuilder): string;
 }
+
+export const attribute: (name: string, nodeType: NodeTypeOption) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/core/BypassNode.d.ts

@@ -1,4 +1,5 @@
 import Node from './Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class BypassNode extends Node {
     isBypassNode: true;
@@ -7,3 +8,5 @@ export default class BypassNode extends Node {
 
     constructor(returnNode: Node, callNode: Node);
 }
+
+export const bypass: (returnNode: NodeRepresentation, callNode: NodeRepresentation) => ShaderNodeObject<BypassNode>;

three/examples/jsm/nodes/core/CacheNode.d.ts

@@ -1,5 +1,6 @@
 import Node from './Node.js';
 import NodeCache from './NodeCache.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class CacheNode extends Node {
     isCacheNode: true;
@@ -8,3 +9,5 @@ export default class CacheNode extends Node {
 
     constructor(node: Node, cache?: NodeCache);
 }
+
+export const cache: (node: Node, cache?: NodeCache) => ShaderNodeObject<CacheNode>;

three/examples/jsm/nodes/core/ConstNode.d.ts

@@ -1,10 +1,10 @@
-import { NodeTypeOption, NodeValueOption } from './constants.js';
+import { NodeTypeOption } from './constants.js';
 import InputNode from './InputNode.js';
 import NodeBuilder from './NodeBuilder.js';
 
-export default class ConstNode extends InputNode {
+export default class ConstNode<Value> extends InputNode<Value> {
     isConstNode: true;
-    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+    constructor(value: Value, nodeType?: NodeTypeOption | null);
 
     generateConst(builder: NodeBuilder): string;
 }

three/examples/jsm/nodes/core/ContextNode.d.ts

@@ -1,5 +1,6 @@
 import Node from './Node.js';
 import { NodeBuilderContext } from './NodeBuilder.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ContextNode extends Node {
     isContextNode: true;
@@ -8,3 +9,5 @@ export default class ContextNode extends Node {
 
     constructor(node: Node, context: NodeBuilderContext);
 }
+
+export const context: (node: NodeRepresentation, context: NodeBuilderContext) => ShaderNodeObject<ContextNode>;

three/examples/jsm/nodes/core/InputNode.d.ts

@@ -1,15 +1,15 @@
-import { NodeTypeOption, NodeValueOption } from './constants.js';
+import { NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeBuilder from './NodeBuilder.js';
 
 export type Precision = 'low' | 'medium' | 'high';
 
-export default abstract class InputNode extends Node {
+export default abstract class InputNode<Value> extends Node {
     isInputNode: true;
-    value: NodeValueOption;
+    value: Value;
     precision: Precision | null;
 
-    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+    constructor(value: Value, nodeType?: NodeTypeOption | null);
 
     getInputType(builder: NodeBuilder): string | null;
     setPrecision(precision: Precision): this;

three/examples/jsm/nodes/core/NodeBuilder.d.ts

@@ -3,14 +3,12 @@ import {
     Material,
     Object3D,
     Renderer,
-    Scene,
     Texture,
     TextureEncoding,
     WebGLRenderTarget,
 } from '../../../../src/Three.js';
 import FogNode from '../fog/FogNode.js';
 import LightsNode from '../lighting/LightsNode.js';
-import { nodeObject } from '../Nodes.js';
 import { AnyObject, NodeShaderStageOption, NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeAttribute from './NodeAttribute.js';
@@ -106,7 +104,12 @@ export default abstract class NodeBuilder {
     getVectorFromMatrix(type: NodeTypeOption): NodeTypeOption;
     getDataFromNode(node: Node, shaderStage?: NodeShaderStageOption): NodeData;
     getNodeProperties(node: Node, shaderStage?: NodeShaderStageOption): AnyObject;
-    getUniformFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeUniform;
+    getUniformFromNode(
+        node: Node,
+        type: NodeTypeOption,
+        shaderStage?: NodeShaderStageOption,
+        name?: string | null,
+    ): NodeUniform<string>;
     getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
     getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
     getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): string;

three/examples/jsm/nodes/core/NodeUniform.d.ts

@@ -1,13 +1,17 @@
-import { NodeValueOption } from './constants.js';
-import InputNode from './InputNode.js';
+import UniformNode from './UniformNode.js';
+
+export default class NodeUniform<Value> {
+    readonly isNodeUniform: true;
 
-export default class NodeUniform {
-    isNodeUniform: true;
     name: string;
     type: string;
-    node: InputNode;
-    needsUpdate: boolean;
-    value: NodeValueOption;
+    node: UniformNode<Value>;
+    needsUpdate: boolean | undefined;
+
+    constructor(name: string, type: string, node: UniformNode<Value>, needsUpdate?: boolean);
+
+    get(): Value;
+    set value(val: Value);
 
-    constructor(name: string, type: string, node: InputNode, needsUpdate?: boolean);
+    get id(): number;
 }

three/examples/jsm/nodes/core/NodeUtils.d.ts

@@ -1,4 +1,4 @@
-import { NodeValueOption } from './constants.js';
+import { Color, Vector2, Vector3, Vector4, Matrix3, Matrix4 } from '../../../../src/Three.js';
 import Node from './Node.js';
 
 export interface NodeChild {
@@ -9,5 +9,8 @@ export interface NodeChild {
 
 export function getCacheKey(object: Node): string;
 export function getNodeChildren(object: Node): Generator<NodeChild, void>;
-export function getValueType(value: NodeValueOption): string | null;
-export function getValueFromType(type: string, ...params: number[]): NodeValueOption | null;
+export function getValueType(value: unknown): string | null;
+export function getValueFromType(
+    type: string,
+    ...params: number[]
+): Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number | string | ArrayBufferLike | null;

three/examples/jsm/nodes/core/PropertyNode.d.ts

@@ -1,6 +1,15 @@
 import { NodeTypeOption } from './constants.js';
 import Node from './Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class PropertyNode extends Node {
     constructor(name?: string, nodeType?: NodeTypeOption);
 }
+
+export const property: (name: string, nodeOrType: Node | NodeTypeOption) => ShaderNodeObject<Node>;
+
+export const diffuseColor: ShaderNodeObject<PropertyNode>;
+export const roughness: ShaderNodeObject<PropertyNode>;
+export const metalness: ShaderNodeObject<PropertyNode>;
+export const specularColor: ShaderNodeObject<PropertyNode>;
+export const shininess: ShaderNodeObject<PropertyNode>;

three/examples/jsm/nodes/core/UniformNode.d.ts

@@ -1,10 +1,18 @@
-import { NodeTypeOption, NodeValueOption } from './constants.js';
+import { NodeTypeOption } from './constants.js';
 import InputNode from './InputNode.js';
 import NodeBuilder from './NodeBuilder.js';
+import Node from './Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export default class UniformNode extends InputNode {
-    isUniformNode: true;
+export default class UniformNode<Value> extends InputNode<Value> {
+    readonly isUniformNode: true;
+
+    constructor(value: Value, nodeType?: NodeTypeOption | null);
 
-    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
     getUniformHash(builder: NodeBuilder): string;
 }
+
+export const uniform: <Value>(
+    arg1: InputNode<Value> | Value,
+    arg2?: Node | string,
+) => ShaderNodeObject<UniformNode<Value>>;

three/examples/jsm/nodes/core/VarNode.d.ts

@@ -1,5 +1,6 @@
 import { OperatorNodeOp } from '../math/OperatorNode.js';
 import Node from './Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class VarNode extends Node {
     node: Node;
@@ -14,3 +15,6 @@ export default class VarNode extends Node {
     mul(...params: Node[]): this;
     div(...params: Node[]): this;
 }
+
+export const label: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VarNode>;
+export const temp: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VarNode>;

three/examples/jsm/nodes/core/VaryingNode.d.ts

@@ -1,4 +1,5 @@
 import Node from './Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class VaryingNode extends Node {
     node: Node;
@@ -6,3 +7,5 @@ export default class VaryingNode extends Node {
 
     constructor(node: Node, name?: string | null);
 }
+
+export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;

three/examples/jsm/nodes/core/constants.d.ts

@@ -1,5 +1,3 @@
-import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '../../../../src/Three.js';
-
 // disable automatic export, we have some private declarations
 export const NodeShaderStage: {
     VERTEX: 'vertex';
@@ -13,7 +11,6 @@ export const NodeUpdateType: {
     OBJECT: 'object';
 };
 
-export type NodeValueOption = Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number;
 export type NodeUpdateTypeOption = 'none' | 'frame' | 'object';
 export type NodeShaderStageOption = 'vertex' | 'fragment' | 'compute';
 export type NodeTypeOption =
@@ -50,13 +47,18 @@ export type NodeTypeOption =
     | 'umat4'
     | 'bmat4';
 
-// can be defined with string template type in Typescript 4.1
-export type SwizzleOption = string;
+export type SwizzleCharacter = 'x' | 'y' | 'z' | 'w' | 'r' | 'g' | 'b' | 'a' | 's' | 't' | 'p' | 'q';
+
+export type SwizzleOption = Exclude<
+    | `${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
+    'abs' | 'sqrt'
+>;
 
 /** Should be the same type as Object3D.userData */
-export interface NodeUserData {
-    [key: string]: any;
-}
+export type NodeUserData = Record<string, any>;
 
 /** generic key value type,curretly used by nodes  */
 export interface AnyObject {

three/examples/jsm/nodes/display/BlendModeNode.d.ts

@@ -1,6 +1,6 @@
 import TempNode from '../core/TempNode.js';
-import { ShaderNode } from '../shadernode/ShaderNodeBaseElements.js';
-import { Node } from '../Nodes.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNode, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export const BurnNode: ShaderNode<{ base: Node; blendNode: Node }>;
 
@@ -30,3 +30,8 @@ export default class BlendModeNode extends TempNode {
 
     setup(): Node;
 }
+
+export const burn: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+export const dodge: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+export const overlay: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+export const screen: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;