@types/three 0.160.0 → 0.161.0

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

@@ -1,18 +1,29 @@
 import Object3DNode, { Object3DNodeScope } from './Object3DNode.js';
 import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export type CameraNodeScope = Object3DNodeScope | typeof CameraNode.PROJECTION_MATRIX;
+export type CameraNodeScope =
+    | Object3DNodeScope
+    | typeof CameraNode.PROJECTION_MATRIX
+    | typeof CameraNode.PROJECTION_MATRIX_INVERSE
+    | typeof CameraNode.NEAR
+    | typeof CameraNode.FAR
+    | typeof CameraNode.LOG_DEPTH;
 
 export default class CameraNode extends Object3DNode {
-    static PROJECTION_MATRIX: 'projectionMatrix';
-
-    // @ts-expect-error
-    scope: CameraNodeScope;
+    constructor(scope?: string);
 
-    constructor(scope?: CameraNodeScope);
+    static PROJECTION_MATRIX: 'projectionMatrix';
+    static PROJECTION_MATRIX_INVERSE: 'projectionMatrixInverse';
+    static NEAR: 'near';
+    static FAR: 'far';
+    static LOG_DEPTH: 'logDepth';
 }
 
 export const cameraProjectionMatrix: ShaderNodeObject<CameraNode>;
+export const cameraProjectionMatrixInverse: ShaderNodeObject<CameraNode>;
+export const cameraNear: ShaderNodeObject<CameraNode>;
+export const cameraFar: ShaderNodeObject<CameraNode>;
+export const cameraLogDepth: ShaderNodeObject<CameraNode>;
 export const cameraViewMatrix: ShaderNodeObject<CameraNode>;
 export const cameraNormalMatrix: ShaderNodeObject<CameraNode>;
 export const cameraWorldMatrix: ShaderNodeObject<CameraNode>;

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

@@ -5,8 +5,8 @@ import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.j
 
 export default class CubeTextureNode extends TextureNode {
     isCubeTextureNode: boolean;
-    uvNode: Node | null;
-    levelNode: Node | null;
+    uvNode: ShaderNodeObject<Node> | null;
+    levelNode: ShaderNodeObject<Node> | null;
 
     constructor(value: CubeTexture, uvNode?: Node | null, levelNode?: Node | null);
 
@@ -18,3 +18,9 @@ export const cubeTexture: (
     uvNode?: NodeRepresentation,
     levelNode?: NodeRepresentation,
 ) => ShaderNodeObject<CubeTextureNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        cubeTexture: typeof cubeTexture;
+    }
+}

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

@@ -9,5 +9,5 @@ export default class MaterialReferenceNode extends ReferenceNode<Material | null
 export const materialReference: (
     name: string,
     nodeOrType: NodeOrType,
-    material: Material,
+    material?: Material | null,
 ) => ShaderNodeObject<MaterialReferenceNode>;

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

@@ -8,8 +8,10 @@ export default class ModelNode extends Object3DNode {
     constructor(scope?: Object3DNodeScope);
 }
 
+export const modelDirection: ShaderNodeObject<ModelNode>;
 export const modelViewMatrix: ShaderNodeObject<ModelNode>;
 export const modelNormalMatrix: ShaderNodeObject<ModelNode>;
 export const modelWorldMatrix: ShaderNodeObject<ModelNode>;
 export const modelPosition: ShaderNodeObject<ModelNode>;
+export const modelScale: ShaderNodeObject<ModelNode>;
 export const modelViewPosition: ShaderNodeObject<ModelNode>;

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

@@ -6,17 +6,21 @@ export type Object3DNodeScope =
     | typeof Object3DNode.NORMAL_MATRIX
     | typeof Object3DNode.WORLD_MATRIX
     | typeof Object3DNode.POSITION
