@types/three 0.160.0 → 0.161.1

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

@@ -1,18 +1,29 @@
-import Object3DNode, { Object3DNodeScope } from './Object3DNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Object3DNode, { Object3DNodeScope } from "./Object3DNode.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';
+    constructor(scope?: string);
 
-    // @ts-expect-error
-    scope: CameraNodeScope;
-
-    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

@@ -1,12 +1,12 @@
-import { CubeTexture } from '../../../../src/Three.js';
-import TextureNode from './TextureNode.js';
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { CubeTexture } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TextureNode from "./TextureNode.js";
 
 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/InstanceNode.d.ts

@@ -1,6 +1,6 @@
-import { InstancedMesh } from '../../../../src/Three.js';
-import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { InstancedMesh } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class InstanceNode extends Node {
     instanceMesh: InstancedMesh;

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

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type MaterialNodeScope =
     | typeof MaterialNode.ALPHA_TEST
@@ -11,13 +11,13 @@ export type MaterialNodeScope =
     | typeof MaterialNode.ROTATION;
 
 export default class MaterialNode extends Node {
-    static ALPHA_TEST: 'alphaTest';
-    static COLOR: 'color';
-    static OPACITY: 'opacity';
-    static ROUGHNESS: 'roughness';
-    static METALNESS: 'metalness';
-    static EMISSIVE: 'emissive';
-    static ROTATION: 'rotation';
+    static ALPHA_TEST: "alphaTest";
+    static COLOR: "color";
+    static OPACITY: "opacity";
+    static ROUGHNESS: "roughness";
+    static METALNESS: "metalness";
+    static EMISSIVE: "emissive";
+    static ROTATION: "rotation";
 
     scope: MaterialNodeScope;
     constructor(scope?: MaterialNodeScope);

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

@@ -1,6 +1,6 @@
-import { Material } from '../../../../src/Three.js';
-import ReferenceNode from './ReferenceNode.js';
-import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { Material } from "../../../../src/Three.js";
+import { NodeOrType, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import ReferenceNode from "./ReferenceNode.js";
 
 export default class MaterialReferenceNode extends ReferenceNode<Material | null> {
     constructor(property: string, inputType: string, material?: Material | null);
@@ -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

@@ -1,5 +1,5 @@
-import Object3DNode, { Object3DNodeScope } from './Object3DNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Object3DNode, { Object3DNodeScope } from "./Object3DNode.js";
 
 /**
  * Similar to {@link Object3DNode} but the object comes from {@link NodeFrame}
@@ -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/ModelViewProjectionNode.d.ts

@@ -1,6 +1,6 @@
-import Node from '../core/Node.js';
-import PositionNode from './PositionNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+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);

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

@@ -1,13 +1,13 @@
-import Node from '../core/Node.js';
-import VarNode from '../core/VarNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import VarNode from "../core/VarNode.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';
+    static GEOMETRY: "geometry";
+    static LOCAL: "local";
+    static VIEW: "view";
     scope: NormalNodeScope;
 
     constructor(scope?: NormalNodeScope);

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

@@ -1,22 +1,26 @@
-import { Object3D } from '../../../../src/Three.js';
-import Node from '../core/Node.js';
+import { Object3D } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
 
 export type Object3DNodeScope =
     | typeof Object3DNode.VIEW_MATRIX
     | 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 {
-    static VIEW_MATRIX: 'viewMatrix';
-    static NORMAL_MATRIX: 'normalMatrix';
-    static WORLD_MATRIX: 'worldMatrix';
-    static POSITION: 'position';
-    static VIEW_POSITION: 'viewPosition';
-
-    scope: Object3DNodeScope;
+    scope: string;
     object3d: Object3D | null;
 
-    constructor(scope?: Object3DNodeScope, 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";
+    static DIRECTION: "direction";
 }

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

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class PointUVNode extends Node {
     isPointUVNode: true;

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

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type PositionNodeScope =
     | typeof PositionNode.GEOMETRY
@@ -10,12 +10,12 @@ export type PositionNodeScope =
     | 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';
+    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);

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

@@ -1,6 +1,6 @@
-import Node from '../core/Node.js';
-import { NodeTypeOption } from '../core/constants.js';
-import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { NodeTypeOption } from "../core/constants.js";
+import Node from "../core/Node.js";
+import { NodeOrType, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class ReferenceNode<T> extends Node {
     object: T;

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

@@ -1,10 +1,10 @@
-import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class ReflectVectorNode extends Node {
     constructor();
 
-    getHash(): 'reflectVector';
+    getHash(): "reflectVector";
     setup(): Node;
 }
 

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

@@ -1,6 +1,6 @@
-import { SkinnedMesh } from '../../../../src/Three.js';
-import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { SkinnedMesh } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class SkinningNode extends Node {
     skinIndexNode: Node;

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

@@ -1,6 +1,6 @@
-import BufferNode from './BufferNode.js';
-import { NodeTypeOption } from '../core/constants.js';
-import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { NodeTypeOption } from "../core/constants.js";
+import { NodeOrType, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import BufferNode from "./BufferNode.js";
 
 export default class StorageBufferNode extends BufferNode {
     constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);

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

@@ -1,6 +1,6 @@
-import Node from '../core/Node.js';
-import MathNode from '../math/MathNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import MathNode from "../math/MathNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type TangentNodeScope =
     | typeof TangentNode.LOCAL
@@ -9,10 +9,10 @@ export type TangentNodeScope =
     | typeof TangentNode.GEOMETRY;
 
 export default class TangentNode extends Node {
-    static GEOMETRY: 'geometry';
-    static LOCAL: 'local';
-    static VIEW: 'view';
-    static WORLD: 'world';
+    static GEOMETRY: "geometry";
+    static LOCAL: "local";
+    static VIEW: "view";
+    static WORLD: "world";
 
     scope: TangentNodeScope;
 

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

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

@@ -1,17 +1,19 @@
-import { Texture } from '../../../../src/Three.js';
-import UniformNode from '../core/UniformNode.js';
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { Texture } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 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/UVNode.d.ts

@@ -1,5 +1,5 @@
-import AttributeNode from '../core/AttributeNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import AttributeNode from "../core/AttributeNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class UVNode extends AttributeNode {
     isUVNode: true;

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

@@ -1,6 +1,6 @@
-import { NodeTypeOption, NodeUserData } from '../core/constants.js';
-import ReferenceNode from './ReferenceNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { NodeTypeOption, NodeUserData } from "../core/constants.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import ReferenceNode from "./ReferenceNode.js";
 
 export default class UserDataNode extends ReferenceNode<NodeUserData> {
     userData: NodeUserData | null;

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

@@ -0,0 +1,12 @@
+import AttributeNode from "../core/AttributeNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.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/CodeNode.d.ts

@@ -1,7 +1,7 @@
-import Node from '../core/Node.js';
-import NodeBuilder from '../core/NodeBuilder.js';
-import { NodeTypeOption } from '../core/constants.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { NodeTypeOption } from "../core/constants.js";
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export interface CodeNodeInclude {
     build(builder: NodeBuilder): void;

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

@@ -1,6 +1,6 @@
-import { NodeTypeOption } from '../core/constants.js';
-import TempNode from '../core/TempNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+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 */

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

@@ -1,7 +1,7 @@
-import FunctionNode, { FunctionNodeArguments } from './FunctionNode.js';
-import TempNode from '../core/TempNode.js';
-import Node from '../core/Node.js';
-import { ProxiedObject, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ProxiedObject, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import FunctionNode, { FunctionNodeArguments } from "./FunctionNode.js";
 
 export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
     functionNode: FunctionNode<P>;
@@ -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/code/FunctionNode.d.ts

@@ -1,10 +1,10 @@
-import CodeNode, { CodeNodeInclude } from './CodeNode.js';
-import FunctionCallNode from './FunctionCallNode.js';
-import NodeBuilder from '../core/NodeBuilder.js';
-import NodeFunction from '../core/NodeFunction.js';
-import NodeFunctionInput from '../core/NodeFunctionInput.js';
-import Node from '../core/Node.js';
-import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import NodeFunction from "../core/NodeFunction.js";
+import NodeFunctionInput from "../core/NodeFunctionInput.js";
+import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import CodeNode, { CodeNodeInclude } from "./CodeNode.js";
+import FunctionCallNode from "./FunctionCallNode.js";
 
 export type FunctionNodeArguments = Node[] | { [name: string]: Node };
 
@@ -17,8 +17,7 @@ export default class FunctionNode<P extends Node[] | { [name: string]: Node }> e
     call(parameters: P): FunctionCallNode<P>;
 }
 
-export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]]
-    ? ProxiedTuple<P>
+export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P>
     : readonly [ProxiedObject<P>];
 
 export const func: <P extends FunctionNodeArguments>(

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

@@ -1,5 +1,5 @@
-import UniformNode from './UniformNode.js';
-import Node from './Node.js';
+import Node from "./Node.js";
+import UniformNode from "./UniformNode.js";
 
 export default class ArrayUniformNode extends UniformNode<undefined> {
     isArrayUniformNode: true;

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

@@ -1,7 +1,7 @@
-import { NodeTypeOption } from './constants.js';
-import Node from './Node.js';
-import NodeBuilder from './NodeBuilder.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeTypeOption } from "./constants.js";
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
 
 export default class AttributeNode extends Node {
     constructor(attributeName: string, nodeType?: NodeTypeOption | null);

three/examples/jsm/nodes/core/BypassNode.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 BypassNode extends Node {
     isBypassNode: true;
@@ -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

@@ -1,6 +1,6 @@
-import Node from './Node.js';
-import NodeCache from './NodeCache.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.js";
+import NodeCache from "./NodeCache.js";
 
 export default class CacheNode extends Node {
     isCacheNode: true;
@@ -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/ConstNode.d.ts

@@ -1,6 +1,6 @@
-import { NodeTypeOption } from './constants.js';
-import InputNode from './InputNode.js';
-import NodeBuilder from './NodeBuilder.js';
+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;

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

@@ -1,6 +1,6 @@
-import Node from './Node.js';
-import { NodeBuilderContext } from './NodeBuilder.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.js";
+import { NodeBuilderContext } from "./NodeBuilder.js";
 
 export default class ContextNode extends Node {
     isContextNode: true;
@@ -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;
+    }
+}