@types/three 0.157.1 → 0.158.0

three/examples/jsm/loaders/MTLLoader.d.ts

@@ -0,0 +1,104 @@
+import {
+    Material,
+    LoadingManager,
+    Mapping,
+    Loader,
+    BufferGeometry,
+    Side,
+    Texture,
+    Vector2,
+    Wrapping,
+} from '../../../src/Three.js';
+
+export interface MaterialCreatorOptions {
+    /**
+     * side: Which side to apply the material
+     * THREE.FrontSide (default), THREE.BackSide, THREE.DoubleSide
+     */
+    side?: Side | undefined;
+    /*
+     * wrap: What type of wrapping to apply for textures
+     * THREE.RepeatWrapping (default), THREE.ClampToEdgeWrapping, THREE.MirroredRepeatWrapping
+     */
+    wrap?: Wrapping | undefined;
+    /*
+     * normalizeRGB: RGBs need to be normalized to 0-1 from 0-255
+     * Default: false, assumed to be already normalized
+     */
+    normalizeRGB?: boolean | undefined;
+    /*
+     * ignoreZeroRGBs: Ignore values of RGBs (Ka,Kd,Ks) that are all 0's
+     * Default: false
+     */
+    ignoreZeroRGBs?: boolean | undefined;
+    /*
+     * invertTrProperty: Use values 1 of Tr field for fully opaque. This option is useful for obj
+     * exported from 3ds MAX, vcglib or meshlab.
+     * Default: false
+     */
+    invertTrProperty?: boolean | undefined;
+}
+
+export class MTLLoader extends Loader<MTLLoader.MaterialCreator> {
+    constructor(manager?: LoadingManager);
+    materialOptions: MaterialCreatorOptions;
+
+    parse(text: string, path: string): MTLLoader.MaterialCreator;
+    setMaterialOptions(value: MaterialCreatorOptions): void;
+}
+
+export interface MaterialInfo {
+    ks?: number[] | undefined;
+    kd?: number[] | undefined;
+    ke?: number[] | undefined;
+    map_kd?: string | undefined;
+    map_ks?: string | undefined;
+    map_ke?: string | undefined;
+    norm?: string | undefined;
+    map_bump?: string | undefined;
+    bump?: string | undefined;
+    map_d?: string | undefined;
+    ns?: number | undefined;
+    d?: number | undefined;
+    tr?: number | undefined;
+}
+
+export interface TexParams {
+    scale: Vector2;
+    offset: Vector2;
+    url: string;
+}
+
+export namespace MTLLoader {
+    class MaterialCreator {
+        constructor(baseUrl?: string, options?: MaterialCreatorOptions);
+
+        baseUrl: string;
+        options: MaterialCreatorOptions;
+        materialsInfo: { [key: string]: MaterialInfo };
+        materials: { [key: string]: Material };
+        private materialsArray: Material[];
+        nameLookup: { [key: string]: number };
+        side: Side;
+        wrap: Wrapping;
+        crossOrigin: string;
+
+        setCrossOrigin(value: string): this;
+        setManager(value: LoadingManager): void;
+        setMaterials(materialsInfo: { [key: string]: MaterialInfo }): void;
+        convert(materialsInfo: { [key: string]: MaterialInfo }): { [key: string]: MaterialInfo };
+        preload(): void;
+        getIndex(materialName: string): number;
+        getAsArray(): Material[];
+        create(materialName: string): Material;
+        createMaterial_(materialName: string): Material;
+        getTextureParams(value: string, matParams: any): TexParams;
+        loadTexture(
+            url: string,
+            mapping?: Mapping,
+            onLoad?: (bufferGeometry: BufferGeometry) => void,
+            onProgress?: (event: ProgressEvent) => void,
+            onError?: (event: ErrorEvent) => void,
+        ): Texture;
+    }
+}

three/examples/jsm/loaders/OBJLoader.d.ts

@@ -0,0 +1,10 @@
+import { Loader, LoadingManager, Group } from '../../../src/Three.js';
+import { MTLLoader } from './MTLLoader.js';
+
+export class OBJLoader extends Loader<Group> {
+    constructor(manager?: LoadingManager);
+    materials: MTLLoader.MaterialCreator;
+
+    parse(data: string): Group;
+    setMaterials(materials: MTLLoader.MaterialCreator): this;
+}

