@types/three 0.164.0 → 0.165.0

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

@@ -1,27 +1,12 @@
-import Node from "../core/Node.js";
+import AttributeNode from "../core/AttributeNode.js";
+import VarNode from "../core/VarNode.js";
+import VaryingNode from "../core/VaryingNode.js";
 import MathNode from "../math/MathNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
-export type TangentNodeScope =
-    | typeof TangentNode.LOCAL
-    | typeof TangentNode.VIEW
-    | typeof TangentNode.WORLD
-    | typeof TangentNode.GEOMETRY;
-
-export default class TangentNode extends Node {
-    static GEOMETRY: "geometry";
-    static LOCAL: "local";
-    static VIEW: "view";
-    static WORLD: "world";
-
-    scope: TangentNodeScope;
-
-    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 tangentGeometry: ShaderNodeObject<AttributeNode>;
+export const tangentLocal: ShaderNodeObject<VaryingNode>;
+export const tangentView: ShaderNodeObject<MathNode>;
+export const tangentWorld: ShaderNodeObject<MathNode>;
+export const transformedTangentView: ShaderNodeObject<VarNode>;
 export const transformedTangentWorld: ShaderNodeObject<MathNode>;

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

@@ -0,0 +1,16 @@
+import { CubeTexture, Texture } from "three";
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TextureNode from "./TextureNode.js";
+
+export default class Texture3DNode extends TextureNode {
+    readonly isTexture3DNode: true;
+
+    constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
+}
+
+export const texture3D: (
+    value: CubeTexture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+) => ShaderNodeObject<Texture3DNode>;

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

@@ -17,7 +17,7 @@ export default class TextureNode extends UniformNode<Texture> {
 
     referenceNode: Node | null;
 
-    constructor(value: Texture, uvNode?: ShaderNodeObject<Node>, levelNode?: ShaderNodeObject<Node> | null);
+    constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
 
     getDefaultUV(): Node;
 

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

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

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

@@ -15,8 +15,6 @@ export default class UniformsNode extends BufferNode {
 
     constructor(value: unknown[], elementType?: string | null);
 
-    getElementType(): string | null;
-
     getElementLength(): number;
 
     element(indexNode: number): ShaderNodeObject<UniformsElementNode>;

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

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

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

@@ -1,4 +1,3 @@
-import { NodeTypeOption } from "../core/constants.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";

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

@@ -1,10 +1,9 @@
-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);
+    constructor(snipped?: string, nodeType?: string);
 }
 
-export const expression: (snipped?: string, nodeType?: NodeTypeOption) => ShaderNodeObject<ExpressionNode>;
+export const expression: (snipped?: string, nodeType?: string) => ShaderNodeObject<ExpressionNode>;

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

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

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

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

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

@@ -1,4 +1,3 @@
-import { NodeTypeOption } from "./constants.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 
@@ -9,7 +8,7 @@ export default abstract class InputNode<Value> extends Node {
     value: Value;
     precision: Precision | null;
 
-    constructor(value: Value, nodeType?: NodeTypeOption | null);
+    constructor(value: Value, nodeType?: string | null);
 
     getInputType(builder: NodeBuilder): string | null;
     setPrecision(precision: Precision): this;

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

@@ -1,61 +1,118 @@
-import { AnyJson, NodeTypeOption, NodeUpdateType } from "./constants.js";
+import { EventDispatcher } from "three";
+import { NodeUpdateType } from "./constants.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
-
-export default abstract class Node {
-    nodeType: NodeTypeOption | null;
-
+interface NodeJSONMeta {
+    textures: {
+        [key: string]: unknown;
+    };
+    images: {
+        [key: string]: unknown;
+    };
+    nodes: {
+        [key: string]: NodeJSONIntermediateOutputData;
+    };
+}
+interface NodeJSONMetadata {
+    version: number;
+    type: "Node";
+    generator: "Node.toJSON";
+}
+interface NodeJSONInputNodes {
+    [property: string]:
+        | string[]
+        | {
+            [index: string]: string | undefined;
+        }
+        | string
+        | undefined;
+}
+interface NodeJSONInputData {
+    inputNodes?: NodeJSONInputNodes | undefined;
+    meta: {
+        textures: {
+            [key: string]: unknown;
+        };
+        nodes: {
+            [key: string]: Node;
+        };
+    };
+}
+interface NodeJSONInputData {
+    uuid: string;
+    type: string | undefined;
+    metadata?: NodeJSONMetadata;
+    inputNodes?: NodeJSONInputNodes | undefined;
+}
+interface NodeJSONIntermediateOutputData {
+    uuid: string;
+    type: string | undefined;
+    meta?: NodeJSONMeta | undefined;
+    metadata?: NodeJSONMetadata;
+    inputNodes?: NodeJSONInputNodes | undefined;
+    textures?: unknown[];
+    images?: unknown[];
+    nodes?: NodeJSONIntermediateOutputData[];
+}
+interface NodeJSONOutputData {
+    uuid: string;
+    type: string | undefined;
+    metadata?: NodeJSONMetadata;
+    inputNodes?: NodeJSONInputNodes | undefined;
+    textures?: unknown[];
+    images?: unknown[];
+    nodes?: NodeJSONOutputData[];
+}
+declare class Node extends EventDispatcher<{
+    dispose: {};
+}> {
+    nodeType: string | null;
     updateType: NodeUpdateType;
     updateBeforeType: NodeUpdateType;
-
     uuid: string;
-
     version: number;
-
+    _cacheKey: string | null;
+    _cacheKeyVersion: number;
+    global: boolean;
     readonly isNode: true;
-
     readonly id: number;
-
-    constructor(nodeType?: NodeTypeOption | null);
-
+    self?: this;
+    constructor(nodeType?: string | null);
     set needsUpdate(value: boolean);
-
-    get type(): number;
-
+    get type(): string | undefined;
+    onUpdate(callback: (this: this, frame: NodeFrame) => unknown, updateType: NodeUpdateType): this;
+    onFrameUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    onRenderUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    onObjectUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    onReference(callback: (this: this, frame: NodeBuilder | NodeFrame) => unknown): this;
+    getSelf(): this;
+    updateReference(state: NodeBuilder | NodeFrame): unknown;
     isGlobal(builder: NodeBuilder): boolean;
-
-    getChildren(): Node[];
-
+    getChildren(): Generator<Node, void, unknown>;
+    dispose(): void;
+    traverse(callback: (node: Node) => void): void;
     getCacheKey(force?: boolean): string;
-
     getHash(builder: NodeBuilder): string;
-
     getUpdateType(): NodeUpdateType;
-
     getUpdateBeforeType(): NodeUpdateType;
-
-    getNodeType(builder: NodeBuilder, output?: string | null): NodeTypeOption | null;
-
-    getReference(builder: NodeBuilder): Node;
-
-    setup(builder: NodeBuilder): Node | null;
-
+    getElementType(builder: NodeBuilder): "bool" | "int" | "float" | "vec2" | "vec3" | "vec4" | "uint" | null;
+    getNodeType(builder: NodeBuilder): string | null;
+    getShared(builder: NodeBuilder): Node;
+    setup(builder: NodeBuilder): unknown;
+    construct(builder: NodeBuilder): unknown;
     increaseUsage(builder: NodeBuilder): number;
-
     analyze(builder: NodeBuilder): void;
-
-    generate(builder: NodeBuilder, output?: string | null): string;
-
+    generate(builder: NodeBuilder, output?: string | null): string | null | undefined;
     updateBefore(frame: NodeFrame): void;
-
-    /** This method must be overriden when {@link updateType} !== 'none' */
     update(frame: NodeFrame): void;
-
-    build(builder: NodeBuilder, output?: string | null): string;
-
-    serialize(json: AnyJson): void;
-
-    deserialize(json: AnyJson): void;
-
-    toJSON(meta?: string | { textures: {}; images: {}; nodes: {} }): AnyJson;
+    build(builder: NodeBuilder, output?: string | null): string | null;
+    getSerializeChildren(): Generator<import("./NodeUtils.js").NodeChild, void, unknown>;
+    serialize(json: NodeJSONIntermediateOutputData): void;
+    deserialize(json: NodeJSONInputData): void;
+    toJSON(meta?: NodeJSONMeta | string): NodeJSONOutputData;
 }
+export default Node;
+export declare function addNodeClass(type: string, nodeClass: {
+    new(...args: any[]): Node;
+}): void;
+export declare function createNodeFromType(type: string): Node | undefined;

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

@@ -1,6 +1,9 @@
-export default class NodeAttribute {
-    isNodeAttribute: true;
+import Node from "./Node.js";
+declare class NodeAttribute {
+    readonly isNodeAttribute: true;
     name: string;
-    type: string;
-    constructor(name: string, type: string);
+    type: string | null;
+    node: Node | null;
+    constructor(name: string, type: string | null, node?: Node | null);
 }
+export default NodeAttribute;

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

@@ -1,7 +1,7 @@
 import { BufferGeometry, Material, Object3D, Renderer } from "three";
 import FogNode from "../fog/FogNode.js";
 import LightsNode from "../lighting/LightsNode.js";
-import { AnyObject, NodeShaderStage, NodeTypeOption } from "./constants.js";
+import { NodeShaderStage } from "./constants.js";
 import Node from "./Node.js";
 import NodeAttribute from "./NodeAttribute.js";
 import NodeCache from "./NodeCache.js";
@@ -18,12 +18,12 @@ export interface FlowData {
 }
 
 export interface NodeData {
-    vertex: AnyObject;
-    fragment: AnyObject;
-    compute: AnyObject;
+    vertex: { [key: string]: unknown };
+    fragment: { [key: string]: unknown };
+    compute: { [key: string]: unknown };
 }
 
-export type NodeBuilderContext = AnyObject;
+export type NodeBuilderContext = { [key: string]: unknown };
 
 export default abstract class NodeBuilder {
     object: Object3D;
@@ -76,35 +76,35 @@ export default abstract class NodeBuilder {
     isFlipY(): boolean;
 
     // @TODO: rename to .generateConst()
-    getConst(type: NodeTypeOption, value?: unknown): Node;
-    getType(type: NodeTypeOption): NodeTypeOption;
+    getConst(type: string, value?: unknown): Node;
+    getType(type: string): string;
 
     generateMethod(method: string): string;
 
-    getAttribute(name: string, type: NodeTypeOption): NodeAttribute;
+    getAttribute(name: string, type: string): NodeAttribute;
 
     getPropertyName(node: Node, shaderStage: NodeShaderStage): string;
-    isVector(type: NodeTypeOption): boolean;
-
-    isMatrix(type: NodeTypeOption): boolean;
-    isReference(type: NodeTypeOption): boolean;
-    isShaderStage(shaderStage: NodeShaderStage): boolean;
-    getComponentType(type: NodeTypeOption): NodeTypeOption;
-    getVectorType(type: NodeTypeOption): NodeTypeOption;
-    getTypeFromLength(length: number): NodeTypeOption;
-    getTypeLength(type: NodeTypeOption): number;
-    getVectorFromMatrix(type: NodeTypeOption): NodeTypeOption;
+    isVector(type: string): boolean;
+
+    isMatrix(type: string): boolean;
+    isReference(type: string): boolean;
+    getElementType(type: string): string | null;
+    getComponentType(type: string): string | null;
+    getVectorType(type: string): string;
+    getTypeFromLength(length: number): string;
+    getTypeLength(type: string): number;
+    getVectorFromMatrix(type: string): string;
     getDataFromNode(node: Node, shaderStage?: NodeShaderStage): NodeData;
-    getNodeProperties(node: Node, shaderStage?: NodeShaderStage): AnyObject;
+    getNodeProperties(node: Node, shaderStage?: NodeShaderStage): { [key: string]: unknown };
     getUniformFromNode(
         node: Node,
-        type: NodeTypeOption,
+        type: string,
         shaderStage?: NodeShaderStage,
         name?: string | null,
     ): NodeUniform<string>;
-    getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStage): NodeVar;
-    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
-    getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStage): string;
+    getVarFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): NodeVar;
+    getVaryFromNode(node: Node, type: string): NodeVarying;
+    getCodeFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): string;
     addFlowCode(code: string): void;
     getFlowData(node: Node, shaderStage: NodeShaderStage): FlowData;
     flowNode(node: Node): FlowData;
@@ -128,6 +128,6 @@ export default abstract class NodeBuilder {
     getBuildStage(): BuildStageOption;
     abstract buildCode(): void;
     build(): this;
-    format(snippet: string, fromType: NodeTypeOption, toType: NodeTypeOption): string;
+    format(snippet: string, fromType: string, toType: string): string;
     getSignature(): string;
 }

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

@@ -1,9 +1,43 @@
 import Node from "./Node.js";
-import { NodeData } from "./NodeBuilder.js";
-
-export default class NodeCache {
+import NodeAttribute from "./NodeAttribute.js";
+import NodeCode from "./NodeCode.js";
+import NodeUniform from "./NodeUniform.js";
+import NodeVar from "./NodeVar.js";
+import NodeVarying from "./NodeVarying.js";
+export interface ShaderStageNodeData {
+    properties?:
+        | (
+            & {
+                outputNode: Node | null;
+                initialized?: boolean | undefined;
+            }
+            & {
+                [K in `node${string}`]?: Node | undefined;
+            }
+        )
+        | undefined;
+    bufferAttribute?: NodeAttribute | undefined;
+    structType?: Node | undefined;
+    uniform?: NodeUniform<unknown> | undefined;
+    variable?: NodeVar | undefined;
+    varying?: NodeVarying | undefined;
+    code?: NodeCode | undefined;
+    usageCount?: number | undefined;
+    snippet?: string | undefined;
+    propertyName?: string | undefined;
+    propertySizeName?: string | undefined;
+}
+interface NodeData {
+    vertex?: ShaderStageNodeData | undefined;
+    fragment?: ShaderStageNodeData | undefined;
+    compute?: ShaderStageNodeData | undefined;
+    any?: ShaderStageNodeData | undefined;
+}
+declare class NodeCache {
     id: number;
     nodesData: WeakMap<Node, NodeData>;
-
     constructor();
+    getNodeData(node: Node): NodeData | undefined;
+    setNodeData(node: Node, data: NodeData): void;
 }
+export default NodeCache;

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

@@ -1,14 +1,17 @@
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
-
-export default class NodeKeywords {
+declare class NodeKeywords {
     keywords: string[];
-    nodes: Node[];
-    keywordsCallback: { [name: string]: (name: string) => Node };
-
+    nodes: {
+        [name: string]: Node;
+    };
+    keywordsCallback: {
+        [name: string]: (name: string) => Node;
+    };
+    constructor();
     getNode(name: string): Node;
-    addKeyword(name: string, callback: (name: string) => Node): void;
-
+    addKeyword(name: string, callback: (name: string) => Node): this;
     parse(code: string): Node[];
     include(builder: NodeBuilder, code: string): void;
 }
+export default NodeKeywords;

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

@@ -1,5 +1,5 @@
-import Node from "./Node.js";
-
-export default abstract class NodeParser {
-    abstract parseFunction(source: string): Node;
+import NodeFunction from "./NodeFunction.js";
+declare abstract class NodeParser {
+    abstract parseFunction(source: string): NodeFunction;
 }
+export default NodeParser;

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

@@ -1,17 +1,14 @@
 import UniformNode from "./UniformNode.js";
-
-export default class NodeUniform<Value> {
+declare class NodeUniform<TValue> {
     readonly isNodeUniform: true;
-
     name: string;
-    type: string;
-    node: UniformNode<Value>;
+    type: string | null;
+    node: UniformNode<TValue>;
     needsUpdate: boolean | undefined;
-
-    constructor(name: string, type: string, node: UniformNode<Value>, needsUpdate?: boolean);
-
-    get(): Value;
-    set value(val: Value);
-
+    constructor(name: string, type: string | null, node: UniformNode<TValue>, needsUpdate?: undefined);
+    get value(): TValue;
+    set value(val: TValue);
     get id(): number;
+    get groupNode(): import("./UniformGroupNode.js").default;
 }
+export default NodeUniform;

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

@@ -1,6 +1,7 @@
-export default class NodeVar {
-    isNodeVar: true;
+declare class NodeVar {
+    readonly isNodeVar: true;
     name: string;
-    type: string;
-    constructor(name: string, type: string);
+    type: string | null;
+    constructor(name: string, type: string | null);
 }
+export default NodeVar;

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

@@ -1,8 +1,7 @@
 import NodeVar from "./NodeVar.js";
-
-export default class NodeVarying extends NodeVar {
-    needsInterpolation: false;
-    isNodeVarying: true;
-
-    constructor(name: string, type: string);
+declare class NodeVarying extends NodeVar {
+    needsInterpolation: boolean;
+    readonly isNodeVarying: true;
+    constructor(name: string, type: string | null);
 }
+export default NodeVarying;

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

@@ -1,5 +1,4 @@
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import { NodeTypeOption } from "./constants.js";
 import Node from "./Node.js";
 
 export default class PropertyNode extends Node {
@@ -8,11 +7,11 @@ export default class PropertyNode extends Node {
 
     readonly isPropertyNode: true;
 
-    constructor(nodeType?: NodeTypeOption | null, name?: string | null, varying?: boolean);
+    constructor(nodeType?: string | null, name?: string | null, varying?: boolean);
 }
 
-export const property: (type?: NodeTypeOption | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
-export const varyingProperty: (type?: NodeTypeOption | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+export const property: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+export const varyingProperty: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
 
 export const diffuseColor: ShaderNodeObject<PropertyNode>;
 export const roughness: ShaderNodeObject<PropertyNode>;
@@ -40,3 +39,4 @@ export const transmission: ShaderNodeObject<PropertyNode>;
 export const thickness: ShaderNodeObject<PropertyNode>;
 export const attenuationDistance: ShaderNodeObject<PropertyNode>;
 export const attenuationColor: ShaderNodeObject<PropertyNode>;
+export const dispersion: ShaderNodeObject<PropertyNode>;

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

@@ -7,5 +7,11 @@ export default class StackNode extends Node {
 
     constructor();
 
-    assign(targetNode: Node, sourceValue: Node): this;
+    add(node: Node): this;
+
+    if(boolNode: Node, method: () => void): this;
+
+    elseIf(node: Node, method: () => void): this;
+
+    else(node: Node, method: () => void): this;
 }

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

@@ -0,0 +1,8 @@
+import Node from "./Node.js";
+declare class StructTypeNode extends Node {
+    types: string[];
+    readonly isStructTypeNode: true;
+    constructor(types: string[]);
+    getMemberTypes(): string[];
+}
+export default StructTypeNode;

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

@@ -1,11 +1,10 @@
-import { NodeTypeOption } from "./constants.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 
 export default class TempNode extends Node {
     isTempNode: true;
 
-    constructor(type: NodeTypeOption | null);
+    constructor(type: string | null);
 
     hasDependencies(builder: NodeBuilder): boolean;
 }

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

@@ -0,0 +1,7 @@
+export default class UniformGroup {
+    name: string;
+
+    readonly isUniformGroup: true;
+
+    constructor(name: string);
+}