@types/three 0.143.2 → 0.146.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Mon, 29 Aug 2022 17:32:33 GMT
+ * Last updated: Mon, 07 Nov 2022 20:26:35 GMT
  * Dependencies: [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 

three/examples/jsm/animation/CCDIKSolver.d.ts

@@ -21,5 +21,6 @@ export class CCDIKSolver {
 }
 
 export class CCDIKHelper extends Object3D {
-    constructor(mesh: SkinnedMesh, iks: IKS[]);
+    constructor(mesh: SkinnedMesh, iks?: IKS[], sphereSize?: number);
+    dispose(): void;
 }

three/examples/jsm/animation/MMDPhysics.d.ts

@@ -115,5 +115,10 @@ export class Constraint {
 }
 
 export class MMDPhysicsHelper extends Object3D {
-    constructor();
+    mesh: THREE.SkinnedMesh;
+    physics: MMDPhysics;
+    materials: [THREE.MeshBasicMaterial, THREE.MeshBasicMaterial, THREE.MeshBasicMaterial];
+
+    constructor(mesh: THREE.SkinnedMesh, physics: MMDPhysics);
+    dispose(): void;
 }

three/examples/jsm/controls/FirstPersonControls.d.ts

@@ -22,7 +22,10 @@ export class FirstPersonControls {
     mouseDragOn: boolean;
 
     handleResize(): void;
-    lookAt(x: number | Vector3, y: number, z: number): this;
+
+    lookAt(x: Vector3): this;
+    lookAt(x: number, y: number, z: number): this;
+
     update(delta: number): this;
     dispose(): void;
 }

three/examples/jsm/csm/CSM.d.ts

@@ -58,4 +58,4 @@ export class CSM {
     dispose(): void;
 }
 
-import CSMFrustrum from './CSMFrustum.js';
+import CSMFrustrum from './CSMFrustum';

three/examples/jsm/csm/CSMHelper.d.ts

@@ -23,4 +23,5 @@ export class CSMHelper<TCSM extends CSM = CSM> extends Group {
     shadowLines: Box3Helper[];
     updateVisibility(): void;
     update(): void;
+    dispose(): void;
 }

three/examples/jsm/environments/RoomEnvironment.d.ts

@@ -2,4 +2,5 @@ import { Scene } from '../../../src/Three';
 
 export class RoomEnvironment extends Scene {
     constructor();
+    dispose(): void;
 }

three/examples/jsm/helpers/OctreeHelper.d.ts

@@ -11,4 +11,7 @@ export class OctreeHelper extends LineSegments {
      * @default 'OctreeHelper'
      */
     type: 'OctreeHelper' | string;
+
+    update(): void;
+    dispose(): void;
 }

three/examples/jsm/helpers/VertexNormalsHelper.d.ts

@@ -7,4 +7,6 @@ export class VertexNormalsHelper extends LineSegments {
     size: number;
 
     update(): void;
+
+    dispose(): void;
 }

three/examples/jsm/helpers/VertexTangentsHelper.d.ts

@@ -7,4 +7,6 @@ export class VertexTangentsHelper extends LineSegments {
     size: number;
 
     update(): void;
+
+    dispose(): void;
 }

three/examples/jsm/interactive/SelectionHelper.d.ts

@@ -1,9 +1,7 @@
 import { WebGLRenderer, Vector2 } from '../../../src/Three';
 
-import { SelectionBox } from './SelectionBox';
-
 export class SelectionHelper {
-    constructor(selectionBox: SelectionBox, renderer: WebGLRenderer, cssClassName: string);
+    constructor(renderer: WebGLRenderer, cssClassName: string);
     element: HTMLElement;
     isDown: boolean;
     pointBottomRight: Vector2;

three/examples/jsm/libs/stats.module.d.ts

@@ -4,7 +4,7 @@ interface Stats {
     addPanel(panel: Stats.Panel): Stats.Panel;
     showPanel(id: number): void;
     begin(): void;
-    end(): void;
+    end(): number;
     update(): void;
     domElement: HTMLDivElement;
     setMode(id: number): void;

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

@@ -11,5 +11,5 @@ export class PCDLoader extends Loader {
         onError?: (event: ErrorEvent) => void,
     ): void;
     loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points>;
-    parse(data: ArrayBuffer | string, url: string): Points;
+    parse(data: ArrayBuffer | string): Points;
 }

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

@@ -7,7 +7,6 @@ export interface RGBE {
     header: string;
     gamma: number;
     exposure: number;
-    format: PixelFormat;
     type: TextureDataType;
 }
 

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

@@ -0,0 +1,16 @@
+import { DataTextureLoader, TextureFilter, LoadingManager } from 'three';
+
+export interface TIFFResult {
+    width: number;
+    height: number;
+    data: Uint8Array;
+    flipY: true;
+    magFilter: TextureFilter;
+    minFilter: TextureFilter;
+}
+
+export class TIFFLoader extends DataTextureLoader {
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: Iterable<number>): TIFFResult;
+}

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

@@ -0,0 +1,18 @@
+import { Loader, LoadingManager, Mesh } from '../../../src/Three';
+
+export class USDAParser {
+    parse(text: string): object;
+}
+
+export class USDZLoader extends Loader {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad: (usdz: Mesh) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+
+    parse(buffer: ArrayBuffer | string): THREE.Group;
+}

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

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

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

@@ -16,6 +16,4 @@ export interface CMYK {
 export namespace ColorConverter {
     function setHSV(color: Color, h: number, s: number, v: number): Color;
     function getHSV(color: Color, target: HSL): HSL;
-    function setCMYK(color: Color, c: number, m: number, y: number, k: number): Color;
-    function getCMYK(color: Color, target: CMYK): CMYK;
 }

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

@@ -49,4 +49,5 @@ export class GPUComputationRenderer {
     createTexture(): DataTexture;
     renderTexture(input: Texture, output: Texture): void;
     doRenderTarget(material: Material, output: WebGLRenderTarget): void;
+    dispose(): void;
 }

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

@@ -5,7 +5,6 @@ import {
     MeshBasicMaterial,
     MeshPhongMaterial,
     Object3D,
-    PlaneBufferGeometry,
     PlaneGeometry,
     Texture,
     Vector3,
@@ -43,7 +42,7 @@ export class ProgressiveLightMap {
 
     uv_boxes: UVBoxes[];
 
-    blurringPlane: Mesh<PlaneBufferGeometry, MeshBasicMaterial>;
+    blurringPlane: Mesh<PlaneGeometry, MeshBasicMaterial>;
 
     labelMaterial: MeshBasicMaterial;
     labelPlane: PlaneGeometry;

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

@@ -1,6 +1,6 @@
 import { Matrix3 } from '../../../src/Three';
 
-import { VolumeSlice } from './VolumeSlice.js';
+import { VolumeSlice } from './VolumeSlice';
 
 export class Volume {
     constructor(xLength?: number, yLength?: number, zLength?: number, type?: string, arrayBuffer?: ArrayLike<number>);

three/examples/jsm/modifiers/CurveModifier.d.ts

@@ -1,7 +1,7 @@
 import {
     DataTexture,
     Curve,
-    Uniform,
+    IUniform,
     Material,
     InstancedMesh,
     BufferGeometry,
@@ -10,11 +10,11 @@ import {
 } from '../../../src/Three';
 
 export interface SplineUniform {
-    spineTexture: Uniform;
-    pathOffset: Uniform;
-    pathSegment: Uniform;
-    spineOffset: Uniform;
-    flow: Uniform;
+    spineTexture: IUniform;
+    pathOffset: IUniform;
+    pathSegment: IUniform;
+    spineOffset: IUniform;
+    flow: IUniform;
 }
 export function initSplineTexture(size?: number): DataTexture;
 

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

@@ -7,7 +7,7 @@ import ConstNode from './core/ConstNode';
 import ContextNode from './core/ContextNode';
 import ExpressionNode from './core/ExpressionNode';
 import FunctionCallNode from './core/FunctionCallNode';
-import FunctionNode from './core/FunctionNode';
+import FunctionNode, { FunctionNodeArguments } from './core/FunctionNode';
 import InstanceIndexNode from './core/InstanceIndexNode';
 import Node from './core/Node';
 import NodeAttribute from './core/NodeAttribute';
@@ -18,7 +18,7 @@ import NodeFunctionInput from './core/NodeFunctionInput';
 import NodeKeywords from './core/NodeKeywords';
 import NodeUniform from './core/NodeUniform';
 import NodeVar from './core/NodeVar';
-import NodeVary from './core/NodeVary';
+import NodeVarying from './core/NodeVarying';
 import PropertyNode from './core/PropertyNode';
 import TempNode from './core/TempNode';
 import UniformNode from './core/UniformNode';
@@ -26,6 +26,7 @@ import VarNode from './core/VarNode';
 import VaryNode from './core/VaryNode';
 
 // accessors
+import BitangentNode, { BitangentNodeScope } from './accessors/BitangentNode';
 import BufferNode from './accessors/BufferNode';
 import CameraNode, { CameraNodeScope } from './accessors/CameraNode';
 import CubeTextureNode from './accessors/CubeTextureNode';
@@ -41,6 +42,7 @@ import PositionNode, { PositionNodeScope } from './accessors/PositionNode';
 import ReferenceNode from './accessors/ReferenceNode';
 import ReflectVectorNode from './accessors/ReflectVectorNode';
 import SkinningNode from './accessors/SkinningNode';
+import TangentNode, { TangentNodeScope } from './accessors/TangentNode';
 import TextureNode from './accessors/TextureNode';
 import UVNode from './accessors/UVNode';
 import UserDataNode from './accessors/UserDataNode';
@@ -52,10 +54,12 @@ import RangeNode, { RangeModeBound } from './geometry/RangeNode';
 import ComputeNode from './gpgpu/ComputeNode';
 
 // display
+import BlendModeNode, { BlendMode } from './display/BlendModeNode';
 import ColorAdjustmentNode, { ColorAdjustmentMethod } from './display/ColorAdjustmentNode';
 import ColorSpaceNode, { ColorSpaceNodeMethod } from './display/ColorSpaceNode';
 import FrontFacingNode from './display/FrontFacingNode';
 import NormalMapNode from './display/NormalMapNode';
+import PosterizeNode from './display/PosterizeNode';
 import ToneMappingNode from './display/ToneMappingNode';
 
 // math
@@ -77,14 +81,17 @@ import AnalyticLightNode from './lighting/AnalyticLightNode';
 
 import ArrayElementNode from './utils/ArrayElementNode';
 import ConvertNode from './utils/ConvertNode';
+import EquirectUVNode from './utils/EquirectUVNode';
 import JoinNode from './utils/JoinNode';
 import MatcapUVNode from './utils/MatcapUVNode';
 import MaxMipLevelNode from './utils/MaxMipLevelNode';
 import OscNode, { OscNodeMethod } from './utils/OscNode';
+import RemapNode from './utils/RemapNode';
 import RotateUVNode from './utils/RotateUVNode';
 import SplitNode from './utils/SplitNode';
 import SpriteSheetUVNode from './utils/SpriteSheetUVNode';
 import TimerNode, { TimerNodeScope } from './utils/TimerNode';
+import TriplanarTexturesNode from './utils/TriplanarTexturesNode';
 
 // loaders
 import NodeLoader from './loaders/NodeLoader';
@@ -118,6 +125,7 @@ export {
     ExpressionNode,
     FunctionCallNode,
     FunctionNode,
+    FunctionNodeArguments,
     InstanceIndexNode,
     Node,
     NodeAttribute,
@@ -128,7 +136,7 @@ export {
     NodeKeywords,
     NodeUniform,
     NodeVar,
-    NodeVary,
+    NodeVarying,
     PropertyNode,
     TempNode,
     UniformNode,
@@ -140,6 +148,8 @@ export {
     // gpgpu
     ComputeNode,
     // accessors
+    BitangentNode,
+    BitangentNodeScope,
     BufferNode,
     CameraNode,
     CameraNodeScope,
@@ -160,16 +170,21 @@ export {
     ReferenceNode,
     ReflectVectorNode,
     SkinningNode,
+    TangentNode,
+    TangentNodeScope,
     TextureNode,
     UVNode,
     UserDataNode,
     // display
+    BlendModeNode,
+    BlendMode,
     ColorAdjustmentNode,
     ColorAdjustmentMethod,
     ColorSpaceNode,
     ColorSpaceNodeMethod,
     FrontFacingNode,
     NormalMapNode,
+    PosterizeNode,
     ToneMappingNode,
     // math
     MathNode,
@@ -193,16 +208,19 @@ export {
     // utils
     ArrayElementNode,
     ConvertNode,
+    EquirectUVNode,
     JoinNode,
     MatcapUVNode,
     MaxMipLevelNode,
     OscNode,
     OscNodeMethod,
+    RemapNode,
     RotateUVNode,
     SplitNode,
     SpriteSheetUVNode,
     TimerNode,
     TimerNodeScope,
+    TriplanarTexturesNode,
     // procedural
     CheckerNode,
     // fog

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

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

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

@@ -1,15 +1,10 @@
 import Node from '../core/Node';
 
-export type NormalNodeScope =
-    | typeof NormalNode.GEOMETRY
-    | typeof NormalNode.LOCAL
-    | typeof NormalNode.WORLD
-    | typeof NormalNode.VIEW;
+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 WORLD: 'world';
     static VIEW: 'view';
     scope: NormalNodeScope;
 

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

@@ -4,6 +4,7 @@ export type PositionNodeScope =
     | typeof PositionNode.GEOMETRY
     | typeof PositionNode.LOCAL
     | typeof PositionNode.WORLD
+    | typeof PositionNode.WORLD_DIRECTION
     | typeof PositionNode.VIEW
     | typeof PositionNode.VIEW_DIRECTION;
 
@@ -11,6 +12,7 @@ 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;

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

@@ -0,0 +1,18 @@
+import Node from '../core/Node.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);
+}

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

@@ -3,13 +3,13 @@ import Node from './Node';
 import NodeBuilder from './NodeBuilder';
 
 export interface CodeNodeInclude {
-    build(): void;
+    build(builder: NodeBuilder): void;
 }
 
 export default class CodeNode extends Node {
     isCodeNode: true;
     code: string;
-    constructor(code: string, nodeType?: NodeTypeOption);
+    constructor(code?: string, includes?: CodeNodeInclude[]);
 
     setIncludes(includes: CodeNodeInclude[]): this;
     getIncludes(builder: NodeBuilder): CodeNodeInclude[];

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

@@ -2,12 +2,12 @@ import FunctionNode from './FunctionNode';
 import TempNode from './TempNode';
 import Node from './Node';
 
-export default class FunctionCallNode extends TempNode {
-    functionNode: FunctionNode;
+export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
+    functionNode: FunctionNode<P>;
     parameters: { [name: string]: Node };
 
-    constructor(functionNode?: FunctionNode, parameters?: { [name: string]: Node });
+    constructor(functionNode?: FunctionNode<P>, parameters?: P);
 
-    setParameters(parameters: { [name: string]: Node }): this;
-    getParameters(): { [name: string]: Node };
+    setParameters(parameters: P): this;
+    getParameters(): P;
 }

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

@@ -1,15 +1,17 @@
-import CodeNode from './CodeNode';
+import CodeNode, { CodeNodeInclude } from './CodeNode';
 import FunctionCallNode from './FunctionCallNode';
 import NodeBuilder from './NodeBuilder';
 import NodeFunction from './NodeFunction';
 import NodeFunctionInput from './NodeFunctionInput';
 import Node from './Node';
 
-export default class FunctionNode extends CodeNode {
+export type FunctionNodeArguments = Node[] | { [name: string]: Node };
+
+export default class FunctionNode<P extends Node[] | { [name: string]: Node }> extends CodeNode {
     keywords: { [key: string]: Node };
-    constructor(code?: string);
+    constructor(code?: string, includes?: CodeNodeInclude[]);
 
     getInputs(builder: NodeBuilder): NodeFunctionInput[];
     getNodeFunction(builder: NodeBuilder): NodeFunction;
-    call(parameters: { [name: string]: Node }): FunctionCallNode;
+    call(parameters: P): FunctionCallNode<P>;
 }

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

@@ -27,4 +27,5 @@ export default abstract class Node {
     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

@@ -17,7 +17,7 @@ import NodeAttribute from './NodeAttribute';
 import NodeParser from './NodeParser';
 import NodeUniform from './NodeUniform';
 import NodeVar from './NodeVar';
-import NodeVary from './NodeVary';
+import NodeVarying from './NodeVarying';
 
 export type BuildStageOption = 'construct' | 'analyze' | 'generate';
 
@@ -82,7 +82,7 @@ export default abstract class NodeBuilder {
     abstract getCubeTextureLevel(textureProperty: string, uvSnippet: string, levelSnippet: string): string;
 
     // @TODO: rename to .generateConst()
-    getConst(type: NodeTypeOption, value: unknown): Node;
+    getConst(type: NodeTypeOption, value?: unknown): Node;
     getType(type: NodeTypeOption): NodeTypeOption;
 
     generateMethod(method: string): string;
@@ -105,7 +105,7 @@ export default abstract class NodeBuilder {
     getNodeProperties(node: Node, shaderStage?: NodeShaderStageOption): AnyObject;
     getUniformFromNode(node: Node, shaderStage: NodeShaderStageOption, type: NodeTypeOption): NodeUniform;
     getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
-    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVary;
+    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
     getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): string;
     addFlowCode(code: string): void;
     getFlowData(node: Node, shaderStage: NodeShaderStageOption): FlowData;
@@ -117,6 +117,7 @@ export default abstract class NodeBuilder {
         output?: string | null,
         propertyName?: string,
     ): FlowData;
+    hasGeometryAttribute(name: string): boolean;
     abstract getAttributes(shaderStage: NodeShaderStageOption): string;
     abstract getVarys(shaderStage: NodeShaderStageOption): string;
     getVars(shaderStage: NodeShaderStageOption): string;

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

@@ -4,3 +4,4 @@ import Node from './Node';
 export function getNodesKeys(object: Node): string[];
 export function getValueType(value: NodeValueOption): string | null;
 export function getValueFromType(type: string, ...params: number[]): NodeValueOption | null;
+export function getCacheKey(object: Node): string;

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

@@ -0,0 +1,8 @@
+import NodeVar from './NodeVar';
+
+export default class NodeVarying extends NodeVar {
+    needsInterpolation: false;
+    isNodeVarying: true;
+
+    constructor(name: string, type: string);
+}

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

@@ -2,14 +2,14 @@ import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '../../../../
 
 // disable automatic export, we have some private declarations
 export const NodeShaderStage: {
-    Vertex: 'vertex';
-    Fragment: 'fragment';
+    VERTEX: 'vertex';
+    FRAGMENT: 'fragment';
 };
 
 export const NodeUpdateType: {
-    None: 'none';
-    Frame: 'frame';
-    Object: 'object';
+    NONE: 'none';
+    FRAME: 'frame';
+    OBJECT: 'object';
 };
 
 export type NodeValueOption = Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number;
@@ -66,12 +66,12 @@ export interface AnyObject {
 export type AnyJson = any;
 
 export const NodeType: {
-    Boolean: 'bool';
-    Integer: 'int';
-    Float: 'float';
-    Vector2: 'vec2';
-    Vector3: 'vec3';
-    Vector4: 'vec4';
-    Matrix3: 'mat3';
-    Matrix4: 'mat4';
+    BOOLEAN: 'bool';
+    INTEGER: 'int';
+    FLOAT: 'float';
+    VECTOR2: 'vec2';
+    VECTOR3: 'vec3';
+    VECTOR4: 'vec4';
+    MATRIX3: 'mat3';
+    MATRIX4: 'mat4';
 };

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

@@ -0,0 +1,32 @@
+import TempNode from '../core/TempNode';
+import { ShaderNode } from '../shadernode/ShaderNodeBaseElements';
+import { Node } from '../Nodes';
+
+export const BurnNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const DodgeNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const ScreenNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const OverlayNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export type BlendMode =
+    | typeof BlendModeNode.BURN
+    | typeof BlendModeNode.DODGE
+    | typeof BlendModeNode.SCREEN
+    | typeof BlendModeNode.OVERLAY;
+
+export default class BlendModeNode extends TempNode {
+    static BURN: 'burn';
+    static DODGE: 'dodge';
+    static SCREEN: 'screen';
+    static OVERLAY: 'overlay';
+
+    baseNode: Node;
+    blendMode: BlendMode;
+    blendNode: Node;
+
+    constructor(blendMode: BlendMode, baseNode: Node, blendNode: Node);
+
+    construct(): Node;
+}

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

@@ -0,0 +1,8 @@
+import Node from '../core/Node';
+
+export default class PosterizeNode extends Node {
+    sourceNode: Node;
+    stepsNode: Node;
+
+    constructor(sourceNode: Node, stepsNode: Node);
+}