-    | typeof Object3DNode.VIEW_POSITION;
+    | typeof Object3DNode.SCALE
+    | typeof Object3DNode.VIEW_POSITION
+    | typeof Object3DNode.DIRECTION;
 
 export default class Object3DNode extends Node {
+    scope: string;
+    object3d: Object3D | null;
+
+    constructor(scope?: string, object3d?: Object3D | null);
+
     static VIEW_MATRIX: 'viewMatrix';
     static NORMAL_MATRIX: 'normalMatrix';
     static WORLD_MATRIX: 'worldMatrix';
     static POSITION: 'position';
+    static SCALE: 'scale';
     static VIEW_POSITION: 'viewPosition';
-
-    scope: Object3DNodeScope;
-    object3d: Object3D | null;
-
-    constructor(scope?: Object3DNodeScope, object3d?: Object3D | null);
+    static DIRECTION: 'direction';
 }

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

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TempNode from '../core/TempNode.js';
+
+export default class TextureBicubicNode extends TempNode {
+    textureNode: Node;
+    blurNode: Node;
+
+    constructor(textureNode: Node, blurNode?: Node);
+}
+
+export const textureBicubic: (textureNode: Node, blurNode?: NodeRepresentation) => ShaderNodeObject<TextureBicubicNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        bicubic: typeof textureBicubic;
+    }
+}

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

@@ -6,12 +6,14 @@ import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.j
 export default class TextureNode extends UniformNode<Texture> {
     isTextureNode: true;
 
-    uvNode: Node | null;
-    levelNode: Node | null;
+    uvNode: ShaderNodeObject<Node> | null;
+    levelNode: ShaderNodeObject<Node> | null;
 
-    constructor(value: Texture, uvNode?: Node, levelNode?: Node | null);
+    constructor(value: Texture, uvNode?: ShaderNodeObject<Node>, levelNode?: ShaderNodeObject<Node> | null);
 
     getDefaultUV(): Node;
+
+    clone(): this;
 }
 
 export const texture: (
@@ -20,3 +22,9 @@ export const texture: (
     levelNode?: NodeRepresentation,
 ) => ShaderNodeObject<TextureNode>;
 export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        texture: typeof texture;
+    }
+}

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

@@ -0,0 +1,12 @@
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import AttributeNode from '../core/AttributeNode.js';
+
+export default class VertexColorNode extends AttributeNode {
+    readonly isVertexColorNode: true;
+
+    index: number;
+
+    constructor(index?: number);
+}
+
+export const vertexColor: (index?: number) => ShaderNodeObject<VertexColorNode>;

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

@@ -17,3 +17,9 @@ export const call: <P extends FunctionNodeArguments>(
     functionNode?: FunctionNode<P>,
     parameters?: ProxiedObject<P>,
 ) => ShaderNodeObject<FunctionCallNode<P>>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        call: typeof call;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import TempNode from './TempNode.js';
+
+export default class AssignNode extends TempNode {
+    constructor(targetNode: Node, sourceNode: Node);
+
+    hasDependencies(): false;
+}
+
+export const assign: (targetNode: NodeRepresentation, sourceNode: NodeRepresentation) => ShaderNodeObject<AssignNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        assign: typeof assign;
+    }
+}

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

@@ -10,3 +10,9 @@ export default class BypassNode extends Node {
 }
 
 export const bypass: (returnNode: NodeRepresentation, callNode: NodeRepresentation) => ShaderNodeObject<BypassNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        bypass: typeof bypass;
+    }
+}

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

@@ -11,3 +11,11 @@ export default class CacheNode extends Node {
 }
 
 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/ContextNode.d.ts

@@ -11,3 +11,11 @@ export default class ContextNode extends Node {
 }
 
 export const context: (node: NodeRepresentation, context: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
+export const label: (node: NodeRepresentation, label: string) => ShaderNodeObject<ContextNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        context: typeof context;
+        label: typeof label;
+    }
+}

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

@@ -0,0 +1,18 @@
+import Node from './Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type IndexNodeScope = typeof IndexNode.VERTEX | typeof IndexNode.INSTANCE;
+
+export default class IndexNode extends Node {
+    scope: IndexNodeScope;
+
+    readonly isInstanceNode: true;
+
+    constructor(scope: IndexNodeScope);
+
+    static VERTEX: 'vertex';
+    static INSTANCE: 'instance';
+}
+
+export const vertexIndex: ShaderNodeObject<IndexNode>;
+export const instanceIndex: ShaderNodeObject<IndexNode>;

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