three/examples/jsm/loaders/PCDLoader.d.ts

@@ -0,0 +1,8 @@
+import { BufferGeometry, Loader, LoadingManager, Points, PointsMaterial } from '../../../src/Three.js';
+
+export class PCDLoader extends Loader<Points<BufferGeometry, PointsMaterial>> {
+    constructor(manager?: LoadingManager);
+    littleEndian: boolean;
+
+    parse(data: ArrayBuffer | string): Points<BufferGeometry, PointsMaterial>;
+}

three/examples/jsm/loaders/RGBELoader.d.ts

@@ -0,0 +1,19 @@
+import { LoadingManager, DataTextureLoader, TextureDataType, PixelFormat } from '../../../src/Three.js';
+
+export interface RGBE {
+    width: number;
+    height: number;
+    data: Float32Array | Uint8Array;
+    header: string;
+    gamma: number;
+    exposure: number;
+    type: TextureDataType;
+}
+
+export class RGBELoader extends DataTextureLoader {
+    constructor(manager?: LoadingManager);
+    type: TextureDataType;
+
+    parse(buffer: ArrayBuffer): RGBE;
+    setDataType(type: TextureDataType): this;
+}

three/examples/jsm/loaders/SVGLoader.d.ts

@@ -0,0 +1,68 @@
+import { Loader, LoadingManager, ShapePath, BufferGeometry, Vector3, Shape, Vector2 } from '../../../src/Three.js';
+
+export interface SVGResultPaths extends ShapePath {
+    userData?:
+        | {
+              [key: string]: any;
+          }
+        | undefined;
+}
+
+export interface SVGResult {
+    paths: SVGResultPaths[];
+    xml: XMLDocument;
+}
+
+export interface StrokeStyle {
+    strokeColor: string;
+    strokeWidth: number;
+    strokeLineJoin: string;
+    strokeLineCap: string;
+    strokeMiterLimit: number;
+}
+
+export class SVGLoader extends Loader<SVGResult> {
+    constructor(manager?: LoadingManager);
+
+    defaultDPI: number;
+    defaultUnit: string;
+
+    parse(text: string): SVGResult;
+
+    static getStrokeStyle(
+        width?: number,
+        color?: string,
+        lineJoin?: string,
+        lineCap?: string,
+        miterLimit?: number,
+    ): StrokeStyle;
+
+    /**
+     * Generates a stroke with some witdh around the given path.
+     * @remarks The path can be open or closed (last point equals to first point)
+     * @param points  Array of Vector2D (the path). Minimum 2 points.
+     * @param style  Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
+     * @param arcDivisions Arc divisions for round joins and endcaps. (Optional)
+     * @param minDistance Points closer to this distance will be merged. (Optional)
+     * @returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)
+     */
+    static pointsToStroke(
+        points: Vector2[],
+        style: StrokeStyle,
+        arcDivisions?: number,
+        minDistance?: number,
+    ): BufferGeometry;
+
+    static pointsToStrokeWithBuffers(
+        points: Vector2[],
+        style: StrokeStyle,
+        arcDivisions?: number,
+        minDistance?: number,
+        vertices?: number[],
+        normals?: number[],
+        uvs?: number[],
+        vertexOffset?: number,
+    ): number;
+
+    static createShapes(shapePath: ShapePath): Shape[];
+}

three/examples/jsm/loaders/TGALoader.d.ts

@@ -0,0 +1,7 @@
+import { DataTexture, DataTextureLoader, LoadingManager } from '../../../src/Three.js';
+
+export class TGALoader extends DataTextureLoader {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBuffer): DataTexture;
+}

three/examples/jsm/loaders/TTFLoader.d.ts

@@ -0,0 +1,8 @@
+import { Loader, LoadingManager } from '../../../src/Three.js';
+
+export class TTFLoader extends Loader<object> {
+    constructor(manager?: LoadingManager);
+    reversed: boolean;
+
+    parse(arraybuffer: ArrayBuffer): object;
+}

three/examples/jsm/loaders/USDZLoader.d.ts

@@ -0,0 +1,11 @@
+import { Loader, LoadingManager, Mesh } from '../../../src/Three.js';
+
+export class USDAParser {
+    parse(text: string): object;
+}
+
+export class USDZLoader extends Loader<Mesh> {
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: ArrayBuffer | string): THREE.Group;
+}

