JSM: More TS files for NodeMaterial.

examples/jsm/nodes/accessors/CameraNode.d.ts

+import { Camera } from '../../../../build/three.module';
+
+import { NodeBuilder } from '../core/NodeBuilder';
+import { NodeFrame } from '../core/NodeFrame';
+import { TempNode } from '../core/TempNode.js';
+import { FunctionNode } from '../core/FunctionNode';
+import { FloatNode } from '../inputs/FloatNode';
+
+export class CameraNode extends TempNode {
+  constructor(scope?: string, camera?: Camera);
+
+  scope: string;
+  near: FloatNode | undefined;
+  far: FloatNode | undefined;
+  camera: Camera | undefined;
+  updateFrame: boolean | undefined;
+  nodeType: string;
+
+  setCamera(camera: Camera): void;
+  setScope(scope: string): void;
+  generate(builder: NodeBuilder, output: string): string;
+  onUpdateFrame(frame: NodeFrame): void;
+  copy(source: CameraNode): this;
+
+  static Nodes: {
+    depthColor: FunctionNode;
+  };
+  static POSITION: string;
+  static DEPTH: string;
+  static TO_VERTEX: string;
+}

examples/jsm/nodes/accessors/ColorsNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode.js';
+
+export class ColorsNode extends TempNode {
+  constructor(index?: number);
+
+  index: number;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: ColorsNode): this;
+}

examples/jsm/nodes/accessors/LightNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode.js';
+
+export class LightNode extends TempNode {
+  constructor(scope?: string);
+
+  scope: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: LightNode): this;
+
+  static TOTAL: string;
+}

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

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode.js';
+
+export class NormalNode extends TempNode {
+  constructor(scope?: string);
+
+  scope: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: NormalNode): this;
+
+  static LOCAL: string;
+  static WORLD: string;
+  static VIEW: string;
+}

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

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode.js';
+
+export class PositionNode extends TempNode {
+  constructor(scope?: string);
+
+  scope: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: PositionNode): this;
+
+  static LOCAL: string;
+  static WORLD: string;
+  static VIEW: string;
+  static PROJECTION: string;
+}

examples/jsm/nodes/accessors/ReflectNode.d.ts

+import { Vector2 } from '../../../../build/three.module.js';
+
+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode.js';
+
+export class ReflectNode extends TempNode {
+  constructor(scope?: string);
+
+  scope: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+
+  static CUBE: string;
+  static SPHERE: string;
+  static VECTOR: string;
+}
\ No newline at end of file

examples/jsm/nodes/accessors/ResolutionNode.d.ts

+import { Vector2 } from '../../../../build/three.module.js';
+
+import { NodeBuilder } from '../core/NodeBuilder';
+import { NodeFrame } from '../core/NodeFrame';
+import { Vector2Node } from '../inputs/Vector2Node';
+
+export class ResolutionNode extends Vector2Node {
+  constructor();
+
+  size: Vector2;
+  nodeType: string;
+
+  updateFrame(frame: NodeFrame): void;
+  copy(source: ResolutionNode): this;
+}

examples/jsm/nodes/accessors/ScreenUVNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+import { ResolutionNode } from './ResolutionNode';
+
+export class ScreenUVNode extends TempNode {
+  constructor(resolution?: ResolutionNode);
+
+  resolution: ResolutionNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: ScreenUVNode): this;
+}

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

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+
+export class UVNode extends TempNode {
+  constructor(index?: number);
+
+  index: number;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: UVNode): this;
+}

examples/jsm/nodes/bsdfs/BlinnExponentToRoughnessNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { BlinnShininessExponentNode } from './BlinnShininessExponentNode';
+
+export class BlinnExponentToRoughnessNode extends TempNode {
+  constructor(blinnExponent?: BlinnShininessExponentNode);
+
+  blinnExponent: BlinnShininessExponentNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: BlinnExponentToRoughnessNode): this;
+}

examples/jsm/nodes/bsdfs/BlinnShininessExponentNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class BlinnShininessExponentNode extends TempNode {
+  constructor();
+
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+}

