@types/three 0.164.1 → 0.166.0

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

@@ -1,3 +1,5 @@
+import { Matrix4 } from "three/src/Three.js";
+import { UniformNode } from "../Nodes.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import Object3DNode from "./Object3DNode.js";
 
@@ -15,3 +17,4 @@ export const modelWorldMatrix: ShaderNodeObject<ModelNode>;
 export const modelPosition: ShaderNodeObject<ModelNode>;
 export const modelScale: ShaderNodeObject<ModelNode>;
 export const modelViewPosition: ShaderNodeObject<ModelNode>;
+export const modelWorldMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;

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

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

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

@@ -1,20 +1,12 @@
-import Node from "../core/Node.js";
+import AttributeNode from "../core/AttributeNode.js";
+import PropertyNode from "../core/PropertyNode.js";
 import VarNode from "../core/VarNode.js";
+import MathNode from "../math/MathNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.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);
-}
-
-export const normalGeometry: ShaderNodeObject<NormalNode>;
-export const normalLocal: ShaderNodeObject<NormalNode>;
-export const normalView: ShaderNodeObject<NormalNode>;
-export const normalWorld: ShaderNodeObject<NormalNode>;
-export const transformedNormalView: ShaderNodeObject<VarNode>;
+export const normalGeometry: ShaderNodeObject<AttributeNode>;
+export const normalLocal: ShaderNodeObject<VarNode>;
+export const normalView: ShaderNodeObject<MathNode>;
+export const normalWorld: ShaderNodeObject<MathNode>;
+export const transformedNormalView: ShaderNodeObject<PropertyNode>;
+export const transformedClearcoatNormalView: ShaderNodeObject<PropertyNode>;

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

@@ -1,29 +1,9 @@
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.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);
-}
-
-export const positionGeometry: ShaderNodeObject<PositionNode>;
-export const positionLocal: ShaderNodeObject<PositionNode>;
-export const positionWorld: ShaderNodeObject<PositionNode>;
-export const positionWorldDirection: ShaderNodeObject<PositionNode>;
-export const positionView: ShaderNodeObject<PositionNode>;
-export const positionViewDirection: ShaderNodeObject<PositionNode>;
+export const positionGeometry: ShaderNodeObject<Node>;
+export const positionLocal: ShaderNodeObject<Node>;
+export const positionWorld: ShaderNodeObject<Node>;
+export const positionWorldDirection: ShaderNodeObject<Node>;
+export const positionView: ShaderNodeObject<Node>;
+export const positionViewDirection: ShaderNodeObject<Node>;

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

