@types/three 0.174.0 → 0.176.0

three/src/nodes/accessors/Object3DNode.d.ts

@@ -16,9 +16,9 @@ export default class Object3DNode extends Node {
     static RADIUS: "radius";
 }
 
-export const objectDirection: (object3d?: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectWorldMatrix: (object3d?: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectPosition: (object3d?: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectScale: (object3d?: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectViewPosition: (object3d?: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectRadius: (object3d?: Object3D | null) => ShaderNodeObject<Object3DNode>;
+export const objectDirection: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
+export const objectWorldMatrix: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
+export const objectPosition: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
+export const objectScale: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
+export const objectViewPosition: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
+export const objectRadius: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;

three/src/nodes/accessors/SkinningNode.d.ts

@@ -5,7 +5,6 @@ import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class SkinningNode extends Node {
     skinnedMesh: SkinnedMesh;
-    useReference: boolean;
 
     skinIndexNode: Node;
     skinWeightNode: Node;
@@ -13,9 +12,11 @@ export default class SkinningNode extends Node {
     bindMatrixNode: Node;
     bindMatrixInverseNode: Node;
     boneMatricesNode: Node;
+    positionNode: Node;
+    toPositionNode: Node;
     previousBoneMatricesNode: Node | null;
 
-    constructor(skinnedMesh: SkinnedMesh, useReference?: boolean);
+    constructor(skinnedMesh: SkinnedMesh);
 
     getSkinnedPosition(boneMatrices?: Node, position?: Node): ShaderNodeObject<Node>;
 
@@ -27,4 +28,4 @@ export default class SkinningNode extends Node {
 }
 
 export const skinning: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;
-export const skinningReference: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;
+export const computeSkinning: (skinnedMesh: SkinnedMesh, toPosition?: Node | null) => ShaderNodeObject<SkinningNode>;

three/src/nodes/accessors/StorageTextureNode.d.ts

@@ -31,12 +31,12 @@ export default class StorageTextureNode extends TextureNode {
 
 export const storageTexture: (
     value: Texture,
-    uvNode?: NodeRepresentation,
+    uvNode?: NodeRepresentation | null,
     storeNode?: NodeRepresentation,
 ) => ShaderNodeObject<StorageTextureNode>;
 
 export const textureStore: (
     value: Texture,
-    uvNode?: NodeRepresentation,
+    uvNode?: NodeRepresentation | null,
     storeNode?: NodeRepresentation,
 ) => ShaderNodeObject<StorageTextureNode>;

three/src/nodes/accessors/TextureNode.d.ts

@@ -68,4 +68,6 @@ export const textureLoad: (
     biasNode?: NodeRepresentation,
 ) => ShaderNodeObject<TextureNode>;
 
-export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;
+export const sampler: (value: Texture | TextureNode) => ShaderNodeObject<Node>;
+
+export const samplerComparison: (value: Texture | TextureNode) => ShaderNodeObject<Node>;

three/src/nodes/accessors/VertexColorNode.d.ts

@@ -6,7 +6,7 @@ export default class VertexColorNode extends AttributeNode {
 
     index: number;
 
-    constructor(index?: number);
+    constructor(index: number);
 }
 
 export const vertexColor: (index?: number) => ShaderNodeObject<VertexColorNode>;

three/src/nodes/code/ExpressionNode.d.ts

@@ -2,8 +2,9 @@ import TempNode from "../core/TempNode.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ExpressionNode extends TempNode {
-    snipped: string; /* sic */
+    snipped: string;
+
     constructor(snipped?: string, nodeType?: string);
 }
 
-export const expression: (snipped?: string, nodeType?: string) => ShaderNodeObject<ExpressionNode>;
+export const expression: (snipped: string, nodeType?: string) => ShaderNodeObject<ExpressionNode>;

three/src/nodes/code/ScriptableNode.d.ts

@@ -17,6 +17,6 @@ declare class ScriptableNode extends Node {
 export default ScriptableNode;
 
 export const scriptable: (
-    codeNode?: NodeRepresentation | null,
+    codeNode: NodeRepresentation,
     parameters?: Record<string, unknown>,
 ) => ShaderNodeObject<ScriptableNode>;

three/src/nodes/code/ScriptableValueNode.d.ts

@@ -7,4 +7,4 @@ declare class ScriptableValueNode extends Node {
 
 export default ScriptableValueNode;
 
-export const scriptableValue: (value?: unknown) => ShaderNodeObject<ScriptableValueNode>;
+export const scriptableValue: (value: unknown) => ShaderNodeObject<ScriptableValueNode>;

three/src/nodes/core/Node.d.ts

@@ -75,6 +75,7 @@ declare class Node extends EventDispatcher<{
     _cacheKey: number | null;
     _cacheKeyVersion: number;
     global: boolean;
+    parents: boolean;
     readonly isNode: true;
     readonly id: number;
     self?: this;
@@ -319,14 +320,16 @@ declare class Node extends EventDispatcher<{
      */
     update(frame: NodeFrame): void;
     /**
-     * This method performs the build of a node. The behavior of this method as well as its return value depend
-     * on the current build stage (setup, analyze or generate).
+     * This method performs the build of a node. The behavior and return value depend on the current build stage:
+     * - **setup**: Prepares the node and its children for the build process. This process can also create new nodes. Returns the node itself or a variant.
+     * - **analyze**: Analyzes the node hierarchy for optimizations in the code generation stage. Returns `null`.
+     * - **generate**: Generates the shader code for the node. Returns the generated shader string.
      *
      * @param {NodeBuilder} builder - The current node builder.
-     * @param {?string} output - Can be used to define the output type.
-     * @return {?string} When this method is executed in the setup or analyze stage, `null` is returned. In the generate stage, the generated shader string.
+     * @param {?string} [output=null] - Can be used to define the output type.
+     * @return {Node|string|null} The result of the build process, depending on the build stage.
      */
-    build(builder: NodeBuilder, output?: string | null): string | null;
+    build(builder: NodeBuilder, output?: string | null): Node | string | null;
     /**
      * Returns the child nodes as a JSON object.
      *

three/src/nodes/core/NodeVarying.d.ts

@@ -1,3 +1,4 @@
+import { InterpolationSamplingMode, InterpolationSamplingType } from "../../constants.js";
 import NodeVar from "./NodeVar.js";
 /**
  * {@link NodeBuilder} is going to create instances of this class during the build process
@@ -10,12 +11,21 @@ import NodeVar from "./NodeVar.js";
 declare class NodeVarying extends NodeVar {
     needsInterpolation: boolean;
     readonly isNodeVarying: true;
+    interpolationType: InterpolationSamplingType | null;
+    interpolationSampling: InterpolationSamplingMode | null;
     /**
      * Constructs a new node varying.
      *
      * @param {string} name - The name of the varying.
      * @param {string} type - The type of the varying.
+     * @param {?string} interpolationType - The interpolation type of the varying.
+     * @param {?string} interpolationSampling - The interpolation sampling type of the varying.
      */
-    constructor(name: string, type: string | null);
+    constructor(
+        name: string,
+        type: string,
+        interpolationType?: InterpolationSamplingType | null,
+        interpolationSampling?: InterpolationSamplingMode | null,
+    );
 }
 export default NodeVarying;

three/src/nodes/core/StackNode.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 declare class StackNode extends Node {
@@ -16,6 +16,12 @@ declare class StackNode extends Node {
 
     Else(method: () => void): this;
 
+    Switch(expression: NodeRepresentation): this;
+
+    Case(...params: NodeRepresentation[]): this;
+
+    Default(method: () => void): this;
+
     /**
      * @deprecated Use {@link StackNode#ElseIf Else()} instead.
      */

three/src/nodes/core/StructTypeNode.d.ts

@@ -28,7 +28,7 @@ declare class StructTypeNode extends Node {
      * Creates an instance of StructTypeNode.
      *
      * @param {Object} membersLayout - The layout of the members for the struct.
-     * @param {string} [name=null] - The optional name of the struct.
+     * @param {?string} [name=null] - The optional name of the struct.
      */
     constructor(membersLayout: MembersLayout, name?: string | null);
     /**

three/src/nodes/core/VaryingNode.d.ts

@@ -1,3 +1,4 @@
+import { InterpolationSamplingMode, InterpolationSamplingType } from "../../constants.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
@@ -6,9 +7,14 @@ import NodeVarying from "./NodeVarying.js";
 export default class VaryingNode extends Node {
     node: Node;
     name: string | null;
+    readonly isVaryingNode: true;
+    interpolationType: InterpolationSamplingType | null;
+    interpolationSampling: InterpolationSamplingMode | null;
 
     constructor(node: Node, name?: string | null);
 
+    setInterpolation(type: InterpolationSamplingType | null, sampling?: InterpolationSamplingMode | null): this;
+
     setupVarying(builder: NodeBuilder): NodeVarying;
 }
 

three/src/nodes/gpgpu/AtomicFunctionNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type AtomicMethod =
@@ -13,13 +12,13 @@ export type AtomicMethod =
     | typeof AtomicFunctionNode.ATOMIC_OR
     | typeof AtomicFunctionNode.ATOMIC_XOR;
 
-declare class AtomicFunctionNode extends TempNode {
+declare class AtomicFunctionNode extends Node {
     method: AtomicMethod;
     pointerNode: Node;
     valueNode: Node;
-    storeNode: Node;
+    parents: boolean;
 
-    constructor(method: AtomicMethod, pointerNode: Node, valueNode: Node, storeNode?: Node | null);
+    constructor(method: AtomicMethod, pointerNode: Node, valueNode: Node);
 
     static ATOMIC_LOAD: "atomicLoad";
     static ATOMIC_STORE: "atomicStore";
@@ -36,58 +35,48 @@ export const atomicFunc: (
     method: AtomicMethod,
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicLoad: (
     pointerNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicStore: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicAdd: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicSub: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicMax: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicMin: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicAnd: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicOr: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicXor: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,
-    storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;

three/src/nodes/lighting/ShadowFilterNode.d.ts

@@ -0,0 +1,28 @@
+import { Light } from "../../lights/Light.js";
+import NodeMaterial from "../../materials/nodes/NodeMaterial.js";
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const BasicShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFSoftShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const VSMShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const getShadowMaterial: (light: Light) => NodeMaterial;

three/src/nodes/lighting/ShadowNode.d.ts

@@ -1,30 +1,33 @@
+import { Camera } from "../../cameras/Camera.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
 import { Light } from "../../lights/Light.js";
 import { LightShadow } from "../../lights/LightShadow.js";
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { Material } from "../../materials/Material.js";
+import { Group } from "../../objects/Group.js";
+import ClippingContext from "../../renderers/common/ClippingContext.js";
+import Renderer from "../../renderers/common/Renderer.js";
+import { Scene } from "../../scenes/Scene.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import LightsNode from "./LightsNode.js";
 import ShadowBaseNode from "./ShadowBaseNode.js";
 
-export const BasicShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-) => ShaderNodeObject<Node>;
-
-export const PCFShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-    shadow: NodeRepresentation,
-) => ShaderNodeObject<Node>;
-
-export const PCFSoftShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-    shadow: NodeRepresentation,
-) => ShaderNodeObject<Node>;
-
-export const VSMShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-) => ShaderNodeObject<Node>;
+export const getShadowRenderObjectFunction: (
+    renderer: Renderer,
+    shadow: LightShadow,
+    shadowType: number,
+    useVelocity: boolean,
+) => (
+    object: Object3D,
+    scene: Scene,
+    _camera: Camera,
+    geometry: BufferGeometry,
+    material: Material,
+    group: Group,
+    lightsNode: LightsNode,
+    clippingContext?: ClippingContext | null,
+    passId?: string | null,
+) => void;
 
 declare class ShadowNode extends ShadowBaseNode {
     constructor(light: Light, shadow: LightShadow | null);
@@ -33,4 +36,3 @@ declare class ShadowNode extends ShadowBaseNode {
 export default ShadowNode;
 
 export const shadow: (light: Light, shadow?: LightShadow) => ShaderNodeObject<ShadowNode>;
-export const shadows: ShaderNodeObject<Node>;

three/src/nodes/math/ConditionalNode.d.ts

@@ -4,9 +4,9 @@ import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 declare class ConditionalNode extends Node {
     condNode: Node;
     ifNode: Node;
-    elseNode: Node;
+    elseNode: Node | null;
 
-    constructor(condNode: Node, ifNode: Node, elseNode: Node);
+    constructor(condNode: Node, ifNode: Node, elseNode?: Node | null);
 }
 
 export default ConditionalNode;
@@ -14,7 +14,7 @@ export default ConditionalNode;
 export const select: (
     condNode: NodeRepresentation,
     ifNode: NodeRepresentation,
-    elseNode: NodeRepresentation,
+    elseNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<Node>;
 
 declare module "../tsl/TSLCore.js" {
@@ -29,7 +29,7 @@ declare module "../tsl/TSLCore.js" {
 export const cond: (
     condNode: NodeRepresentation,
     ifNode: NodeRepresentation,
-    elseNode: NodeRepresentation,
+    elseNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<Node>;
 
 declare module "../tsl/TSLCore.js" {

three/src/nodes/math/MathNode.d.ts

@@ -39,7 +39,6 @@ export type MathNodeMethod1 =
 export type MathNodeMethod2 =
     | typeof MathNode.MIN
     | typeof MathNode.MAX
-    | typeof MathNode.MOD
     | typeof MathNode.STEP
     | typeof MathNode.REFLECT
     | typeof MathNode.DISTANCE
@@ -100,7 +99,6 @@ export default class MathNode extends TempNode {
 
     static MIN: "min";
     static MAX: "max";
-    static MOD: "mod";
     static STEP: "step";
     static REFLECT: "reflect";
     static DISTANCE: "distance";
@@ -138,6 +136,10 @@ type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
 export const all: Unary;
 export const any: Unary;
+
+/**
+ * @deprecated "equals" is deprecated. Use "equal" inside a vector instead, like: "bvec*( equal( ... ) )"
+ */
 export const equals: Unary;
 
 export const radians: Unary;
@@ -169,14 +171,21 @@ export const round: Unary;
 export const reciprocal: Unary;
 export const trunc: Unary;
 export const fwidth: Unary;
-export const bitcast: Unary;
 export const transpose: Unary;
 
 type Binary = (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
-export const min: Binary;
-export const max: Binary;
-export const mod: Binary;
+export const bitcast: Binary;
+export const min: (
+    x: NodeRepresentation,
+    y: NodeRepresentation,
+    ...values: NodeRepresentation[]
+) => ShaderNodeObject<MathNode>;
+export const max: (
+    x: NodeRepresentation,
+    y: NodeRepresentation,
+    ...values: NodeRepresentation[]
+) => ShaderNodeObject<MathNode>;
 export const step: Binary;
 export const reflect: Binary;
 export const distance: Binary;
@@ -184,15 +193,15 @@ export const difference: Binary;
 export const dot: Binary;
 export const cross: Binary;
 export const pow: Binary;
-export const pow2: Binary;
-export const pow3: Binary;
-export const pow4: Binary;
+export const pow2: Unary;
+export const pow3: Unary;
+export const pow4: Unary;
 export const transformDirection: Binary;
+export const cbrt: Unary;
+export const lengthSq: Unary;
 
 type Ternary = (a: NodeRepresentation, b: NodeRepresentation, c: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
-export const cbrt: Unary;
-export const lengthSq: Unary;
 export const mix: Ternary;
 export const clamp: (
     a: NodeRepresentation,
@@ -259,7 +268,6 @@ declare module "../tsl/TSLCore.js" {
         atan2: typeof atan2;
         min: typeof min;
         max: typeof max;
-        mod: typeof mod;
         step: typeof step;
         reflect: typeof reflect;
         distance: typeof distance;

three/src/nodes/math/OperatorNode.d.ts

@@ -33,33 +33,56 @@ export default class OperatorNode extends TempNode {
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
 
-type Operator = (
+export const add: (
     a: NodeRepresentation,
     b: NodeRepresentation,
-    ...others: NodeRepresentation[]
+    ...params: NodeRepresentation[]
 ) => ShaderNodeObject<OperatorNode>;
+export const sub: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const mul: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const div: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const mod: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const equal: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const notEqual: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const lessThan: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const greaterThan: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const lessThanEqual: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const greaterThanEqual: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const and: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const or: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const not: (value: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const xor: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitAnd: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitNot: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitOr: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitXor: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const shiftLeft: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const shiftRight: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 
-export const add: Operator;
-export const sub: Operator;
-export const mul: Operator;
-export const div: Operator;
-export const modInt: Operator;
-export const equal: Operator;
-export const notEqual: Operator;
-export const lessThan: Operator;
-export const greaterThan: Operator;
-export const lessThanEqual: Operator;
-export const greaterThanEqual: Operator;
-export const and: Operator;
-export const or: Operator;
-export const not: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
-export const xor: Operator;
-export const bitAnd: Operator;
-export const bitNot: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
-export const bitOr: Operator;
-export const bitXor: Operator;
-export const shiftLeft: Operator;
-export const shiftRight: Operator;
+export const incrementBefore: (a: NodeRepresentation) => ShaderNodeObject<Node>;
+export const decrementBefore: (a: NodeRepresentation) => ShaderNodeObject<Node>;
+export const increment: (a: NodeRepresentation) => ShaderNodeObject<Node>;
+export const decrement: (a: NodeRepresentation) => ShaderNodeObject<Node>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
@@ -67,7 +90,7 @@ declare module "../tsl/TSLCore.js" {
         sub: typeof sub;
         mul: typeof mul;
         div: typeof div;
-        modInt: typeof modInt;
+        mod: typeof mod;
         equal: typeof equal;
         notEqual: typeof notEqual;
         lessThan: typeof lessThan;
@@ -84,13 +107,26 @@ declare module "../tsl/TSLCore.js" {
         bitXor: typeof bitXor;
         shiftLeft: typeof shiftLeft;
         shiftRight: typeof shiftRight;
+        incrementBefore: typeof incrementBefore;
+        decrementBefore: typeof decrement;
+        increment: typeof increment;
+        decrement: typeof decrement;
     }
 }
 
 /**
  * @deprecated .remainder() has been renamed to .modInt().
  */
-export const remainder: Operator;
+export const remainder: (
+    aNode: NodeRepresentation,
+    bNode: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+
+/**
+ * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
+ */
+export const modInt: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
@@ -98,5 +134,9 @@ declare module "../tsl/TSLCore.js" {
          * @deprecated .remainder() has been renamed to .modInt().
          */
         remainder: typeof remainder;
+        /**
+         * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
+         */
+        modInt: typeof modInt;
     }
 }

three/src/nodes/tsl/TSLBase.d.ts

@@ -17,6 +17,7 @@ export * from "../gpgpu/ComputeNode.js";
 export * from "../math/ConditionalNode.js";
 export * from "../math/MathNode.js";
 export * from "../math/OperatorNode.js";
+export * from "../utils/DebugNode.js";
 export * from "../utils/Discard.js";
 export * from "../utils/RemapNode.js";
 export * from "./TSLCore.js";