examples/jsm/nodes/bsdfs/RoughnessToBlinnExponentNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { MaxMIPLevelNode } from '../utils/MaxMIPLevelNode';
+import { BlinnShininessExponentNode } from './BlinnShininessExponentNode';
+import { FunctionNode } from '../core/FunctionNode';
+
+export class RoughnessToBlinnExponentNode extends TempNode {
+  constructor(texture: Node);
+
+  texture: Node;
+  maxMIPLevel: MaxMIPLevelNode;
+  blinnShininessExponent: BlinnShininessExponentNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: RoughnessToBlinnExponentNode): this;
+
+  static Nodes: {
+    getSpecularMIPLevel: FunctionNode;
+  };
+}

examples/jsm/nodes/core/NodeFrame.d.ts

 import {
-    Texture,
-	WebGLRenderer
+  Texture,
+  WebGLRenderer
 } from "../../../../build/three.module.js";
 
 import { Node } from './Node';
 
 export class NodeFrame {
-    constructor(time: number);
-    time: number;
-    id: number;
-    delta: number | undefined;
-    renderer: WebGLRenderer | undefined;
-    renderTexture: Texture | undefined;
-
-    update(delta: number): this;
-    setRenderer(renderer: WebGLRenderer): this;
-    setRenderTexture(renderTexture: Texture): this;
-    updateNode(node: Node): this;
+  constructor(time: number);
+  time: number;
+  id: number;
+  delta: number | undefined;
+  renderer: WebGLRenderer | undefined;
+  renderTexture: Texture | undefined;
+  
+  update(delta: number): this;
+  setRenderer(renderer: WebGLRenderer): this;
+  setRenderTexture(renderTexture: Texture): this;
+  updateNode(node: Node): this;
 }

examples/jsm/nodes/inputs/BoolNode.d.ts

+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class BoolNode extends InputNode {
+  constructor(value?: boolean);
+
+  value: boolean;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: BoolNode): this;
+}

examples/jsm/nodes/inputs/ColorNode.d.ts

+import { Color } from '../../../../build/three.module.js';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class ColorNode extends InputNode {
+  constructor(color: Color | number | string, g?: number, b?: number);
+
+  value: Color;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: ColorNode): this;
+}

examples/jsm/nodes/inputs/CubeTextureNode.d.ts

+import { CubeTexture } from '../../../../build/three.module.js';
+
+import { InputNode } from '../core/InputNode';
+import { Node } from '../core/Node';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class CubeTextureNode extends InputNode {
+  constructor(value: CubeTexture, uv?: Node, bias?: Node);
+
+  value: CubeTexture;
+  uv: Node | undefined;
+  bias: Node | undefined;
+  nodeType: string;
+
+  getTexture(builder: NodeBuilder, output: string): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: CubeTextureNode): this;
+}

examples/jsm/nodes/inputs/FloatNode.d.ts

+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class FloatNode extends InputNode {
+  constructor(value?: number);
+
+  value: number;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: FloatNode): this;
+}

examples/jsm/nodes/inputs/IntNode.d.ts

+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class IntNode extends InputNode {
+  constructor(value?: number);
+
+  value: number;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: IntNode): this;
+}

examples/jsm/nodes/inputs/Matrix3Node.d.ts

+import { Matrix3 } from '../../../../build/three.module.js';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Matrix3Node extends InputNode {
+  constructor(matrix?: Matrix3);
+
+  value: Matrix3;
+  nodeType: string;
+  elements: number[];
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Matrix3Node): this;
+}

examples/jsm/nodes/inputs/Matrix4Node.d.ts

+import { Matrix4 } from '../../../../build/three.module.js';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Matrix4Node extends InputNode {
+  constructor(matrix?: Matrix4);
+
+  value: Matrix4;
+  nodeType: string;
+  elements: number[];
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Matrix4Node): this;
+}

examples/jsm/nodes/inputs/PropertyNode.d.ts

+import { InputNode } from '../core/InputNode';
+
+export class PropertyNode extends InputNode {
+  constructor(object: object, property: string, type: string);
+
+  object: object;
+  property: string;
+  nodeType: string;
+  value: any;
+}

examples/jsm/nodes/inputs/RTTNode.d.ts

