@types/three 0.160.0 → 0.161.1

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

@@ -0,0 +1,18 @@
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.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/InputNode.d.ts

@@ -1,8 +1,8 @@
-import { NodeTypeOption } from './constants.js';
-import Node from './Node.js';
-import NodeBuilder from './NodeBuilder.js';
+import { NodeTypeOption } from "./constants.js";
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
 
-export type Precision = 'low' | 'medium' | 'high';
+export type Precision = "low" | "medium" | "high";
 
 export default abstract class InputNode<Value> extends Node {
     isInputNode: true;

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 NodeBuilder from './NodeBuilder.js';
-import NodeFrame from './NodeFrame.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

@@ -6,19 +6,20 @@ import {
     Texture,
     TextureEncoding,
     WebGLRenderTarget,
-} from '../../../../src/Three.js';
-import FogNode from '../fog/FogNode.js';
-import LightsNode from '../lighting/LightsNode.js';
-import { AnyObject, NodeShaderStageOption, NodeTypeOption } from './constants.js';
-import Node from './Node.js';
-import NodeAttribute from './NodeAttribute.js';
-import NodeCache from './NodeCache.js';
-import NodeParser from './NodeParser.js';
-import NodeUniform from './NodeUniform.js';
-import NodeVar from './NodeVar.js';
-import NodeVarying from './NodeVarying.js';
-
-export type BuildStageOption = 'construct' | 'analyze' | 'generate';
+} from "../../../../src/Three.js";
+import FogNode from "../fog/FogNode.js";
+import LightsNode from "../lighting/LightsNode.js";
+import { AnyObject, NodeShaderStage, NodeTypeOption } from "./constants.js";
+import Node from "./Node.js";
+import NodeAttribute from "./NodeAttribute.js";
+import NodeCache from "./NodeCache.js";
+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";
 
 export interface FlowData {
     code: string;
@@ -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/NodeCache.d.ts

@@ -1,5 +1,5 @@
-import Node from './Node.js';
-import { NodeData } from './NodeBuilder.js';
+import Node from "./Node.js";
+import { NodeData } from "./NodeBuilder.js";
 
 export default class NodeCache {
     id: number;

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';
+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/NodeFunction.d.ts

@@ -1,4 +1,4 @@
-import NodeFunctionInput from './NodeFunctionInput.js';
+import NodeFunctionInput from "./NodeFunctionInput.js";
 
 export default abstract class NodeFunction {
     isNodeFunction: true;

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

@@ -1,5 +1,5 @@
-import NodeBuilder from './NodeBuilder.js';
-import Node from './Node.js';
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
 
 export default class NodeKeywords {
     keywords: string[];

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

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

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

@@ -1,4 +1,4 @@
-import UniformNode from './UniformNode.js';
+import UniformNode from "./UniformNode.js";
 
 export default class NodeUniform<Value> {
     readonly isNodeUniform: true;

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

@@ -1,5 +1,5 @@
-import { Color, Vector2, Vector3, Vector4, Matrix3, Matrix4 } from '../../../../src/Three.js';
-import Node from './Node.js';
+import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from "../../../../src/Three.js";
+import Node from "./Node.js";
 
 export interface NodeChild {
     property: string;

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

@@ -1,4 +1,4 @@
-import NodeVar from './NodeVar.js';
+import NodeVar from "./NodeVar.js";
 
 export default class NodeVarying extends NodeVar {
     needsInterpolation: false;

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

@@ -1,15 +1,32 @@
-import { NodeTypeOption } from './constants.js';
-import Node from './Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeTypeOption } from "./constants.js";
+import Node from "./Node.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/StackNode.d.ts

@@ -1,4 +1,4 @@
-import Node from './Node.js';
+import Node from "./Node.js";
 
 export default class StackNode extends Node {
     isStackNode: true;

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

@@ -1,6 +1,6 @@
-import { NodeTypeOption } from './constants.js';
-import Node from './Node.js';
-import NodeBuilder from './NodeBuilder.js';
+import { NodeTypeOption } from "./constants.js";
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
 
 export default class TempNode extends Node {
     isTempNode: true;

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

@@ -1,8 +1,8 @@
-import { NodeTypeOption } from './constants.js';
-import InputNode from './InputNode.js';
-import NodeBuilder from './NodeBuilder.js';
-import Node from './Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeTypeOption } from "./constants.js";
+import InputNode from "./InputNode.js";
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
 
 export default class UniformNode<Value> extends InputNode<Value> {
     readonly isUniformNode: true;

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

@@ -1,6 +1,6 @@
-import { OperatorNodeOp } from '../math/OperatorNode.js';
-import Node from './Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { OperatorNodeOp } from "../math/OperatorNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.js";
 
 export default class VarNode extends Node {
     node: Node;
@@ -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

@@ -1,5 +1,5 @@
-import Node from './Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.js";
 
 export default class VaryingNode extends Node {
     node: Node;
@@ -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,60 +1,70 @@
-// 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'
-    | 'float'
-    | 'vec2'
-    | 'vec3'
-    | 'vec4'
-    | 'mat3'
-    | 'mat4'
-    | 'code' /* CodeNode */
-    | 'color' /* NodeUtis.getValueType */
-    | 'uint'
-    | 'int' /* NodeBuilder.getComponentType */
-    | 'void'
-    | 'property'
-    | 'sampler'
-    | 'texture'
-    | 'cubeTexture' /* NodeBuilder.isReference */
-    | 'ivec2'
-    | 'uvec2'
-    | 'bvec2' /* ShaderNodeBaseElements */
-    | 'ivec3'
-    | 'uvec3'
-    | 'bvec3'
-    | 'ivec4'
-    | 'uvec4'
-    | 'bvec4'
-    | 'imat3'
-    | 'umat3'
-    | 'bmat3'
-    | 'imat4'
-    | 'umat4'
-    | 'bmat4';
+    | "bool"
+    | "int"
+    | "float"
+    | "vec2"
+    | "vec3"
+    | "vec4"
+    | "mat2"
+    | "mat3"
+    | "mat4"
+    | "code" /* CodeNode */
+    | "color" /* NodeUtis.getValueType */
+    | "uint"
+    | "int" /* NodeBuilder.getComponentType */
+    | "void"
+    | "property"
+    | "sampler"
+    | "texture"
+    | "cubeTexture" /* NodeBuilder.isReference */
+    | "ivec2"
+    | "uvec2"
+    | "bvec2" /* ShaderNodeBaseElements */
+    | "ivec3"
+    | "uvec3"
+    | "bvec3"
+    | "ivec4"
+    | "uvec4"
+    | "bvec4"
+    | "imat3"
+    | "umat3"
+    | "bmat3"
+    | "imat4"
+    | "umat4"
+    | "bmat4";
 
-export type SwizzleCharacter = 'x' | 'y' | 'z' | 'w' | 'r' | 'g' | 'b' | 'a' | 's' | 't' | 'p' | 'q';
+export type SwizzleCharacter = "x" | "y" | "z" | "w" | "r" | "g" | "b" | "a" | "s" | "t" | "p" | "q";
 
 export type SwizzleOption = Exclude<
     | `${SwizzleCharacter}`
     | `${SwizzleCharacter}${SwizzleCharacter}`
     | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
     | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
-    'abs' | 'sqrt'
+    "abs" | "sqrt"
 >;
 
 /** Should be the same type as Object3D.userData */
@@ -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 TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.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;
+    }
+}