three/examples/jsm/materials/MeshGouraudMaterial.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MeshGouraudMaterial
+ *
+ * Lambert illumination model with Gouraud (per-vertex) shading
+ *
+ */
+
+import { ShaderMaterial, ShaderMaterialParameters } from '../../../src/Three.js';
+
+export class MeshGouraudMaterial extends ShaderMaterial {
+    isMeshGouraudMaterial: true;
+    type: 'MeshGouraudMaterial';
+
+    constructor(parameters?: ShaderMaterialParameters);
+
+    copy(source: MeshGouraudMaterial): this;
+}

three/examples/jsm/math/Capsule.d.ts

@@ -23,5 +23,4 @@ export class Capsule {
         radius: number,
     ): boolean;
     intersectsBox(box: Box3): boolean;
-    lineLineMinimumPoints(line1: Line3, line2: Line3): Vector3[];
 }

three/examples/jsm/misc/MD2CharacterComplex.d.ts

@@ -14,7 +14,15 @@ export class MD2CharacterComplex {
     root: Object3D;
     meshBody: Mesh | null;
     meshWeapon: Mesh | null;
-    controls: null;
+    controls: {
+        crouch?: boolean | undefined;
+        jump?: boolean | undefined;
+        attack?: boolean | undefined;
+        moveForward?: boolean | undefined;
+        moveBackward?: boolean | undefined;
+        moveLeft?: boolean | undefined;
+        moveRight?: boolean | undefined;
+    } | null;
     skinsBody: Texture[];
     skinsWeapon: Texture[];
     weapons: Mesh[];

three/examples/jsm/nodes/Nodes.d.ts

@@ -0,0 +1,149 @@
+// constants
+export * from './core/constants.js';
+
+// core
+export { default as ArrayUniformNode } from './core/ArrayUniformNode.js';
+export { default as AttributeNode } from './core/AttributeNode.js';
+export { default as BypassNode } from './core/BypassNode.js';
+export { default as CacheNode } from './core/CacheNode.js';
+export { default as ConstNode } from './core/ConstNode.js';
+export { default as ContextNode } from './core/ContextNode.js';
+export { default as Node } from './core/Node.js';
+export { default as NodeAttribute } from './core/NodeAttribute.js';
+export { default as NodeBuilder } from './core/NodeBuilder.js';
+export { default as NodeCache } from './core/NodeCache.js';
+export { default as NodeCode } from './core/NodeCode.js';
+export { default as NodeFrame } from './core/NodeFrame.js';
+export { default as NodeFunctionInput } from './core/NodeFunctionInput.js';
+export { default as NodeKeywords } from './core/NodeKeywords.js';
+export { default as NodeUniform } from './core/NodeUniform.js';
+export { default as NodeVar } from './core/NodeVar.js';
+export { default as NodeVarying } from './core/NodeVarying.js';
+export { default as PropertyNode } from './core/PropertyNode.js';
+export { default as StackNode } from './core/StackNode.js';
+export { default as TempNode } from './core/TempNode.js';
+export { default as UniformNode } from './core/UniformNode.js';
+export { default as VarNode } from './core/VarNode.js';
+export { default as VaryingNode } from './core/VaryingNode.js';
+
+import * as NodeUtils from './core/NodeUtils.js';
+export { NodeUtils };
+
+// math
+export {
+    default as MathNode,
+    MathNodeMethod1,
+    MathNodeMethod2,
+    MathNodeMethod3,
+    MathNodeMethod,
+} from './math/MathNode.js';
+export { default as OperatorNode, OperatorNodeOp } from './math/OperatorNode.js';
+export { default as CondNode } from './math/CondNode.js';
+
+// utils
+export { default as ArrayElementNode } from './utils/ArrayElementNode.js';
+export { default as ConvertNode } from './utils/ConvertNode.js';
+export { default as EquirectUVNode } from './utils/EquirectUVNode.js';
+export { default as JoinNode } from './utils/JoinNode.js';
+export { default as MatcapUVNode } from './utils/MatcapUVNode.js';
+export { default as MaxMipLevelNode } from './utils/MaxMipLevelNode.js';
+export { default as OscNode, OscNodeMethod } from './utils/OscNode.js';
+export { default as RemapNode } from './utils/RemapNode.js';
+export { default as RotateUVNode } from './utils/RotateUVNode.js';
+export { default as SpecularMIPLevelNode } from './utils/SpecularMIPLevelNode.js';
+export { default as SplitNode } from './utils/SplitNode.js';
+export { default as SpriteSheetUVNode } from './utils/SpriteSheetUVNode.js';
+export { default as TimerNode, TimerNodeScope } from './utils/TimerNode.js';
+export { default as TriplanarTexturesNode } from './utils/TriplanarTexturesNode.js';
+
+// shader node
+export * from './shadernode/ShaderNodeElements.js';
+
+// accessors
+export { default as BitangentNode, BitangentNodeScope } from './accessors/BitangentNode.js';
+export { default as BufferNode } from './accessors/BufferNode.js';
+export { default as CameraNode, CameraNodeScope } from './accessors/CameraNode.js';
+export { default as CubeTextureNode } from './accessors/CubeTextureNode.js';
+export { default as InstanceNode } from './accessors/InstanceNode.js';
+export { default as MaterialNode, MaterialNodeScope } from './accessors/MaterialNode.js';
+export { default as MaterialReferenceNode } from './accessors/MaterialReferenceNode.js';
+export { default as ModelNode } from './accessors/ModelNode.js';
+export { default as ModelViewProjectionNode } from './accessors/ModelViewProjectionNode.js';
+export { default as NormalNode, NormalNodeScope } from './accessors/NormalNode.js';
+export { default as Object3DNode, Object3DNodeScope as OObject3DNodeScope } from './accessors/Object3DNode.js';
+export { default as PointUVNode } from './accessors/PointUVNode.js';
+export { default as PositionNode, PositionNodeScope } from './accessors/PositionNode.js';
+export { default as ReferenceNode } from './accessors/ReferenceNode.js';
+export { default as ReflectVectorNode } from './accessors/ReflectVectorNode.js';
+export { default as SkinningNode } from './accessors/SkinningNode.js';
+export { default as TangentNode, TangentNodeScope } from './accessors/TangentNode.js';
+export { default as TextureNode } from './accessors/TextureNode.js';
+export { default as UVNode } from './accessors/UVNode.js';
+export { default as UserDataNode } from './accessors/UserDataNode.js';
+
+// display
+export { default as BlendModeNode, BlendMode } from './display/BlendModeNode.js';
+export { default as ColorAdjustmentNode, ColorAdjustmentMethod } from './display/ColorAdjustmentNode.js';
+export { default as ColorSpaceNode, ColorSpaceNodeMethod } from './display/ColorSpaceNode.js';
+export { default as FrontFacingNode } from './display/FrontFacingNode.js';
+export { default as NormalMapNode } from './display/NormalMapNode.js';
+export { default as PosterizeNode } from './display/PosterizeNode.js';
+export { default as ToneMappingNode } from './display/ToneMappingNode.js';
+export { default as ViewportNode } from './display/ViewportNode.js';
+
+// code
+export { default as ExpressionNode } from './code/ExpressionNode.js';
+export { default as CodeNode, CodeNodeInclude } from './code/CodeNode.js';
+export { default as FunctionCallNode } from './code/FunctionCallNode.js';
+export { default as FunctionNode, FunctionNodeArguments } from './code/FunctionNode.js';
+
+// fog
+export { default as FogNode } from './fog/FogNode.js';
+export { default as FogRangeNode } from './fog/FogRangeNode.js';
+export { default as FogExp2Node } from './fog/FogExp2Node.js';
+
+// geometry
+export { default as RangeNode, RangeModeBound } from './geometry/RangeNode.js';
+
+// gpgpu
+export { default as ComputeNode } from './gpgpu/ComputeNode.js';
+
+// lighting
+export { default as PointLightNode } from './lighting/PointLightNode.js';
+export { default as SpotLightNode } from './lighting/SpotLightNode.js';
+export { default as LightsNode } from './lighting/LightsNode.js';
+export { default as LightingNode } from './lighting/LightingNode.js';
+export { default as LightingContextNode, LightingModelNode } from './lighting/LightingContextNode.js';
+export { default as HemisphereLightNode } from './lighting/HemisphereLightNode.js';
+export { default as EnvironmentNode } from './lighting/EnvironmentNode.js';
+export { default as AONode } from './lighting/AONode.js';
+export { default as AnalyticLightNode } from './lighting/AnalyticLightNode.js';
+
+// procedural
+export { default as CheckerNode } from './procedural/CheckerNode.js';
+
+// loaders
+export { default as NodeLoader } from './loaders/NodeLoader.js';
+export { default as NodeObjectLoader } from './loaders/NodeObjectLoader.js';
+export { default as NodeMaterialLoader } from './loaders/NodeMaterialLoader.js';
+
+// materials
+export * from './materials/Materials.js';
+
+// materialX
+export * from './materialx/MaterialXNodes.js';
+
+// functions
+export { default as BRDF_GGX } from './functions/BSDF/BRDF_GGX.js';
+export { default as BRDF_Lambert } from './functions/BSDF/BRDF_Lambert.js';
+export { default as D_GGX } from './functions/BSDF/D_GGX.js';
+export { default as DFGApprox } from './functions/BSDF/DFGApprox.js';
+export { default as F_Schlick } from './functions/BSDF/F_Schlick.js';
+export { default as V_GGX_SmithCorrelated } from './functions/BSDF/V_GGX_SmithCorrelated.js';
+
+export { getDistanceAttenuation } from './lighting/LightUtils.js';
+
+export { default as getGeometryRoughness } from './functions/material/getGeometryRoughness.js';
+export { default as getRoughness } from './functions/material/getRoughness.js';
+
+export { default as physicalLightingModel } from './functions/PhysicalLightingModel.js';

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

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+
+export type BitangentNodeScope =
+    | typeof BitangentNode.LOCAL
+    | typeof BitangentNode.VIEW
+    | typeof BitangentNode.WORLD
+    | typeof BitangentNode.GEOMETRY;
+
+export default class BitangentNode extends Node {
+    static GEOMETRY: 'geometry';
+    static LOCAL: 'local';
+    static VIEW: 'view';
+    static WORLD: 'world';
+
+    scope: BitangentNodeScope;
+
+    constructor(scope?: BitangentNodeScope);
+}

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

@@ -0,0 +1,11 @@
+import { NodeTypeOption } from '../core/constants.js';
+import UniformNode from '../core/UniformNode.js';
+
+export default class BufferNode extends UniformNode {
+    isBufferNode: true;
+
+    bufferType: string;
+    bufferCount: number;
+
+    constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
+}

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

@@ -0,0 +1,12 @@
+import Object3DNode, { Object3DNodeScope } from './Object3DNode.js';
+
+export type CameraNodeScope = Object3DNodeScope | typeof CameraNode.PROJECTION_MATRIX;
+
+export default class CameraNode extends Object3DNode {
+    static PROJECTION_MATRIX: 'projectionMatrix';
+
+    // @ts-expect-error
+    scope: CameraNodeScope;
+
+    constructor(scope?: CameraNodeScope);
+}

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

@@ -0,0 +1,13 @@
+import TextureNode from './TextureNode.js';
+import { Node } from '../Nodes.js';
+import { CubeTexture } from '../../../../src/Three.js';
+
+export default class CubeTextureNode extends TextureNode {
+    isCubeTextureNode: boolean;
+    uvNode: Node | null;
+    levelNode: Node | null;
+
+    constructor(value: CubeTexture, uvNode?: Node | null, levelNode?: Node | null);
+
+    getDefaultUV(): Node;
+}

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

@@ -0,0 +1,9 @@
+import { InstancedMesh } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+
+export default class InstanceNode extends Node {
+    instanceMesh: InstancedMesh;
+    instanceMatrixNode: Node;
+
+    constructor(instanceMesh: InstancedMesh);
+}

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

@@ -0,0 +1,23 @@
+import Node from '../core/Node.js';
+
+export type MaterialNodeScope =
+    | typeof MaterialNode.ALPHA_TEST
+    | typeof MaterialNode.COLOR
+    | typeof MaterialNode.OPACITY
+    | typeof MaterialNode.ROUGHNESS
+    | typeof MaterialNode.METALNESS
+    | typeof MaterialNode.EMISSIVE
+    | typeof MaterialNode.ROTATION;
+
+export default class MaterialNode extends Node {
+    static ALPHA_TEST: 'alphaTest';
+    static COLOR: 'color';
+    static OPACITY: 'opacity';
+    static ROUGHNESS: 'roughness';
+    static METALNESS: 'metalness';
+    static EMISSIVE: 'emissive';
+    static ROTATION: 'rotation';
+
+    scope: MaterialNodeScope;
+    constructor(scope?: MaterialNodeScope);
+}

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

@@ -0,0 +1,6 @@
+import { Material } from '../../../../src/Three.js';
+import ReferenceNode from './ReferenceNode.js';
+
+export default class MaterialReferenceNode extends ReferenceNode<Material | null> {
+    constructor(property: string, inputType: string, material?: Material | null);
+}

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

@@ -0,0 +1,9 @@
+import { NodeFrame } from '../Nodes.js';
+import Object3DNode, { Object3DNodeScope } from './Object3DNode.js';
+
+/**
+ * Similar to {@link Object3DNode} but the object comes from {@link NodeFrame}
+ */
+export default class ModelNode extends Object3DNode {
+    constructor(scope?: Object3DNodeScope);
+}

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

@@ -0,0 +1,6 @@
+import Node from '../core/Node.js';
+import PositionNode from './PositionNode.js';
+
+export default class ModelViewProjectionNode extends Node {
+    constructor(positionNode?: PositionNode);
+}

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

@@ -0,0 +1,12 @@
+import Node from '../core/Node.js';
+
+export type NormalNodeScope = typeof NormalNode.GEOMETRY | typeof NormalNode.LOCAL | typeof NormalNode.VIEW;
+
+export default class NormalNode extends Node {
+    static GEOMETRY: 'geometry';
+    static LOCAL: 'local';
+    static VIEW: 'view';
+    scope: NormalNodeScope;
+
+    constructor(scope?: NormalNodeScope);
+}

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

@@ -0,0 +1,22 @@
+import { Object3D } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+
+export type Object3DNodeScope =
+    | typeof Object3DNode.VIEW_MATRIX
+    | typeof Object3DNode.NORMAL_MATRIX
+    | typeof Object3DNode.WORLD_MATRIX
+    | typeof Object3DNode.POSITION
+    | typeof Object3DNode.VIEW_POSITION;
+
+export default class Object3DNode extends Node {
+    static VIEW_MATRIX: 'viewMatrix';
+    static NORMAL_MATRIX: 'normalMatrix';
+    static WORLD_MATRIX: 'worldMatrix';
+    static POSITION: 'position';
+    static VIEW_POSITION: 'viewPosition';
+
+    scope: Object3DNodeScope;
+    object3d: Object3D | null;
+
+    constructor(scope?: Object3DNodeScope, object3d?: Object3D | null);
+}

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

@@ -0,0 +1,7 @@
+import Node from '../core/Node.js';
+
+export default class PointUVNode extends Node {
+    isPointUVNode: true;
+
+    constructor();
+}

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

@@ -0,0 +1,21 @@
+import Node from '../core/Node.js';
+
+export type PositionNodeScope =
+    | typeof PositionNode.GEOMETRY
+    | typeof PositionNode.LOCAL
+    | typeof PositionNode.WORLD
+    | typeof PositionNode.WORLD_DIRECTION
+    | typeof PositionNode.VIEW
+    | typeof PositionNode.VIEW_DIRECTION;
+
+export default class PositionNode extends Node {
+    static GEOMETRY: 'geometry';
+    static LOCAL: 'local';
+    static WORLD: 'world';
+    static WORLD_DIRECTION: 'worldDirection';
+    static VIEW: 'view';
+    static VIEW_DIRECTION: 'viewDirection';
+    scope: PositionNodeScope;
+
+    constructor(scope?: PositionNodeScope);
+}

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

@@ -0,0 +1,13 @@
+import Node from '../core/Node.js';
+import { NodeTypeOption } from '../Nodes.js';
+
+export default class ReferenceNode<T> extends Node {
+    object: T;
+    property: string;
+    uniformType: string;
+    node: Node | null;
+
+    constructor(property: string, uniformType: NodeTypeOption, object?: T | null);
+
+    setNodeType(uniformType: NodeTypeOption): void;
+}

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

@@ -0,0 +1,8 @@
+import Node from '../core/Node.js';
+
+export default class ReflectVectorNode extends Node {
+    constructor();
+
+    getHash(): 'reflectVector';
+    setup(): Node;
+}