+import { 
+  Mesh,
+  OrthographicCamera,
+  SceneUtils,
+  WebGLRenderTarget,
+  WebGLRenderTargetOptions
+} from '../../../../build/three.module';
+
+import { NodeBuilder } from '../core/NodeBuilder';
+import { NodeFrame } from '../core/NodeFrame';
+import { TextureNode } from './TextureNode.js';
+
+export interface RTTNodeOptions extends WebGLRenderTargetOptions {
+  clear?: boolean;
+}
+
+export class RTTNode extends TextureNode {
+  constructor(width: number, height: number, input: TextureNode, options?: RTTNodeOptions);
+
+  input: TextureNode;
+  clear: boolean;
+  renderTarget: WebGLRenderTarget;
+  material: object; // NodeMaterial
+  camera: OrthographicCamera;
+  scene: Scene;
+  quad: Mesh;
+  render: boolean;
+
+  build(builder: NodeBuilder, output: string, uuid?: string): string;
+  updateFramesaveTo(frame: NodeFrame): void;
+  updateFrame(frame: NodeFrame): void;
+  copy(source: RTTNode): this;
+}

examples/jsm/nodes/inputs/ReflectorNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode.js';
+import { Matrix4Node } from './Matrix4Node';
+import { OperatorNode } from '../math/OperatorNode';
+import { ReflectorRTT } from '../../objects/ReflectorRTT';
+import { TextureNode } from './TextureNode';
+import { PositionNode } from '../accessors/PositionNode';
+
+export class ReflectorNode extends TempNode {
+  constructor(mirror?: ReflectorRTT);
+
+  mirror: ReflectorRTT;
+  textureMatrix: Matrix4Node;
+  localPosition: PositionNode;
+  uv: OperatorNode;
+  uvResult: OperatorNode;
+  texture: TextureNode;
+
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: ReflectorNode): this;
+}

examples/jsm/nodes/inputs/ScreenNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TextureNode } from './TextureNode.js';
+import { UVNode } from '../accessors/UVNode';
+
+export class ScreenNode extends TextureNode {
+  constructor(uv?: UVNode);
+
+  nodeType: string;
+
+  getTexture(builder: NodeBuilder, output: string): string;
+}

examples/jsm/nodes/inputs/TextureNode.d.ts

+import { Texture } from '../../../../build/three.module.js';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Node } from '../core/Node.js';
+import { UVNode } from '../accessors/UVNode.js';
+
+export class TextureNode extends InputNode {
+  constructor(value: Texture, uv?: UVNode, bias?: Node, project?: boolean);
+
+  value: Matrix4;
+  uv: UVNode;
+  bias: Matrix4;
+  project: boolean;
+  nodeType: string;
+
+  getTexture(builder: NodeBuilder, output: string): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: TextureNode): this;
+}

examples/jsm/nodes/inputs/Vector2Node.d.ts

+import { Vector2 } from '../../../../build/three.module.js';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Vector2Node extends InputNode {
+  constructor(x: Vector2 | number, y?: number);
+
+  value: Vector2;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Vector2Node): this;
+}

examples/jsm/nodes/inputs/Vector3Node.d.ts

+import { Vector3 } from '../../../../build/three.module.js';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Vector3Node extends InputNode {
+  constructor(x: Vector3 | number, y?: number, z?: number);
+
+  value: Vector3;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Vector3Node): this;
+}

examples/jsm/nodes/inputs/Vector4Node.d.ts

+import { Vector4 } from '../../../../build/three.module.js';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Vector4Node extends InputNode {
+  constructor(x: Vector4 | number, y?: number, z?: number, w?: number);
+
+  value: Vector4;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Vector4Node): this;
+}

examples/jsm/nodes/math/CondNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Node } from '../core/Node';
+
+export class CondNode extends TempNode {
+  constructor(a: Node, b: Node, op: string, ifNode: Node, elseNode: Node);
+
+  a: Node;
+  b: Node;
+  op: string;
+  ifNode: Node;
+  elseNode: Node;
+  nodeType: string;
+
+  getCondType(builder: NodeBuilder): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: CondNode): this;
+
+  static EQUAL: string;
+  static NOT_EQUAL: string;
+  static GREATER: string;
+  static GREATER_EQUAL: string;
+  static LESS: string;
+  static LESS_EQUAL: string;
+}