@@ -1,11 +1,10 @@
-import { NodeTypeOption } from "../core/constants.js";
 import Node from "../core/Node.js";
 import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class ReferenceNode<T> extends Node {
     property: string;
 
-    uniformType: NodeTypeOption;
+    uniformType: string;
 
     object: T;
     count: number | null;
@@ -14,9 +13,9 @@ export default class ReferenceNode<T> extends Node {
     reference: T | null;
     node: Node | null;
 
-    constructor(property: string, uniformType: NodeTypeOption, object?: T | null, count?: number | null);
+    constructor(property: string, uniformType: string, object?: T | null, count?: number | null);
 
-    setNodeType(uniformType: NodeTypeOption): void;
+    setNodeType(uniformType: string): void;
 }
 
 export const reference: <T>(name: string, nodeOrType: NodeOrType, object: T) => ShaderNodeObject<ReferenceNode<T>>;

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

@@ -1,11 +1,6 @@
 import Node from "../core/Node.js";
+import VarNode from "../core/VarNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
-export default class ReflectVectorNode extends Node {
-    constructor();
-
-    getHash(): "reflectVector";
-    setup(): Node;
-}
-
-export const reflectVector: ShaderNodeObject<ReflectVectorNode>;
+export const reflectView: ShaderNodeObject<Node>;
+export const reflectVector: ShaderNodeObject<VarNode>;

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

@@ -1,16 +1,15 @@
 import Renderer from "../../renderers/common/Renderer.js";
-import { NodeTypeOption } from "../core/constants.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import ReferenceNode from "./ReferenceNode.js";
 
 export default class RendererReferenceNode extends ReferenceNode<Renderer> {
     renderer: Renderer | null;
 
-    constructor(property: string, inputType: NodeTypeOption, renderer?: Renderer | null);
+    constructor(property: string, inputType: string, renderer?: Renderer | null);
 }
 
 export const rendererReference: (
     name: string,
-    type: NodeTypeOption,
+    type: string,
     renderer?: Renderer | null,
 ) => ShaderNodeObject<RendererReferenceNode>;

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

@@ -1,4 +1,6 @@
-import { NodeTypeOption } from "../core/constants.js";
+import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
+import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
+import { GPUBufferBindingType } from "../../renderers/webgpu/utils/WebGPUConstants.js";
 import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import StorageArrayElementNode from "../utils/StoargeArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
@@ -7,20 +9,30 @@ export default class StorageBufferNode extends BufferNode {
     readonly isStorageBufferNode: true;
     bufferObject: boolean;
 
-    constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
+    access: GPUBufferBindingType;
+
+    constructor(
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute,
+        bufferType: string,
+        bufferCount?: number,
+    );
 
     element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
 
     setBufferObject(value: boolean): this;
+
+    setAccess(value: GPUBufferBindingType): this;
+
+    toReadOnly(): this;
 }
 
 export const storage: (
-    value: ArrayLike<number>,
+    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
     nodeOrType: NodeOrType,
     count: number,
 ) => ShaderNodeObject<StorageBufferNode>;
 export const storageObject: (
-    value: ArrayLike<number>,
+    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
     nodeOrType: NodeOrType,
     count: number,
 ) => ShaderNodeObject<StorageBufferNode>;

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

@@ -0,0 +1,40 @@
+import { Texture } from "three";
+import { GPUStorageTextureAccess } from "../../renderers/webgpu/utils/WebGPUConstants.js";
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TextureNode from "./TextureNode.js";
+
+export default class StorageTextureNode extends TextureNode {
+    storeNode: Node | null;
+
+    readonly isStorageTextureNode: true;
+
+    access: GPUStorageTextureAccess;
+
+    constructor(
+        value: Texture,
+        uvNode?: ShaderNodeObject<Node> | null,
+        storeNode?: Node | null,
+    );
+
+    setAccess(value: GPUStorageTextureAccess): this;
+
+    toReadOnly(): this;
+
+    toWriteOnly(): this;
+
+    generateStore(builder: NodeBuilder): void;
+}
+
+export const storageTexture: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    storeNode?: NodeRepresentation,
+) => ShaderNodeObject<StorageTextureNode>;
+
+export const textureStore: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    storeNode?: NodeRepresentation,
+) => ShaderNodeObject<StorageTextureNode>;

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/CacheNode.d.ts

@@ -3,19 +3,18 @@ import Node from "./Node.js";
 import NodeCache from "./NodeCache.js";
 
 export default class CacheNode extends Node {
-    isCacheNode: true;
     node: Node;
-    cache: NodeCache;
+    parent: boolean;
 
-    constructor(node: Node, cache?: NodeCache);
+    readonly isCacheNode: true;
+
+    constructor(node: Node, parent?: boolean);
 }
 
 export const cache: (node: Node, cache?: NodeCache) => ShaderNodeObject<CacheNode>;
-export const globalCache: (node: Node) => ShaderNodeObject<CacheNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {
         cache: typeof cache;
-        globalCache: typeof globalCache;
     }
 }

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/LightingModel.d.ts

@@ -16,6 +16,16 @@ export interface LightingModelDirectInput {
     shadowMask: Node;
 }
 
+export interface LightingModelDirectRectAreaInput {
+    lightColor: Node;
+    lightPosition: Node;
+    halfWidth: Node;
+    halfHeight: Node;
+    reflectedLight: LightingModelReflectedLight;
+    ltc_1: Node;
+    ltc_2: Node;
+}
+
 export interface LightingModelIndirectInput {
     radiance: Node;
     irradiance: Node;
@@ -31,6 +41,7 @@ export default class LightingModel {
     start(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
     finish(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
     direct(input: LightingModelDirectInput, stack: StackNode, builder: NodeBuilder): void;
+    directRectArea(input: LightingModelDirectRectAreaInput, stack: StackNode, builder: NodeBuilder): void;
     indirectDiffuse(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
     indirectSpecular(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
     ambientOcclusion(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;

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

@@ -1,61 +1,121 @@
-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;
-
+    updateAfterType: 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;
-
+    getUpdateAfterType(): NodeUpdateType;
+    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' */
+    updateAfter(frame: NodeFrame): void;
     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;