@@ -0,0 +1,36 @@
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+import StackNode from './StackNode.js';
+
+export interface LightingModelReflectedLight {
+    directDiffuse: Node;
+    directSpecular: Node;
+    indirectDiffuse: Node;
+    indirectSpecular: Node;
+}
+
+export interface LightingModelDirectInput {
+    lightDirection: Node;
+    lightColor: Node;
+    reflectedLight: LightingModelReflectedLight;
+}
+
+export interface LightingModelIndirectInput {
+    radiance: Node;
+    irradiance: Node;
+    iblIrradiance: Node;
+    ambientOcclusion: Node;
+    reflectedLight: LightingModelReflectedLight;
+    backdrop: Node;
+    backdropAlpha: Node;
+    outgoingLight: Node;
+}
+
+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;
+    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,31 +1,55 @@
-import { AnyJson, NodeTypeOption, NodeUpdateTypeOption } from './constants.js';
+import { AnyJson, NodeTypeOption, NodeUpdateType } from './constants.js';
 import NodeBuilder from './NodeBuilder.js';
 import NodeFrame from './NodeFrame.js';
 
 export default abstract class Node {
-    uuid: string;
-    type: string;
-    isNode: true;
+    readonly isNode: true;
+
     nodeType: NodeTypeOption | null;
-    updateType: NodeUpdateTypeOption;
-    id: number;
+
+    updateType: NodeUpdateType;
+    updateBeforeType: NodeUpdateType;
+
+    uuid: string;
+
+    readonly id: number;
 
     constructor(nodeType?: NodeTypeOption | null);
 
+    get type(): number;
+
     isGlobal(builder: NodeBuilder): boolean;
+
     getChildren(): Node[];
+
+    getCacheKey(): string;
+
     getHash(builder: NodeBuilder): string;
-    getUpdateType(builder: NodeBuilder): NodeUpdateTypeOption;
+
+    getUpdateType(): NodeUpdateType;
+
+    getUpdateBeforeType(): NodeUpdateType;
+
     getNodeType(builder: NodeBuilder, output?: string | null): NodeTypeOption | null;
+
     getReference(builder: NodeBuilder): Node;
+
     setup(builder: NodeBuilder): Node | null;
+
     analyze(builder: NodeBuilder): void;
+
     generate(builder: NodeBuilder, output?: string | null): string;
+
+    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;
-    getCacheKey(): string;
 }

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

@@ -9,7 +9,7 @@ import {
 } from '../../../../src/Three.js';
 import FogNode from '../fog/FogNode.js';
 import LightsNode from '../lighting/LightsNode.js';