examples/jsm/nodes/math/MathNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Node } from '../core/Node';
+
+export class MathNode extends TempNode {
+  constructor(a: Node, bOrMethod: Node | string, cOrMethod?: Node | string, method?: string);
+
+  a: Node;
+  b: Node | string | undefined;
+  c: Node | string | undefined;
+  method: string;
+  nodeType: string;
+
+  getNumInputs(builder: NodeBuilder): number;
+  getInputType(builder: NodeBuilder): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: MathNode): this;
+
+  static RAD: string;
+  static DEG: string;
+  static EXP: string;
+  static EXP2: string;
+  static LOG: string;
+  static LOG2: string;
+  static SQRT: string;
+  static INV_SQRT: string;
+  static FLOOR: string;
+  static CEIL: string;
+  static NORMALIZE: string;
+  static SATURATE: string;
+  static SIN: string;
+  static COS: string;
+  static TAN: string;
+  static ASIN: string;
+  static ACOS: string;
+  static ARCTAN: string;
+  static ABS: string;
+  static SIGN: string;
+  static LENGTH: string;
+  static NEGATE: string;
+  static INVERT: string;
+
+  static MIN: string;
+  static MAX: string;
+  static MOD: string;
+  static STEP: string;
+  static REFLECT: string;
+  static DISTANCE: string;
+  static DOT: string;
+  static CROSS: string;
+  static POW: string;
+
+  static MIX: string;
+  static CLAMP: string;
+  static REFRACT: string;
+  static SMOOTHSTEP: string;
+  static FACEFORWARD: string;
+}

examples/jsm/nodes/math/OperatorNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Node } from '../core/Node';
+
+export class OperatorNode extends TempNode {
+  constructor(a: Node, b: Node, op: string);
+
+  a: Node;
+  b: Node;
+  op: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: OperatorNode): this;
+
+  static ADD: string;
+  static SUB: string;
+  static MUL: string;
+  static DIV: string;
+}

examples/jsm/nodes/procedural/CheckerNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { FunctionNode } from '../core/FunctionNode';
+import { UVNode } from '../accessors/UVNode';
+import { UVTransformNode } from '../utils/UVTransformNode';
+
+export class CheckerNode extends TempNode {
+  constructor(uv?: UVNode | UVTransformNode);
+
+  uv: UVNode | UVTransformNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: CheckerNode): this;
+
+  static Nodes: {
+    checker: FunctionNode;
+  };
+}

examples/jsm/nodes/procedural/NoiseNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { FunctionNode } from '../core/FunctionNode';
+import { UVNode } from '../accessors/UVNode';
+import { UVTransformNode } from '../utils/UVTransformNode';
+
+export class NoiseNode extends TempNode {
+  constructor(uv?: UVNode | UVTransformNode);
+
+  uv: UVNode | UVTransformNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: NoiseNode): this;
+
+  static Nodes: {
+    snoise: FunctionNode;
+  };
+}

examples/jsm/nodes/utils/BypassNode.d.ts

+import { Node } from '../core/Node';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class BypassNode extends Node {
+  constructor(code: Node, value?: Node);
+
+  code: Node;
+  value: Node | undefined;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: BypassNode): this;
+}

examples/jsm/nodes/utils/ColorSpaceNode.d.ts

+import { Node } from '../core/Node';
+import { TempNode } from '../core/TempNode';
+import { FunctionNode } from '../core/FunctionNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class ColorSpaceNode extends TempNode {
+  constructor(input: Node, method?: string);
+
+  input: Node;
+  method: string | undefined;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  fromEncoding(encoding: number);
+  fromDecoding(encoding: number);
+  copy(source: ColorSpaceNode): this;
+
+  static Nodes: {
+    LinearToLinear: FunctionNode;
+    GammaToLinear: FunctionNode;
+    LinearToGamma: FunctionNode;
+    sRGBToLinear: FunctionNode;
+    LinearTosRGB: FunctionNode;
+    RGBEToLinear: FunctionNode;
+    LinearToRGBE: FunctionNode;
+    RGBMToLinear: FunctionNode;
+    LinearToRGBM: FunctionNode;
+    RGBDToLinear: FunctionNode;
+    LinearToRGBD: FunctionNode;
+    cLogLuvM: FunctionNode;
+    LinearToLogLuv: FunctionNode;
+    cLogLuvInverseM: FunctionNode;
+    LogLuvToLinear: FunctionNode;
+  };
+
+  static LINEAR_TO_LINEAR: string;
+
+  static GAMMA_TO_LINEAR: string;
+  static LINEAR_TO_GAMMA: string;
+
+  static SRGB_TO_LINEAR: string;
+  static LINEAR_TO_SRGB: string;
+
+  static RGBE_TO_LINEAR: string;
+  static LINEAR_TO_RGBE: string;
+
+  static RGBM_TO_LINEAR: string;
+  static LINEAR_TO_RGBM: string;
+
+  static RGBD_TO_LINEAR: string;
+  static LINEAR_TO_RGBD: string;
+
+  static LINEAR_TO_LOG_LUV: string;
+  static LOG_LUV_TO_LINEAR: string;
+
+  static getEncodingComponents(encoding: number): any[];
+}

