@types/three 0.160.0 → 0.161.1

three/examples/jsm/nodes/gpgpu/ComputeNode.d.ts

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class ComputeNode extends Node {
     isComputeNode: true;
@@ -16,3 +16,9 @@ export const compute: (
     count: number,
     workgroupSize: number[],
 ) => ShaderNodeObject<ComputeNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        compute: typeof compute;
+    }
+}

three/examples/jsm/nodes/lighting/AONode.d.ts

@@ -1,5 +1,5 @@
-import LightingNode from './LightingNode.js';
-import Node from '../core/Node.js';
+import Node from "../core/Node.js";
+import LightingNode from "./LightingNode.js";
 
 export default class AONode extends LightingNode {
     aoNode: Node | null;

three/examples/jsm/nodes/lighting/AnalyticLightNode.d.ts

@@ -1,6 +1,6 @@
-import LightingNode from './LightingNode.js';
-import { Light } from '../../../../src/Three.js';
-import Node from '../core/Node.js';
+import { Light } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import LightingNode from "./LightingNode.js";
 
 export default class AnalyticLightNode<T extends Light> extends LightingNode {
     light: T | null;

three/examples/jsm/nodes/lighting/EnvironmentNode.d.ts

@@ -1,5 +1,5 @@
-import LightingNode from './LightingNode.js';
-import Node from '../core/Node.js';
+import Node from "../core/Node.js";
+import LightingNode from "./LightingNode.js";
 
 export default class EnvironmentNode extends LightingNode {
     envNode: Node | null;

three/examples/jsm/nodes/lighting/HemisphereLightNode.d.ts

@@ -1,7 +1,7 @@
-import AnalyticLightNode from './AnalyticLightNode.js';
-import Object3DNode from '../accessors/Object3DNode.js';
-import { HemisphereLight } from '../../../../src/Three.js';
-import Node from '../core/Node.js';
+import { HemisphereLight } from "../../../../src/Three.js";
+import Object3DNode from "../accessors/Object3DNode.js";
+import Node from "../core/Node.js";
+import AnalyticLightNode from "./AnalyticLightNode.js";
 
 export default class HemisphereLightNode extends AnalyticLightNode<HemisphereLight> {
     lightPositionNode: Object3DNode;

three/examples/jsm/nodes/lighting/LightUtils.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../shadernode/ShaderNode.js';
-import Node from '../core/Node.js';
+import Node from "../core/Node.js";
+import { ShaderNode } from "../shadernode/ShaderNode.js";
 
 export const getDistanceAttenuation: ShaderNode<{ lightDistance: Node; cutoffDistance: Node; decayExponent: Node }>;

three/examples/jsm/nodes/lighting/LightingContextNode.d.ts

@@ -1,20 +1,27 @@
-import ContextNode from '../core/ContextNode.js';
-import Node from '../core/Node.js';
-import { ShaderNode, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export interface LightingModelNode {
-    indirectDiffuse?: ShaderNode;
-    indirectSpecular?: ShaderNode;
-    ambientOcclusion?: ShaderNode;
-}
+import ContextNode from "../core/ContextNode.js";
+import LightingModel, { LightingModelIndirectInput } from "../core/LightingModel.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class LightingContextNode extends ContextNode {
-    lightingModelNode: LightingModelNode | null;
+    lightingModelNode: LightingModel | null;
+    backdropNode: Node | null;
+    backdropAlphaNode: Node | null;
+
+    constructor(
+        node: Node,
+        lightingModel?: LightingModel | null,
+        backdropNode?: Node | null,
+        backdropAlphaNode?: Node | null,
+    );
 
-    constructor(node: Node, lightingModelNode?: LightingModelNode | null);
+    getContext(): LightingModelIndirectInput;
 }
 
-export const lightingContext: (
-    node: Node,
-    lightingModelNode?: LightingModelNode,
-) => ShaderNodeObject<LightingContextNode>;
+export const lightingContext: (node: Node, lightingModelNode?: LightingModel) => ShaderNodeObject<LightingContextNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        lightingContext: typeof lightingContext;
+    }
+}

three/examples/jsm/nodes/lighting/LightingNode.d.ts

@@ -1,4 +1,4 @@
-import Node from '../core/Node.js';
+import Node from "../core/Node.js";
 
 export default abstract class LightingNode extends Node {
     constructor();

three/examples/jsm/nodes/lighting/LightsNode.d.ts

@@ -1,7 +1,7 @@
-import { Light } from '../../../../src/Three.js';
-import Node from '../core/Node.js';
-import LightingNode from './LightingNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { Light } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import LightingNode from "./LightingNode.js";
 
 export default class LightsNode extends Node {
     lightNodes: LightingNode[];
@@ -14,8 +14,8 @@ export default class LightsNode extends Node {
     fromLights(lights: Light[]): this;
 
     static setReference<T extends Light>(
-        lightClass: { new (): T },
-        lightNodeClass: { new (light: T): LightingNode },
+        lightClass: { new(): T },
+        lightNodeClass: { new(light: T): LightingNode },
     ): void;
 }
 

three/examples/jsm/nodes/lighting/PointLightNode.d.ts

@@ -1,6 +1,6 @@
-import AnalyticLightNode from './AnalyticLightNode.js';
-import Node from '../core/Node.js';
-import { PointLight } from '../../../../src/Three.js';
+import { PointLight } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import AnalyticLightNode from "./AnalyticLightNode.js";
 
 export default class PointLightNode extends AnalyticLightNode<PointLight> {
     cutoffDistanceNode: Node;

three/examples/jsm/nodes/lighting/SpotLightNode.d.ts

@@ -1,6 +1,6 @@
-import AnalyticLightNode from './AnalyticLightNode.js';
-import Node from '../core/Node.js';
-import { SpotLight } from '../../../../src/Three.js';
+import { SpotLight } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import AnalyticLightNode from "./AnalyticLightNode.js";
 
 export default class PointLightNode extends AnalyticLightNode<SpotLight> {
     directionNode: Node;

three/examples/jsm/nodes/loaders/NodeLoader.d.ts

@@ -1,5 +1,5 @@
-import { Loader, LoadingManager, Texture } from '../../../../src/Three.js';
-import { Node, AnyJson } from '../Nodes.js';
+import { Loader, LoadingManager, Texture } from "../../../../src/Three.js";
+import { AnyJson, Node } from "../Nodes.js";
 
 export interface NodeLoaderResult {
     [hash: string]: Node;

three/examples/jsm/nodes/loaders/NodeMaterialLoader.d.ts

@@ -1,5 +1,5 @@
-import { MaterialLoader } from '../../../../src/Three.js';
-import { NodeLoaderResult } from './NodeLoader.js';
+import { MaterialLoader } from "../../../../src/Three.js";
+import { NodeLoaderResult } from "./NodeLoader.js";
 
 export default class NodeMaterialLoader extends MaterialLoader {
     nodes: NodeLoaderResult;

three/examples/jsm/nodes/loaders/NodeObjectLoader.d.ts

@@ -1,6 +1,6 @@
-import { NodeLoaderResult } from './NodeLoader.js';
-import { Material, ObjectLoader, Texture } from '../../../../src/Three.js';
-import { AnyJson } from '../core/constants.js';
+import { Material, ObjectLoader, Texture } from "../../../../src/Three.js";
+import { AnyJson } from "../core/constants.js";
+import { NodeLoaderResult } from "./NodeLoader.js";
 
 export default class NodeObjectLoader extends ObjectLoader {
     parseNodes(json: AnyJson, textures: { [key: string]: Texture }): NodeLoaderResult;

three/examples/jsm/nodes/materials/LineBasicNodeMaterial.d.ts

@@ -1,9 +1,8 @@
-import NodeMaterial from './NodeMaterial.js';
-import { ShaderMaterialParameters } from '../../../../src/Three.js';
+import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import NodeMaterial from "./NodeMaterial.js";
 
 export default class LineBasicNodeMaterial extends NodeMaterial {
-    isLineBasicNodeMaterial: true;
+    readonly isLineBasicNodeMaterial: true;
 
     constructor(parameters?: ShaderMaterialParameters);
-    copy(source: LineBasicNodeMaterial): this;
 }

three/examples/jsm/nodes/materials/Materials.d.ts

@@ -1,17 +1,9 @@
-import NodeMaterial from './NodeMaterial.js';
-import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
-import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
-import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
-import PointsNodeMaterial from './PointsNodeMaterial.js';
-import SpriteNodeMaterial from './SpriteNodeMaterial.js';
-import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
-
-export {
-    NodeMaterial,
-    LineBasicNodeMaterial,
-    MeshBasicNodeMaterial,
-    MeshPhysicalNodeMaterial,
-    MeshStandardNodeMaterial,
-    PointsNodeMaterial,
-    SpriteNodeMaterial,
-};
+export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
+export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.js";
+export { default as MeshPhongNodeMaterial } from "./MeshPhongNodeMaterial.js";
+export { default as MeshPhysicalNodeMaterial } from "./MeshPhysicalNodeMaterial.js";
+export { default as MeshSSSPhysicalNodeMaterial } from "./MeshSSSNodeMaterial.js";
+export { default as MeshStandardNodeMaterial } from "./MeshStandardNodeMaterial.js";
+export { default as NodeMaterial } from "./NodeMaterial.js";
+export { default as PointsNodeMaterial } from "./PointsNodeMaterial.js";
+export { default as SpriteNodeMaterial } from "./SpriteNodeMaterial.js";

three/examples/jsm/nodes/materials/MeshBasicNodeMaterial.d.ts

@@ -1,10 +1,8 @@
-import NodeMaterial from './NodeMaterial.js';
-import { ShaderMaterialParameters } from '../../../../src/Three.js';
+import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import NodeMaterial from "./NodeMaterial.js";
 
 export default class MeshBasicNodeMaterial extends NodeMaterial {
-    isMeshBasicNodeMaterial: true;
-    lights: true;
+    readonly isMeshBasicNodeMaterial: true;
 
-    constructor(paramters?: ShaderMaterialParameters);
-    copy(source: MeshBasicNodeMaterial): this;
+    constructor(parameters?: ShaderMaterialParameters);
 }

three/examples/jsm/nodes/materials/MeshPhongNodeMaterial.d.ts

@@ -0,0 +1,12 @@
+import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import NodeMaterial from "./NodeMaterial.js";
+
+export default class MeshPhongNodeMaterial extends NodeMaterial {
+    readonly isMeshPhongNodeMaterial: true;
+
+    shininessNode: Node | null;
+    specularNode: Node | null;
+
+    constructor(parameters?: ShaderMaterialParameters);
+}

three/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -1,9 +1,7 @@
-import { ShaderMaterialParameters } from '../../../../src/Three.js';
+import { ShaderMaterialParameters } from "../../../../src/Three.js";
 
-import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
-import Node from '../core/Node.js';
-import CheckerNode from '../procedural/CheckerNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
 
 export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     readonly isMeshPhysicalNodeMaterial: true;
@@ -15,9 +13,9 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     sheenNode: Node | null;
     sheenRoughnessNode: Node | null;
 
-    iridescenceNode: null | ShaderNodeObject<CheckerNode>;
-    iridescenceIORNode: null | ShaderNodeObject<Node>;
-    iridescenceThicknessNode: null | ShaderNodeObject<Node>;
+    iridescenceNode: Node | null;
+    iridescenceIORNode: Node | null;
+    iridescenceThicknessNode: Node | null;
 
     iorNode?: Node | null;
 
@@ -30,6 +28,4 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     attenuationColorNode: Node | null;
 
     constructor(parameters?: ShaderMaterialParameters);
-
-    copy(source: MeshPhysicalNodeMaterial): this;
 }

three/examples/jsm/nodes/materials/MeshSSSNodeMaterial.d.ts

@@ -0,0 +1,17 @@
+import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import ConstNode from "../core/ConstNode.js";
+import Node from "../core/Node.js";
+import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
+
+export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
+    thicknessColorNode: Node | null;
+    thicknessDistortionNode: ConstNode<number>;
+    thicknessAmbientNode: ConstNode<number>;
+    thicknessAttenuationNode: ConstNode<number>;
+    thicknessPowerNode: ConstNode<number>;
+    thicknessScaleNode: ConstNode<number>;
+
+    constructor(parameters?: ShaderMaterialParameters);
+
+    get useSSS(): boolean;
+}

three/examples/jsm/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -1,9 +1,9 @@
-import { ShaderMaterialParameters } from '../../../../src/Three.js';
-import Node from '../core/Node.js';
-import NodeMaterial from './NodeMaterial.js';
+import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import NodeMaterial from "./NodeMaterial.js";
 
 export default class MeshStandardNodeMaterial extends NodeMaterial {
-    isMeshStandardNodeMaterial: true;
+    readonly isMeshStandardNodeMaterial: true;
 
     emissiveNode: Node | null;
 
@@ -11,5 +11,4 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
     roughnessNode: Node | null;
 
     constructor(paramters?: ShaderMaterialParameters);
-    copy(source: MeshStandardNodeMaterial): this;
 }

three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -2,31 +2,33 @@ import {
     LineBasicMaterial,
     Material,
     MeshBasicMaterial,
+    MeshPhongMaterial,
     MeshPhysicalMaterial,
     MeshStandardMaterial,
     PointsMaterial,
     ShaderMaterial,
     SpriteMaterial,
-} from '../../../../src/Three.js';
-import NodeBuilder from '../core/NodeBuilder.js';
-import Node from '../core/Node.js';
-import { LightingModelNode } from '../lighting/LightingContextNode.js';
-import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
-import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
-import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
-import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
-import PointsNodeMaterial from './PointsNodeMaterial.js';
-import SpriteNodeMaterial from './SpriteNodeMaterial.js';
+} from "../../../../src/Three.js";
+import LightingModel from "../core/LightingModel.js";
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import LightsNode from "../lighting/LightsNode.js";
+import LineBasicNodeMaterial from "./LineBasicNodeMaterial.js";
+import MeshBasicNodeMaterial from "./MeshBasicNodeMaterial.js";
+import MeshPhongNodeMaterial from "./MeshPhongNodeMaterial.js";
+import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
+import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
+import PointsNodeMaterial from "./PointsNodeMaterial.js";
+import SpriteNodeMaterial from "./SpriteNodeMaterial.js";
 
 export default class NodeMaterial extends ShaderMaterial {
-    isNodeMaterial: true;
+    readonly isNodeMaterial: true;
 
-    type: string;
+    normals: boolean;
 
-    lights: true;
-    normals: true;
+    colorSpaced: boolean;
 
-    lightsNode: Node | null;
+    lightsNode: LightsNode | null;
     envNode: Node | null;
 
     colorNode: Node | null;
@@ -38,20 +40,34 @@ export default class NodeMaterial extends ShaderMaterial {
 
     positionNode: Node | null;
 
+    depthNode: Node | null;
+    shadowNode: Node | null;
+
+    outputNode: Node | null;
+
+    fragmentNode: Node | null;
+    vertexNode: Node | null;
+
     constructor();
 
     build(builder: NodeBuilder): void;
-    customProgramCacheKey(): string;
-    generatePosition(builder: NodeBuilder): void;
-    generateDiffuseColor(builder: NodeBuilder): void;
-    generateLight(
-        builder: NodeBuilder,
-        lights: { diffuseColorNode: Node; lightingModelNode: LightingModelNode; lightsNode?: Node },
-    ): void;
-    generateOutput(builder: NodeBuilder, lights: { diffuseColorNode: Node; outgoingLightNode: Node }): void;
+    setup(builder: NodeBuilder): void;
+    setupDepth(builder: NodeBuilder): void;
+    setupPosition(builder: NodeBuilder): Node;
+    setupDiffuseColor(builder: NodeBuilder): void;
+    setupVariants(builder: NodeBuilder): void;
+    setupNormal(builder: NodeBuilder): void;
+    getEnvNode(builder: NodeBuilder): Node | null;
+    setupLights(builder: NodeBuilder): LightsNode;
+    setupLightingModel(builder: NodeBuilder): LightingModel;
+    setupLighting(builder: NodeBuilder): Node;
+    setupOutput(builder: NodeBuilder, outputNode: Node): Node;
+
+    setDefaultValues(material: Material): void;
 
     static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
     static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
     static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
     static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
     static fromMaterial(material: PointsMaterial): PointsNodeMaterial;

three/examples/jsm/nodes/materials/PointsNodeMaterial.d.ts

@@ -1,15 +1,9 @@
-import NodeMaterial from './NodeMaterial.js';
-import { ShaderMaterialParameters } from '../../../../src/Three.js';
-import { Node } from '../Nodes.js';
+import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import { Node } from "../Nodes.js";
+import NodeMaterial from "./NodeMaterial.js";
 
 export default class PointsNodeMaterial extends NodeMaterial {
-    isPointsNodeMateria: true;
-    colorNode: Node | null;
-    opacityNode: Node | null;
-    alphaTestNode: Node | null;
-    lightNode: Node | null;
-    sizeNode: Node | null;
-    positionNode: Node | null;
+    readonly isPointsNodeMaterial: true;
+
     constructor(parameters?: ShaderMaterialParameters);
-    copy(source: PointsNodeMaterial): this;
 }

three/examples/jsm/nodes/materials/SpriteNodeMaterial.d.ts

@@ -1,23 +1,13 @@
-import NodeMaterial from './NodeMaterial.js';
-import { ShaderMaterialParameters } from '../../../../src/Three.js';
-import { NodeBuilder } from '../Nodes.js';
-import Node from '../core/Node.js';
+import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import { NodeBuilder } from "../Nodes.js";
+import NodeMaterial from "./NodeMaterial.js";
 
 export default class SpriteNodeMaterial extends NodeMaterial {
     isSpriteNodeMaterial: true;
 
-    colorNode: Node | null;
-    opacityNode: Node | null;
-
-    alphaTestNode: Node | null;
-
-    lightNode: Node | null;
-
-    positionNode: Node | null;
     rotationNode: Node | null;
     scaleNode: Node | null;
 
     constructor(parameters?: ShaderMaterialParameters);
-    generatePosition(builder: NodeBuilder): void;
-    copy(source: SpriteNodeMaterial): this;
 }

three/examples/jsm/nodes/materialx/MaterialXNodes.d.ts

@@ -1,7 +1,7 @@
-import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv.js';
-import Node from '../core/Node.js';
-import MathNode from '../math/MathNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import MathNode from "../math/MathNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { mx_hsvtorgb, mx_rgbtohsv } from "./lib/mx_hsv.js";
 
 export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): ShaderNodeObject<MathNode>;
 

three/examples/jsm/nodes/materialx/lib/mx_hsv.d.ts

@@ -1,6 +1,6 @@
-import Node from '../../core/Node.js';
-import { Fn } from '../../code/FunctionNode.js';
-import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+import { Fn } from "../../code/FunctionNode.js";
+import Node from "../../core/Node.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
 export function mx_hsvtorgb(...params: Fn<[Node]>): ShaderNodeObject<Node>;
 export function mx_rgbtohsv(...params: Fn<[Node]>): ShaderNodeObject<Node>;

three/examples/jsm/nodes/materialx/lib/mx_noise.d.ts

@@ -1,6 +1,6 @@
-import Node from '../../core/Node.js';
-import { Fn } from '../../code/FunctionNode.js';
-import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+import { Fn } from "../../code/FunctionNode.js";
+import Node from "../../core/Node.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
 export function mx_perlin_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
 export function mx_cell_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;

three/examples/jsm/nodes/math/CondNode.d.ts

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class CondNode extends Node {
     condNode: Node;
@@ -14,3 +14,9 @@ export function cond(
     ifNode: NodeRepresentation,
     elseNode: NodeRepresentation,
 ): ShaderNodeObject<Node>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        cond: typeof cond;
+    }
+}

three/examples/jsm/nodes/math/HashNode.d.ts

@@ -0,0 +1,16 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class HashNode extends Node {
+    seedNode: Node;
+
+    constructor(seedNode: Node);
+}
+
+export const hash: (seedNode: NodeRepresentation) => ShaderNodeObject<HashNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        hash: typeof hash;
+    }
+}