-import { AnyObject, NodeShaderStageOption, NodeTypeOption } from './constants.js';
+import { AnyObject, NodeShaderStage, NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeAttribute from './NodeAttribute.js';
 import NodeCache from './NodeCache.js';
@@ -17,6 +17,7 @@ import NodeParser from './NodeParser.js';
 import NodeUniform from './NodeUniform.js';
 import NodeVar from './NodeVar.js';
 import NodeVarying from './NodeVarying.js';
+import StackNode from './StackNode.js';
 
 export type BuildStageOption = 'construct' | 'analyze' | 'generate';
 
@@ -58,9 +59,9 @@ export default abstract class NodeBuilder {
      */
     flowsData: any;
 
-    shaderStage: NodeShaderStageOption | null;
+    shaderStage: NodeShaderStage | null;
     buildStage: BuildStageOption | null;
-    stack: Node[];
+    stack: StackNode;
 
     setHashNode(node: Node, hash: string): void;
     addNode(node: Node): void;
@@ -68,7 +69,7 @@ export default abstract class NodeBuilder {
     getMethod(method: string): string;
     getNodeFromHash(hash: string): Node;
 
-    addFlow(shaderStage: NodeShaderStageOption, node: Node): Node;
+    addFlow(shaderStage: NodeShaderStage, node: Node): Node;
 
     setContext(context: NodeBuilderContext): void;
     getContext(): NodeBuilderContext;
@@ -90,52 +91,52 @@ export default abstract class NodeBuilder {
 
     getAttribute(name: string, type: NodeTypeOption): NodeAttribute;
 
-    getPropertyName(node: Node, shaderStage: NodeShaderStageOption): string;
+    getPropertyName(node: Node, shaderStage: NodeShaderStage): string;
     isVector(type: NodeTypeOption): boolean;
 
     isMatrix(type: NodeTypeOption): boolean;
     isReference(type: NodeTypeOption): boolean;
-    isShaderStage(shaderStage: NodeShaderStageOption): boolean;
+    isShaderStage(shaderStage: NodeShaderStage): boolean;
     getTextureEncodingFromMap(map: Texture | WebGLRenderTarget | unknown): TextureEncoding;
     getComponentType(type: NodeTypeOption): NodeTypeOption;
     getVectorType(type: NodeTypeOption): NodeTypeOption;
     getTypeFromLength(length: number): NodeTypeOption;
     getTypeLength(type: NodeTypeOption): number;
     getVectorFromMatrix(type: NodeTypeOption): NodeTypeOption;
-    getDataFromNode(node: Node, shaderStage?: NodeShaderStageOption): NodeData;
-    getNodeProperties(node: Node, shaderStage?: NodeShaderStageOption): AnyObject;
+    getDataFromNode(node: Node, shaderStage?: NodeShaderStage): NodeData;
+    getNodeProperties(node: Node, shaderStage?: NodeShaderStage): AnyObject;
     getUniformFromNode(
         node: Node,
         type: NodeTypeOption,
-        shaderStage?: NodeShaderStageOption,
+        shaderStage?: NodeShaderStage,
         name?: string | null,
     ): NodeUniform<string>;
-    getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
+    getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStage): NodeVar;
     getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
-    getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): string;
+    getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStage): string;
     addFlowCode(code: string): void;
-    getFlowData(node: Node, shaderStage: NodeShaderStageOption): FlowData;
+    getFlowData(node: Node, shaderStage: NodeShaderStage): FlowData;
     flowNode(node: Node): FlowData;
     flowChildNode(node: Node, output?: string | null): FlowData;
     flowNodeFromShaderStage(
-        shaderStage: NodeShaderStageOption,
+        shaderStage: NodeShaderStage,
         node: Node,
         output?: string | null,
         propertyName?: string,
     ): FlowData;
     hasGeometryAttribute(name: string): boolean;
-    abstract getAttributes(shaderStage: NodeShaderStageOption): string;
-    abstract getVarys(shaderStage: NodeShaderStageOption): string;
-    getVars(shaderStage: NodeShaderStageOption): string;
-    abstract getUniforms(stage: NodeShaderStageOption): string;
-    getCodes(shaderStage: NodeShaderStageOption): string;
+    abstract getAttributes(shaderStage: NodeShaderStage): string;
+    abstract getVarys(shaderStage: NodeShaderStage): string;
+    getVars(shaderStage: NodeShaderStage): string;
+    abstract getUniforms(stage: NodeShaderStage): string;
+    getCodes(shaderStage: NodeShaderStage): string;
     getHash(): string;
-    setShaderStage(shaderStage: NodeShaderStageOption): void;
-    getShaderStage(): NodeShaderStageOption;
+    setShaderStage(shaderStage: NodeShaderStage): void;
+    getShaderStage(): NodeShaderStage;
     setBuildStage(buildStage: BuildStageOption): void;
     getBuildStage(): BuildStageOption;
     abstract buildCode(): void;
-    build(): this;
+    build(createMaterial?: boolean): this;
     format(snippet: string, fromType: NodeTypeOption, toType: NodeTypeOption): string;
     getSignature(): string;
 }

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

@@ -1,19 +1,31 @@
-import { Camera, Material, Object3D, Renderer } from '../../../../src/Three.js';
+import { Camera, Material, Object3D, Renderer, Scene } from '../../../../src/Three.js';
 
 import Node from './Node.js';
 
 export default class NodeFrame {
     time: number;
     deltaTime: number;
+
     frameId: number;
-    startTime: null | number;
-    renderer: null | Renderer;
-    material: null | Material;
-    camera: null | Camera;
-    object: null | Object3D;
+    renderId: number;
+
+    startTime: number | null;
+
+    frameMap: WeakMap<Node, number>;
+    frameBeforeMap: WeakMap<Node, number>;
+    renderMap: WeakMap<Node, number>;
+    renderBeforeMap: WeakMap<Node, number>;
+
+    renderer: Renderer | null;
+    material: Material | null;
+    camera: Camera | null;
+    object: Object3D | null;
+    scene: Scene | null;
 
     constructor();
 
+    updateBeforeNode(node: Node): void;
+
     updateNode(node: Node): void;
     update(): void;
 }

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

@@ -3,13 +3,30 @@ import Node from './Node.js';
 import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class PropertyNode extends Node {
-    constructor(name?: string, nodeType?: NodeTypeOption);
+    name: string | null;
+    varying: boolean;
+
+    readonly isPropertyNode: true;
+
+    constructor(nodeType?: NodeTypeOption | null, name?: string | null, varying?: boolean);
 }
 