examples/jsm/nodes/utils/JoinNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class JoinNode extends TempNode {
+  constructor(x: Node, y: Node, z?: Node, w?: Node);
+
+  x: Node;
+  y: Node;
+  z: Node | undefined;
+  w: Node | undefined;
+  nodeType: string;
+
+  getNumElements(): number;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: JoinNode): this;
+}

examples/jsm/nodes/utils/MaxMIPLevelNode.d.ts

+import { FloatNode } from '../inputs/FloatNode';
+import { Node } from '../core/Node';
+
+export class MaxMIPLevelNode extends FloatNode {
+  constructor(texture: Node);
+
+  texture: Node;
+  maxMIPLevel: number;
+  nodeType: string;
+  value: number;
+}

examples/jsm/nodes/utils/SwitchNode.d.ts

+import { Node } from '../core/Node';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class SwitchNode extends Node {
+  constructor(node: Node, components?: string);
+
+  node: Node;
+  components: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: SwitchNode): this;
+}

examples/jsm/nodes/utils/TimerNode.d.ts

+import { NodeFrame } from '../core/NodeFrame';
+import { FloatNode } from '../inputs/FloatNode';
+
+export class TimerNode extends FloatNode {
+  constructor(scale?: number, scope?: string, timeScale?: boolean);
+
+  scale: number;
+  scope: string;
+  timeScale: boolean;
+  nodeType: string;
+
+  getUnique(): boolean;
+  updateFrame(frame: NodeFrame): void;
+  copy(source: TimerNode): this;
+
+  static GLOBAL: string;
+  static LOCAL: string;
+  static DELTA: string;
+}

examples/jsm/nodes/utils/UVTransformNode.d.ts

+import { ExpressionNode } from '../core/ExpressionNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Matrix3Node } from '../inputs/Matrix3Node';
+import { UVNode } from '../accessors/UVNode.js';
+  
+export class UVTransformNode extends ExpressionNode {
+  constructor(uv?: UVNode, position?: Matrix3Node);
+
+  uv: UVNode;
+  position: Matrix3Node;
+
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  setUvTransform(tx: number, ty: number, sx: number, sy: number, rotation: number, cx?: number, cy?: number): void;
+  copy(source: UVTransformNode): this;
+
+}
+  
\ No newline at end of file

examples/jsm/nodes/utils/VelocityNode.d.ts

+import { 
+  Object3D,
+  Vector3
+} from '../../../../build/three.module';
+
+import { NodeFrame } from '../core/NodeFrame';
+import { Vector3Node } from '../inputs/Vector3Node';
+
+export interface VelocityNodeParams {
+  damping: number;
+  spring: number;
+  type: string;
+}
+
+export class VelocityNode extends Vector3Node {
+  constructor(target: Object3D, params?: VelocityNodeParams);
+
+  velocity: Vector3;
+  moment: Vector3 | undefined;
+  speed: Vector3 | undefined;
+  springVelocity: Vector3 | undefined;
+  lastVelocity: Vector3 | undefined;
+
+  nodeType: string;
+
+  setParams(params: VelocityNodeParams): void;
+  setTarget(target: Object3D): void;
+  updateFrameVelocity(frame: NodeFrame): void;
+  updateFrame(frame: NodeFrame): void;
+  copy(source: VelocityNode): this;
+
+}