@types/three 0.182.0 → 0.183.0

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

@@ -5,6 +5,7 @@ import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribut
 import InputNode from "../core/InputNode.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
+
 /**
  * In earlier `three.js` versions it was only possible to define attribute data
  * on geometry level. With `BufferAttributeNode`, it is also possible to do this
@@ -27,15 +28,7 @@ import NodeBuilder from "../core/NodeBuilder.js";
  * ```
  * @augments InputNode
  */
-declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuffer | BufferAttribute> {
-    static get type(): string;
-    readonly isBufferNode: true;
-    bufferType: string | null;
-    bufferStride: number;
-    bufferOffset: number;
-    usage: Usage;
-    instanced: boolean;
-    attribute: BufferAttribute | InterleavedBufferAttribute | null;
+declare class BufferAttributeNodeClass extends InputNode<unknown, TypedArray | InterleavedBuffer | BufferAttribute> {
     /**
      * Constructs a new buffer attribute node.
      *
@@ -45,11 +38,62 @@ declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuff
      * @param {number} [bufferOffset=0] - The buffer offset.
      */
     constructor(
-        value: TypedArray | InterleavedBuffer | BufferAttribute,
+        value: BufferAttribute | InterleavedBuffer | TypedArray,
         bufferType?: string | null,
         bufferStride?: number,
         bufferOffset?: number,
     );
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isBufferNode: boolean;
+    /**
+     * The buffer type (e.g. `'vec3'`).
+     *
+     * @type {?string}
+     * @default null
+     */
+    bufferType: string | null;
+    /**
+     * The buffer stride.
+     *
+     * @type {number}
+     * @default 0
+     */
+    bufferStride: number;
+    /**
+     * The buffer offset.
+     *
+     * @type {number}
+     * @default 0
+     */
+    bufferOffset: number;
+    /**
+     * The usage property. Set this to `THREE.DynamicDrawUsage` via `.setUsage()`,
+     * if you are planning to update the attribute data per frame.
+     *
+     * @type {number}
+     * @default StaticDrawUsage
+     */
+    usage: Usage;
+    /**
+     * Whether the attribute is instanced or not.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    instanced: boolean;
+    /**
+     * A reference to the buffer attribute.
+     *
+     * @type {?BufferAttribute}
+     * @default null
+     */
+    attribute: BufferAttribute | InterleavedBufferAttribute | null;
     /**
      * This method is overwritten since the attribute data might be shared
      * and thus the hash should be shared as well.
@@ -65,7 +109,7 @@ declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuff
      * @param {NodeBuilder} builder - The current node builder.
      * @return {string} The node type.
      */
-    getNodeType(builder: NodeBuilder): string | null;
+    getNodeType(builder: NodeBuilder): string;
     /**
      * Depending on which value was passed to the node, `setup()` behaves
      * differently. If no instance of `BufferAttribute` was passed, the method
@@ -73,14 +117,14 @@ declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuff
      *
      * @param {NodeBuilder} builder - The current node builder.
      */
-    setup(builder: NodeBuilder): void;
+    setup(builder: NodeBuilder): undefined;
     /**
      * Generates the code snippet of the buffer attribute node.
      *
      * @param {NodeBuilder} builder - The current node builder.
      * @return {string} The generated code snippet.
      */
-    generate(builder: NodeBuilder): string | null | undefined;
+    generate(builder: NodeBuilder): string;
     /**
      * Overwrites the default implementation to return a fixed value `'bufferAttribute'`.
      *
@@ -103,11 +147,33 @@ declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuff
      */
     setInstanced(value: boolean): this;
 }
+
+declare const BufferAttributeNode: {
+    /**
+     * Constructs a new buffer attribute node.
+     *
+     * @param {BufferAttribute|InterleavedBuffer|TypedArray} value - The attribute data.
+     * @param {?string} [bufferType=null] - The buffer type (e.g. `'vec3'`).
+     * @param {number} [bufferStride=0] - The buffer stride.
+     * @param {number} [bufferOffset=0] - The buffer offset.
+     */
+    new<TNodeType>(
+        value: TypedArray | InterleavedBuffer | BufferAttribute,
+        bufferType?: string | null,
+        bufferStride?: number,
+        bufferOffset?: number,
+    ): BufferAttributeNode<TNodeType>;
+};
+
+type BufferAttributeNode<TNodeType> =
+    & InputNode<TNodeType, TypedArray | InterleavedBuffer | BufferAttribute>
+    & BufferAttributeNodeClass;
+
 export default BufferAttributeNode;
+
 /**
  * TSL function for creating a buffer attribute node.
  *
- * @tsl
  * @function
  * @param {BufferAttribute|InterleavedBuffer|TypedArray} array - The attribute data.
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
@@ -115,17 +181,17 @@ export default BufferAttributeNode;
  * @param {number} [offset=0] - The buffer offset.
  * @returns {BufferAttributeNode|Node}
  */
-export declare const bufferAttribute: (
+export declare const bufferAttribute: <TNodeType>(
     array: BufferAttribute | InterleavedBuffer | TypedArray,
-    type?: string | null,
+    type?: TNodeType | null,
     stride?: number,
     offset?: number,
-) => Node;
+) => Node<TNodeType>;
+
 /**
  * TSL function for creating a buffer attribute node but with dynamic draw usage.
  * Use this function if attribute data are updated per frame.
  *
- * @tsl
  * @function
  * @param {BufferAttribute|InterleavedBuffer|TypedArray} array - The attribute data.
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
@@ -133,16 +199,16 @@ export declare const bufferAttribute: (
  * @param {number} [offset=0] - The buffer offset.
  * @returns {BufferAttributeNode|Node}
  */
-export declare const dynamicBufferAttribute: (
+export declare const dynamicBufferAttribute: <TNodeType>(
     array: BufferAttribute | InterleavedBuffer | TypedArray,
-    type?: string | null,
+    type?: TNodeType | null,
     stride?: number,
     offset?: number,
-) => Node;
+) => Node<TNodeType>;
+
 /**
  * TSL function for creating a buffer attribute node but with enabled instancing
  *
- * @tsl
  * @function
  * @param {BufferAttribute|InterleavedBuffer|TypedArray} array - The attribute data.
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
@@ -150,16 +216,16 @@ export declare const dynamicBufferAttribute: (
  * @param {number} [offset=0] - The buffer offset.
  * @returns {BufferAttributeNode|Node}
  */
-export declare const instancedBufferAttribute: (
+export declare const instancedBufferAttribute: <TNodeType>(
     array: BufferAttribute | InterleavedBuffer | TypedArray,
-    type?: string | null,
+    type?: TNodeType | null,
     stride?: number,
     offset?: number,
-) => Node;
+) => Node<TNodeType>;
+
 /**
  * TSL function for creating a buffer attribute node but with dynamic draw usage and enabled instancing
  *
- * @tsl
  * @function
  * @param {BufferAttribute|InterleavedBuffer|TypedArray} array - The attribute data.
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
@@ -167,15 +233,15 @@ export declare const instancedBufferAttribute: (
  * @param {number} [offset=0] - The buffer offset.
  * @returns {BufferAttributeNode|Node}
  */
-export declare const instancedDynamicBufferAttribute: (
+export declare const instancedDynamicBufferAttribute: <TNodeType>(
     array: BufferAttribute | InterleavedBuffer | TypedArray,
-    type?: string | null,
+    type?: TNodeType | null,
     stride?: number,
     offset?: number,
-) => Node;
-declare module "../Nodes.js" {
-    interface BufferNode<TValue> {
-        toAttribute: () => BufferAttributeNode;
-        toAttributeAssign: () => this;
+) => Node<TNodeType>;
+
+declare module "./BufferNode.js" {
+    interface BufferNodeExtensions<TNodeType, TValue> {
+        toAttribute: () => BufferAttributeNode<TNodeType>;
     }
 }

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

@@ -1,17 +1,31 @@
 import UniformNode from "../core/UniformNode.js";
-import { NodeOrType } from "../tsl/TSLCore.js";
 
-export default class BufferNode<TValue> extends UniformNode<TValue> {
+export interface BufferNodeInterface {
     isBufferNode: true;
 
     bufferType: string;
     bufferCount: number;
+}
+
+declare const BufferNode: {
+    new<TNodeType, TValue>(value: TValue, bufferType: TNodeType, bufferCount?: number): BufferNode<TNodeType, TValue>;
+};
 
-    constructor(value: TValue, bufferType: string, bufferCount?: number);
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface BufferNodeExtensions<TNodeType, TValue> {
 }
 
-export const buffer: <TValue>(
-    value: unknown,
-    nodeOrType: NodeOrType,
+type BufferNode<TNodeType, TValue> =
+    & UniformNode<TNodeType, TValue>
+    & BufferNodeInterface
+    & BufferNodeExtensions<TNodeType, TValue>;
+
+export default BufferNode;
+
+export const buffer: <TNodeType, TValue>(
+    value: TValue,
+    type: TNodeType,
     count: number,
-) => BufferNode<TValue>;
+) => BufferNode<TNodeType, TValue>;
+
+export {};

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

@@ -4,13 +4,13 @@ import { Vector3 } from "../../math/Vector3.js";
 import { Vector4 } from "../../math/Vector4.js";
 import UniformNode from "../core/UniformNode.js";
 
-export const cameraIndex: UniformNode<number>;
-export const cameraNear: UniformNode<number>;
-export const cameraFar: UniformNode<number>;
-export const cameraProjectionMatrix: UniformNode<Matrix4>;
-export const cameraProjectionMatrixInverse: UniformNode<Matrix4>;
-export const cameraViewMatrix: UniformNode<Matrix4>;
-export const cameraWorldMatrix: UniformNode<Matrix4>;
-export const cameraNormalMatrix: UniformNode<Matrix3>;
-export const cameraPosition: UniformNode<Vector3>;
-export const cameraViewport: UniformNode<Vector4>;
+export const cameraIndex: UniformNode<"uint", number>;
+export const cameraNear: UniformNode<"float", number>;
+export const cameraFar: UniformNode<"float", number>;
+export const cameraProjectionMatrix: UniformNode<"mat4", Matrix4>;
+export const cameraProjectionMatrixInverse: UniformNode<"mat4", Matrix4>;
+export const cameraViewMatrix: UniformNode<"mat4", Matrix4>;
+export const cameraWorldMatrix: UniformNode<"mat4", Matrix4>;
+export const cameraNormalMatrix: UniformNode<"mat3", Matrix3>;
+export const cameraPosition: UniformNode<"vec3", Vector3>;
+export const cameraViewport: UniformNode<"vec4", Vector4>;

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

@@ -4,7 +4,7 @@ import TextureNode from "./TextureNode.js";
 
 declare class CubeTextureNode extends TextureNode {
     isCubeTextureNode: boolean;
-    uvNode: Node | null;
+    uvNode: Node<"vec3"> | null;
     levelNode: Node | null;
 
     constructor(

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

@@ -1,4 +1,5 @@
 import { InstancedBufferAttribute } from "../../core/InstancedBufferAttribute.js";
+import { InstancedInterleavedBuffer } from "../../core/InstancedInterleavedBuffer.js";
 import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
 import Node from "../core/Node.js";
 
@@ -10,6 +11,11 @@ export default class InstanceNode extends Node {
     instanceMatrixNode: Node | null;
     instanceColorNode: Node | null;
 
+    buffer: InstancedInterleavedBuffer | null;
+    bufferColor: InstancedBufferAttribute | null;
+
+    previousInstancedMatrixNode: Node | null;
+
     constructor(
         count: number,
         instanceMatrix: InstancedBufferAttribute | StorageInstancedBufferAttribute,

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

@@ -1,14 +1,17 @@
 import { Light } from "../../lights/Light.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector3 } from "../../math/Vector3.js";
 import Node from "../core/Node.js";
+import UniformNode from "../core/UniformNode.js";
 
-export function lightShadowMatrix(light: Light): Node;
+export function lightShadowMatrix(light: Light): UniformNode<"mat4", Matrix4>;
 
-export function lightProjectionUV(light: Light, position?: Node): Node;
+export function lightProjectionUV(light: Light, position?: Node): Node<"vec3">;
 
-export function lightPosition(light: Light): Node;
+export function lightPosition(light: Light): UniformNode<"vec3", Vector3>;
 
-export function lightTargetPosition(light: Light): Node;
+export function lightTargetPosition(light: Light): UniformNode<"vec3", Vector3>;
 
-export function lightViewPosition(light: Light): Node;
+export function lightViewPosition(light: Light): UniformNode<"vec3", Vector3>;
 
-export const lightTargetDirection: (light: Light) => Node;
+export const lightTargetDirection: (light: Light) => Node<"vec3">;

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

@@ -1,6 +1,4 @@
-import { Vector2 } from "../../math/Vector2.js";
 import Node from "../core/Node.js";
-import UniformNode from "../core/UniformNode.js";
 
 export type MaterialNodeScope =
     | typeof MaterialNode.ALPHA_TEST
@@ -125,4 +123,4 @@ export const materialPointSize: MaterialNode;
 export const materialDispersion: MaterialNode;
 export const materialLightMap: MaterialNode;
 export const materialAO: MaterialNode;
-export const materialAnisotropyVector: UniformNode<Vector2>;
+export const materialAnisotropyVector: MaterialNode;

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

@@ -1,8 +1,8 @@
-import { Matrix4 } from "../../math/Matrix4.js";
+import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
 
-export const materialRefractionRatio: UniformNode<number>;
+export const materialRefractionRatio: UniformNode<"float", number>;
 
-export const materialEnvIntensity: UniformNode<number>;
+export const materialEnvIntensity: Node<"float">;
 
-export const materialEnvRotation: UniformNode<Matrix4>;
+export const materialEnvRotation: Node<"mat4">;

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

@@ -2,7 +2,7 @@ import { Material } from "../../materials/Material.js";
 import { NodeOrType } from "../tsl/TSLCore.js";
 import ReferenceNode from "./ReferenceNode.js";
 
-export default class MaterialReferenceNode extends ReferenceNode<Material | null> {
+export default class MaterialReferenceNode extends ReferenceNode<unknown, Material | null> {
     readonly isMaterialReferenceNode: true;
 
     constructor(property: string, inputType: string, material?: Material | null);

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

@@ -1,3 +1,4 @@
+import { Matrix3 } from "../../math/Matrix3.js";
 import { Matrix4 } from "../../math/Matrix4.js";
 import Node from "../core/Node.js";
 import { UniformNode } from "../Nodes.js";
@@ -6,27 +7,43 @@ import Object3DNode from "./Object3DNode.js";
 /**
  * Similar to {@link Object3DNode} but the object comes from {@link NodeFrame}
  */
-export default class ModelNode extends Object3DNode {
-    constructor(scope: string);
-}
-
-export const modelDirection: ModelNode;
-export const modelWorldMatrix: ModelNode;
-export const modelPosition: ModelNode;
-export const modelScale: ModelNode;
-export const modelViewPosition: ModelNode;
-export const modelRadius: ModelNode;
-export const modelNormalMatrix: Node;
-export const modelWorldMatrixInverse: UniformNode<Matrix4>;
-
-export const modelViewMatrix: ModelNode;
+declare const ModelNode: {
+    new(scope: typeof ModelNode.WORLD_MATRIX): ModelNode<"mat4">;
+    new(scope: typeof ModelNode.POSITION): ModelNode<"vec3">;
+    new(scope: typeof ModelNode.SCALE): ModelNode<"vec3">;
+    new(scope: typeof ModelNode.VIEW_POSITION): ModelNode<"vec3">;
+    new(scope: typeof ModelNode.DIRECTION): ModelNode<"vec3">;
+    new(scope: typeof ModelNode.RADIUS): ModelNode<"float">;
+
+    WORLD_MATRIX: "worldMatrix";
+    POSITION: "position";
+    SCALE: "scale";
+    VIEW_POSITION: "viewPosition";
+    DIRECTION: "direction";
+    RADIUS: "radius";
+};
+
+type ModelNode<TNodeType> = Object3DNode<TNodeType>;
+
+export default Object3DNode;
+
+export const modelDirection: ModelNode<"vec3">;
+export const modelWorldMatrix: ModelNode<"mat4">;
+export const modelPosition: ModelNode<"vec3">;
+export const modelScale: ModelNode<"vec3">;
+export const modelViewPosition: ModelNode<"vec3">;
+export const modelRadius: ModelNode<"float">;
+export const modelNormalMatrix: UniformNode<"mat3", Matrix3>;
+export const modelWorldMatrixInverse: UniformNode<"mat4", Matrix4>;
+
+export const modelViewMatrix: Node<"mat4">;
 
 // GPU Precision
 
-export const mediumpModelViewMatrix: Node;
+export const mediumpModelViewMatrix: Node<"mat4">;
 
 // CPU Precision
 
-export const highpModelViewMatrix: Node;
+export const highpModelViewMatrix: Node<"mat4">;
 
-export const highpModelNormalViewMatrix: Node;
+export const highpModelNormalViewMatrix: Node<"mat3">;

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

@@ -4,7 +4,7 @@ import UniformNode from "../core/UniformNode.js";
 
 declare class MorphNode extends Node {
     mesh: Mesh;
-    morphBaseInfluence: UniformNode<number>;
+    morphBaseInfluence: UniformNode<"float", number>;
 
     constructor(mesh: Mesh);
 }

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

@@ -1,38 +1,36 @@
-import AttributeNode from "../core/AttributeNode.js";
 import Node from "../core/Node.js";
-import VarNode from "../core/VarNode.js";
 
-export const normalGeometry: AttributeNode;
+export const normalGeometry: Node<"vec3">;
 
-export const normalLocal: VarNode;
+export const normalLocal: Node<"vec3">;
 
-export const normalFlat: VarNode;
+export const normalFlat: Node<"vec3">;
 
-export const normalViewGeometry: VarNode;
+export const normalViewGeometry: Node<"vec3">;
 
-export const normalWorldGeometry: VarNode;
+export const normalWorldGeometry: Node<"vec3">;
 
-export const normalView: VarNode;
+export const normalView: Node<"vec3">;
 
-export const normalWorld: VarNode;
+export const normalWorld: Node<"vec3">;
 
-export const clearcoatNormalView: VarNode;
+export const clearcoatNormalView: Node<"vec3">;
 
-export const transformNormal: (normal: Node, matrix?: Node) => Node;
+export const transformNormal: (normal: Node, matrix?: Node) => Node<"vec3">;
 
-export const transformNormalToView: (normal: Node) => Node;
+export const transformNormalToView: (normal: Node) => Node<"vec3">;
 
 /**
  * @deprecated since r178. Use `normalView` instead.
  */
-export const transformedNormalView: VarNode;
+export const transformedNormalView: Node<"vec3">;
 
 /**
  * @deprecated since r178. Use `normalWorld` instead.
  */
-export const transformedNormalWorld: VarNode;
+export const transformedNormalWorld: Node<"vec3">;
 
 /**
  * @deprecated since r178. Use `clearcoatNormalView` instead.
  */
-export const transformedClearcoatNormalView: VarNode;
+export const transformedClearcoatNormalView: Node<"vec3">;

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

@@ -1,23 +1,42 @@
 import { Object3D } from "../../core/Object3D.js";
 import Node from "../core/Node.js";
 
-export default class Object3DNode extends Node {
-    scope: string;
+export type Object3DNodeScope =
+    | typeof Object3DNode.WORLD_MATRIX
+    | typeof Object3DNode.POSITION
+    | typeof Object3DNode.SCALE
+    | typeof Object3DNode.VIEW_POSITION
+    | typeof Object3DNode.DIRECTION
+    | typeof Object3DNode.RADIUS;
+
+interface Object3DNodeInterface {
+    scope: Object3DNodeScope;
     object3d: Object3D | null;
+}
 
-    constructor(scope: string, object3d?: Object3D | null);
+declare const Object3DNode: {
+    new(scope: typeof Object3DNode.WORLD_MATRIX, object3d?: Object3D | null): Object3DNode<"mat4">;
+    new(scope: typeof Object3DNode.POSITION, object3d?: Object3D | null): Object3DNode<"vec3">;
+    new(scope: typeof Object3DNode.SCALE, object3d?: Object3D | null): Object3DNode<"vec3">;
+    new(scope: typeof Object3DNode.VIEW_POSITION, object3d?: Object3D | null): Object3DNode<"vec3">;
+    new(scope: typeof Object3DNode.DIRECTION, object3d?: Object3D | null): Object3DNode<"vec3">;
+    new(scope: typeof Object3DNode.RADIUS, object3d?: Object3D | null): Object3DNode<"float">;
 
-    static WORLD_MATRIX: "worldMatrix";
-    static POSITION: "position";
-    static SCALE: "scale";
-    static VIEW_POSITION: "viewPosition";
-    static DIRECTION: "direction";
-    static RADIUS: "radius";
-}
+    WORLD_MATRIX: "worldMatrix";
+    POSITION: "position";
+    SCALE: "scale";
+    VIEW_POSITION: "viewPosition";
+    DIRECTION: "direction";
+    RADIUS: "radius";
+};
+
+type Object3DNode<TNodeType> = Node<TNodeType> & Object3DNodeInterface;
+
+export default Object3DNode;
 
-export const objectDirection: (object3d: Object3D | null) => Object3DNode;
-export const objectWorldMatrix: (object3d: Object3D | null) => Object3DNode;
-export const objectPosition: (object3d: Object3D | null) => Object3DNode;
-export const objectScale: (object3d: Object3D | null) => Object3DNode;
-export const objectViewPosition: (object3d: Object3D | null) => Object3DNode;
-export const objectRadius: (object3d: Object3D | null) => Object3DNode;
+export const objectDirection: (object3d: Object3D | null) => Object3DNode<"vec3">;
+export const objectWorldMatrix: (object3d: Object3D | null) => Object3DNode<"mat4">;
+export const objectPosition: (object3d: Object3D | null) => Object3DNode<"vec3">;
+export const objectScale: (object3d: Object3D | null) => Object3DNode<"vec3">;
+export const objectViewPosition: (object3d: Object3D | null) => Object3DNode<"vec3">;
+export const objectRadius: (object3d: Object3D | null) => Object3DNode<"float">;

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

@@ -1,9 +1,11 @@
+import AttributeNode from "../core/AttributeNode.js";
 import Node from "../core/Node.js";
 
-export const positionGeometry: Node;
-export const positionLocal: Node;
-export const positionPrevious: Node;
-export const positionWorld: Node;
-export const positionWorldDirection: Node;
-export const positionView: Node;
-export const positionViewDirection: Node;
+export const clipSpace: Node<"vec4">;
+export const positionGeometry: AttributeNode<"vec3">;
+export const positionLocal: AttributeNode<"vec3">;
+export const positionPrevious: AttributeNode<"vec3">;
+export const positionWorld: Node<"vec3">;
+export const positionWorldDirection: Node<"vec3">;
+export const positionView: Node<"vec3">;
+export const positionViewDirection: Node<"vec3">;

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

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 
-declare class ReferenceNode<T> extends Node {
+interface ReferenceNodeInterface<T> extends Node {
     property: string;
 
     uniformType: string;
@@ -12,17 +12,26 @@ declare class ReferenceNode<T> extends Node {
     reference: T | null;
     node: Node | null;
 
-    constructor(property: string, uniformType: string, object?: T | null, count?: number | null);
-
     setNodeType(uniformType: string): void;
 }
 
+declare const ReferenceNode: {
+    new<TNodeType, T>(
+        property: string,
+        uniformType: TNodeType,
+        object?: T | null,
+        count?: number | null,
+    ): ReferenceNode<TNodeType, T>;
+};
+
+type ReferenceNode<TNodeType, T> = ReferenceNodeInterface<T> & Node<TNodeType>;
+
 export default ReferenceNode;
 
-export const reference: <T>(name: string, type: string, object: T) => ReferenceNode<T>;
-export const referenceBuffer: <T>(
+export const reference: <const TNodeType, T>(name: string, type: TNodeType, object: T) => ReferenceNode<TNodeType, T>;
+export const referenceBuffer: <const TNodeType, T>(
     name: string,
-    type: string,
+    type: TNodeType,
     count: number,
     object: T,
-) => ReferenceNode<T>;
+) => ReferenceNode<TNodeType, T>;

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

@@ -1,8 +1,7 @@
 import Node from "../core/Node.js";
-import VarNode from "../core/VarNode.js";
 
-export const reflectView: Node;
-export const refractView: Node;
+export const reflectView: Node<"vec3">;
+export const refractView: Node<"vec3">;
 
-export const reflectVector: VarNode;
-export const refractVector: VarNode;
+export const reflectVector: Node<"vec3">;
+export const refractVector: Node<"vec3">;