-export const property: (name: string, nodeOrType: Node | NodeTypeOption) => ShaderNodeObject<Node>;
+export const property: (type?: NodeTypeOption | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+export const varyingProperty: (type?: NodeTypeOption | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
 
 export const diffuseColor: ShaderNodeObject<PropertyNode>;
 export const roughness: ShaderNodeObject<PropertyNode>;
 export const metalness: ShaderNodeObject<PropertyNode>;
+export const clearcoat: ShaderNodeObject<PropertyNode>;
+export const clearcoatRoughness: ShaderNodeObject<PropertyNode>;
+export const sheen: ShaderNodeObject<PropertyNode>;
+export const sheenRoughness: ShaderNodeObject<PropertyNode>;
+export const iridescence: ShaderNodeObject<PropertyNode>;
+export const iridescenceIOR: ShaderNodeObject<PropertyNode>;
+export const iridescenceThickness: ShaderNodeObject<PropertyNode>;
 export const specularColor: ShaderNodeObject<PropertyNode>;
 export const shininess: ShaderNodeObject<PropertyNode>;
+export const output: ShaderNodeObject<PropertyNode>;
+export const dashSize: ShaderNodeObject<PropertyNode>;
+export const gapSize: ShaderNodeObject<PropertyNode>;
+export const pointWidth: ShaderNodeObject<PropertyNode>;

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

@@ -16,5 +16,11 @@ export default class VarNode extends Node {
     div(...params: Node[]): this;
 }
 
-export const label: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VarNode>;
-export const temp: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VarNode>;
+export const temp: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        temp: typeof temp;
+        toVar: typeof temp;
+    }
+}

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

@@ -9,3 +9,9 @@ export default class VaryingNode extends Node {
 }
 
 export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        varying: typeof varying;
+    }
+}

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

@@ -1,18 +1,27 @@
-// disable automatic export, we have some private declarations
-export const NodeShaderStage: {
-    VERTEX: 'vertex';
-    FRAGMENT: 'fragment';
-};
+export enum NodeShaderStage {
+    VERTEX = 'vertex',
+    FRAGMENT = 'fragment',
+}
 
-export const NodeUpdateType: {
-    NONE: 'none';
-    FRAME: 'frame';
-    RENDER: 'render';
-    OBJECT: 'object';
-};
+export enum NodeUpdateType {
+    NONE = 'none',
+    FRAME = 'frame',
+    RENDER = 'render',
+    OBJECT = 'object',
+}
+
+export enum NodeType {
+    BOOLEAN = 'bool',
+    INTEGER = 'int',
+    FLOAT = 'float',
+    VECTOR2 = 'vec2',
+    VECTOR3 = 'vec3',
+    VECTOR4 = 'vec4',
+    MATRIX2 = 'mat2',
+    MATRIX3 = 'mat3',
+    MATRIX4 = 'mat4',
+}
 
-export type NodeUpdateTypeOption = 'none' | 'frame' | 'object';
-export type NodeShaderStageOption = 'vertex' | 'fragment' | 'compute';
 export type NodeTypeOption =
     | 'bool'
     | 'int'
@@ -20,6 +29,7 @@ export type NodeTypeOption =
     | 'vec2'
     | 'vec3'
     | 'vec4'
+    | 'mat2'
     | 'mat3'
     | 'mat4'
     | 'code' /* CodeNode */
@@ -67,14 +77,3 @@ export interface AnyObject {
 
 /** a generic JSON type, used by nodes only */
 export type AnyJson = any;
-
-export const NodeType: {
-    BOOLEAN: 'bool';
-    INTEGER: 'int';
-    FLOAT: 'float';
-    VECTOR2: 'vec2';
-    VECTOR3: 'vec3';
-    VECTOR4: 'vec4';
-    MATRIX3: 'mat3';
-    MATRIX4: 'mat4';
-};

three/examples/jsm/nodes/display/AfterImageNode.d.ts

@@ -0,0 +1,25 @@
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class AfterImageNode extends TempNode {
+    textureNode: TextureNode;
+    textureNodeOld: Node;
+    damp: UniformNode<number>;
+
+    constructor(textureNode: Node, damp?: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const afterImage: (node: Node, damp?: number) => ShaderNodeObject<AfterImageNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        afterImage: typeof afterImage;
+    }
+}